commit 3271fee5cca958ce35018f2bc9600d3ba86b839a
Author: Quentin <1771956812@qq.com>
Date:   Tue Sep 29 09:43:13 2026 +0800

    init: WordFileParse docx→HTML 解析服务（含 Word EQ 域公式修复）
    
    服务：Spring Boot 3.2 + docx4j 8.3.9，POST /api/v3/server_office_file/file/parse
          接受 .docx，返回 HTML（公式 → LaTeX，图片 → RustFS 外链）
    
    公式支持三类来源：
    - OMML（Word 2007+ 公式）      → Python omml_mathml2latex
    - MathType OLE 对象            → Ruby mathtype2mathml → MathML → LaTeX
    - Word EQ 域（老教辅主力）      → EqToLatexUtil（本次新增）
    
    本次改动：
    1. 新增 java-svc/.../core/EqToLatexUtil.java：
       移植自 jby backend-services office-core，EQ 语法 → LaTeX
       （\f→\dfrac、\r→\sqrt、\i→\int/\sum/\prod、\s→^{}/_{}、\b→\left\right、
         \a→array、\x→\boxed/\overline、\o\al 堆叠、圈码、化学符号、极限、连等式）
       品牌标记 JBYU* → WPU*，与采集端一致
    2. CtoMathFinder：接上 EQ 分支（原为 not-ported 桩），域代码经
       EqToLatexUtil.convert 转 LaTeX 写入 eqLatexMap（WPEQNUM 占位符）
    3. WordParseUtil.dealPlaceholder：EQ 的 LaTeX 同样加 \( \) 包裹
       （原先因 WPEQNUM 例外不加包裹，前端/MathJax 不渲染）
    
    修前症状：教辅 Word 里分式/方程组/上下标整段丢失（如 {−1/3, 1} 变成 {－，1}）
    修后实测：46 份教辅 2908 处 EQ 域全部还原，公式总数 2954 处、零未包裹残留
    
    安全：application.yml（含 RustFS 密钥）不入库，提供 application.yml.example；
          OssService 的 @Value 默认密钥已清空

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b96bd4e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,18 @@
+# 构建产物
+java-svc/target/
+java-svc-jdk8/target/
+*.class
+*.jar
+!scripts/**/*.jar
+
+# 含密钥的本地配置（仓库里只放 application.yml.example）
+java-svc/src/main/resources/application.yml
+
+# 备份/临时
+*.bak-*
+*.log
+logs/
+.DS_Store
+__MACOSX/
+.idea/
+.vscode/
diff --git a/java-src/config/OfficeCoreConfig.java b/java-src/config/OfficeCoreConfig.java
new file mode 100644
index 0000000..0936bec
--- /dev/null
+++ b/java-src/config/OfficeCoreConfig.java
@@ -0,0 +1,413 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.jby.common.util.SpringContextHolder
+ *  org.apache.commons.lang3.StringUtils
+ *  org.springframework.boot.context.properties.ConfigurationProperties
+ *  org.springframework.cloud.context.config.annotation.RefreshScope
+ *  org.springframework.stereotype.Component
+ */
+package com.jby.officecore.config;
+
+import com.jby.common.util.SpringContextHolder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.stereotype.Component;
+
+@Component
+@RefreshScope
+@ConfigurationProperties(prefix="office.core.config")
+public class OfficeCoreConfig {
+    private String tmpPath = "/opt/files/tmp";
+    private String templatePath;
+    private Boolean deleteTmpFile = true;
+    private String foreLatexToMathMlApi = "https://test.xinjiaoyu.com/api/v3/server_node_sheet_new/latex/to-mathml";
+    private String latexToMathMlApi = "http://172.26.197.220:8050/latex_to_mathml";
+    private String mathMlToLatexApi = "http://172.26.197.220:8050/mathml_to_latex";
+    private Boolean mathMlToLatexApiSwitch;
+    private String mf2SvgApi = "http://test.format.xinjiaoyu.com/server_format/graphic/mf2svg";
+    private String downloadPdfApi = "https://test.xinjiaoyu.com/api/v3/server_node_sheet_new/office/download";
+    private String errorBookTemplate = "https://test.xinjiaoyu.com/main/print.html?%s#/downloadNotebook";
+    private Integer nodeConnectTimeout = 5000;
+    private Integer nodeSocketTimeout = 30000;
+    private Long contentLimit = 100000L;
+    private Double limitRatio = 0.6;
+    private Integer checkSize = 10;
+    private Double imageScalingFactor = 0.7;
+    private String copyrightAddresses = "www.zxxk.com,www.zujuan.com,www.jyeoo.com";
+    private Boolean newParseVersion;
+    private Boolean newDownloadVersion;
+    private Boolean openParseCache = true;
+    private Map<String, List<String>> cleanStyleMap = new HashMap<String, List<String>>();
+    private String transformScriptPath = "E:\\IdeaProject\\jby-project\\base_server\\jby-office\\jby-office-transform";
+
+    public String getTransformScriptPath() {
+        return this.isLocal() ? this.transformScriptPath : "/opt/servers/jby-office-transform";
+    }
+
+    public String getPythonCommand() {
+        return this.isLocal() ? "python" : "python3";
+    }
+
+    private boolean isLocal() {
+        String env = SpringContextHolder.getActiveProfile();
+        return StringUtils.isBlank((CharSequence)env) || env.contains("local");
+    }
+
+    public String getTmpPath() {
+        return this.tmpPath;
+    }
+
+    public String getTemplatePath() {
+        return this.templatePath;
+    }
+
+    public Boolean getDeleteTmpFile() {
+        return this.deleteTmpFile;
+    }
+
+    public String getForeLatexToMathMlApi() {
+        return this.foreLatexToMathMlApi;
+    }
+
+    public String getLatexToMathMlApi() {
+        return this.latexToMathMlApi;
+    }
+
+    public String getMathMlToLatexApi() {
+        return this.mathMlToLatexApi;
+    }
+
+    public Boolean getMathMlToLatexApiSwitch() {
+        return this.mathMlToLatexApiSwitch;
+    }
+
+    public String getMf2SvgApi() {
+        return this.mf2SvgApi;
+    }
+
+    public String getDownloadPdfApi() {
+        return this.downloadPdfApi;
+    }
+
+    public String getErrorBookTemplate() {
+        return this.errorBookTemplate;
+    }
+
+    public Integer getNodeConnectTimeout() {
+        return this.nodeConnectTimeout;
+    }
+
+    public Integer getNodeSocketTimeout() {
+        return this.nodeSocketTimeout;
+    }
+
+    public Long getContentLimit() {
+        return this.contentLimit;
+    }
+
+    public Double getLimitRatio() {
+        return this.limitRatio;
+    }
+
+    public Integer getCheckSize() {
+        return this.checkSize;
+    }
+
+    public Double getImageScalingFactor() {
+        return this.imageScalingFactor;
+    }
+
+    public String getCopyrightAddresses() {
+        return this.copyrightAddresses;
+    }
+
+    public Boolean getNewParseVersion() {
+        return this.newParseVersion;
+    }
+
+    public Boolean getNewDownloadVersion() {
+        return this.newDownloadVersion;
+    }
+
+    public Boolean getOpenParseCache() {
+        return this.openParseCache;
+    }
+
+    public Map<String, List<String>> getCleanStyleMap() {
+        return this.cleanStyleMap;
+    }
+
+    public void setTmpPath(String tmpPath) {
+        this.tmpPath = tmpPath;
+    }
+
+    public void setTemplatePath(String templatePath) {
+        this.templatePath = templatePath;
+    }
+
+    public void setDeleteTmpFile(Boolean deleteTmpFile) {
+        this.deleteTmpFile = deleteTmpFile;
+    }
+
+    public void setForeLatexToMathMlApi(String foreLatexToMathMlApi) {
+        this.foreLatexToMathMlApi = foreLatexToMathMlApi;
+    }
+
+    public void setLatexToMathMlApi(String latexToMathMlApi) {
+        this.latexToMathMlApi = latexToMathMlApi;
+    }
+
+    public void setMathMlToLatexApi(String mathMlToLatexApi) {
+        this.mathMlToLatexApi = mathMlToLatexApi;
+    }
+
+    public void setMathMlToLatexApiSwitch(Boolean mathMlToLatexApiSwitch) {
+        this.mathMlToLatexApiSwitch = mathMlToLatexApiSwitch;
+    }
+
+    public void setMf2SvgApi(String mf2SvgApi) {
+        this.mf2SvgApi = mf2SvgApi;
+    }
+
+    public void setDownloadPdfApi(String downloadPdfApi) {
+        this.downloadPdfApi = downloadPdfApi;
+    }
+
+    public void setErrorBookTemplate(String errorBookTemplate) {
+        this.errorBookTemplate = errorBookTemplate;
+    }
+
+    public void setNodeConnectTimeout(Integer nodeConnectTimeout) {
+        this.nodeConnectTimeout = nodeConnectTimeout;
+    }
+
+    public void setNodeSocketTimeout(Integer nodeSocketTimeout) {
+        this.nodeSocketTimeout = nodeSocketTimeout;
+    }
+
+    public void setContentLimit(Long contentLimit) {
+        this.contentLimit = contentLimit;
+    }
+
+    public void setLimitRatio(Double limitRatio) {
+        this.limitRatio = limitRatio;
+    }
+
+    public void setCheckSize(Integer checkSize) {
+        this.checkSize = checkSize;
+    }
+
+    public void setImageScalingFactor(Double imageScalingFactor) {
+        this.imageScalingFactor = imageScalingFactor;
+    }
+
+    public void setCopyrightAddresses(String copyrightAddresses) {
+        this.copyrightAddresses = copyrightAddresses;
+    }
+
+    public void setNewParseVersion(Boolean newParseVersion) {
+        this.newParseVersion = newParseVersion;
+    }
+
+    public void setNewDownloadVersion(Boolean newDownloadVersion) {
+        this.newDownloadVersion = newDownloadVersion;
+    }
+
+    public void setOpenParseCache(Boolean openParseCache) {
+        this.openParseCache = openParseCache;
+    }
+
+    public void setCleanStyleMap(Map<String, List<String>> cleanStyleMap) {
+        this.cleanStyleMap = cleanStyleMap;
+    }
+
+    public void setTransformScriptPath(String transformScriptPath) {
+        this.transformScriptPath = transformScriptPath;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof OfficeCoreConfig)) {
+            return false;
+        }
+        OfficeCoreConfig other = (OfficeCoreConfig)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        String this$tmpPath = this.getTmpPath();
+        String other$tmpPath = other.getTmpPath();
+        if (this$tmpPath == null ? other$tmpPath != null : !this$tmpPath.equals(other$tmpPath)) {
+            return false;
+        }
+        String this$templatePath = this.getTemplatePath();
+        String other$templatePath = other.getTemplatePath();
+        if (this$templatePath == null ? other$templatePath != null : !this$templatePath.equals(other$templatePath)) {
+            return false;
+        }
+        Boolean this$deleteTmpFile = this.getDeleteTmpFile();
+        Boolean other$deleteTmpFile = other.getDeleteTmpFile();
+        if (this$deleteTmpFile == null ? other$deleteTmpFile != null : !((Object)this$deleteTmpFile).equals(other$deleteTmpFile)) {
+            return false;
+        }
+        String this$foreLatexToMathMlApi = this.getForeLatexToMathMlApi();
+        String other$foreLatexToMathMlApi = other.getForeLatexToMathMlApi();
+        if (this$foreLatexToMathMlApi == null ? other$foreLatexToMathMlApi != null : !this$foreLatexToMathMlApi.equals(other$foreLatexToMathMlApi)) {
+            return false;
+        }
+        String this$latexToMathMlApi = this.getLatexToMathMlApi();
+        String other$latexToMathMlApi = other.getLatexToMathMlApi();
+        if (this$latexToMathMlApi == null ? other$latexToMathMlApi != null : !this$latexToMathMlApi.equals(other$latexToMathMlApi)) {
+            return false;
+        }
+        String this$mathMlToLatexApi = this.getMathMlToLatexApi();
+        String other$mathMlToLatexApi = other.getMathMlToLatexApi();
+        if (this$mathMlToLatexApi == null ? other$mathMlToLatexApi != null : !this$mathMlToLatexApi.equals(other$mathMlToLatexApi)) {
+            return false;
+        }
+        Boolean this$mathMlToLatexApiSwitch = this.getMathMlToLatexApiSwitch();
+        Boolean other$mathMlToLatexApiSwitch = other.getMathMlToLatexApiSwitch();
+        if (this$mathMlToLatexApiSwitch == null ? other$mathMlToLatexApiSwitch != null : !((Object)this$mathMlToLatexApiSwitch).equals(other$mathMlToLatexApiSwitch)) {
+            return false;
+        }
+        String this$mf2SvgApi = this.getMf2SvgApi();
+        String other$mf2SvgApi = other.getMf2SvgApi();
+        if (this$mf2SvgApi == null ? other$mf2SvgApi != null : !this$mf2SvgApi.equals(other$mf2SvgApi)) {
+            return false;
+        }
+        String this$downloadPdfApi = this.getDownloadPdfApi();
+        String other$downloadPdfApi = other.getDownloadPdfApi();
+        if (this$downloadPdfApi == null ? other$downloadPdfApi != null : !this$downloadPdfApi.equals(other$downloadPdfApi)) {
+            return false;
+        }
+        String this$errorBookTemplate = this.getErrorBookTemplate();
+        String other$errorBookTemplate = other.getErrorBookTemplate();
+        if (this$errorBookTemplate == null ? other$errorBookTemplate != null : !this$errorBookTemplate.equals(other$errorBookTemplate)) {
+            return false;
+        }
+        Integer this$nodeConnectTimeout = this.getNodeConnectTimeout();
+        Integer other$nodeConnectTimeout = other.getNodeConnectTimeout();
+        if (this$nodeConnectTimeout == null ? other$nodeConnectTimeout != null : !((Object)this$nodeConnectTimeout).equals(other$nodeConnectTimeout)) {
+            return false;
+        }
+        Integer this$nodeSocketTimeout = this.getNodeSocketTimeout();
+        Integer other$nodeSocketTimeout = other.getNodeSocketTimeout();
+        if (this$nodeSocketTimeout == null ? other$nodeSocketTimeout != null : !((Object)this$nodeSocketTimeout).equals(other$nodeSocketTimeout)) {
+            return false;
+        }
+        Long this$contentLimit = this.getContentLimit();
+        Long other$contentLimit = other.getContentLimit();
+        if (this$contentLimit == null ? other$contentLimit != null : !((Object)this$contentLimit).equals(other$contentLimit)) {
+            return false;
+        }
+        Double this$limitRatio = this.getLimitRatio();
+        Double other$limitRatio = other.getLimitRatio();
+        if (this$limitRatio == null ? other$limitRatio != null : !((Object)this$limitRatio).equals(other$limitRatio)) {
+            return false;
+        }
+        Integer this$checkSize = this.getCheckSize();
+        Integer other$checkSize = other.getCheckSize();
+        if (this$checkSize == null ? other$checkSize != null : !((Object)this$checkSize).equals(other$checkSize)) {
+            return false;
+        }
+        Double this$imageScalingFactor = this.getImageScalingFactor();
+        Double other$imageScalingFactor = other.getImageScalingFactor();
+        if (this$imageScalingFactor == null ? other$imageScalingFactor != null : !((Object)this$imageScalingFactor).equals(other$imageScalingFactor)) {
+            return false;
+        }
+        String this$copyrightAddresses = this.getCopyrightAddresses();
+        String other$copyrightAddresses = other.getCopyrightAddresses();
+        if (this$copyrightAddresses == null ? other$copyrightAddresses != null : !this$copyrightAddresses.equals(other$copyrightAddresses)) {
+            return false;
+        }
+        Boolean this$newParseVersion = this.getNewParseVersion();
+        Boolean other$newParseVersion = other.getNewParseVersion();
+        if (this$newParseVersion == null ? other$newParseVersion != null : !((Object)this$newParseVersion).equals(other$newParseVersion)) {
+            return false;
+        }
+        Boolean this$newDownloadVersion = this.getNewDownloadVersion();
+        Boolean other$newDownloadVersion = other.getNewDownloadVersion();
+        if (this$newDownloadVersion == null ? other$newDownloadVersion != null : !((Object)this$newDownloadVersion).equals(other$newDownloadVersion)) {
+            return false;
+        }
+        Boolean this$openParseCache = this.getOpenParseCache();
+        Boolean other$openParseCache = other.getOpenParseCache();
+        if (this$openParseCache == null ? other$openParseCache != null : !((Object)this$openParseCache).equals(other$openParseCache)) {
+            return false;
+        }
+        Map<String, List<String>> this$cleanStyleMap = this.getCleanStyleMap();
+        Map<String, List<String>> other$cleanStyleMap = other.getCleanStyleMap();
+        if (this$cleanStyleMap == null ? other$cleanStyleMap != null : !((Object)this$cleanStyleMap).equals(other$cleanStyleMap)) {
+            return false;
+        }
+        String this$transformScriptPath = this.getTransformScriptPath();
+        String other$transformScriptPath = other.getTransformScriptPath();
+        return !(this$transformScriptPath == null ? other$transformScriptPath != null : !this$transformScriptPath.equals(other$transformScriptPath));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof OfficeCoreConfig;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        String $tmpPath = this.getTmpPath();
+        result = result * 59 + ($tmpPath == null ? 43 : $tmpPath.hashCode());
+        String $templatePath = this.getTemplatePath();
+        result = result * 59 + ($templatePath == null ? 43 : $templatePath.hashCode());
+        Boolean $deleteTmpFile = this.getDeleteTmpFile();
+        result = result * 59 + ($deleteTmpFile == null ? 43 : ((Object)$deleteTmpFile).hashCode());
+        String $foreLatexToMathMlApi = this.getForeLatexToMathMlApi();
+        result = result * 59 + ($foreLatexToMathMlApi == null ? 43 : $foreLatexToMathMlApi.hashCode());
+        String $latexToMathMlApi = this.getLatexToMathMlApi();
+        result = result * 59 + ($latexToMathMlApi == null ? 43 : $latexToMathMlApi.hashCode());
+        String $mathMlToLatexApi = this.getMathMlToLatexApi();
+        result = result * 59 + ($mathMlToLatexApi == null ? 43 : $mathMlToLatexApi.hashCode());
+        Boolean $mathMlToLatexApiSwitch = this.getMathMlToLatexApiSwitch();
+        result = result * 59 + ($mathMlToLatexApiSwitch == null ? 43 : ((Object)$mathMlToLatexApiSwitch).hashCode());
+        String $mf2SvgApi = this.getMf2SvgApi();
+        result = result * 59 + ($mf2SvgApi == null ? 43 : $mf2SvgApi.hashCode());
+        String $downloadPdfApi = this.getDownloadPdfApi();
+        result = result * 59 + ($downloadPdfApi == null ? 43 : $downloadPdfApi.hashCode());
+        String $errorBookTemplate = this.getErrorBookTemplate();
+        result = result * 59 + ($errorBookTemplate == null ? 43 : $errorBookTemplate.hashCode());
+        Integer $nodeConnectTimeout = this.getNodeConnectTimeout();
+        result = result * 59 + ($nodeConnectTimeout == null ? 43 : ((Object)$nodeConnectTimeout).hashCode());
+        Integer $nodeSocketTimeout = this.getNodeSocketTimeout();
+        result = result * 59 + ($nodeSocketTimeout == null ? 43 : ((Object)$nodeSocketTimeout).hashCode());
+        Long $contentLimit = this.getContentLimit();
+        result = result * 59 + ($contentLimit == null ? 43 : ((Object)$contentLimit).hashCode());
+        Double $limitRatio = this.getLimitRatio();
+        result = result * 59 + ($limitRatio == null ? 43 : ((Object)$limitRatio).hashCode());
+        Integer $checkSize = this.getCheckSize();
+        result = result * 59 + ($checkSize == null ? 43 : ((Object)$checkSize).hashCode());
+        Double $imageScalingFactor = this.getImageScalingFactor();
+        result = result * 59 + ($imageScalingFactor == null ? 43 : ((Object)$imageScalingFactor).hashCode());
+        String $copyrightAddresses = this.getCopyrightAddresses();
+        result = result * 59 + ($copyrightAddresses == null ? 43 : $copyrightAddresses.hashCode());
+        Boolean $newParseVersion = this.getNewParseVersion();
+        result = result * 59 + ($newParseVersion == null ? 43 : ((Object)$newParseVersion).hashCode());
+        Boolean $newDownloadVersion = this.getNewDownloadVersion();
+        result = result * 59 + ($newDownloadVersion == null ? 43 : ((Object)$newDownloadVersion).hashCode());
+        Boolean $openParseCache = this.getOpenParseCache();
+        result = result * 59 + ($openParseCache == null ? 43 : ((Object)$openParseCache).hashCode());
+        Map<String, List<String>> $cleanStyleMap = this.getCleanStyleMap();
+        result = result * 59 + ($cleanStyleMap == null ? 43 : ((Object)$cleanStyleMap).hashCode());
+        String $transformScriptPath = this.getTransformScriptPath();
+        result = result * 59 + ($transformScriptPath == null ? 43 : $transformScriptPath.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "OfficeCoreConfig(tmpPath=" + this.getTmpPath() + ", templatePath=" + this.getTemplatePath() + ", deleteTmpFile=" + this.getDeleteTmpFile() + ", foreLatexToMathMlApi=" + this.getForeLatexToMathMlApi() + ", latexToMathMlApi=" + this.getLatexToMathMlApi() + ", mathMlToLatexApi=" + this.getMathMlToLatexApi() + ", mathMlToLatexApiSwitch=" + this.getMathMlToLatexApiSwitch() + ", mf2SvgApi=" + this.getMf2SvgApi() + ", downloadPdfApi=" + this.getDownloadPdfApi() + ", errorBookTemplate=" + this.getErrorBookTemplate() + ", nodeConnectTimeout=" + this.getNodeConnectTimeout() + ", nodeSocketTimeout=" + this.getNodeSocketTimeout() + ", contentLimit=" + this.getContentLimit() + ", limitRatio=" + this.getLimitRatio() + ", checkSize=" + this.getCheckSize() + ", imageScalingFactor=" + this.getImageScalingFactor() + ", copyrightAddresses=" + this.getCopyrightAddresses() + ", newParseVersion=" + this.getNewParseVersion() + ", newDownloadVersion=" + this.getNewDownloadVersion() + ", openParseCache=" + this.getOpenParseCache() + ", cleanStyleMap=" + this.getCleanStyleMap() + ", transformScriptPath=" + this.getTransformScriptPath() + ")";
+    }
+}
+
diff --git a/java-src/controller/FileController.java b/java-src/controller/FileController.java
new file mode 100644
index 0000000..f599393
--- /dev/null
+++ b/java-src/controller/FileController.java
@@ -0,0 +1,152 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.fastjson.JSON
+ *  com.jby.common.advisor.annotation.ParamBarrier
+ *  com.jby.common.result.Result
+ *  com.jby.office.api.FileServiceApi
+ *  com.jby.office.domain.param.DownloadFileParam
+ *  com.jby.office.domain.param.DownloadParam
+ *  com.jby.office.domain.param.FileParam
+ *  com.jby.office.domain.param.GenerateFileParam
+ *  com.jby.office.domain.param.OfficeFileParseParam
+ *  com.jby.office.domain.param.OfficeFileParseRecordParam
+ *  com.jby.office.domain.vo.OfficeFileDownloadScheduleVO
+ *  com.jby.office.domain.vo.OfficeFileInfoVO
+ *  com.jby.office.domain.vo.OfficeFileParseRecordVO
+ *  com.jby.office.domain.vo.OfficeFileParseVO
+ *  com.jby.officecore.annotation.CostTime
+ *  com.jby.officecore.domain.dto.CreateWordDTO
+ *  com.jby.officecore.utils.WordExportUtil
+ *  com.jby.system.domain.param.NodeParam
+ *  javax.annotation.Resource
+ *  org.map.utils.BeanMapping
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.web.bind.annotation.GetMapping
+ *  org.springframework.web.bind.annotation.PathVariable
+ *  org.springframework.web.bind.annotation.PostMapping
+ *  org.springframework.web.bind.annotation.RequestBody
+ *  org.springframework.web.bind.annotation.RequestMapping
+ *  org.springframework.web.bind.annotation.RestController
+ */
+package com.jby.officefile.controller;
+
+import com.alibaba.fastjson.JSON;
+import com.jby.common.advisor.annotation.ParamBarrier;
+import com.jby.common.result.Result;
+import com.jby.office.api.FileServiceApi;
+import com.jby.office.domain.param.DownloadFileParam;
+import com.jby.office.domain.param.DownloadParam;
+import com.jby.office.domain.param.FileParam;
+import com.jby.office.domain.param.GenerateFileParam;
+import com.jby.office.domain.param.OfficeFileParseParam;
+import com.jby.office.domain.param.OfficeFileParseRecordParam;
+import com.jby.office.domain.vo.OfficeFileDownloadScheduleVO;
+import com.jby.office.domain.vo.OfficeFileInfoVO;
+import com.jby.office.domain.vo.OfficeFileParseRecordVO;
+import com.jby.office.domain.vo.OfficeFileParseVO;
+import com.jby.officecore.annotation.CostTime;
+import com.jby.officecore.domain.dto.CreateWordDTO;
+import com.jby.officecore.utils.WordExportUtil;
+import com.jby.officefile.service.FileService;
+import com.jby.system.domain.param.NodeParam;
+import java.util.List;
+import java.util.Objects;
+import javax.annotation.Resource;
+import org.map.utils.BeanMapping;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping(value={"/file"})
+public class FileController
+implements FileServiceApi {
+    private static final Logger log = LoggerFactory.getLogger(FileController.class);
+    @Resource
+    private FileService fileService;
+
+    @CostTime
+    @PostMapping(value={"/generate/by/url"})
+    public Result<OfficeFileInfoVO> generateFileByUrl(@RequestBody GenerateFileParam param) {
+        log.info("\u901a\u8fc7word\u8d44\u6e90\u5730\u5740\u751f\u6210\u5728\u7ebf\u7f16\u8f91\u6587\u4ef6(\u5b8c\u6574\u6587\u6863), param={}", (Object)JSON.toJSONString((Object)param));
+        OfficeFileInfoVO result = this.fileService.generateFileByUrl(param);
+        return Result.success((Object)result);
+    }
+
+    @CostTime
+    @PostMapping(value={"/generate/by/file"}, consumes={"multipart/form-data"})
+    public Result<OfficeFileInfoVO> generateFileByFile(FileParam param) {
+        log.info("\u901a\u8fc7word\u8d44\u6e90\u6587\u4ef6\u751f\u6210\u5728\u7ebf\u7f16\u8f91\u6587\u4ef6(\u5b8c\u6574\u6587\u6863), param={}", (Object)JSON.toJSONString((Object)param));
+        OfficeFileInfoVO result = this.fileService.generateFileByFile(param);
+        return Result.success((Object)result);
+    }
+
+    @CostTime
+    @PostMapping(value={"/parse"}, consumes={"multipart/form-data"})
+    public Result<OfficeFileParseVO> parseOfficeFile(OfficeFileParseParam param) {
+        OfficeFileParseVO parseVO = this.fileService.parseOfficeFile(param);
+        return Result.success((Object)parseVO);
+    }
+
+    @CostTime
+    @PostMapping(value={"/download"}, consumes={"multipart/form-data"})
+    public Result<String> downloadOfficeFile(DownloadFileParam param) {
+        log.info("\u4e0b\u8f7d\u5728\u7ebf\u7f16\u8f91\u6587\u4ef6, file={}, param={}", (Object)Objects.nonNull(param.getPdfFile()), (Object)JSON.toJSONString((Object)param));
+        String fileUrl = this.fileService.downloadOfficeFile(param);
+        return Result.success((Object)fileUrl);
+    }
+
+    @CostTime
+    @PostMapping(value={"/v2/download"})
+    public Result<String> downloadFile(@RequestBody DownloadParam param) {
+        log.info("\u4e0b\u8f7d\u5728\u7ebf\u7f16\u8f91\u6587\u4ef6V2, param={}", (Object)JSON.toJSONString((Object)param));
+        DownloadFileParam fileParam = (DownloadFileParam)BeanMapping.toBean((Object)param, DownloadFileParam.class);
+        String fileUrl = this.fileService.downloadOfficeFile(fileParam);
+        return Result.success((Object)fileUrl);
+    }
+
+    @Deprecated
+    @CostTime
+    @PostMapping(value={"/batch/download"})
+    public Result<OfficeFileDownloadScheduleVO> batchDownloadOfficeFile(@RequestBody NodeParam rootNode) {
+        log.info("\u6279\u91cf\u4e0b\u8f7d\u5728\u7ebf\u6587\u4ef6, \u8282\u70b9\u53c2\u6570rootNode={}", (Object)JSON.toJSONString((Object)rootNode));
+        OfficeFileDownloadScheduleVO result = this.fileService.batchDownloadOfficeFile(rootNode);
+        return Result.success((Object)result);
+    }
+
+    @CostTime
+    @PostMapping(value={"/download/word"})
+    public Result<String> downloadWord(@RequestBody CreateWordDTO param) {
+        log.info("\u4e0b\u8f7dword\u6587\u4ef6, param={}", (Object)JSON.toJSONString((Object)param));
+        String result = WordExportUtil.createWord((CreateWordDTO)param);
+        return Result.success((Object)result);
+    }
+
+    @GetMapping(value={"/parse/record/{md5}"})
+    public Result<OfficeFileParseRecordVO> getOfficeFileParseRecordByMd5(@PathVariable String md5) {
+        OfficeFileParseRecordVO result = this.fileService.getOfficeFileParseRecordByMd5(md5);
+        return Result.success((Object)result);
+    }
+
+    @PostMapping(value={"/parse/record"})
+    public Result<?> saveOfficeFileParseRecord(@RequestBody OfficeFileParseRecordParam param) {
+        this.fileService.saveOfficeFileParseRecord(param);
+        return Result.success();
+    }
+
+    @PostMapping(value={"/parse/record/query"})
+    @ParamBarrier(value={"fileIds"})
+    public Result<List<OfficeFileParseRecordVO>> queryFileUrlByFileIds(@RequestBody OfficeFileParseRecordParam param) {
+        List<OfficeFileParseRecordVO> result = this.fileService.queryFileUrlByFileIds(param);
+        return Result.success(result);
+    }
+}
+
diff --git a/java-src/domain/bo/ImageBO.java b/java-src/domain/bo/ImageBO.java
new file mode 100644
index 0000000..47b4d83
--- /dev/null
+++ b/java-src/domain/bo/ImageBO.java
@@ -0,0 +1,123 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.jby.officecore.domain.bo;
+
+import java.io.InputStream;
+import java.io.Serializable;
+
+public class ImageBO
+implements Serializable {
+    private static final long serialVersionUID = 6640950035295880234L;
+    private InputStream is;
+    private Double width;
+    private Double height;
+    private Integer pictureType;
+    private String pictureUrl;
+
+    public InputStream getIs() {
+        return this.is;
+    }
+
+    public Double getWidth() {
+        return this.width;
+    }
+
+    public Double getHeight() {
+        return this.height;
+    }
+
+    public Integer getPictureType() {
+        return this.pictureType;
+    }
+
+    public String getPictureUrl() {
+        return this.pictureUrl;
+    }
+
+    public ImageBO setIs(InputStream is) {
+        this.is = is;
+        return this;
+    }
+
+    public ImageBO setWidth(Double width) {
+        this.width = width;
+        return this;
+    }
+
+    public ImageBO setHeight(Double height) {
+        this.height = height;
+        return this;
+    }
+
+    public ImageBO setPictureType(Integer pictureType) {
+        this.pictureType = pictureType;
+        return this;
+    }
+
+    public ImageBO setPictureUrl(String pictureUrl) {
+        this.pictureUrl = pictureUrl;
+        return this;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof ImageBO)) {
+            return false;
+        }
+        ImageBO other = (ImageBO)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        InputStream this$is = this.getIs();
+        InputStream other$is = other.getIs();
+        if (this$is == null ? other$is != null : !this$is.equals(other$is)) {
+            return false;
+        }
+        Double this$width = this.getWidth();
+        Double other$width = other.getWidth();
+        if (this$width == null ? other$width != null : !((Object)this$width).equals(other$width)) {
+            return false;
+        }
+        Double this$height = this.getHeight();
+        Double other$height = other.getHeight();
+        if (this$height == null ? other$height != null : !((Object)this$height).equals(other$height)) {
+            return false;
+        }
+        Integer this$pictureType = this.getPictureType();
+        Integer other$pictureType = other.getPictureType();
+        if (this$pictureType == null ? other$pictureType != null : !((Object)this$pictureType).equals(other$pictureType)) {
+            return false;
+        }
+        String this$pictureUrl = this.getPictureUrl();
+        String other$pictureUrl = other.getPictureUrl();
+        return !(this$pictureUrl == null ? other$pictureUrl != null : !this$pictureUrl.equals(other$pictureUrl));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof ImageBO;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        InputStream $is = this.getIs();
+        result = result * 59 + ($is == null ? 43 : $is.hashCode());
+        Double $width = this.getWidth();
+        result = result * 59 + ($width == null ? 43 : ((Object)$width).hashCode());
+        Double $height = this.getHeight();
+        result = result * 59 + ($height == null ? 43 : ((Object)$height).hashCode());
+        Integer $pictureType = this.getPictureType();
+        result = result * 59 + ($pictureType == null ? 43 : ((Object)$pictureType).hashCode());
+        String $pictureUrl = this.getPictureUrl();
+        result = result * 59 + ($pictureUrl == null ? 43 : $pictureUrl.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "ImageBO(is=" + this.getIs() + ", width=" + this.getWidth() + ", height=" + this.getHeight() + ", pictureType=" + this.getPictureType() + ", pictureUrl=" + this.getPictureUrl() + ")";
+    }
+}
+
diff --git a/java-src/domain/bo/ParseBO.java b/java-src/domain/bo/ParseBO.java
new file mode 100644
index 0000000..0679e54
--- /dev/null
+++ b/java-src/domain/bo/ParseBO.java
@@ -0,0 +1,455 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.fastjson.JSONObject
+ *  org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart
+ */
+package com.jby.officecore.domain.bo;
+
+import com.alibaba.fastjson.JSONObject;
+import com.jby.officecore.domain.bo.ImageBO;
+import com.jby.officecore.utils.NumPr;
+import java.io.Serializable;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.xml.transform.Transformer;
+import org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart;
+
+public class ParseBO
+implements Serializable {
+    private static final long serialVersionUID = -1386361606482288851L;
+    public static final String IMAGES = "images";
+    public static final String PARSE_ = "parse-";
+    public static final String OUTPUT_HTML = "output.html";
+    private static final String JBY_OPEN_OFFICE_XML_ = "JBY_OPEN_OFFICE_XML_";
+    private static final String JBY_IMAGE_DATA_ = "JBY_IMAGE_DATA_";
+    private static final String PLACEHOLDER_SUFFIX = "_END";
+    private static final String IMAGE_ = "image_";
+    private static final String JBY_EQ_LATEX_ = "JBY_EQ_LATEX_";
+    public static final String JBY_TEXTBOX = "JBY_TEXTBOX_JBY";
+    private static final String JBY_MATHTYPE_DATA_ = "JBY_MATHTYPE_DATA_";
+    private Path tempDir;
+    private String sourceFilePath;
+    private String sourceFileUrl;
+    private String sourceFileMd5;
+    private String sourceFileBakPath;
+    private String htmlPath;
+    private String imagesDir;
+    private String ossFolder;
+    private Transformer transformer;
+    private List<JSONObject> latexReplaceList;
+    private Map<String, String> imgMap = new HashMap<String, String>();
+    private Map<String, String> shapeImgMap;
+    private Map<String, String> openOfficeXmlMap = new HashMap<String, String>();
+    private Map<String, String> mathTypeMap = new HashMap<String, String>();
+    private Map<String, String> eqLatexMap = new HashMap<String, String>();
+    private StyleDefinitionsPart styleDefinitionsPart;
+    private Map<String, NumPr> numberingDefinitionsMap = new HashMap<String, NumPr>();
+    private Map<String, ImageBO> imageMap;
+    private Boolean newParseVersion;
+    private Integer count = 0;
+    private Long fileId;
+
+    public ParseBO() {
+        this.shapeImgMap = new HashMap<String, String>();
+        this.imageMap = new HashMap<String, ImageBO>();
+    }
+
+    private Integer incrCount() {
+        this.count = this.count + 1;
+        return this.count;
+    }
+
+    public String getOpenOfficeXmlPlaceholder() {
+        return JBY_OPEN_OFFICE_XML_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getMathTypePlaceholder() {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getMathTypePlaceholder(String ctOleObjectRid) {
+        return JBY_MATHTYPE_DATA_ + ctOleObjectRid + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getImgName() {
+        return IMAGE_ + this.incrCount();
+    }
+
+    public String getEqLatexPlaceholder() {
+        return JBY_EQ_LATEX_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getShapeImgPlaceholder() {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getImagePlaceholder(String rid) {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public Path getTempDir() {
+        return this.tempDir;
+    }
+
+    public String getSourceFilePath() {
+        return this.sourceFilePath;
+    }
+
+    public String getSourceFileUrl() {
+        return this.sourceFileUrl;
+    }
+
+    public String getSourceFileMd5() {
+        return this.sourceFileMd5;
+    }
+
+    public String getSourceFileBakPath() {
+        return this.sourceFileBakPath;
+    }
+
+    public String getHtmlPath() {
+        return this.htmlPath;
+    }
+
+    public String getImagesDir() {
+        return this.imagesDir;
+    }
+
+    public String getOssFolder() {
+        return this.ossFolder;
+    }
+
+    public Transformer getTransformer() {
+        return this.transformer;
+    }
+
+    public List<JSONObject> getLatexReplaceList() {
+        return this.latexReplaceList;
+    }
+
+    public Map<String, String> getImgMap() {
+        return this.imgMap;
+    }
+
+    public Map<String, String> getShapeImgMap() {
+        return this.shapeImgMap;
+    }
+
+    public Map<String, String> getOpenOfficeXmlMap() {
+        return this.openOfficeXmlMap;
+    }
+
+    public Map<String, String> getMathTypeMap() {
+        return this.mathTypeMap;
+    }
+
+    public Map<String, String> getEqLatexMap() {
+        return this.eqLatexMap;
+    }
+
+    public StyleDefinitionsPart getStyleDefinitionsPart() {
+        return this.styleDefinitionsPart;
+    }
+
+    public Map<String, NumPr> getNumberingDefinitionsMap() {
+        return this.numberingDefinitionsMap;
+    }
+
+    public Map<String, ImageBO> getImageMap() {
+        return this.imageMap;
+    }
+
+    public Boolean getNewParseVersion() {
+        return this.newParseVersion;
+    }
+
+    public Integer getCount() {
+        return this.count;
+    }
+
+    public Long getFileId() {
+        return this.fileId;
+    }
+
+    public ParseBO setTempDir(Path tempDir) {
+        this.tempDir = tempDir;
+        return this;
+    }
+
+    public ParseBO setSourceFilePath(String sourceFilePath) {
+        this.sourceFilePath = sourceFilePath;
+        return this;
+    }
+
+    public ParseBO setSourceFileUrl(String sourceFileUrl) {
+        this.sourceFileUrl = sourceFileUrl;
+        return this;
+    }
+
+    public ParseBO setSourceFileMd5(String sourceFileMd5) {
+        this.sourceFileMd5 = sourceFileMd5;
+        return this;
+    }
+
+    public ParseBO setSourceFileBakPath(String sourceFileBakPath) {
+        this.sourceFileBakPath = sourceFileBakPath;
+        return this;
+    }
+
+    public ParseBO setHtmlPath(String htmlPath) {
+        this.htmlPath = htmlPath;
+        return this;
+    }
+
+    public ParseBO setImagesDir(String imagesDir) {
+        this.imagesDir = imagesDir;
+        return this;
+    }
+
+    public ParseBO setOssFolder(String ossFolder) {
+        this.ossFolder = ossFolder;
+        return this;
+    }
+
+    public ParseBO setTransformer(Transformer transformer) {
+        this.transformer = transformer;
+        return this;
+    }
+
+    public ParseBO setLatexReplaceList(List<JSONObject> latexReplaceList) {
+        this.latexReplaceList = latexReplaceList;
+        return this;
+    }
+
+    public ParseBO setImgMap(Map<String, String> imgMap) {
+        this.imgMap = imgMap;
+        return this;
+    }
+
+    public ParseBO setShapeImgMap(Map<String, String> shapeImgMap) {
+        this.shapeImgMap = shapeImgMap;
+        return this;
+    }
+
+    public ParseBO setOpenOfficeXmlMap(Map<String, String> openOfficeXmlMap) {
+        this.openOfficeXmlMap = openOfficeXmlMap;
+        return this;
+    }
+
+    public ParseBO setMathTypeMap(Map<String, String> mathTypeMap) {
+        this.mathTypeMap = mathTypeMap;
+        return this;
+    }
+
+    public ParseBO setEqLatexMap(Map<String, String> eqLatexMap) {
+        this.eqLatexMap = eqLatexMap;
+        return this;
+    }
+
+    public ParseBO setStyleDefinitionsPart(StyleDefinitionsPart styleDefinitionsPart) {
+        this.styleDefinitionsPart = styleDefinitionsPart;
+        return this;
+    }
+
+    public ParseBO setNumberingDefinitionsMap(Map<String, NumPr> numberingDefinitionsMap) {
+        this.numberingDefinitionsMap = numberingDefinitionsMap;
+        return this;
+    }
+
+    public ParseBO setImageMap(Map<String, ImageBO> imageMap) {
+        this.imageMap = imageMap;
+        return this;
+    }
+
+    public ParseBO setNewParseVersion(Boolean newParseVersion) {
+        this.newParseVersion = newParseVersion;
+        return this;
+    }
+
+    public ParseBO setCount(Integer count) {
+        this.count = count;
+        return this;
+    }
+
+    public ParseBO setFileId(Long fileId) {
+        this.fileId = fileId;
+        return this;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof ParseBO)) {
+            return false;
+        }
+        ParseBO other = (ParseBO)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        Path this$tempDir = this.getTempDir();
+        Path other$tempDir = other.getTempDir();
+        if (this$tempDir == null ? other$tempDir != null : !((Object)this$tempDir).equals(other$tempDir)) {
+            return false;
+        }
+        String this$sourceFilePath = this.getSourceFilePath();
+        String other$sourceFilePath = other.getSourceFilePath();
+        if (this$sourceFilePath == null ? other$sourceFilePath != null : !this$sourceFilePath.equals(other$sourceFilePath)) {
+            return false;
+        }
+        String this$sourceFileUrl = this.getSourceFileUrl();
+        String other$sourceFileUrl = other.getSourceFileUrl();
+        if (this$sourceFileUrl == null ? other$sourceFileUrl != null : !this$sourceFileUrl.equals(other$sourceFileUrl)) {
+            return false;
+        }
+        String this$sourceFileMd5 = this.getSourceFileMd5();
+        String other$sourceFileMd5 = other.getSourceFileMd5();
+        if (this$sourceFileMd5 == null ? other$sourceFileMd5 != null : !this$sourceFileMd5.equals(other$sourceFileMd5)) {
+            return false;
+        }
+        String this$sourceFileBakPath = this.getSourceFileBakPath();
+        String other$sourceFileBakPath = other.getSourceFileBakPath();
+        if (this$sourceFileBakPath == null ? other$sourceFileBakPath != null : !this$sourceFileBakPath.equals(other$sourceFileBakPath)) {
+            return false;
+        }
+        String this$htmlPath = this.getHtmlPath();
+        String other$htmlPath = other.getHtmlPath();
+        if (this$htmlPath == null ? other$htmlPath != null : !this$htmlPath.equals(other$htmlPath)) {
+            return false;
+        }
+        String this$imagesDir = this.getImagesDir();
+        String other$imagesDir = other.getImagesDir();
+        if (this$imagesDir == null ? other$imagesDir != null : !this$imagesDir.equals(other$imagesDir)) {
+            return false;
+        }
+        String this$ossFolder = this.getOssFolder();
+        String other$ossFolder = other.getOssFolder();
+        if (this$ossFolder == null ? other$ossFolder != null : !this$ossFolder.equals(other$ossFolder)) {
+            return false;
+        }
+        Transformer this$transformer = this.getTransformer();
+        Transformer other$transformer = other.getTransformer();
+        if (this$transformer == null ? other$transformer != null : !this$transformer.equals(other$transformer)) {
+            return false;
+        }
+        List<JSONObject> this$latexReplaceList = this.getLatexReplaceList();
+        List<JSONObject> other$latexReplaceList = other.getLatexReplaceList();
+        if (this$latexReplaceList == null ? other$latexReplaceList != null : !((Object)this$latexReplaceList).equals(other$latexReplaceList)) {
+            return false;
+        }
+        Map<String, String> this$imgMap = this.getImgMap();
+        Map<String, String> other$imgMap = other.getImgMap();
+        if (this$imgMap == null ? other$imgMap != null : !((Object)this$imgMap).equals(other$imgMap)) {
+            return false;
+        }
+        Map<String, String> this$shapeImgMap = this.getShapeImgMap();
+        Map<String, String> other$shapeImgMap = other.getShapeImgMap();
+        if (this$shapeImgMap == null ? other$shapeImgMap != null : !((Object)this$shapeImgMap).equals(other$shapeImgMap)) {
+            return false;
+        }
+        Map<String, String> this$openOfficeXmlMap = this.getOpenOfficeXmlMap();
+        Map<String, String> other$openOfficeXmlMap = other.getOpenOfficeXmlMap();
+        if (this$openOfficeXmlMap == null ? other$openOfficeXmlMap != null : !((Object)this$openOfficeXmlMap).equals(other$openOfficeXmlMap)) {
+            return false;
+        }
+        Map<String, String> this$mathTypeMap = this.getMathTypeMap();
+        Map<String, String> other$mathTypeMap = other.getMathTypeMap();
+        if (this$mathTypeMap == null ? other$mathTypeMap != null : !((Object)this$mathTypeMap).equals(other$mathTypeMap)) {
+            return false;
+        }
+        Map<String, String> this$eqLatexMap = this.getEqLatexMap();
+        Map<String, String> other$eqLatexMap = other.getEqLatexMap();
+        if (this$eqLatexMap == null ? other$eqLatexMap != null : !((Object)this$eqLatexMap).equals(other$eqLatexMap)) {
+            return false;
+        }
+        StyleDefinitionsPart this$styleDefinitionsPart = this.getStyleDefinitionsPart();
+        StyleDefinitionsPart other$styleDefinitionsPart = other.getStyleDefinitionsPart();
+        if (this$styleDefinitionsPart == null ? other$styleDefinitionsPart != null : !this$styleDefinitionsPart.equals(other$styleDefinitionsPart)) {
+            return false;
+        }
+        Map<String, NumPr> this$numberingDefinitionsMap = this.getNumberingDefinitionsMap();
+        Map<String, NumPr> other$numberingDefinitionsMap = other.getNumberingDefinitionsMap();
+        if (this$numberingDefinitionsMap == null ? other$numberingDefinitionsMap != null : !((Object)this$numberingDefinitionsMap).equals(other$numberingDefinitionsMap)) {
+            return false;
+        }
+        Map<String, ImageBO> this$imageMap = this.getImageMap();
+        Map<String, ImageBO> other$imageMap = other.getImageMap();
+        if (this$imageMap == null ? other$imageMap != null : !((Object)this$imageMap).equals(other$imageMap)) {
+            return false;
+        }
+        Boolean this$newParseVersion = this.getNewParseVersion();
+        Boolean other$newParseVersion = other.getNewParseVersion();
+        if (this$newParseVersion == null ? other$newParseVersion != null : !((Object)this$newParseVersion).equals(other$newParseVersion)) {
+            return false;
+        }
+        Integer this$count = this.getCount();
+        Integer other$count = other.getCount();
+        if (this$count == null ? other$count != null : !((Object)this$count).equals(other$count)) {
+            return false;
+        }
+        Long this$fileId = this.getFileId();
+        Long other$fileId = other.getFileId();
+        return !(this$fileId == null ? other$fileId != null : !((Object)this$fileId).equals(other$fileId));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof ParseBO;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        Path $tempDir = this.getTempDir();
+        result = result * 59 + ($tempDir == null ? 43 : ((Object)$tempDir).hashCode());
+        String $sourceFilePath = this.getSourceFilePath();
+        result = result * 59 + ($sourceFilePath == null ? 43 : $sourceFilePath.hashCode());
+        String $sourceFileUrl = this.getSourceFileUrl();
+        result = result * 59 + ($sourceFileUrl == null ? 43 : $sourceFileUrl.hashCode());
+        String $sourceFileMd5 = this.getSourceFileMd5();
+        result = result * 59 + ($sourceFileMd5 == null ? 43 : $sourceFileMd5.hashCode());
+        String $sourceFileBakPath = this.getSourceFileBakPath();
+        result = result * 59 + ($sourceFileBakPath == null ? 43 : $sourceFileBakPath.hashCode());
+        String $htmlPath = this.getHtmlPath();
+        result = result * 59 + ($htmlPath == null ? 43 : $htmlPath.hashCode());
+        String $imagesDir = this.getImagesDir();
+        result = result * 59 + ($imagesDir == null ? 43 : $imagesDir.hashCode());
+        String $ossFolder = this.getOssFolder();
+        result = result * 59 + ($ossFolder == null ? 43 : $ossFolder.hashCode());
+        Transformer $transformer = this.getTransformer();
+        result = result * 59 + ($transformer == null ? 43 : $transformer.hashCode());
+        List<JSONObject> $latexReplaceList = this.getLatexReplaceList();
+        result = result * 59 + ($latexReplaceList == null ? 43 : ((Object)$latexReplaceList).hashCode());
+        Map<String, String> $imgMap = this.getImgMap();
+        result = result * 59 + ($imgMap == null ? 43 : ((Object)$imgMap).hashCode());
+        Map<String, String> $shapeImgMap = this.getShapeImgMap();
+        result = result * 59 + ($shapeImgMap == null ? 43 : ((Object)$shapeImgMap).hashCode());
+        Map<String, String> $openOfficeXmlMap = this.getOpenOfficeXmlMap();
+        result = result * 59 + ($openOfficeXmlMap == null ? 43 : ((Object)$openOfficeXmlMap).hashCode());
+        Map<String, String> $mathTypeMap = this.getMathTypeMap();
+        result = result * 59 + ($mathTypeMap == null ? 43 : ((Object)$mathTypeMap).hashCode());
+        Map<String, String> $eqLatexMap = this.getEqLatexMap();
+        result = result * 59 + ($eqLatexMap == null ? 43 : ((Object)$eqLatexMap).hashCode());
+        StyleDefinitionsPart $styleDefinitionsPart = this.getStyleDefinitionsPart();
+        result = result * 59 + ($styleDefinitionsPart == null ? 43 : $styleDefinitionsPart.hashCode());
+        Map<String, NumPr> $numberingDefinitionsMap = this.getNumberingDefinitionsMap();
+        result = result * 59 + ($numberingDefinitionsMap == null ? 43 : ((Object)$numberingDefinitionsMap).hashCode());
+        Map<String, ImageBO> $imageMap = this.getImageMap();
+        result = result * 59 + ($imageMap == null ? 43 : ((Object)$imageMap).hashCode());
+        Boolean $newParseVersion = this.getNewParseVersion();
+        result = result * 59 + ($newParseVersion == null ? 43 : ((Object)$newParseVersion).hashCode());
+        Integer $count = this.getCount();
+        result = result * 59 + ($count == null ? 43 : ((Object)$count).hashCode());
+        Long $fileId = this.getFileId();
+        result = result * 59 + ($fileId == null ? 43 : ((Object)$fileId).hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "ParseBO(tempDir=" + this.getTempDir() + ", sourceFilePath=" + this.getSourceFilePath() + ", sourceFileUrl=" + this.getSourceFileUrl() + ", sourceFileMd5=" + this.getSourceFileMd5() + ", sourceFileBakPath=" + this.getSourceFileBakPath() + ", htmlPath=" + this.getHtmlPath() + ", imagesDir=" + this.getImagesDir() + ", ossFolder=" + this.getOssFolder() + ", transformer=" + this.getTransformer() + ", latexReplaceList=" + this.getLatexReplaceList() + ", imgMap=" + this.getImgMap() + ", shapeImgMap=" + this.getShapeImgMap() + ", openOfficeXmlMap=" + this.getOpenOfficeXmlMap() + ", mathTypeMap=" + this.getMathTypeMap() + ", eqLatexMap=" + this.getEqLatexMap() + ", styleDefinitionsPart=" + this.getStyleDefinitionsPart() + ", numberingDefinitionsMap=" + this.getNumberingDefinitionsMap() + ", imageMap=" + this.getImageMap() + ", newParseVersion=" + this.getNewParseVersion() + ", count=" + this.getCount() + ", fileId=" + this.getFileId() + ")";
+    }
+}
+
diff --git a/java-src/domain/bo/TagStyleBO.java b/java-src/domain/bo/TagStyleBO.java
new file mode 100644
index 0000000..e02f95c
--- /dev/null
+++ b/java-src/domain/bo/TagStyleBO.java
@@ -0,0 +1,42 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.jby.officecore.domain.bo;
+
+import java.io.Serializable;
+
+public class TagStyleBO
+implements Serializable {
+    private static final long serialVersionUID = -5541312317983576319L;
+    private String tagName;
+    private String attr;
+    private String value;
+
+    public String getTagName() {
+        return this.tagName;
+    }
+
+    public String getAttr() {
+        return this.attr;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    public TagStyleBO setTagName(String tagName) {
+        this.tagName = tagName;
+        return this;
+    }
+
+    public TagStyleBO setAttr(String attr) {
+        this.attr = attr;
+        return this;
+    }
+
+    public TagStyleBO setValue(String value) {
+        this.value = value;
+        return this;
+    }
+}
+
diff --git a/java-src/domain/param/ParseParam.java b/java-src/domain/param/ParseParam.java
new file mode 100644
index 0000000..5815f4c
--- /dev/null
+++ b/java-src/domain/param/ParseParam.java
@@ -0,0 +1,132 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.fastjson.JSONObject
+ *  com.alibaba.fastjson.annotation.JSONField
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.jby.officecore.domain.param;
+
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.annotation.JSONField;
+import java.io.Serializable;
+import java.util.List;
+import org.springframework.web.multipart.MultipartFile;
+
+public class ParseParam
+implements Serializable {
+    private static final long serialVersionUID = 4113866861283462539L;
+    private String sourceUrl;
+    @JSONField(serialize=false)
+    private MultipartFile sourceFile;
+    private List<JSONObject> latexReplaceList;
+    private Boolean newParseVersion;
+    private Long fileId;
+
+    public String getSourceUrl() {
+        return this.sourceUrl;
+    }
+
+    public MultipartFile getSourceFile() {
+        return this.sourceFile;
+    }
+
+    public List<JSONObject> getLatexReplaceList() {
+        return this.latexReplaceList;
+    }
+
+    public Boolean getNewParseVersion() {
+        return this.newParseVersion;
+    }
+
+    public Long getFileId() {
+        return this.fileId;
+    }
+
+    public ParseParam setSourceUrl(String sourceUrl) {
+        this.sourceUrl = sourceUrl;
+        return this;
+    }
+
+    public ParseParam setSourceFile(MultipartFile sourceFile) {
+        this.sourceFile = sourceFile;
+        return this;
+    }
+
+    public ParseParam setLatexReplaceList(List<JSONObject> latexReplaceList) {
+        this.latexReplaceList = latexReplaceList;
+        return this;
+    }
+
+    public ParseParam setNewParseVersion(Boolean newParseVersion) {
+        this.newParseVersion = newParseVersion;
+        return this;
+    }
+
+    public ParseParam setFileId(Long fileId) {
+        this.fileId = fileId;
+        return this;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof ParseParam)) {
+            return false;
+        }
+        ParseParam other = (ParseParam)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        String this$sourceUrl = this.getSourceUrl();
+        String other$sourceUrl = other.getSourceUrl();
+        if (this$sourceUrl == null ? other$sourceUrl != null : !this$sourceUrl.equals(other$sourceUrl)) {
+            return false;
+        }
+        MultipartFile this$sourceFile = this.getSourceFile();
+        MultipartFile other$sourceFile = other.getSourceFile();
+        if (this$sourceFile == null ? other$sourceFile != null : !this$sourceFile.equals(other$sourceFile)) {
+            return false;
+        }
+        List<JSONObject> this$latexReplaceList = this.getLatexReplaceList();
+        List<JSONObject> other$latexReplaceList = other.getLatexReplaceList();
+        if (this$latexReplaceList == null ? other$latexReplaceList != null : !((Object)this$latexReplaceList).equals(other$latexReplaceList)) {
+            return false;
+        }
+        Boolean this$newParseVersion = this.getNewParseVersion();
+        Boolean other$newParseVersion = other.getNewParseVersion();
+        if (this$newParseVersion == null ? other$newParseVersion != null : !((Object)this$newParseVersion).equals(other$newParseVersion)) {
+            return false;
+        }
+        Long this$fileId = this.getFileId();
+        Long other$fileId = other.getFileId();
+        return !(this$fileId == null ? other$fileId != null : !((Object)this$fileId).equals(other$fileId));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof ParseParam;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        String $sourceUrl = this.getSourceUrl();
+        result = result * 59 + ($sourceUrl == null ? 43 : $sourceUrl.hashCode());
+        MultipartFile $sourceFile = this.getSourceFile();
+        result = result * 59 + ($sourceFile == null ? 43 : $sourceFile.hashCode());
+        List<JSONObject> $latexReplaceList = this.getLatexReplaceList();
+        result = result * 59 + ($latexReplaceList == null ? 43 : ((Object)$latexReplaceList).hashCode());
+        Boolean $newParseVersion = this.getNewParseVersion();
+        result = result * 59 + ($newParseVersion == null ? 43 : ((Object)$newParseVersion).hashCode());
+        Long $fileId = this.getFileId();
+        result = result * 59 + ($fileId == null ? 43 : ((Object)$fileId).hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "ParseParam(sourceUrl=" + this.getSourceUrl() + ", sourceFile=" + this.getSourceFile() + ", latexReplaceList=" + this.getLatexReplaceList() + ", newParseVersion=" + this.getNewParseVersion() + ", fileId=" + this.getFileId() + ")";
+    }
+}
+
diff --git a/java-src/enums/AttrEnum.java b/java-src/enums/AttrEnum.java
new file mode 100644
index 0000000..182c34e
--- /dev/null
+++ b/java-src/enums/AttrEnum.java
@@ -0,0 +1,79 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.jby.officecore.enums;
+
+public enum AttrEnum {
+    STYLE("style"),
+    COLOR("color"),
+    BACKGROUND_COLOR("background-color"),
+    BACKGROUND("background"),
+    FONT_WEIGHT("font-weight"),
+    FONT_SIZE("font-size"),
+    MIN_HEIGHT("min-height"),
+    LINE_HEIGHT("line-height"),
+    TEXT_ALIGN("text-align"),
+    PADDING("padding"),
+    PADDING_TOP("padding-top"),
+    PADDING_RIGHT("padding-right"),
+    PADDING_BOTTOM("padding-bottom"),
+    PADDING_LEFT("padding-left"),
+    TEXT_INDENT("text-indent"),
+    MARGIN("margin"),
+    MARGIN_TOP("margin-top"),
+    MARGIN_RIGHT("margin-right"),
+    MARGIN_BOTTOM("margin-bottom"),
+    MARGIN_LEFT("margin-left"),
+    VERTICAL_ALIGN("vertical-align"),
+    FONT_FAMILY("font-family"),
+    FONT_STYLE("font-style"),
+    FACE("face"),
+    SIZE("size"),
+    HREF("href"),
+    SRC("src"),
+    WIDTH("width"),
+    HEIGHT("height"),
+    CLASS("class"),
+    BORDER_STYLE("border-style"),
+    COLSPAN("colspan"),
+    ROWSPAN("rowspan"),
+    TEXT_DECORATION("text-decoration"),
+    BACKGROUND_IMAGE("background-image"),
+    TINYMCE_HORIZONTAL_LINE("tinymce-horizontal-line"),
+    TINYMCE_LINE_NUMBER("tinymce-line-number"),
+    TEXT_EMPHASIS_POSITION("text-emphasis-position"),
+    DATA_TYPE("data-type"),
+    SEGMENT("segment"),
+    BUSINESS("business"),
+    LIST_STYLE_TYPE("list-style-type"),
+    ALT("alt"),
+    NAME("name"),
+    DATA_HREF("data-href"),
+    DATA_File_SUFFIX("data-file-suffix"),
+    TINYMCE_LINK("tinymce-link"),
+    DATA_RESOURCE_URL("data-resource-url"),
+    DATA_COURSE_NETWORK_LESSON_RESOURCE_NAME("data-course-network-lesson-resource-name"),
+    TINYMCE_HOLLOWOUT("tinymce-hollowOut"),
+    TINYMCE_HIDDENONLY("tinymce-hiddenOnly"),
+    TINYMCE_HIDDENANDANSWER("tinymce-hiddenAndAnswer"),
+    BORDER("border"),
+    BORDER_LEFT("border-left"),
+    BORDER_BOTTOM("border-bottom"),
+    BORDER_RIGHT("border-right"),
+    BORDER_TOP("border-top"),
+    BORDER_LEFT_COLOR("border-left-color"),
+    BORDER_BOTTOM_COLOR("border-bottom-color"),
+    BORDER_RIGHT_COLOR("border-right-color"),
+    BORDER_TOP_COLOR("border-top-color");
+
+    private final String attr;
+
+    public String getAttr() {
+        return this.attr;
+    }
+
+    private AttrEnum(String attr) {
+        this.attr = attr;
+    }
+}
+
diff --git a/java-src/enums/TagEnum.java b/java-src/enums/TagEnum.java
new file mode 100644
index 0000000..2d0befa
--- /dev/null
+++ b/java-src/enums/TagEnum.java
@@ -0,0 +1,140 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.jby.common.util.DistinctUtils
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.jsoup.nodes.Element
+ */
+package com.jby.officecore.enums;
+
+import com.jby.common.util.DistinctUtils;
+import com.jby.officecore.domain.bo.TagStyleBO;
+import com.jby.officecore.enums.AttrEnum;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.jsoup.nodes.Element;
+
+public enum TagEnum {
+    H1("h1", true, null),
+    H2("h2", true, null),
+    H3("h3", true, null),
+    H4("h4", true, null),
+    P("p", false, null),
+    DIV("div", false, null),
+    FONT("font", false, Stream.of(AttrEnum.FACE, AttrEnum.SIZE, AttrEnum.COLOR).collect(Collectors.toList())),
+    STRIKE("strike", true, null),
+    BR("br", false, null),
+    PBR("pbr", false, null),
+    HR("hr", false, null),
+    U("u", true, null),
+    I("i", true, null),
+    SUB("sub", true, null),
+    SUP("sup", true, null),
+    WAVE("wave", true, null),
+    DOT("dot", true, null),
+    B("b", true, null),
+    A("a", false, Stream.of(AttrEnum.HREF).collect(Collectors.toList())),
+    TABLE("table", false, null),
+    UL("ul", false, null),
+    OL("ol", false, null),
+    LI("li", false, null),
+    IMG("img", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    IMQ("imq", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    VIDEO("video", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    SOURCE("source", false, null),
+    MATH("math", false, null),
+    TAB("tab", false, null),
+    TEXT("#text", false, null),
+    SPAN("span", false, Stream.of(AttrEnum.CLASS).collect(Collectors.toList())),
+    EM("em", true, null),
+    STRONG("strong", true, null);
+
+    private final String name;
+    private final Boolean dealTagStyle;
+    private final List<AttrEnum> attrList;
+    public static final Set<String> H_P_SET;
+    public static final Set<String> H_SET;
+    public static final Set<String> UL_OL_SET;
+    private static final Map<String, TagEnum> MAP;
+
+    public static TagEnum getTagEnum(String tagName) {
+        return MAP.get(tagName);
+    }
+
+    public static List<TagStyleBO> getStyleList(Element element) {
+        ArrayList<TagStyleBO> styleList = new ArrayList<TagStyleBO>();
+        TagEnum tagEnum = TagEnum.getTagEnum(element.tagName());
+        if (Objects.nonNull((Object)tagEnum) && Boolean.TRUE.equals(tagEnum.dealTagStyle)) {
+            styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(tagEnum.getName()).setValue(tagEnum.getName()));
+        }
+        if (Objects.nonNull((Object)tagEnum) && CollectionUtils.isNotEmpty(tagEnum.getAttrList())) {
+            for (AttrEnum attrEnum : tagEnum.getAttrList()) {
+                if (!StringUtils.isNotBlank((CharSequence)element.attr(attrEnum.getAttr())) || "null".equals(element.attr(attrEnum.getAttr()))) continue;
+                styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(attrEnum.getAttr()).setValue(element.attr(attrEnum.getAttr())));
+            }
+        }
+        List<String> styles = StringUtils.isBlank((CharSequence)element.attr(AttrEnum.STYLE.getAttr())) ? Collections.emptyList() : Arrays.asList(element.attr(AttrEnum.STYLE.getAttr()).split(";"));
+        styles.forEach(style -> {
+            if (StringUtils.isBlank((CharSequence)style)) {
+                return;
+            }
+            String[] split = style.split(":");
+            if (split.length < 2) {
+                return;
+            }
+            String attr = split[0].trim();
+            String value = split[1].trim();
+            if (StringUtils.isBlank((CharSequence)value) || "null".equals(value) || StringUtils.isBlank((CharSequence)attr) || "null".equals(attr)) {
+                return;
+            }
+            styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(attr).setValue(value));
+        });
+        return styleList.stream().filter(DistinctUtils.distinctByKey(TagStyleBO::getAttr)).filter(e -> !e.getValue().contains("auto")).collect(Collectors.toList());
+    }
+
+    public static Map<String, String> getStyleMap(Element element) {
+        List<TagStyleBO> styleList = TagEnum.getStyleList(element);
+        return styleList.stream().collect(Collectors.toMap(TagStyleBO::getAttr, TagStyleBO::getValue, (l, r) -> l));
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public Boolean getDealTagStyle() {
+        return this.dealTagStyle;
+    }
+
+    public List<AttrEnum> getAttrList() {
+        return this.attrList;
+    }
+
+    private TagEnum(String name, Boolean dealTagStyle, List<AttrEnum> attrList) {
+        this.name = name;
+        this.dealTagStyle = dealTagStyle;
+        this.attrList = attrList;
+    }
+
+    static {
+        H_P_SET = Stream.of(H1.getName(), H2.getName(), H3.getName(), H4.getName(), P.getName()).collect(Collectors.toSet());
+        H_SET = Stream.of(H1.getName(), H2.getName(), H3.getName(), H4.getName()).collect(Collectors.toSet());
+        UL_OL_SET = Stream.of(UL.getName(), OL.getName()).collect(Collectors.toSet());
+        MAP = new HashMap<String, TagEnum>();
+        for (TagEnum tagEnum : TagEnum.values()) {
+            MAP.put(tagEnum.getName(), tagEnum);
+        }
+    }
+}
+
diff --git a/java-src/pool/OMml2MmlTransformerPool.java b/java-src/pool/OMml2MmlTransformerPool.java
new file mode 100644
index 0000000..4d54bb0
--- /dev/null
+++ b/java-src/pool/OMml2MmlTransformerPool.java
@@ -0,0 +1,110 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.jby.common.exceptions.BusinessException
+ *  org.apache.commons.pool2.BasePooledObjectFactory
+ *  org.apache.commons.pool2.PooledObject
+ *  org.apache.commons.pool2.PooledObjectFactory
+ *  org.apache.commons.pool2.impl.DefaultPooledObject
+ *  org.apache.commons.pool2.impl.GenericObjectPool
+ *  org.apache.commons.pool2.impl.GenericObjectPoolConfig
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.core.io.ClassPathResource
+ */
+package com.jby.officecore.pool;
+
+import com.jby.common.exceptions.BusinessException;
+import java.util.Objects;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamSource;
+import org.apache.commons.pool2.BasePooledObjectFactory;
+import org.apache.commons.pool2.PooledObject;
+import org.apache.commons.pool2.PooledObjectFactory;
+import org.apache.commons.pool2.impl.DefaultPooledObject;
+import org.apache.commons.pool2.impl.GenericObjectPool;
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ClassPathResource;
+
+public enum OMml2MmlTransformerPool {
+    INSTANCE;
+
+    private static final Logger log;
+    private GenericObjectPool<Transformer> objectPool;
+
+    private OMml2MmlTransformerPool() {
+        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+        poolConfig.setMaxTotal(30);
+        poolConfig.setMinIdle(4);
+        poolConfig.setMaxIdle(8);
+        poolConfig.setBlockWhenExhausted(true);
+        poolConfig.setMaxWaitMillis(3000L);
+        poolConfig.setTestOnCreate(true);
+        poolConfig.setTestOnBorrow(true);
+        poolConfig.setTestOnReturn(true);
+        poolConfig.setTestWhileIdle(true);
+        PooledTransformerFactory objectFactory = new PooledTransformerFactory();
+        this.objectPool = new GenericObjectPool((PooledObjectFactory)objectFactory, poolConfig);
+    }
+
+    public Transformer borrowObject() {
+        log.info("\u8f6c\u6362\u5668\u6c60TransformerPool, \u7a7a\u95f2\u5bf9\u8c61\u6570\u91cf:{}, \u6d3b\u8dc3\u5bf9\u8c61\u6570\u91cf:{}, \u963b\u585e\u7b49\u5f85\u6570\u91cf:{},", new Object[]{this.objectPool.getNumIdle(), this.objectPool.getNumActive(), this.objectPool.getNumWaiters()});
+        try {
+            return (Transformer)this.objectPool.borrowObject();
+        }
+        catch (Exception e) {
+            log.error("\u4ece\u5bf9\u8c61\u6c60\u4e2d\u501f\u51fa\u5bf9\u8c61\u5f02\u5e38", (Throwable)e);
+            return null;
+        }
+    }
+
+    public void returnObject(Transformer transformer) {
+        log.info("\u8f6c\u6362\u5668\u6c60TransformerPool, \u7a7a\u95f2\u5bf9\u8c61\u6570\u91cf:{}, \u6d3b\u8dc3\u5bf9\u8c61\u6570\u91cf:{}, \u963b\u585e\u7b49\u5f85\u6570\u91cf:{},", new Object[]{this.objectPool.getNumIdle(), this.objectPool.getNumActive(), this.objectPool.getNumWaiters()});
+        if (Objects.nonNull(transformer)) {
+            this.objectPool.returnObject((Object)transformer);
+        }
+    }
+
+    static {
+        log = LoggerFactory.getLogger(OMml2MmlTransformerPool.class);
+    }
+
+    public static class PooledTransformerFactory
+    extends BasePooledObjectFactory<Transformer> {
+        private static final Logger log = LoggerFactory.getLogger(PooledTransformerFactory.class);
+        private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
+
+        public Transformer create() throws Exception {
+            return PooledTransformerFactory.buildTransformer();
+        }
+
+        public PooledObject<Transformer> wrap(Transformer transformer) {
+            return new DefaultPooledObject((Object)transformer);
+        }
+
+        public void destroyObject(PooledObject<Transformer> p) throws Exception {
+            super.destroyObject(p);
+        }
+
+        public boolean validateObject(PooledObject<Transformer> p) {
+            return Objects.nonNull(p.getObject());
+        }
+
+        private static Transformer buildTransformer() {
+            try {
+                ClassPathResource resource = new ClassPathResource("xsl/OMML2MML.XSL");
+                StreamSource xslSource = new StreamSource(resource.getInputStream());
+                return TRANSFORMER_FACTORY.newTransformer(xslSource);
+            }
+            catch (Exception e) {
+                log.error("\u751f\u6210\u8f6c\u6362\u5668\u5f02\u5e38", (Throwable)e);
+                throw new BusinessException("\u751f\u6210\u8f6c\u6362\u5668\u5f02\u5e38");
+            }
+        }
+    }
+}
+
diff --git a/java-src/service/impl/FileServiceImpl.java b/java-src/service/impl/FileServiceImpl.java
new file mode 100644
index 0000000..2be3d26
--- /dev/null
+++ b/java-src/service/impl/FileServiceImpl.java
@@ -0,0 +1,2255 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.hutool.core.io.FileUtil
+ *  com.alibaba.fastjson.JSON
+ *  com.alibaba.fastjson.JSONObject
+ *  com.baomidou.mybatisplus.core.conditions.Wrapper
+ *  com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
+ *  com.baomidou.mybatisplus.core.toolkit.Wrappers
+ *  com.jby.common.base.entity.CommonBean
+ *  com.jby.common.bo.SessionUser
+ *  com.jby.common.exceptions.BizAssert
+ *  com.jby.common.exceptions.BusinessException
+ *  com.jby.common.feign.FeignUtils
+ *  com.jby.common.result.Result
+ *  com.jby.common.util.FileUtil
+ *  com.jby.common.util.RequestUtil
+ *  com.jby.common.util.SpringContextHolder
+ *  com.jby.common.util.UniqueUtil
+ *  com.jby.office.constant.ConfigConstants$FileConfig
+ *  com.jby.office.constant.Constants
+ *  com.jby.office.domain.dto.QuestionSourceFeatureMetadataDTO
+ *  com.jby.office.domain.param.DownloadFileParam
+ *  com.jby.office.domain.param.FileParam
+ *  com.jby.office.domain.param.GenerateFileParam
+ *  com.jby.office.domain.param.GlobalConfigParam
+ *  com.jby.office.domain.param.OfficeFileParseParam
+ *  com.jby.office.domain.param.OfficeFileParseRecordParam
+ *  com.jby.office.domain.param.QueryFileParam
+ *  com.jby.office.domain.param.UpdateFileParam
+ *  com.jby.office.domain.vo.ExportQuestionVO
+ *  com.jby.office.domain.vo.OfficeConfigVO
+ *  com.jby.office.domain.vo.OfficeFileConfigVO
+ *  com.jby.office.domain.vo.OfficeFileDownloadScheduleVO
+ *  com.jby.office.domain.vo.OfficeFileElementVO
+ *  com.jby.office.domain.vo.OfficeFileInfoVO
+ *  com.jby.office.domain.vo.OfficeFileParseRecordVO
+ *  com.jby.office.domain.vo.OfficeFileParseVO
+ *  com.jby.office.domain.vo.OfficeFileStyleVO
+ *  com.jby.office.domain.vo.OfficeGlobalConfigVO
+ *  com.jby.office.domain.vo.OfficeMarginVO
+ *  com.jby.office.domain.vo.OfficeQuestionBlockVO
+ *  com.jby.office.domain.vo.QuestionDetailVO
+ *  com.jby.office.domain.vo.TagVO
+ *  com.jby.office.enums.BooleanEnum
+ *  com.jby.office.enums.DownScheduleTypeEnum
+ *  com.jby.office.enums.EditionEnum
+ *  com.jby.office.enums.ElementTypeEnum
+ *  com.jby.office.enums.FileTypeEnum
+ *  com.jby.office.enums.ListenEnum
+ *  com.jby.officecore.config.OfficeCoreConfig
+ *  com.jby.officecore.domain.bo.CreateDocumentBO
+ *  com.jby.officecore.domain.bo.CreateFileBO
+ *  com.jby.officecore.domain.bo.ElementNumBO
+ *  com.jby.officecore.domain.bo.QuestionBO
+ *  com.jby.officecore.domain.bo.TitleBO
+ *  com.jby.officecore.domain.param.CreatePdfParam
+ *  com.jby.officecore.domain.param.ParseParam
+ *  com.jby.officecore.enums.AttrEnum
+ *  com.jby.officecore.enums.CollectQuestionEnum
+ *  com.jby.officecore.enums.LogicTypeEnum
+ *  com.jby.officecore.enums.MarginTypeEnum
+ *  com.jby.officecore.enums.PageEnum
+ *  com.jby.officecore.enums.QuestionEnum
+ *  com.jby.officecore.enums.TagEnum
+ *  com.jby.officecore.enums.TitleShowEnum
+ *  com.jby.officecore.utils.AttachmentUtil
+ *  com.jby.officecore.utils.CodeUtil
+ *  com.jby.officecore.utils.ElementNumberUtil
+ *  com.jby.officecore.utils.OfficeParseUtil
+ *  com.jby.officecore.utils.WordExportUtil
+ *  com.jby.officecore.utils.WordParseUtil
+ *  com.jby.system.domain.param.NodeParam
+ *  com.jby.system.enums.AttachmentModuleEnum
+ *  javax.annotation.Resource
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.compress.utils.Lists
+ *  org.apache.commons.lang3.StringUtils
+ *  org.apache.poi.xwpf.usermodel.XWPFDocument
+ *  org.jsoup.Jsoup
+ *  org.jsoup.nodes.Document
+ *  org.jsoup.nodes.Element
+ *  org.jsoup.nodes.Node
+ *  org.jsoup.select.Elements
+ *  org.map.utils.BeanMapping
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
+ *  org.springframework.stereotype.Service
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.jby.officefile.service.impl;
+
+import cn.hutool.core.io.FileUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.jby.common.base.entity.CommonBean;
+import com.jby.common.bo.SessionUser;
+import com.jby.common.exceptions.BizAssert;
+import com.jby.common.exceptions.BusinessException;
+import com.jby.common.feign.FeignUtils;
+import com.jby.common.result.Result;
+import com.jby.common.util.RequestUtil;
+import com.jby.common.util.SpringContextHolder;
+import com.jby.common.util.UniqueUtil;
+import com.jby.office.constant.ConfigConstants;
+import com.jby.office.constant.Constants;
+import com.jby.office.domain.dto.QuestionSourceFeatureMetadataDTO;
+import com.jby.office.domain.param.DownloadFileParam;
+import com.jby.office.domain.param.FileParam;
+import com.jby.office.domain.param.GenerateFileParam;
+import com.jby.office.domain.param.GlobalConfigParam;
+import com.jby.office.domain.param.OfficeFileParseParam;
+import com.jby.office.domain.param.OfficeFileParseRecordParam;
+import com.jby.office.domain.param.QueryFileParam;
+import com.jby.office.domain.param.UpdateFileParam;
+import com.jby.office.domain.vo.ExportQuestionVO;
+import com.jby.office.domain.vo.OfficeConfigVO;
+import com.jby.office.domain.vo.OfficeFileConfigVO;
+import com.jby.office.domain.vo.OfficeFileDownloadScheduleVO;
+import com.jby.office.domain.vo.OfficeFileElementVO;
+import com.jby.office.domain.vo.OfficeFileInfoVO;
+import com.jby.office.domain.vo.OfficeFileParseRecordVO;
+import com.jby.office.domain.vo.OfficeFileParseVO;
+import com.jby.office.domain.vo.OfficeFileStyleVO;
+import com.jby.office.domain.vo.OfficeGlobalConfigVO;
+import com.jby.office.domain.vo.OfficeMarginVO;
+import com.jby.office.domain.vo.OfficeQuestionBlockVO;
+import com.jby.office.domain.vo.QuestionDetailVO;
+import com.jby.office.domain.vo.TagVO;
+import com.jby.office.enums.BooleanEnum;
+import com.jby.office.enums.DownScheduleTypeEnum;
+import com.jby.office.enums.EditionEnum;
+import com.jby.office.enums.ElementTypeEnum;
+import com.jby.office.enums.FileTypeEnum;
+import com.jby.office.enums.ListenEnum;
+import com.jby.officecore.config.OfficeCoreConfig;
+import com.jby.officecore.domain.bo.CreateDocumentBO;
+import com.jby.officecore.domain.bo.CreateFileBO;
+import com.jby.officecore.domain.bo.ElementNumBO;
+import com.jby.officecore.domain.bo.QuestionBO;
+import com.jby.officecore.domain.bo.TitleBO;
+import com.jby.officecore.domain.param.CreatePdfParam;
+import com.jby.officecore.domain.param.ParseParam;
+import com.jby.officecore.enums.AttrEnum;
+import com.jby.officecore.enums.CollectQuestionEnum;
+import com.jby.officecore.enums.LogicTypeEnum;
+import com.jby.officecore.enums.MarginTypeEnum;
+import com.jby.officecore.enums.PageEnum;
+import com.jby.officecore.enums.QuestionEnum;
+import com.jby.officecore.enums.TagEnum;
+import com.jby.officecore.enums.TitleShowEnum;
+import com.jby.officecore.utils.AttachmentUtil;
+import com.jby.officecore.utils.CodeUtil;
+import com.jby.officecore.utils.ElementNumberUtil;
+import com.jby.officecore.utils.OfficeParseUtil;
+import com.jby.officecore.utils.WordExportUtil;
+import com.jby.officecore.utils.WordParseUtil;
+import com.jby.officefile.config.OfficeFileConfig;
+import com.jby.officefile.domain.entity.OfficeFileDownloadSchedule;
+import com.jby.officefile.domain.entity.OfficeFileParseRecord;
+import com.jby.officefile.feign.OfficeFileServiceFeign;
+import com.jby.officefile.feign.OfficeGlobalConfigServiceFeign;
+import com.jby.officefile.mapper.OfficeFileDownloadScheduleMapper;
+import com.jby.officefile.service.FileService;
+import com.jby.officefile.service.OfficeFileDownloadScheduleService;
+import com.jby.officefile.service.OfficeFileParseRecordService;
+import com.jby.system.domain.param.NodeParam;
+import com.jby.system.enums.AttachmentModuleEnum;
+import java.io.File;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Resource;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.compress.utils.Lists;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.nodes.Node;
+import org.jsoup.select.Elements;
+import org.map.utils.BeanMapping;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+@Service
+public class FileServiceImpl
+implements FileService {
+    private static final Logger log = LoggerFactory.getLogger(FileServiceImpl.class);
+    private static final Pattern QUESTION_NUM_PATTERN = Pattern.compile("<u>(?:(?:</?u>|[\u300a\u300b\\s]|&nbsp;)*\\d(?:</?u>|[\u300a\u300b\\s]|&nbsp;)*)+</u>");
+    public static final Set<Long> ANSWER_MERGE_QUESTION_TYPE_SET_OLD = Stream.of(1L, 2L, 3L, 4L, 5L, 7L, 8L, 9L, 10L, 11L).collect(Collectors.toSet());
+    private static final Set<Long> ANSWER_MERGE_QUESTION_TYPE_SET_NEW = Stream.of(1048L, 1049L, 1050L, 1051L, 1054L, 1055L, 1525L).collect(Collectors.toSet());
+    @Resource
+    private OfficeCoreConfig officeCoreConfig;
+    @Resource
+    private OfficeFileConfig officeFileConfig;
+    @Resource
+    private OfficeFileDownloadScheduleService downloadScheduleService;
+    @Resource
+    private OfficeFileDownloadScheduleMapper officeFileDownloadScheduleMapper;
+    @Resource
+    private OfficeFileServiceFeign officeFileServiceFeign;
+    @Resource
+    private OfficeGlobalConfigServiceFeign officeGlobalConfigServiceFeign;
+    @Resource(name="batchDownloadMainExecutor")
+    private ThreadPoolTaskExecutor batchDownloadMainExecutor;
+    @Resource(name="batchDownloadTaskExecutor")
+    private ThreadPoolTaskExecutor batchDownloadTaskExecutor;
+    @Resource
+    private OfficeFileParseRecordService officeFileParseRecordService;
+
+    @Override
+    public OfficeFileInfoVO generateFileByUrl(GenerateFileParam param) {
+        BizAssert.isNotBlank((String)param.getSourceUrl(), (String)"\u6e90\u6587\u4ef6\u5730\u5740\u4e3a\u7a7a");
+        BizAssert.notNull((Object)param.getPhaseId(), (String)"\u5b66\u6bb5id\u4e3a\u7a7a");
+        BizAssert.notNull((Object)param.getCourseId(), (String)"\u5b66\u79d1id\u4e3a\u7a7a");
+        FileServiceImpl.compatibleEncode(param);
+        if (StringUtils.isBlank((CharSequence)param.getFileName())) {
+            param.setFileName(com.jby.common.util.FileUtil.getFileName((String)param.getSourceUrl()));
+        }
+        ParseParam parseParam = new ParseParam().setSourceUrl(param.getSourceUrl());
+        this.addLatexReplaceList(parseParam);
+        String html = WordParseUtil.parseByUrl((ParseParam)parseParam);
+        List elementList = OfficeParseUtil.buildElements((String)html);
+        param.setElementList(elementList);
+        return (OfficeFileInfoVO)FeignUtils.parse((Result)this.officeFileServiceFeign.generateFile(param));
+    }
+
+    private static void compatibleEncode(GenerateFileParam param) {
+        if (!param.getFileName().contains("+")) {
+            param.setFileName(com.jby.common.util.FileUtil.decodeUrl((String)param.getFileName()));
+        }
+        if (!param.getSourceUrl().contains("+")) {
+            param.setSourceUrl(com.jby.common.util.FileUtil.decodeUrl((String)param.getSourceUrl()));
+        }
+    }
+
+    @Override
+    public OfficeFileInfoVO generateFileByFile(FileParam fileParam) {
+        BizAssert.notNull((Object)fileParam.getSourceFile(), (String)"\u6e90\u6587\u4ef6\u4e3a\u7a7a");
+        BizAssert.isTrue((fileParam.getSourceFile().getSize() != 0L ? 1 : 0) != 0, (String)"\u6587\u6863\u5185\u5bb9\u4e3a\u7a7a\uff01");
+        BizAssert.isNotBlank((String)fileParam.getGenerateFileJson(), (String)"json\u53c2\u6570\u4e3a\u7a7a");
+        GenerateFileParam param = (GenerateFileParam)JSONObject.parseObject((String)fileParam.getGenerateFileJson(), GenerateFileParam.class);
+        BizAssert.notNull((Object)param.getPhaseId(), (String)"\u5b66\u6bb5id\u4e3a\u7a7a");
+        BizAssert.notNull((Object)param.getCourseId(), (String)"\u5b66\u79d1id\u4e3a\u7a7a");
+        if (StringUtils.isBlank((CharSequence)param.getFileName())) {
+            param.setFileName(com.jby.common.util.FileUtil.getFileName((String)fileParam.getSourceFile().getOriginalFilename()));
+        }
+        ParseParam parseParam = new ParseParam().setSourceFile(fileParam.getSourceFile());
+        this.addLatexReplaceList(parseParam);
+        String html = WordParseUtil.parseByFile((ParseParam)parseParam);
+        List elementList = OfficeParseUtil.buildElements((String)html);
+        param.setElementList(elementList);
+        return (OfficeFileInfoVO)FeignUtils.parse((Result)this.officeFileServiceFeign.generateFile(param));
+    }
+
+    @Override
+    public OfficeFileParseVO parseOfficeFile(OfficeFileParseParam param) {
+        BizAssert.notNull((Object)param.getFile(), (String)"\u6587\u6863\u4e3a\u7a7a");
+        BizAssert.isTrue((param.getFile().getSize() != 0L ? 1 : 0) != 0, (String)"\u6587\u6863\u5185\u5bb9\u4e3a\u7a7a\uff01");
+        WordParseUtil.validSize((double)param.getFile().getSize(), null);
+        ParseParam parseParam = new ParseParam().setSourceFile(param.getFile()).setNewParseVersion(param.getNewParseVersion()).setFileId(param.getFileId());
+        this.addLatexReplaceList(parseParam);
+        String html = WordParseUtil.parseByFile((ParseParam)parseParam);
+        return new OfficeFileParseVO().setFileId(param.getFileId()).setContent(html);
+    }
+
+    private void addLatexReplaceList(ParseParam parseParam) {
+        try {
+            OfficeGlobalConfigVO configVO = (OfficeGlobalConfigVO)FeignUtils.parse((Result)this.officeGlobalConfigServiceFeign.getGlobalConfigInfo(new GlobalConfigParam().setConfigKey("LATEX_REPLACE")));
+            if (Objects.nonNull(configVO) && CollectionUtils.isNotEmpty((Collection)configVO.getConfigList())) {
+                List latexReplaceList = JSONObject.parseArray((String)JSON.toJSONString((Object)configVO.getConfigList()), JSONObject.class);
+                parseParam.setLatexReplaceList(latexReplaceList);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u6dfb\u52a0latex\u516c\u5f0f\u89c4\u8303\u914d\u7f6e\u4fe1\u606f\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    @Override
+    public String downloadOfficeFile(DownloadFileParam param) {
+        String fileUrl;
+        if (FileTypeEnum.PDF.getType().equals(param.getFileType())) {
+            fileUrl = Objects.isNull(param.getPdfFile()) ? this.downloadPdf(param) : this.downloadListenAudio(param);
+        } else {
+            CreateFileBO createFileBO;
+            OfficeFileInfoVO fileInfo = (OfficeFileInfoVO)FeignUtils.parse((Result)this.officeFileServiceFeign.getFileDetail(new QueryFileParam().setFileId(param.getFileId())));
+            if (EditionEnum.STUDENT_ANSWER_END.getEdition().equals(param.getEdition())) {
+                createFileBO = this.createDocument(param.setEdition(EditionEnum.STUDENT.getEdition()), fileInfo, null);
+                this.createDocument(param.setEdition(EditionEnum.ANSWER.getEdition()), fileInfo, createFileBO.getDocument());
+            } else {
+                createFileBO = this.createDocument(param, fileInfo, null);
+            }
+            fileUrl = WordExportUtil.createOfficeFile((CreateFileBO)createFileBO);
+        }
+        log.info("\u4e0b\u8f7d\u5728\u7ebf\u7f16\u8f91\u6587\u4ef6\u6210\u529f, fileUrl={}, param={}", (Object)fileUrl, (Object)JSON.toJSONString((Object)param));
+        if (BooleanEnum.TRUE.getValue().equals(param.getIsEncodeUrl())) {
+            fileUrl = com.jby.common.util.FileUtil.encodeUrl((String)fileUrl);
+        }
+        return fileUrl;
+    }
+
+    private CreateFileBO createDocument(DownloadFileParam param, OfficeFileInfoVO fileInfoVO, XWPFDocument xwpfDocument) {
+        OfficeFileInfoVO fileInfo = (OfficeFileInfoVO)JSON.parseObject((String)JSON.toJSONString((Object)fileInfoVO), OfficeFileInfoVO.class);
+        this.filterElementList(fileInfo, param.getEdition());
+        ArrayList<String> contentList = new ArrayList<String>();
+        ArrayList<ExportQuestionVO> questionList = new ArrayList<ExportQuestionVO>();
+        this.collectContent(contentList, questionList, fileInfo, fileInfo.getOfficeConfigVO(), param.getEdition());
+        PageEnum pageEnum = PageEnum.getPageEnum((String)param.getPage());
+        String templateName = this.getTemplateName(StringUtils.isBlank((CharSequence)param.getTemplateName()) ? pageEnum.name() : param.getTemplateName(), param.getEdition(), fileInfo.getFileConfigList());
+        XWPFDocument document = WordExportUtil.createDocument((CreateDocumentBO)new CreateDocumentBO().setTemplateName(templateName).setPageEnum(pageEnum).setOfficeConfig(fileInfo.getOfficeConfigVO()).setContentList(contentList).setFileMarginVO(fileInfo.getFileMarginVO()).setEdition(param.getEdition()).setNewDownloadVersion(param.getNewDownloadVersion()).setXwpfDocument(xwpfDocument));
+        BizAssert.notNull((Object)document, (String)"\u751f\u6210\u6587\u6863\u5f02\u5e38");
+        return new CreateFileBO().setDocument(document).setFileName(fileInfo.getFileName()).setQuestionList(questionList).setDownloadListenType(param.getDownloadListenType());
+    }
+
+    private String getTemplateName(String templateName, Integer edition, List<OfficeFileConfigVO> fileConfigList) {
+        Optional<OfficeFileConfigVO> bindingLine;
+        if (EditionEnum.STUDENT.getEdition().equals(edition) && (bindingLine = fileConfigList.stream().filter(e -> "bindingLine".equals(e.getFieldKey()) && BooleanEnum.TRUE.getValue().equals(e.getEnableField())).findAny()).isPresent()) {
+            templateName = templateName + "_" + bindingLine.get().getFieldKey();
+        }
+        return templateName + "." + "docx";
+    }
+
+    private void collectContent(List<String> contentList, List<ExportQuestionVO> questionList, OfficeFileInfoVO fileInfo, OfficeConfigVO officeConfig, Integer edition) {
+        Map configMap = fileInfo.getFileConfigList().stream().collect(Collectors.toMap(OfficeFileConfigVO::getFieldKey, Function.identity(), (l, r) -> l));
+        for (String head : ConfigConstants.FileConfig.FILE_HEAD_LIST) {
+            String content;
+            OfficeFileConfigVO headConfig = (OfficeFileConfigVO)configMap.get(head);
+            String string = content = "title".equals(headConfig.getFieldKey()) ? fileInfo.getFileLabelName() : headConfig.getFieldValue();
+            if (!BooleanEnum.TRUE.getValue().equals(headConfig.getEnableField()) || !StringUtils.isNotBlank((CharSequence)content)) continue;
+            String fieldValue = this.addDefaultTemplateStyle(officeConfig.getTemplateStyleMap(), headConfig.getFieldKey(), content);
+            contentList.add(fieldValue);
+        }
+        this.collectElementInfo(fileInfo, contentList, questionList, officeConfig, edition);
+    }
+
+    private String addDefaultTemplateStyle(Map<String, String> templateStyleMap, String templateKey, String template) {
+        String templateStyle = templateStyleMap.get(templateKey);
+        if (StringUtils.isNotBlank((CharSequence)templateStyle) && templateStyle.contains("replaceKey")) {
+            return templateStyle.replace("replaceKey", template);
+        }
+        return template;
+    }
+
+    private void filterElementList(OfficeFileInfoVO fileInfo, Integer edition) {
+        if (EditionEnum.STUDENT.getEdition().equals(edition)) {
+            fileInfo.setElementList(fileInfo.getElementList().stream().filter(e -> Boolean.TRUE.equals(e.getStudentShow())).collect(Collectors.toList()));
+        }
+        if (EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) {
+            fileInfo.setElementList(fileInfo.getElementList().stream().filter(e -> ElementTypeEnum.ANSWER_FILTER_SET.contains(e.getElementType())).peek(m -> {
+                if (ElementTypeEnum.TEXT.getType().equals(m.getElementType()) && StringUtils.isNotBlank((CharSequence)m.getContent())) {
+                    Document doc = Jsoup.parse((String)m.getContent());
+                    Element body = doc.body();
+                    Elements targetSpans = body.select("span." + AttrEnum.TINYMCE_HOLLOWOUT.getAttr() + ", span." + AttrEnum.TINYMCE_HIDDENANDANSWER.getAttr());
+                    if (CollectionUtils.isEmpty((Collection)targetSpans)) {
+                        m.setDeleted(Boolean.TRUE);
+                        return;
+                    }
+                    Element container = body.child(0);
+                    container.empty();
+                    for (int i = 0; i < targetSpans.size(); ++i) {
+                        ((Element)targetSpans.get(i)).removeClass(AttrEnum.TINYMCE_HOLLOWOUT.getAttr());
+                        ((Element)targetSpans.get(i)).removeClass(AttrEnum.TINYMCE_HIDDENANDANSWER.getAttr());
+                        container.appendChild((Node)((Element)targetSpans.get(i)).clone());
+                        if (i >= targetSpans.size() - 1) continue;
+                        container.appendChild((Node)new Element("span").text("\uff1b"));
+                    }
+                    m.setContent(body.html());
+                }
+            }).filter(e -> !Boolean.TRUE.equals(e.getDeleted())).collect(Collectors.toList()));
+        }
+    }
+
+    private void collectElementInfo(OfficeFileInfoVO fileInfo, List<String> contentList, List<ExportQuestionVO> questionList, OfficeConfigVO officeConfig, Integer edition) {
+        ElementNumberUtil elementNumberUtil = new ElementNumberUtil();
+        ArrayList<TitleBO> titleList = new ArrayList<TitleBO>();
+        titleList.add(new TitleBO().setQuestionList(new ArrayList()));
+        for (OfficeFileElementVO element : fileInfo.getElementList()) {
+            if (ElementTypeEnum.TITLE_1.getType().equals(element.getElementType())) {
+                titleList.add(new TitleBO().setIndex(Integer.valueOf(contentList.size())).setElementNumberStyle(element.getElementNumberStyle()).setQuestionList(new ArrayList()));
+            }
+            if (ElementTypeEnum.QUESTION.getType().equals(element.getElementType()) && element.getQuestionShowType() != 1) {
+                this.collectQuestionBankInfo(contentList, edition, officeConfig, element, titleList, questionList, fileInfo.getFileStyle());
+            } else if (ElementTypeEnum.RELATION_SET.contains(element.getElementType()) && (EditionEnum.STUDENT.getEdition().equals(edition) || EditionEnum.TEACHER.getEdition().equals(edition))) {
+                this.collectAttachmentInfo(contentList, officeConfig.getAttachmentCard(), officeConfig.getCommonIconMap(), element, fileInfo.getFileMarginVO());
+            } else if (ElementTypeEnum.CONTENT_SET.contains(element.getElementType())) {
+                ElementNumBO elementNumBO = elementNumberUtil.getElementNum(element, fileInfo.getFileStyle(), officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap());
+                String elementContent = elementNumBO.getStyleElementNum() + officeConfig.getTagVO().getDivStart() + this.notNullContent(element.getContent()) + officeConfig.getTagVO().getDivEnd();
+                contentList.add(elementContent);
+            } else if (ElementTypeEnum.QUESTION_BLOCK.getType().equals(element.getElementType())) {
+                String[] split;
+                OfficeQuestionBlockVO officeQuestionBlockVO = element.getOfficeQuestionBlockVO();
+                if (officeQuestionBlockVO == null) continue;
+                ElementNumBO elementNumBO = elementNumberUtil.getElementNum(element, fileInfo.getFileStyle(), officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap());
+                TagVO tagVO = officeConfig.getTagVO();
+                String questionBlockType = tagVO.getQuestionBlockType();
+                String questionBlockTypeTag = "";
+                if (StringUtils.isNotBlank((CharSequence)questionBlockType) && (split = questionBlockType.split("#")).length == 3) {
+                    int blockType = element.getOfficeQuestionBlockVO().getBlockType();
+                    questionBlockTypeTag = split[blockType - 1];
+                }
+                if (StringUtils.isNotBlank((CharSequence)questionBlockTypeTag)) {
+                    questionBlockTypeTag = questionBlockTypeTag.replaceAll("number", elementNumBO.getStyleElementNum());
+                    String scoreStr = FileServiceImpl.getScoreStr(officeQuestionBlockVO);
+                    questionBlockTypeTag = questionBlockTypeTag.replaceAll("score", scoreStr);
+                }
+                String blockContent = this.notNullContent(officeQuestionBlockVO.getBlockContent());
+                if (StringUtils.isNotBlank((CharSequence)questionBlockTypeTag) && StringUtils.isNotBlank((CharSequence)blockContent)) {
+                    blockContent = this.insertTagIntoFirstElement(blockContent, questionBlockTypeTag);
+                }
+                String elementContent = officeConfig.getTagVO().getDivStart() + blockContent + officeConfig.getTagVO().getDivEnd();
+                contentList.add(elementContent);
+            }
+            this.addElementAfterInfo(contentList, edition, element, officeConfig.getTagVO());
+        }
+        this.dealTitle(fileInfo, contentList, titleList, officeConfig.getElementNumStyleMap());
+        if (EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) {
+            this.dealAnswerMergeNew2(contentList, titleList);
+        }
+    }
+
+    private static String getScoreStr(OfficeQuestionBlockVO officeQuestionBlockVO) {
+        BigDecimal score = officeQuestionBlockVO.getScore();
+        String scoreStr = "";
+        if (score != null && score.compareTo(BigDecimal.ZERO) != 0) {
+            BigDecimal stripped = score.stripTrailingZeros();
+            scoreStr = stripped.scale() <= 0 ? stripped.toPlainString() : stripped.setScale(1, RoundingMode.HALF_UP).toPlainString();
+            scoreStr = "(" + scoreStr + "\u5206" + ")";
+        }
+        return scoreStr;
+    }
+
+    private String insertTagIntoFirstElement(String blockContent, String insertTag) {
+        try {
+            Element firstChild;
+            Document doc = Jsoup.parse((String)blockContent);
+            doc.outputSettings().prettyPrint(false).indentAmount(0);
+            Element body = doc.body();
+            Element firstElement = body.children().first();
+            if (firstElement == null) {
+                return insertTag + blockContent;
+            }
+            Elements children = firstElement.children();
+            if (!children.isEmpty() && "br".equalsIgnoreCase((firstChild = children.first()).tagName())) {
+                firstChild.remove();
+            }
+            firstElement.prepend(insertTag);
+            return body.html();
+        }
+        catch (Exception e) {
+            log.error("\u63d2\u5165\u9898\u5757\u6807\u7b7e\u5230\u5185\u5bb9\u5931\u8d25, blockContent:{}, insertTag:{}", new Object[]{blockContent, insertTag, e});
+            return insertTag + blockContent;
+        }
+    }
+
+    private void dealAnswerMerge(List<String> contentList, List<TitleBO> titleList) {
+        List<ArrayList<List<Integer>>> groups;
+        if (CollectionUtils.isEmpty(contentList)) {
+            return;
+        }
+        HashMap<Integer, TitleBO> indexToTitleMap = new HashMap<Integer, TitleBO>();
+        for (TitleBO titleBO : titleList) {
+            if (CollectionUtils.isEmpty((Collection)titleBO.getQuestionList())) continue;
+            for (QuestionBO q2 : titleBO.getQuestionList()) {
+                if (!Objects.nonNull(q2.getIndex())) continue;
+                indexToTitleMap.put(q2.getIndex(), titleBO);
+            }
+        }
+        IdentityHashMap<TitleBO, List<ArrayList<List<Integer>>>> titleGroups = new IdentityHashMap<TitleBO, List<ArrayList<List<Integer>>>>();
+        for (TitleBO title : titleList) {
+            if (CollectionUtils.isEmpty((Collection)title.getQuestionList())) continue;
+            List sortedQuestions = title.getQuestionList().stream().filter(q -> Objects.nonNull(q.getIndex())).sorted(Comparator.comparing(QuestionBO::getIndex)).collect(Collectors.toList());
+            groups = new ArrayList();
+            ArrayList<Integer> currentGroup = new ArrayList<Integer>();
+            for (QuestionBO questionBO : sortedQuestions) {
+                if (Boolean.TRUE.equals(questionBO.getIsMergeAnswer())) {
+                    currentGroup.add(questionBO.getIndex());
+                    continue;
+                }
+                if (!currentGroup.isEmpty()) {
+                    groups.add(new ArrayList(currentGroup));
+                    currentGroup.clear();
+                }
+                groups.add((ArrayList<List<Integer>>)Collections.singletonList(questionBO.getIndex()));
+            }
+            if (!currentGroup.isEmpty()) {
+                groups.add(currentGroup);
+            }
+            titleGroups.put(title, groups);
+        }
+        ArrayList<String> arrayList = new ArrayList<String>();
+        int i = 0;
+        while (i < contentList.size()) {
+            if (indexToTitleMap.containsKey(i)) {
+                TitleBO title = (TitleBO)indexToTitleMap.get(i);
+                groups = (List)titleGroups.get(title);
+                boolean found = false;
+                for (List list : groups) {
+                    if (!list.contains(i) || !((Integer)list.get(0)).equals(i)) continue;
+                    StringBuilder merged = new StringBuilder();
+                    Iterator iterator = list.iterator();
+                    while (iterator.hasNext()) {
+                        int idx = (Integer)iterator.next();
+                        if (merged.length() > 0) {
+                            merged.append("    ");
+                        }
+                        merged.append(contentList.get(idx));
+                    }
+                    arrayList.add(merged.toString());
+                    i = (Integer)Collections.max(list) + 1;
+                    found = true;
+                    break;
+                }
+                if (found) continue;
+                arrayList.add(contentList.get(i));
+                ++i;
+                continue;
+            }
+            arrayList.add(contentList.get(i));
+            ++i;
+        }
+        contentList.clear();
+        contentList.addAll(arrayList);
+    }
+
+    private void dealTitle(OfficeFileInfoVO fileInfo, List<String> contentList, List<TitleBO> titleList, Map<String, Map<String, String>> styleMap) {
+        titleList.forEach(titleBO -> {
+            if (Objects.isNull(titleBO.getIndex()) || CollectionUtils.isEmpty((Collection)titleBO.getQuestionList())) {
+                return;
+            }
+            Integer showType = fileInfo.getFileStyle().getShowQuestionNumberScore();
+            ArrayList<String> showList = new ArrayList<String>();
+            if (TitleShowEnum.SHOW_QUESTION_NUM_SET.contains(showType)) {
+                showList.add("\u5171" + titleBO.getQuestionList().size() + "\u5c0f\u9898");
+            }
+            if (TitleShowEnum.SHOW_QUESTION_SCORE_SET.contains(showType)) {
+                BigDecimal total = titleBO.getQuestionList().stream().map(QuestionBO::getScore).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
+                if ((total = total.stripTrailingZeros()).scale() <= 0) {
+                    total = total.setScale(0);
+                }
+                showList.add("\u5171" + total + "\u5206");
+            }
+            if (CollectionUtils.isNotEmpty(showList)) {
+                String questionTip = "(" + String.join((CharSequence)",", showList) + ")";
+                if (StringUtils.isBlank((CharSequence)titleBO.getElementNumberStyle())) {
+                    String elementNumberStyle = (String)((Map)styleMap.get("elementType" + ElementTypeEnum.TITLE_1.getType())).get("numStyle");
+                    questionTip = elementNumberStyle.replace("elementNumber\u3001", questionTip);
+                }
+                String title = (String)contentList.get(titleBO.getIndex());
+                contentList.set(titleBO.getIndex(), title + questionTip);
+            }
+            fileInfo.getFileConfigList().stream().filter(e -> "bigScoreLine".equals(e.getFieldKey()) && BooleanEnum.TRUE.getValue().equals(e.getEnableField()) && StringUtils.isNotBlank((CharSequence)e.getFieldValue())).map(OfficeFileConfigVO::getFieldValue).findFirst().ifPresent(bigScoreLine -> {
+                String title = (String)contentList.get(titleBO.getIndex());
+                contentList.set(titleBO.getIndex(), bigScoreLine + title);
+            });
+        });
+    }
+
+    private void collectAttachmentInfo(List<String> contentList, String attachmentCard, Map<String, String> commonIconMap, OfficeFileElementVO element, OfficeMarginVO officeMarginVO) {
+        String qrCodeUrl = null;
+        if (ElementTypeEnum.AUDIO.getType().equals(element.getElementType()) && Objects.nonNull(element.getAudioDetail())) {
+            qrCodeUrl = element.getAudioDetail().getQrCodeUrl();
+        }
+        if (ElementTypeEnum.VIDEO.getType().equals(element.getElementType()) && Objects.nonNull(element.getVideoDetail())) {
+            qrCodeUrl = element.getVideoDetail().getQrCodeUrl();
+        }
+        if (ElementTypeEnum.GGB.getType().equals(element.getElementType()) && Objects.nonNull(element.getGgbDetail())) {
+            qrCodeUrl = element.getGgbDetail().getQrCodeUrl();
+        }
+        if (ElementTypeEnum.CHEMISTRY.getType().equals(element.getElementType()) && Objects.nonNull(element.getChemistryDetail())) {
+            qrCodeUrl = element.getChemistryDetail().getQrCodeUrl();
+        }
+        if (ElementTypeEnum.MINDMAP.getType().equals(element.getElementType()) && Objects.nonNull(element.getMindmapDetailVo())) {
+            qrCodeUrl = element.getMindmapDetailVo().getQrCodeUrl();
+        }
+        String attachmentContent = this.getAttachmentCard(attachmentCard, commonIconMap, element.getElementType(), element.getAttachmentName(), qrCodeUrl);
+        if (officeMarginVO != null && !StringUtils.isEmpty((CharSequence)officeMarginVO.getLeftMargin())) {
+            Document doc;
+            Element tabNode;
+            String currLeftMarginStr = officeMarginVO.getLeftMargin();
+            double currLeftMargin = Double.parseDouble(currLeftMarginStr = currLeftMarginStr.replaceAll("[^\\d.]", ""));
+            if (currLeftMargin > MarginTypeEnum.NORMAL.getLeftMargin() && (tabNode = (doc = Jsoup.parse((String)attachmentContent)).select(TagEnum.TAB.getName()).first()) != null) {
+                String widthStr = tabNode.attr(AttrEnum.WIDTH.getAttr());
+                double width = Double.parseDouble(widthStr);
+                tabNode.attr(AttrEnum.WIDTH.getAttr(), (int)(width *= MarginTypeEnum.NORMAL.getLeftMargin() / currLeftMargin) + "");
+                attachmentContent = doc.body().html();
+            }
+        }
+        contentList.add(attachmentContent);
+    }
+
+    private void collectQuestionInfo(List<String> contentList, List<ExportQuestionVO> questionList, OfficeFileStyleVO fileStyle, Integer edition, OfficeConfigVO officeConfig, ElementNumberUtil elementNumberUtil, List<TitleBO> titleList, OfficeFileElementVO element) {
+        QuestionDetailVO question = element.getQuestionDetail();
+        if (Objects.isNull(question)) {
+            ElementNumBO elementNumBO = elementNumberUtil.getElementNum(element, fileStyle, officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap());
+            String questionContent = officeConfig.getTagVO().getDivStart() + "\u9898\u76ee\u4fe1\u606f\u4e3a\u7a7a" + officeConfig.getTagVO().getDivEnd();
+            this.addRestoreInfo(titleList, contentList.size(), questionContent, null, false);
+            contentList.add(elementNumBO.getStyleElementNum() + questionContent);
+            return;
+        }
+        if (CollectionUtils.isEmpty((Collection)question.getChildList())) {
+            ElementNumBO elementNumBO = question.isSystemQuestionNumber() != false ? elementNumberUtil.getElementNum(element, fileStyle, officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap()) : new ElementNumBO().setStyleElementNum(question.getShowCustomQuestionNumber());
+            Set collectTypes = CollectQuestionEnum.getCollectTypes((QuestionEnum)QuestionEnum.SINGLE_QUESTION, (Integer)edition, (String)question.getTypeName());
+            this.addQuestionInfo(contentList, titleList, elementNumBO.getStyleElementNum(), question, collectTypes, officeConfig.getTagVO(), QuestionEnum.SINGLE_QUESTION, fileStyle, edition);
+            questionList.add(new ExportQuestionVO().setQuestion(question));
+            return;
+        }
+        String elementNum = question.isSystemQuestionNumber() != false ? "" : question.getShowCustomQuestionNumber();
+        Set collectTypes = CollectQuestionEnum.getCollectTypes((QuestionEnum)QuestionEnum.PARENT_QUESTION, (Integer)edition, (String)question.getTypeName());
+        Integer contentIndex = this.addQuestionInfo(contentList, titleList, elementNum, question, collectTypes, officeConfig.getTagVO(), QuestionEnum.PARENT_QUESTION, fileStyle, edition);
+        collectTypes = CollectQuestionEnum.getCollectTypes((QuestionEnum)QuestionEnum.CHILD_QUESTION, (Integer)edition, (String)question.getTypeName());
+        ArrayList<Integer> elementNumList = new ArrayList<Integer>();
+        for (int i = 0; i < question.getChildList().size(); ++i) {
+            ElementNumBO elementNumBO;
+            QuestionDetailVO child = (QuestionDetailVO)question.getChildList().get(i);
+            if (question.isSystemQuestionNumber().booleanValue()) {
+                elementNumBO = elementNumberUtil.getElementNum(element, fileStyle, officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap());
+            } else {
+                elementNumBO = new ElementNumBO().setElementNum(Integer.valueOf(i + 1));
+                String customNumber = elementNumBO.getElementNum() + ".";
+                if ((EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) && StringUtils.isNotBlank((CharSequence)question.getShowCustomQuestionNumber())) {
+                    customNumber = question.getShowCustomQuestionNumber().trim() + "-" + customNumber;
+                }
+                elementNumBO.setStyleElementNum(customNumber);
+            }
+            this.addQuestionInfo(contentList, titleList, elementNumBO.getStyleElementNum(), child, collectTypes, officeConfig.getTagVO(), QuestionEnum.CHILD_QUESTION, null, edition);
+            elementNumList.add(elementNumBO.getElementNum());
+        }
+        this.dealQuestionNum(contentList, question, contentIndex, elementNumList);
+        questionList.add(new ExportQuestionVO().setQuestion(question));
+    }
+
+    private void dealQuestionNum(List<String> contentList, QuestionDetailVO question, Integer contentIndex, List<Integer> elementNumList) {
+        if ((Constants.QUESTION_TYPE_SET.contains(question.getTypeName()) || "\u5b8c\u5f62\u586b\u7a7a".equals(question.getTypeName())) && Objects.nonNull(contentIndex)) {
+            String content = contentList.get(contentIndex);
+            Matcher matcher = QUESTION_NUM_PATTERN.matcher(content);
+            StringBuffer sb = new StringBuffer();
+            int count = 0;
+            while (matcher.find() && count <= elementNumList.size() - 1) {
+                String newNum = "<u> " + elementNumList.get(count++).toString() + " " + "</u>";
+                matcher.appendReplacement(sb, newNum);
+            }
+            matcher.appendTail(sb);
+            contentList.set(contentIndex, sb.toString());
+        }
+    }
+
+    private void markQuestionImg(QuestionDetailVO question) {
+        if (Objects.nonNull(question)) {
+            this.replaceQuestionImg(question);
+            if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                question.getChildList().forEach(this::replaceQuestionImg);
+            }
+        }
+    }
+
+    private void replaceQuestionImg(QuestionDetailVO question) {
+        question.setContent(this.replaceImg(question.getContent()));
+        question.setOptionA(this.replaceImg(question.getOptionA()));
+        question.setOptionB(this.replaceImg(question.getOptionB()));
+        question.setOptionC(this.replaceImg(question.getOptionC()));
+        question.setOptionD(this.replaceImg(question.getOptionD()));
+        question.setOptionE(this.replaceImg(question.getOptionE()));
+        question.setOptionF(this.replaceImg(question.getOptionF()));
+        question.setOptionG(this.replaceImg(question.getOptionG()));
+        question.setAnswer(this.replaceImg(question.getAnswer()));
+        question.setAnswerExplanation(Optional.ofNullable(question.getAnswerExplanation()).orElse(Collections.emptyList()).stream().map(this::replaceImg).collect(Collectors.toList()));
+    }
+
+    private String replaceImg(String content) {
+        if (StringUtils.isBlank((CharSequence)content)) {
+            return content;
+        }
+        return content.replace("<img", "<imq");
+    }
+
+    private void addElementAfterInfo(List<String> contentList, Integer edition, OfficeFileElementVO element, TagVO tagVO) {
+        if (!EditionEnum.ANSWER.getEdition().equals(edition) && !EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) {
+            this.addEmptyArea(contentList, element.getEmptyLineNum(), element.getHasLine());
+        }
+        this.addTeachingRemark(contentList, edition, element, tagVO);
+        this.addPageBreak(contentList, edition, element.getHasPageBreak());
+    }
+
+    private void addEmptyArea(List<String> contentList, Integer emptyLineNum, Boolean hasLine) {
+        if (Objects.nonNull(emptyLineNum) && emptyLineNum > 0) {
+            String tag = Boolean.TRUE.equals(hasLine) ? "<hr>" : "<br>";
+            for (int i = 0; i < emptyLineNum; ++i) {
+                contentList.add(tag);
+            }
+        }
+    }
+
+    private void addTeachingRemark(List<String> contentList, Integer edition, OfficeFileElementVO element, TagVO tagVO) {
+        if (EditionEnum.TEACHER.getEdition().equals(edition) && Boolean.TRUE.equals(element.getIsShowRemark()) && StringUtils.isNotBlank((CharSequence)element.getTeachingRemark())) {
+            contentList.add(tagVO.getTeachingRemark() + tagVO.getDivStart() + element.getTeachingRemark() + tagVO.getDivEnd());
+        }
+    }
+
+    private void addPageBreak(List<String> contentList, Integer edition, Boolean hasPageBreak) {
+        if (!EditionEnum.STUDENT.getEdition().equals(edition) || !Boolean.TRUE.equals(hasPageBreak)) {
+            return;
+        }
+        contentList.add("<pbr></pbr>");
+    }
+
+    private Integer addQuestionInfo(List<String> contentList, List<TitleBO> titleList, String elementNum, QuestionDetailVO question, Set<CollectQuestionEnum> collectTypes, TagVO tagVO, QuestionEnum questionEnum, OfficeFileStyleVO fileStyle, Integer edition) {
+        ArrayList<String> questionContentList = new ArrayList<String>();
+        Integer contentIndex = null;
+        if (collectTypes.contains(CollectQuestionEnum.CONTENT) && StringUtils.isNotBlank((CharSequence)question.getContent())) {
+            questionContentList.add(tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd());
+            contentIndex = contentList.size();
+        }
+        if (collectTypes.contains(CollectQuestionEnum.ORIGINAL_TEXT) && StringUtils.isNotBlank((CharSequence)question.getOriginalText())) {
+            questionContentList.add(tagVO.getListeningText() + tagVO.getDivStart() + question.getOriginalText() + tagVO.getDivEnd());
+        }
+        if (collectTypes.contains(CollectQuestionEnum.DECIPHERMENT) && StringUtils.isNotBlank((CharSequence)question.getDecipherment())) {
+            questionContentList.add(tagVO.getDecipherment() + tagVO.getDivStart() + question.getDecipherment() + tagVO.getDivEnd());
+        }
+        if (collectTypes.contains(CollectQuestionEnum.OPTION)) {
+            this.addOption(questionContentList, question, tagVO);
+        }
+        if (collectTypes.contains(CollectQuestionEnum.EMPTY_AREA)) {
+            this.addEmptyArea(questionContentList, question.getEmptyLineNum(), question.getHasLine());
+        }
+        String answer = collectTypes.contains(CollectQuestionEnum.ANSWER) ? question.getAnswer() : "";
+        ArrayList answerExplanationList = new ArrayList();
+        if (collectTypes.contains(CollectQuestionEnum.EXPLANATION) && CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation())) {
+            question.getAnswerExplanation().stream().filter(StringUtils::isNotBlank).forEach(answerExplanationList::add);
+        }
+        String answerTag = tagVO.getAnswer();
+        if (EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) {
+            answerTag = " ";
+        }
+        if ((EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) && (ANSWER_MERGE_QUESTION_TYPE_SET_OLD.contains(question.getTypeDetailId()) || ANSWER_MERGE_QUESTION_TYPE_SET_NEW.contains(question.getLogicTypeId()) || StringUtils.isNotBlank((CharSequence)question.getDecipherment()))) {
+            String answerExplanation2 = "";
+            if (StringUtils.isNotBlank((CharSequence)answer)) {
+                answerExplanation2 = answerTag + tagVO.getDivStart() + answer + tagVO.getDivEnd();
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                answerExplanation2 = answerExplanation2 + tagVO.getExplanation() + tagVO.getDivStart() + String.join((CharSequence)",", answerExplanationList) + tagVO.getDivEnd();
+            }
+            if (StringUtils.isNotBlank((CharSequence)answerExplanation2)) {
+                questionContentList.add(answerExplanation2);
+            }
+        } else {
+            if (StringUtils.isNotBlank((CharSequence)answer)) {
+                questionContentList.add(answerTag + tagVO.getDivStart() + answer + tagVO.getDivEnd());
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                answerExplanationList.forEach(answerExplanation -> questionContentList.add(tagVO.getExplanation() + tagVO.getDivStart() + answerExplanation + tagVO.getDivEnd()));
+            }
+        }
+        Boolean isMergeAnswer = !(!EditionEnum.ANSWER.getEdition().equals(edition) && !EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition) || !ANSWER_MERGE_QUESTION_TYPE_SET_OLD.contains(question.getTypeDetailId()) && !ANSWER_MERGE_QUESTION_TYPE_SET_NEW.contains(question.getLogicTypeId()) || !CollectionUtils.isEmpty(answerExplanationList));
+        if (CollectionUtils.isEmpty(questionContentList)) {
+            return null;
+        }
+        if (Boolean.TRUE.equals(question.getIsShowScore()) && Objects.nonNull(question.getScore()) && question.getScore().compareTo(BigDecimal.ZERO) > 0) {
+            elementNum = elementNum + "\uff08" + question.getScore().stripTrailingZeros().toPlainString() + "\u5206\uff09";
+        }
+        String firstContent = (String)questionContentList.get(0);
+        if (StringUtils.isNotEmpty((CharSequence)question.getSource()) && fileStyle != null && fileStyle.getQuestionSourceShowFlag() == 1) {
+            questionContentList.set(0, elementNum + "\uff08" + question.getSource() + "\uff09" + firstContent);
+        } else {
+            questionContentList.set(0, elementNum + firstContent);
+        }
+        if (QuestionEnum.PARENT_QUESTION.equals((Object)questionEnum)) {
+            contentList.addAll(questionContentList);
+            return contentIndex;
+        }
+        this.addRestoreInfo(titleList, contentList.size(), firstContent, question.getScore(), isMergeAnswer);
+        contentList.addAll(questionContentList);
+        return null;
+    }
+
+    private void addRestoreInfo(List<TitleBO> titleList, int index, String restore, BigDecimal score, Boolean isMergeAnswer) {
+        titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setIndex(Integer.valueOf(index)).setQuestionContent(restore).setScore(score).setIsMergeAnswer(isMergeAnswer));
+    }
+
+    private void addOption(List<String> contentList, QuestionDetailVO question, TagVO tagVO) {
+        if (Boolean.TRUE.equals(question.getIsSubjective())) {
+            return;
+        }
+        List<String> optionList = this.getOptionList(question, tagVO);
+        if (Objects.nonNull(question.getOptionColumn()) && question.getOptionColumn() > 1) {
+            this.addMultiColumnOptionByTab(contentList, optionList, question.getOptionColumn());
+        } else {
+            contentList.addAll(optionList);
+        }
+    }
+
+    private void addMultiColumnOptionByTab(List<String> contentList, List<String> optionList, Integer columnNum) {
+        if (CollectionUtils.isEmpty(optionList)) {
+            return;
+        }
+        StringBuilder optionBuilder = new StringBuilder();
+        for (int i = 0; i < optionList.size(); ++i) {
+            if (i > 0) {
+                optionBuilder.append(i % columnNum == 0 ? "<br>" : "<tab></tab>");
+            }
+            optionBuilder.append(optionList.get(i));
+        }
+        contentList.add(optionBuilder.toString());
+    }
+
+    private String addMultiColumnOptionByTab(List<String> optionList, Integer columnNum) {
+        StringBuilder optionBuilder = new StringBuilder();
+        for (int i = 0; i < optionList.size(); ++i) {
+            if (i > 0) {
+                optionBuilder.append(i % columnNum == 0 ? "<br>" : "<tab></tab>");
+            }
+            String option = FileServiceImpl.removeSpaceStrOfEnd(optionList.get(i));
+            optionBuilder.append(option);
+        }
+        return optionBuilder.toString();
+    }
+
+    private List<String> getOptionList(QuestionDetailVO question, TagVO tagVO) {
+        ArrayList<String> optionList = new ArrayList<String>();
+        if ("\u5224\u65ad\u9898".equals(question.getTypeDetailName())) {
+            optionList.add(tagVO.getDivStart() + "T. \u6b63\u786e" + tagVO.getDivEnd());
+            optionList.add(tagVO.getDivStart() + "F. \u9519\u8bef" + tagVO.getDivEnd());
+            return optionList;
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionA())) {
+            String optionA = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionA());
+            optionList.add("A. " + tagVO.getDivStart() + optionA + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionB())) {
+            String optionB = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionB());
+            optionList.add("B. " + tagVO.getDivStart() + optionB + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionC())) {
+            String optionC = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionC());
+            optionList.add("C. " + tagVO.getDivStart() + optionC + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionD())) {
+            String optionD = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionD());
+            optionList.add("D. " + tagVO.getDivStart() + optionD + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionE())) {
+            String optionE = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionE());
+            optionList.add("E. " + tagVO.getDivStart() + optionE + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionF())) {
+            String optionF = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionF());
+            optionList.add("F. " + tagVO.getDivStart() + optionF + tagVO.getDivEnd());
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOptionG())) {
+            String optionG = FileServiceImpl.removeSpaceStrOfEnd(question.getOptionG());
+            optionList.add("G. " + tagVO.getDivStart() + optionG + tagVO.getDivEnd());
+        }
+        return optionList;
+    }
+
+    private static String removeSpaceStrOfEnd(String input) {
+        if (input == null) {
+            return null;
+        }
+        String step1 = input.replaceAll("(?<=>)([^<]*?)\\s+(?=<)", "$1");
+        String step2 = step1.replaceAll("\\s+$", "");
+        return step2;
+    }
+
+    private String notNullContent(String content) {
+        return StringUtils.isBlank((CharSequence)content) ? "" : content;
+    }
+
+    private String getAttachmentCard(String attachmentCard, Map<String, String> iconMap, Integer elementType, String attachmentName, String qrCodeUrl) {
+        BizAssert.isNotBlank((String)attachmentCard, (String)"\u9644\u4ef6\u5361\u7247\u6837\u5f0f\u4e3a\u7a7a");
+        BizAssert.notNull(iconMap, (String)"\u56fe\u6807\u914d\u7f6e\u4fe1\u606f\u4e3a\u7a7a");
+        ElementTypeEnum elementTypeEnum = ElementTypeEnum.get((Integer)elementType);
+        BizAssert.notNull((Object)elementTypeEnum, (String)"\u975e\u6cd5\u5143\u7d20\u7c7b\u578b");
+        qrCodeUrl = StringUtils.isBlank((CharSequence)qrCodeUrl) ? "" : qrCodeUrl;
+        attachmentName = StringUtils.isBlank((CharSequence)attachmentName) ? "\u672a\u547d\u540d" : attachmentName;
+        try {
+            String attachmentIcon = null;
+            if (ElementTypeEnum.AUDIO.getType().equals(elementType)) {
+                attachmentIcon = iconMap.get("audioIcon");
+            } else if (ElementTypeEnum.VIDEO.getType().equals(elementType)) {
+                attachmentIcon = iconMap.get("videoIcon");
+            } else if (ElementTypeEnum.GGB.getType().equals(elementType)) {
+                attachmentIcon = iconMap.get("ggbIcon");
+            } else if (ElementTypeEnum.CHEMISTRY.getType().equals(elementType)) {
+                attachmentIcon = iconMap.get("chemistryIcon");
+            } else if (ElementTypeEnum.MINDMAP.getType().equals(elementType)) {
+                attachmentIcon = iconMap.get("mindmapIcon");
+            }
+            BizAssert.isNotBlank((String)attachmentIcon, (String)("\u672a\u627e\u5230\u5143\u7d20\u3010" + elementTypeEnum.getName() + "\u3011\u56fe\u6807\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458"));
+            assert (attachmentIcon != null);
+            return attachmentCard.replace("attachmentIcon", attachmentIcon).replace("attachmentName", attachmentName).replace("qrCodeUrl", qrCodeUrl);
+        }
+        catch (BusinessException e) {
+            log.error("\u83b7\u53d6\u9644\u4ef6\u5361\u7247\u6837\u5f0f\u5f02\u5e38, attachmentCard:{}, iconMap:{}, elementType:{},attachmentName:{},qrCodeUrl:{}", new Object[]{attachmentCard, JSON.toJSONString(iconMap), elementType, attachmentName, qrCodeUrl, e});
+            throw e;
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u9644\u4ef6\u5361\u7247\u6837\u5f0f\u5f02\u5e38, attachmentCard:{}, iconMap:{}, elementType:{},attachmentName:{},qrCodeUrl:{}", new Object[]{attachmentCard, JSON.toJSONString(iconMap), elementType, attachmentName, qrCodeUrl, e});
+            throw new BusinessException("\u83b7\u53d6\u9644\u4ef6\u5361\u7247\u6837\u5f0f\u5f02\u5e38, \u8bf7\u8054\u7cfb\u7ba1\u7406\u5458");
+        }
+    }
+
+    private String downloadListenAudio(DownloadFileParam param) {
+        BizAssert.notNull((Object)param.getPdfFile(), (String)"pdf\u6587\u4ef6\u4e3a\u7a7a");
+        OfficeFileInfoVO fileInfo = (OfficeFileInfoVO)FeignUtils.parse((Result)this.officeFileServiceFeign.getFileInfo(new QueryFileParam().setFileId(param.getFileId())));
+        this.filterElementList(fileInfo, param.getEdition());
+        List<ExportQuestionVO> questionList = this.getQuestionList(fileInfo);
+        return WordExportUtil.createOfficeFile((CreateFileBO)new CreateFileBO().setPdf(param.getPdfFile()).setFileName(fileInfo.getFileName()).setQuestionList(questionList).setDownloadListenType(param.getDownloadListenType()));
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    private String downloadPdf(DownloadFileParam param) {
+        BizAssert.notNull((Object)param.getFileId(), (String)"\u6587\u6863id\u4e3a\u7a7a");
+        BizAssert.notNull((Object)param.getEdition(), (String)"\u4e0b\u8f7d\u7248\u672c\u4e3a\u7a7a");
+        String path = WordExportUtil.createPdf((CreatePdfParam)new CreatePdfParam().setShareCode(CodeUtil.convertToCode((long)param.getFileId())).setTemplate(String.format(this.officeFileConfig.getOfficeTemplate(), System.currentTimeMillis(), param.getFileId(), param.getEdition())));
+        assert (path != null);
+        File localFile = com.jby.common.util.FileUtil.getFile((String)path);
+        try {
+            MultipartFile file = com.jby.common.util.FileUtil.getMultipartFile((String)localFile.getName(), (File)localFile);
+            OfficeFileInfoVO fileInfo = (OfficeFileInfoVO)FeignUtils.parse((Result)this.officeFileServiceFeign.getFileInfo(new QueryFileParam().setFileId(param.getFileId())));
+            this.filterElementList(fileInfo, param.getEdition());
+            List<ExportQuestionVO> questionList = this.getQuestionList(fileInfo);
+            String string = WordExportUtil.createOfficeFile((CreateFileBO)new CreateFileBO().setPdf(file).setFileName(fileInfo.getFileName()).setQuestionList(questionList).setDownloadListenType(param.getDownloadListenType()));
+            return string;
+        }
+        finally {
+            FileUtil.del((File)localFile);
+        }
+    }
+
+    private List<ExportQuestionVO> getQuestionList(OfficeFileInfoVO fileInfo) {
+        return fileInfo.getElementList().stream().filter(e -> ElementTypeEnum.QUESTION.getType().equals(e.getElementType()) && Objects.nonNull(e.getQuestionDetail())).map(e -> new ExportQuestionVO().setQuestion(e.getQuestionDetail())).collect(Collectors.toList());
+    }
+
+    @Override
+    public OfficeFileDownloadScheduleVO batchDownloadOfficeFile(NodeParam rootNode) {
+        OfficeFileDownloadScheduleVO schedule = (OfficeFileDownloadScheduleVO)BeanMapping.toBean((Object)((Object)this.initDownloadSchedule(rootNode)), OfficeFileDownloadScheduleVO.class);
+        CompletableFuture.runAsync(() -> {
+            try {
+                this.asyncExecuteDownloadTask(rootNode, schedule.getId());
+                log.info("\u6279\u91cf\u4e0b\u8f7d\u5728\u7ebf\u6587\u4ef6\u5f02\u6b65\u4e3b\u7ebf\u7a0b====>\u7ed3\u675f, \u8fdb\u5ea6\u4e3b\u952eid:{}", (Object)schedule.getId());
+            }
+            catch (Exception e) {
+                log.error("\u5f02\u6b65\u4e0b\u8f7d\u4efb\u52a1\u6267\u884c\u5931\u8d25: {}", (Object)e.getMessage(), (Object)e);
+            }
+        }, (Executor)this.batchDownloadMainExecutor).exceptionally(e -> {
+            log.error("\u6279\u91cf\u4e0b\u8f7d\u5728\u7ebf\u6587\u4ef6\u5f02\u6b65\u4e3b\u4efb\u52a1\u63d0\u4ea4\u5931\u8d25: {}", (Object)e.getMessage(), e);
+            throw new BusinessException("\u6279\u91cf\u4e0b\u8f7d\u5728\u7ebf\u6587\u4ef6\u5f02\u6b65\u4e3b\u4efb\u52a1\u63d0\u4ea4\u5931\u8d25");
+        });
+        return schedule;
+    }
+
+    private OfficeFileDownloadSchedule initDownloadSchedule(NodeParam rootNode) {
+        SessionUser sessionUser = RequestUtil.getSessionUser((boolean)true);
+        OfficeFileDownloadSchedule progress = new OfficeFileDownloadSchedule();
+        progress.setCreateBy(sessionUser.getId());
+        progress.setCreateTime(LocalDateTime.now());
+        progress.setUpdateBy(sessionUser.getId());
+        progress.setUpdateTime(LocalDateTime.now());
+        progress.setFileName(rootNode.getNodeName());
+        AtomicInteger totalCount = new AtomicInteger(0);
+        this.countTotalFiles(rootNode, progress, totalCount);
+        if (this.officeFileConfig.getMaxDownloadNum() < totalCount.get()) {
+            throw new BusinessException("\u6587\u4ef6\u6570\u91cf\u8d85\u8fc7 " + this.officeFileConfig.getMaxDownloadNum() + "\u4e2a\uff0c\u65e0\u6cd5\u4e0b\u8f7d\uff0c\u8bf7\u91cd\u65b0\u9009\u62e9");
+        }
+        this.downloadScheduleService.saveOrUpdate((Object)progress);
+        return progress;
+    }
+
+    private void countTotalFiles(NodeParam rootNode, OfficeFileDownloadSchedule progress, AtomicInteger totalCount) {
+        if (rootNode.getIsFile().booleanValue()) {
+            progress.setTotalCount(totalCount.incrementAndGet());
+        } else if (CollectionUtils.isNotEmpty((Collection)rootNode.getNodeList())) {
+            for (NodeParam child : rootNode.getNodeList()) {
+                this.countTotalFiles(child, progress, totalCount);
+            }
+        }
+    }
+
+    private void asyncExecuteDownloadTask(NodeParam rootNode, Long id) {
+        OfficeFileDownloadSchedule downloadProgress = (OfficeFileDownloadSchedule)((Object)this.downloadScheduleService.getById(id));
+        ArrayList<CompletableFuture<Void>> downloadFutures = new ArrayList<CompletableFuture<Void>>();
+        try {
+            this.submitDownloadTasks(rootNode, "", downloadFutures);
+        }
+        catch (Exception e) {
+            log.error("\u4e0b\u8f7d\u4efb\u52a1\u5f02\u5e38{}", (Object)e.getMessage());
+            downloadProgress.setStatus(Integer.valueOf(DownScheduleTypeEnum.FAIL_TYPE.getType()));
+            this.officeFileDownloadScheduleMapper.updateById((Object)downloadProgress);
+            throw new BusinessException("\u4e0b\u8f7d\u4efb\u52a1\u5f02\u5e38");
+        }
+        CompletableFuture.allOf(downloadFutures.toArray(new CompletableFuture[0])).join();
+        String saveKey = AttachmentUtil.organize((NodeParam)rootNode);
+        AtomicInteger successCount = new AtomicInteger(0);
+        AtomicInteger failureCount = new AtomicInteger(0);
+        try {
+            for (CompletableFuture completableFuture : downloadFutures) {
+                try {
+                    completableFuture.join();
+                    downloadProgress.setSuccessCount(successCount.incrementAndGet());
+                }
+                catch (CompletionException e) {
+                    log.error("Download task failed\uff1a{}", (Object)e.getMessage());
+                    downloadProgress.setFailCount(failureCount.incrementAndGet());
+                }
+            }
+            String sourceKey = saveKey + "/" + rootNode.getNodeName();
+            String string = AttachmentUtil.compressToZip((String)sourceKey, (String)saveKey, (String)rootNode.getNodeName());
+            log.info("Compression completed: {}", (Object)string);
+            downloadProgress.setFileUrl(string);
+            downloadProgress.setStatus(Integer.valueOf(DownScheduleTypeEnum.SUCCESS_TYPE.getType()));
+            this.officeFileDownloadScheduleMapper.updateById((Object)downloadProgress);
+        }
+        catch (Exception e) {
+            log.error("\u538b\u7f29\u5931\u8d25\uff1a{}", (Object)e.getMessage());
+            downloadProgress.setStatus(Integer.valueOf(DownScheduleTypeEnum.FAIL_TYPE.getType()));
+            this.officeFileDownloadScheduleMapper.updateById((Object)downloadProgress);
+            throw new BusinessException("\u538b\u7f29\u5931\u8d25");
+        }
+    }
+
+    private void submitDownloadTasks(NodeParam node, String currentPath, List<CompletableFuture<Void>> downloadFutures) {
+        if (node.getIsFile().booleanValue()) {
+            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+                if (node.getOfficeFileId() != null && StringUtils.isBlank((CharSequence)node.getFileUrl())) {
+                    DownloadFileParam param = new DownloadFileParam();
+                    param.setFileId(node.getOfficeFileId());
+                    param.setFileType(FileTypeEnum.WORD.getType());
+                    param.setEdition(EditionEnum.TEACHER.getEdition());
+                    param.setDownloadListenType(ListenEnum.COMBINE_FILE.getType());
+                    try {
+                        String filePath = this.downloadOfficeFile(param);
+                        node.setFileUrl(filePath);
+                    }
+                    catch (Exception e) {
+                        log.error("Download task failed for file {}: {}", new Object[]{node.getOfficeFileId(), e.getMessage(), e});
+                    }
+                }
+            }, (Executor)this.batchDownloadTaskExecutor);
+            downloadFutures.add(future);
+        } else {
+            String newPath = currentPath + node.getNodeName() + "/";
+            if (CollectionUtils.isNotEmpty((Collection)node.getNodeList())) {
+                node.getNodeList().forEach(child -> this.submitDownloadTasks((NodeParam)child, newPath, downloadFutures));
+            }
+        }
+    }
+
+    public OfficeFileDownloadScheduleVO batchDownloadOfficeFile2(NodeParam rootNode) {
+        OfficeFileDownloadSchedule downloadProgress = this.initDownloadSchedule(rootNode);
+        String parentPath = this.initDownloadPath();
+        ArrayList<CompletableFuture<Void>> downloadFutures = new ArrayList<CompletableFuture<Void>>();
+        this.submitDownloadTasks(rootNode, "", downloadFutures);
+        CompletableFuture.allOf(downloadFutures.toArray(new CompletableFuture[0])).join();
+        String saveKey = AttachmentUtil.organize((NodeParam)rootNode);
+        CompletableFuture<Void> allDownloadsFuture = CompletableFuture.allOf(downloadFutures.toArray(new CompletableFuture[0]));
+        CompletionStage future = allDownloadsFuture.thenApplyAsync(v -> {
+            AtomicInteger successCount = new AtomicInteger(0);
+            AtomicInteger failureCount = new AtomicInteger(0);
+            try {
+                for (CompletableFuture downloadFuture : downloadFutures) {
+                    try {
+                        downloadFuture.join();
+                        downloadProgress.setSuccessCount(successCount.incrementAndGet());
+                    }
+                    catch (CompletionException e) {
+                        log.error("Download task failed", e.getCause());
+                        downloadProgress.setFailCount(failureCount.incrementAndGet());
+                    }
+                }
+                String sourceKey = saveKey + "/" + rootNode.getNodeName();
+                String zipPath = AttachmentUtil.compressToZip((String)sourceKey, (String)saveKey, (String)rootNode.getNodeName());
+                log.info("Compression completed: {}", (Object)zipPath);
+                downloadProgress.setFileUrl(zipPath);
+                downloadProgress.setStatus(Integer.valueOf(DownScheduleTypeEnum.SUCCESS_TYPE.getType()));
+                this.officeFileDownloadScheduleMapper.updateById((Object)downloadProgress);
+                return downloadProgress;
+            }
+            catch (Exception e) {
+                log.error("Compression failed", (Throwable)e);
+                downloadProgress.setStatus(Integer.valueOf(DownScheduleTypeEnum.FAIL_TYPE.getType()));
+                this.officeFileDownloadScheduleMapper.updateById((Object)downloadProgress);
+                return null;
+            }
+        }, (Executor)this.batchDownloadTaskExecutor);
+        OfficeFileDownloadSchedule join = (OfficeFileDownloadSchedule)((Object)((CompletableFuture)future).join());
+        return (OfficeFileDownloadScheduleVO)BeanMapping.toBean((Object)((Object)join), OfficeFileDownloadScheduleVO.class, (s, t) -> t.setId(s.getId()));
+    }
+
+    private String initDownloadPath() {
+        return SpringContextHolder.getActiveProfile() + "/" + AttachmentModuleEnum.OFFICE_FILE.getModule() + "/" + "organize" + "/" + LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE) + "/" + UniqueUtil.getUuid();
+    }
+
+    @Override
+    public OfficeFileParseRecordVO getOfficeFileParseRecordByMd5(String md5) {
+        List officeFileParseRecordList = this.officeFileParseRecordService.list((Wrapper)((LambdaQueryWrapper)Wrappers.lambdaQuery().eq(OfficeFileParseRecord::getFileMd5, (Object)md5)).orderByDesc(CommonBean::getCreateTime));
+        if (CollectionUtils.isNotEmpty((Collection)officeFileParseRecordList)) {
+            return (OfficeFileParseRecordVO)BeanMapping.toBean(officeFileParseRecordList.get(0), OfficeFileParseRecordVO.class);
+        }
+        return null;
+    }
+
+    @Override
+    public void saveOfficeFileParseRecord(OfficeFileParseRecordParam param) {
+        OfficeFileParseRecord bean = (OfficeFileParseRecord)((Object)BeanMapping.toBean((Object)param, OfficeFileParseRecord.class));
+        this.officeFileParseRecordService.save((Object)bean);
+        if (Objects.nonNull(bean.getFileId()) && bean.getFileId() > 0L && StringUtils.isNotBlank((CharSequence)bean.getFileUrl())) {
+            UpdateFileParam updateFileParam = new UpdateFileParam();
+            updateFileParam.setFileUrl(bean.getFileUrl());
+            updateFileParam.setFileId(bean.getFileId());
+            this.officeFileServiceFeign.updateFileUrl(updateFileParam);
+        }
+    }
+
+    @Override
+    public List<OfficeFileParseRecordVO> queryFileUrlByFileIds(OfficeFileParseRecordParam param) {
+        List officeFileParseRecordList = this.officeFileParseRecordService.list((Wrapper)((LambdaQueryWrapper)Wrappers.lambdaQuery().in(OfficeFileParseRecord::getFileId, (Collection)param.getFileIds())).orderByDesc(CommonBean::getCreateTime));
+        if (CollectionUtils.isEmpty((Collection)officeFileParseRecordList)) {
+            return Collections.emptyList();
+        }
+        return officeFileParseRecordList.stream().map(record -> (OfficeFileParseRecordVO)BeanMapping.toBean((Object)record, OfficeFileParseRecordVO.class)).collect(Collectors.toList());
+    }
+
+    private void addOption(QuestionDetailVO question, List<String> contentList, String questionNumber) {
+        if (Boolean.FALSE.equals(question.getIsSubjective()) && CollectionUtils.isNotEmpty((Collection)question.getOptionsList())) {
+            AtomicInteger counter = new AtomicInteger(0);
+            List<String> optionList = question.getOptionsList().stream().filter(StringUtils::isNotBlank).map(m -> (char)(65 + counter.getAndIncrement()) + "." + m.replace("<p>", "<span>").replace("</p>", "</span>")).collect(Collectors.toList());
+            if (Objects.nonNull(question.getOptionColumn()) && question.getOptionColumn() > 1) {
+                contentList.add(questionNumber + this.addMultiColumnOptionByTab(optionList, question.getOptionColumn()));
+            } else {
+                for (int i = 0; i < optionList.size(); ++i) {
+                    if (i == 0 && Objects.nonNull(question.getQuestionNumber())) {
+                        contentList.add(questionNumber + optionList.get(i));
+                        continue;
+                    }
+                    contentList.add((String)optionList.get(i));
+                }
+            }
+        }
+    }
+
+    private void dealCombination(QuestionDetailVO question, Integer edition, TagVO tagVO, List<String> contentList, OfficeFileStyleVO fileStyle) {
+        String allExplation;
+        boolean isAnswerEdition = EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition);
+        String string = allExplation = CollectionUtils.isEmpty((Collection)question.getAnswerExplanation()) ? "" : (String)question.getAnswerExplanation().get(0);
+        if (!isAnswerEdition) {
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            String contentPrefix1 = this.getContentPrefix(question, fileStyle);
+            contentList.add(contentPrefix1 + tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd());
+            if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                question.getChildList().forEach(two -> {
+                    String contentPrefix2 = this.getContentPrefix((QuestionDetailVO)two, fileStyle);
+                    contentList.add(contentPrefix2 + tagVO.getDivStart() + two.getContent() + tagVO.getDivEnd());
+                    this.addOption((QuestionDetailVO)two, contentList, "");
+                    if (CollectionUtils.isNotEmpty((Collection)two.getChildList())) {
+                        two.getChildList().forEach(three -> {
+                            if (LogicTypeEnum.MULTIPLE_CHOOSE_MULTIPLE.getLogicTypeId().equals(three.getLogicTypeId())) {
+                                return;
+                            }
+                            String contentPrefix3 = this.getContentPrefix((QuestionDetailVO)three, fileStyle);
+                            contentList.add(contentPrefix3 + tagVO.getDivStart() + three.getContent() + tagVO.getDivEnd());
+                            this.addOption((QuestionDetailVO)three, contentList, "");
+                        });
+                    }
+                });
+            }
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                HashMap questionMap = new HashMap();
+                AtomicBoolean lastMerger = new AtomicBoolean(false);
+                if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                    ArrayList twoAnswerList = new ArrayList();
+                    question.getChildList().forEach(two -> {
+                        questionMap.put(two.getQuestionId(), two);
+                        String twoAnswer = two.getAnswer();
+                        if (StringUtils.isNotBlank((CharSequence)twoAnswer) && !LogicTypeEnum.MULTIPLE_CHOOSE_MULTIPLE.getLogicTypeId().equals(two.getLogicTypeId())) {
+                            if (CollectionUtils.isEmpty((Collection)twoAnswerList)) {
+                                twoAnswerList.add(tagVO.getAnswer() + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), twoAnswer) + tagVO.getDivEnd());
+                            } else if (lastMerger.get() || LogicTypeEnum.RESPONSE.getLogicTypeId().equals(two.getLogicTypeId()) || LogicTypeEnum.COMBINATION.getLogicTypeId().equals(two.getLogicTypeId())) {
+                                twoAnswerList.add(tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), twoAnswer) + tagVO.getDivEnd());
+                            } else {
+                                twoAnswerList.set(twoAnswerList.size() - 1, (String)twoAnswerList.get(twoAnswerList.size() - 1) + "  " + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), twoAnswer) + tagVO.getDivEnd());
+                            }
+                            lastMerger.set(LogicTypeEnum.RESPONSE.getLogicTypeId().equals(two.getLogicTypeId()) || LogicTypeEnum.COMBINATION.getLogicTypeId().equals(two.getLogicTypeId()));
+                        }
+                        if (CollectionUtils.isNotEmpty((Collection)two.getChildList())) {
+                            ArrayList threeAnswerList = Lists.newArrayList();
+                            two.getChildList().forEach(three -> {
+                                String threeAnswer = three.getAnswer();
+                                if (StringUtils.isNotBlank((CharSequence)threeAnswer)) {
+                                    if (CollectionUtils.isEmpty((Collection)threeAnswerList)) {
+                                        threeAnswerList.add(((QuestionDetailVO)questionMap.get(three.getParentId())).getShowQuestionNumber() + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), threeAnswer) + tagVO.getDivEnd());
+                                        if (CollectionUtils.isEmpty((Collection)twoAnswerList)) {
+                                            threeAnswerList.set(0, tagVO.getAnswer() + (String)threeAnswerList.get(0));
+                                        }
+                                    } else if (lastMerger.get() || LogicTypeEnum.RESPONSE.getLogicTypeId().equals(three.getLogicTypeId())) {
+                                        threeAnswerList.add(tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), threeAnswer) + tagVO.getDivEnd());
+                                    } else {
+                                        threeAnswerList.set(threeAnswerList.size() - 1, (String)threeAnswerList.get(threeAnswerList.size() - 1) + "  " + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), threeAnswer) + tagVO.getDivEnd());
+                                    }
+                                    lastMerger.set(LogicTypeEnum.RESPONSE.getLogicTypeId().equals(two.getLogicTypeId()));
+                                }
+                            });
+                            if (CollectionUtils.isNotEmpty((Collection)threeAnswerList)) {
+                                twoAnswerList.addAll(threeAnswerList);
+                            }
+                        }
+                    });
+                    if (CollectionUtils.isNotEmpty(twoAnswerList)) {
+                        contentList.addAll(twoAnswerList.stream().map(m -> FileServiceImpl.checkContentStyle(m) ? m.replace("<p>", "<span>").replace("</p>", "</span>") : m).collect(Collectors.toList()));
+                    }
+                }
+                if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                    ArrayList twoExplanationList = new ArrayList();
+                    question.getChildList().forEach(two -> {
+                        if (CollectionUtils.isNotEmpty((Collection)two.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)two.getAnswerExplanation().get(0)))) {
+                            if (CollectionUtils.isEmpty((Collection)twoExplanationList)) {
+                                twoExplanationList.add(tagVO.getExplanation() + tagVO.getDivStart() + allExplation + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), (String)two.getAnswerExplanation().get(0)) + tagVO.getDivEnd());
+                            } else {
+                                twoExplanationList.add(tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), (String)two.getAnswerExplanation().get(0)) + tagVO.getDivEnd());
+                            }
+                        }
+                        if (CollectionUtils.isNotEmpty((Collection)two.getChildList())) {
+                            ArrayList threeExplanationList = new ArrayList();
+                            two.getChildList().forEach(three -> {
+                                if (CollectionUtils.isNotEmpty((Collection)three.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)three.getAnswerExplanation().get(0)))) {
+                                    if (CollectionUtils.isEmpty((Collection)threeExplanationList)) {
+                                        threeExplanationList.add(((QuestionDetailVO)questionMap.get(three.getParentId())).getShowQuestionNumber() + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), (String)three.getAnswerExplanation().get(0)) + tagVO.getDivEnd());
+                                        if (CollectionUtils.isEmpty((Collection)twoExplanationList)) {
+                                            threeExplanationList.set(0, tagVO.getExplanation() + allExplation + (String)threeExplanationList.get(0));
+                                        }
+                                    } else {
+                                        threeExplanationList.add(tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), (String)three.getAnswerExplanation().get(0)) + tagVO.getDivEnd());
+                                    }
+                                }
+                            });
+                            if (CollectionUtils.isNotEmpty(threeExplanationList)) {
+                                twoExplanationList.addAll(threeExplanationList);
+                            }
+                        }
+                    });
+                    if (CollectionUtils.isNotEmpty(twoExplanationList)) {
+                        contentList.addAll(twoExplanationList.stream().map(m -> FileServiceImpl.checkContentStyle(m) ? m.replace("<p>", "<span>").replace("</p>", "</span>") : m).collect(Collectors.toList()));
+                    }
+                    this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+                }
+            }
+        } else {
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+                if (StringUtils.isNotBlank((CharSequence)allExplation)) {
+                    contentList.add(tagVO.getDivStart() + allExplation + tagVO.getDivEnd());
+                }
+            }
+            HashMap<Long, QuestionDetailVO> questionMap = new HashMap<Long, QuestionDetailVO>();
+            questionMap.put(question.getQuestionId(), question);
+            if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                ArrayList twoAnswerExplanationList = new ArrayList();
+                AtomicInteger index = new AtomicInteger(0);
+                question.getChildList().forEach(two -> {
+                    FileServiceImpl.dealQuestionAnswerExplationStyle(two);
+                    questionMap.put(two.getQuestionId(), (QuestionDetailVO)two);
+                    String twoAnswer = two.getAnswer();
+                    String twoTmp = "";
+                    if (StringUtils.isNotBlank((CharSequence)twoAnswer) && !LogicTypeEnum.MULTIPLE_CHOOSE_MULTIPLE.getLogicTypeId().equals(two.getLogicTypeId())) {
+                        twoTmp = twoTmp + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(two.getShowQuestionNumber(), twoAnswer) + tagVO.getDivEnd();
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)two.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)two.getAnswerExplanation().get(0)))) {
+                        twoTmp = LogicTypeEnum.MULTIPLE_CHOOSE_MULTIPLE.getLogicTypeId().equals(two.getLogicTypeId()) ? twoTmp + tagVO.getDivStart() + (String)two.getAnswerExplanation().get(0) + tagVO.getDivEnd() : (LogicTypeEnum.RESPONSE.getLogicTypeId().equals(two.getLogicTypeId()) ? twoTmp + "<br/>" + tagVO.getExplanation() + tagVO.getDivStart() + (String)two.getAnswerExplanation().get(0) + tagVO.getDivEnd() : twoTmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)two.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+                        twoTmp = twoTmp + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                    }
+                    if (StringUtils.isNotBlank((CharSequence)twoTmp)) {
+                        if (!twoTmp.contains(tagVO.getExplanation()) && (LogicTypeEnum.RESPONSE.getLogicTypeId().equals(two.getLogicTypeId()) || LogicTypeEnum.COMBINATION.getLogicTypeId().equals(two.getLogicTypeId()))) {
+                            twoAnswerExplanationList.add(twoTmp + "###\u3010\u4e0d\u5408\u5e76\u3011###");
+                        } else {
+                            twoAnswerExplanationList.add(twoTmp);
+                        }
+                    }
+                    if (CollectionUtils.isNotEmpty((Collection)two.getChildList())) {
+                        ArrayList threeAnswerExplanationList = new ArrayList();
+                        two.getChildList().forEach(three -> {
+                            FileServiceImpl.dealQuestionAnswerExplationStyle(three);
+                            String threeAnswer = three.getAnswer();
+                            String threeTmp = "";
+                            if (StringUtils.isNotBlank((CharSequence)threeAnswer)) {
+                                threeTmp = threeTmp + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(three.getShowQuestionNumber(), threeAnswer) + tagVO.getDivEnd();
+                            }
+                            if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)three.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)three.getAnswerExplanation().get(0)))) {
+                                threeTmp = threeTmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)three.getAnswerExplanation().get(0) + tagVO.getDivEnd() + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                            }
+                            if (StringUtils.isNotBlank((CharSequence)threeTmp)) {
+                                if (CollectionUtils.isEmpty((Collection)threeAnswerExplanationList)) {
+                                    threeTmp = ((QuestionDetailVO)questionMap.get(three.getParentId())).getShowQuestionNumber() + threeTmp;
+                                }
+                                if (!threeTmp.contains(tagVO.getExplanation()) && LogicTypeEnum.RESPONSE.getLogicTypeId().equals(three.getLogicTypeId())) {
+                                    threeAnswerExplanationList.add(threeTmp + "###\u3010\u4e0d\u5408\u5e76\u3011###");
+                                } else {
+                                    threeAnswerExplanationList.add(threeTmp);
+                                }
+                            }
+                        });
+                        if (CollectionUtils.isNotEmpty(threeAnswerExplanationList)) {
+                            twoAnswerExplanationList.addAll(threeAnswerExplanationList);
+                        }
+                    }
+                    if (index.getAndIncrement() == 0 && CollectionUtils.isNotEmpty((Collection)twoAnswerExplanationList)) {
+                        String content = (String)twoAnswerExplanationList.get(0);
+                        String newContent = question.getShowQuestionNumber() + content;
+                        twoAnswerExplanationList.set(0, newContent);
+                    }
+                });
+                if (CollectionUtils.isNotEmpty(twoAnswerExplanationList)) {
+                    contentList.addAll(twoAnswerExplanationList);
+                }
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        }
+    }
+
+    private void dealBlank(QuestionDetailVO question, Integer edition, TagVO tagVO, List<String> contentList, OfficeFileStyleVO fileStyle) {
+        boolean isAnswerEdition;
+        boolean bl = isAnswerEdition = EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition);
+        if (!isAnswerEdition) {
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            String contentPrefix = this.getContentPrefix(question, fileStyle);
+            String questionStem = contentPrefix + tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd();
+            List numList = question.getChildList().stream().map(QuestionDetailVO::getShowQuestionNumber).collect(Collectors.toList());
+            Document parse = Jsoup.parseBodyFragment((String)questionStem);
+            parse.outputSettings().prettyPrint(false).indentAmount(0);
+            Elements numberSpans = parse.select("span.tinymce-horizontal-number, span.tinymce-line-number");
+            for (int i = 0; i < numberSpans.size(); ++i) {
+                Element span = (Element)numberSpans.get(i);
+                span.html(span.html().replaceAll("\\d+\\.?", (String)numList.get(i)).replace("&nbsp;", "&ensp;"));
+            }
+            contentList.add(parse.body().html());
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining("  "));
+                if (StringUtils.isNotBlank((CharSequence)answer)) {
+                    contentList.add(tagVO.getAnswer() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle(answer) ? answer.replace("<p>", "<span>").replace("</p>", "</span>") : answer) + tagVO.getDivEnd());
+                }
+                ArrayList<String> answerExplanation = new ArrayList<String>();
+                if (CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                    answerExplanation.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+                }
+                answerExplanation.addAll(question.getChildList().stream().filter(f -> CollectionUtils.isNotEmpty((Collection)f.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)f.getAnswerExplanation().get(0)))).map(m -> FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), (String)m.getAnswerExplanation().get(0))).collect(Collectors.toList()));
+                if (CollectionUtils.isNotEmpty(answerExplanation)) {
+                    for (int i = 0; i < answerExplanation.size(); ++i) {
+                        if (i == 0) {
+                            contentList.add(tagVO.getExplanation() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                            continue;
+                        }
+                        contentList.add(tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                    }
+                }
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        } else {
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            ArrayList<String> answerExplanationList = new ArrayList<String>();
+            if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                answerExplanationList.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                answerExplanationList.addAll(question.getChildList().stream().map(m -> {
+                    String tmp = "";
+                    if (StringUtils.isNotBlank((CharSequence)m.getAnswer())) {
+                        tmp = tmp + FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), m.getAnswer());
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)m.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)m.getAnswerExplanation().get(0)))) {
+                        tmp = tmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)m.getAnswerExplanation().get(0) + tagVO.getDivEnd() + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                    }
+                    return tmp;
+                }).collect(Collectors.toList()));
+            } else {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining("  "));
+                answerExplanationList.add(answer);
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                contentList.addAll(answerExplanationList.stream().map(m -> FileServiceImpl.checkContentStyle(m) ? m.replace("<p>", "<span>").replace("</p>", "</span>") : m).collect(Collectors.toList()));
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        }
+    }
+
+    private void dealCompletion(QuestionDetailVO question, Integer edition, TagVO tagVO, List<String> contentList, OfficeFileStyleVO fileStyle) {
+        boolean isAnswerEdition;
+        boolean bl = isAnswerEdition = EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition);
+        if (!isAnswerEdition) {
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            String contentPrefix = this.getContentPrefix(question, fileStyle);
+            String questionStem = contentPrefix + tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd();
+            List numList = question.getChildList().stream().map(QuestionDetailVO::getQuestionNumber).collect(Collectors.toList());
+            Document parse = Jsoup.parseBodyFragment((String)questionStem);
+            parse.outputSettings().prettyPrint(false).indentAmount(0);
+            Elements numberSpans = parse.select("span.tinymce-horizontal-number, span.tinymce-line-number");
+            for (int i = 0; i < numberSpans.size(); ++i) {
+                Element span = (Element)numberSpans.get(i);
+                span.html(span.html().replaceAll("\\d+\\.?", (String)numList.get(i)).replace("&nbsp;", "&ensp;"));
+            }
+            contentList.add(parse.body().html());
+            question.getChildList().forEach(f -> this.addOption((QuestionDetailVO)f, contentList, f.getShowQuestionNumber()));
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining("  "));
+                if (StringUtils.isNotBlank((CharSequence)answer)) {
+                    contentList.add(tagVO.getAnswer() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle(answer) ? answer.replace("<p>", "<span>").replace("</p>", "</span>") : answer) + tagVO.getDivEnd());
+                }
+                ArrayList<String> answerExplanation = new ArrayList<String>();
+                if (CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                    answerExplanation.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+                }
+                answerExplanation.addAll(question.getChildList().stream().filter(f -> CollectionUtils.isNotEmpty((Collection)f.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)f.getAnswerExplanation().get(0)))).map(m -> FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), (String)m.getAnswerExplanation().get(0))).collect(Collectors.toList()));
+                if (CollectionUtils.isNotEmpty(answerExplanation)) {
+                    for (int i = 0; i < answerExplanation.size(); ++i) {
+                        if (i == 0) {
+                            contentList.add(tagVO.getExplanation() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                            continue;
+                        }
+                        contentList.add(tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                    }
+                }
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        } else {
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            ArrayList<String> answerExplanationList = new ArrayList<String>();
+            if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                answerExplanationList.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                answerExplanationList.addAll(question.getChildList().stream().map(m -> {
+                    String tmp = "";
+                    if (StringUtils.isNotBlank((CharSequence)m.getAnswer())) {
+                        tmp = tmp + FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), m.getAnswer());
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)m.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)m.getAnswerExplanation().get(0)))) {
+                        tmp = tmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)m.getAnswerExplanation().get(0) + tagVO.getDivEnd() + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                    }
+                    return tmp;
+                }).collect(Collectors.toList()));
+            } else {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining("  "));
+                answerExplanationList.add(answer);
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                contentList.addAll(answerExplanationList.stream().map(m -> FileServiceImpl.checkContentStyle(m) ? m.replace("<p>", "<span>").replace("</p>", "</span>") : m).collect(Collectors.toList()));
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        }
+    }
+
+    private void dealMultipleChooseMultiple(QuestionDetailVO question, Integer edition, TagVO tagVO, List<String> contentList, OfficeFileStyleVO fileStyle) {
+        boolean isAnswerEdition;
+        boolean bl = isAnswerEdition = EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition);
+        if (!isAnswerEdition) {
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            String contentPrefix = this.getContentPrefix(question, fileStyle);
+            String questionStem = contentPrefix + tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd();
+            List numList = question.getChildList().stream().map(QuestionDetailVO::getQuestionNumber).collect(Collectors.toList());
+            Document parse = Jsoup.parseBodyFragment((String)questionStem);
+            parse.outputSettings().prettyPrint(false).indentAmount(0);
+            Elements numberSpans = parse.select("span.tinymce-horizontal-number, span.tinymce-line-number");
+            for (int i = 0; i < numberSpans.size(); ++i) {
+                Element span = (Element)numberSpans.get(i);
+                span.html(span.html().replaceAll("\\d+\\.?", (String)numList.get(i)).replace("&nbsp;", "&ensp;"));
+            }
+            contentList.add(parse.body().html());
+            this.addOption(question, contentList, "");
+            if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining(" "));
+                if (StringUtils.isNotBlank((CharSequence)answer)) {
+                    contentList.add(tagVO.getAnswer() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle(answer) ? answer.replace("<p>", "<span>").replace("</p>", "</span>") : answer) + tagVO.getDivEnd());
+                }
+                ArrayList<String> answerExplanation = new ArrayList<String>();
+                if (CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                    answerExplanation.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+                }
+                answerExplanation.addAll(question.getChildList().stream().filter(f -> CollectionUtils.isNotEmpty((Collection)f.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)f.getAnswerExplanation().get(0)))).map(m -> FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), (String)m.getAnswerExplanation().get(0))).collect(Collectors.toList()));
+                if (CollectionUtils.isNotEmpty(answerExplanation)) {
+                    for (int i = 0; i < answerExplanation.size(); ++i) {
+                        if (i == 0) {
+                            contentList.add(tagVO.getExplanation() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                            continue;
+                        }
+                        contentList.add(tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)answerExplanation.get(i)) ? ((String)answerExplanation.get(i)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)answerExplanation.get(i)) + tagVO.getDivEnd());
+                    }
+                }
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        } else {
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 1);
+            }
+            ArrayList<String> answerExplanationList = new ArrayList<String>();
+            if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)question.getAnswerExplanation().get(0)))) {
+                answerExplanationList.add(tagVO.getDivStart() + (String)question.getAnswerExplanation().get(0) + tagVO.getDivEnd());
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                answerExplanationList.addAll(question.getChildList().stream().map(m -> {
+                    String tmp = "";
+                    if (StringUtils.isNotBlank((CharSequence)m.getAnswer())) {
+                        tmp = tmp + FileServiceImpl.joinQuestionNum(m.getShowQuestionNumber(), m.getAnswer());
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)m.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)m.getAnswerExplanation().get(0)))) {
+                        tmp = tmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)m.getAnswerExplanation().get(0) + tagVO.getDivEnd() + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                    }
+                    return tmp;
+                }).collect(Collectors.toList()));
+            } else {
+                String answer = question.getChildList().stream().filter(f -> StringUtils.isNotBlank((CharSequence)f.getAnswer())).map(m -> FileServiceImpl.joinQuestionNum2(m.getShowQuestionNumber(), m.getAnswer())).collect(Collectors.joining("  "));
+                answerExplanationList.add(answer);
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                contentList.addAll(answerExplanationList.stream().map(m -> FileServiceImpl.checkContentStyle(m) ? m.replace("<p>", "<span>").replace("</p>", "</span>") : m).collect(Collectors.toList()));
+            }
+            if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                this.addQuestionInfo(edition, question, tagVO, contentList, 2);
+            }
+        }
+    }
+
+    private void collectQuestionBankInfo(List<String> contentList, Integer edition, OfficeConfigVO officeConfig, OfficeFileElementVO element, List<TitleBO> titleList, List<ExportQuestionVO> questionList, OfficeFileStyleVO fileStyle) {
+        QuestionDetailVO one = element.getQuestionDetail();
+        int startIndex = contentList.size();
+        if (Objects.nonNull(one)) {
+            questionList.add(new ExportQuestionVO().setQuestion(one));
+            if (EditionEnum.STUDENT.getEdition().equals(edition) || EditionEnum.TEACHER.getEdition().equals(edition)) {
+                if (LogicTypeEnum.COMBINATION.getLogicTypeId().equals(one.getLogicTypeId()) && Objects.nonNull(one.getMergerType()) && one.getMergerType() == 1) {
+                    BigDecimal score = one.getChildList().stream().map(m -> {
+                        if (CollectionUtils.isNotEmpty((Collection)m.getChildList())) {
+                            return m.getChildList().stream().filter(c2 -> Objects.nonNull(c2.getScore()) && c2.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                        }
+                        return Objects.nonNull(m.getScore()) ? m.getScore() : BigDecimal.ZERO;
+                    }).reduce(BigDecimal.ZERO, BigDecimal::add);
+                    titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(one.getContent()).setScore(score));
+                } else if (CollectionUtils.isNotEmpty((Collection)one.getChildList())) {
+                    for (QuestionDetailVO child1 : one.getChildList()) {
+                        if ("\u6bb5\u843d".equals(child1.getLogicTypeName())) continue;
+                        if (CollectionUtils.isNotEmpty((Collection)child1.getChildList())) {
+                            List child1List = child1.getChildList();
+                            if (child1.getLogicTypeName().equals("\u7ec4\u5408")) {
+                                BigDecimal reduce = child1List.stream().filter(m -> Objects.nonNull(m.getScore()) && m.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                                titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(child1.getContent()).setScore(reduce));
+                                continue;
+                            }
+                            child1List.forEach(child2 -> ((TitleBO)titleList.get(titleList.size() - 1)).getQuestionList().add(new QuestionBO().setQuestionContent(child2.getContent()).setScore(child2.getScore())));
+                            continue;
+                        }
+                        titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(child1.getContent()).setScore(child1.getScore()));
+                    }
+                } else {
+                    titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(one.getContent()).setScore(one.getScore()));
+                }
+            }
+            TagVO tagVO = officeConfig.getTagVO();
+            if (LogicTypeEnum.COMBINATION.getLogicTypeId().equals(one.getLogicTypeId())) {
+                this.dealCombination(one, edition, tagVO, contentList, fileStyle);
+            } else if (LogicTypeEnum.BLANK.getLogicTypeId().equals(one.getLogicTypeId()) && Objects.nonNull(one.getMergerType()) && one.getMergerType() == 1) {
+                this.dealBlank(one, edition, tagVO, contentList, fileStyle);
+            } else if (LogicTypeEnum.COMPLETION.getLogicTypeId().equals(one.getLogicTypeId())) {
+                this.dealCompletion(one, edition, tagVO, contentList, fileStyle);
+            } else if (LogicTypeEnum.MULTIPLE_CHOOSE_MULTIPLE.getLogicTypeId().equals(one.getLogicTypeId())) {
+                this.dealMultipleChooseMultiple(one, edition, tagVO, contentList, fileStyle);
+            } else {
+                boolean isAnswerEdition;
+                boolean bl = isAnswerEdition = EditionEnum.ANSWER.getEdition().equals(edition) || EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition);
+                if (!isAnswerEdition) {
+                    if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                        this.addQuestionInfo(edition, one, tagVO, contentList, 1);
+                    }
+                    String contentPrefix = this.getContentPrefix(one, fileStyle);
+                    contentList.add(contentPrefix + tagVO.getDivStart() + one.getContent() + tagVO.getDivEnd());
+                    this.addOption(one, contentList, "");
+                    if (EditionEnum.TEACHER.getEdition().equals(edition)) {
+                        if (StringUtils.isNotBlank((CharSequence)one.getAnswer())) {
+                            contentList.add(tagVO.getAnswer() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle(one.getAnswer()) ? one.getAnswer().replace("<p>", "<span>").replace("</p>", "</span>") : one.getAnswer()) + tagVO.getDivEnd());
+                        }
+                        if (CollectionUtils.isNotEmpty((Collection)one.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)one.getAnswerExplanation().get(0)))) {
+                            contentList.add(tagVO.getExplanation() + tagVO.getDivStart() + (FileServiceImpl.checkContentStyle((String)one.getAnswerExplanation().get(0)) ? ((String)one.getAnswerExplanation().get(0)).replace("<p>", "<span>").replace("</p>", "</span>") : (String)one.getAnswerExplanation().get(0)) + tagVO.getDivEnd());
+                        }
+                        this.addQuestionInfo(edition, one, tagVO, contentList, 2);
+                    }
+                } else {
+                    if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                        this.addQuestionInfo(edition, one, tagVO, contentList, 1);
+                    }
+                    String tmp = "";
+                    if (StringUtils.isNotBlank((CharSequence)one.getAnswer())) {
+                        tmp = FileServiceImpl.checkContentStyle(one.getAnswer()) ? tmp + one.getShowQuestionNumber() + tagVO.getDivStart() + one.getAnswer().replace("<p>", "<span>").replace("</p>", "</span>") + tagVO.getDivEnd() : tmp + tagVO.getDivStart() + FileServiceImpl.joinQuestionNum(one.getShowQuestionNumber(), one.getAnswer()) + tagVO.getDivEnd();
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition) && CollectionUtils.isNotEmpty((Collection)one.getAnswerExplanation()) && StringUtils.isNotBlank((CharSequence)((CharSequence)one.getAnswerExplanation().get(0)))) {
+                        if (LogicTypeEnum.RESPONSE.getLogicTypeId().equals(one.getLogicTypeId())) {
+                            tmp = tmp + "<br/>";
+                        }
+                        tmp = tmp + tagVO.getExplanation() + tagVO.getDivStart() + (String)one.getAnswerExplanation().get(0) + tagVO.getDivEnd() + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+                    }
+                    if (!tmp.contains(tagVO.getExplanation()) && LogicTypeEnum.RESPONSE.getLogicTypeId().equals(one.getLogicTypeId())) {
+                        contentList.add(tmp + "###\u3010\u4e0d\u5408\u5e76\u3011###");
+                    } else {
+                        contentList.add(tmp);
+                    }
+                    if (EditionEnum.ANSWER.getEdition().equals(edition)) {
+                        this.addQuestionInfo(edition, one, tagVO, contentList, 2);
+                    }
+                }
+            }
+            for (int i = startIndex; i < contentList.size(); ++i) {
+                if (!EditionEnum.ANSWER.getEdition().equals(edition) && !EditionEnum.ANSWER_ONLY_ANSWER.getEdition().equals(edition)) continue;
+                contentList.set(i, contentList.get(i) + "###\u3010\u9898\u76ee\u3011###");
+            }
+        }
+    }
+
+    private void collectQuestionInfoNew(List<String> contentList, List<ExportQuestionVO> questionList, OfficeFileStyleVO fileStyle, String editionStr, OfficeConfigVO officeConfig, ElementNumberUtil elementNumberUtil, List<TitleBO> titleList, OfficeFileElementVO element) {
+        QuestionDetailVO question1 = element.getQuestionDetail();
+        String logicTypeName = question1.getLogicTypeName();
+        questionList.add(new ExportQuestionVO().setQuestion(question1));
+        String elementNum1 = "\u586b\u7a7a".equals(logicTypeName) && Objects.nonNull(question1.getMergerType()) && question1.getMergerType() == 1 || "\u5b8c\u5f62".equals(logicTypeName) || "\u591a\u9009\u591a".equals(logicTypeName) || "\u7ec4\u5408".equals(logicTypeName) && question1.getMergerType() == 0 ? "" : this.getQuestionNum(question1, element, fileStyle, officeConfig, elementNumberUtil);
+        Integer startIndex1 = this.dealQuestionInfo(contentList, elementNum1, question1, logicTypeName, officeConfig.getTagVO(), fileStyle, 1, editionStr);
+        if (editionStr.equals("\u3010\u5b66\u751f\u7248\u3011") || editionStr.equals("\u3010\u6559\u5e08\u7248\u3011")) {
+            if (question1.getLogicTypeName().equals("\u7ec4\u5408") && Objects.nonNull(question1.getMergerType()) && question1.getMergerType() == 1) {
+                BigDecimal score = question1.getChildList().stream().map(m -> {
+                    if (CollectionUtils.isNotEmpty((Collection)m.getChildList())) {
+                        return m.getChildList().stream().filter(c2 -> Objects.nonNull(c2.getScore()) && c2.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                    }
+                    return Objects.nonNull(m.getScore()) ? m.getScore() : BigDecimal.ZERO;
+                }).reduce(BigDecimal.ZERO, BigDecimal::add);
+                titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(question1.getContent()).setScore(score));
+            } else if (CollectionUtils.isNotEmpty((Collection)question1.getChildList())) {
+                for (QuestionDetailVO child1 : question1.getChildList()) {
+                    if ("\u6bb5\u843d".equals(child1.getLogicTypeName())) continue;
+                    if (CollectionUtils.isNotEmpty((Collection)child1.getChildList())) {
+                        List child1List = child1.getChildList();
+                        if (child1.getLogicTypeName().equals("\u7ec4\u5408")) {
+                            BigDecimal reduce = child1List.stream().filter(m -> Objects.nonNull(m.getScore()) && m.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                            titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(child1.getContent()).setScore(reduce));
+                            continue;
+                        }
+                        child1List.forEach(child2 -> ((TitleBO)titleList.get(titleList.size() - 1)).getQuestionList().add(new QuestionBO().setQuestionContent(child2.getContent()).setScore(child2.getScore())));
+                        continue;
+                    }
+                    titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(child1.getContent()).setScore(child1.getScore()));
+                }
+            } else {
+                titleList.get(titleList.size() - 1).getQuestionList().add(new QuestionBO().setQuestionContent(question1.getContent()).setScore(question1.getScore()));
+            }
+        }
+        ArrayList<String> numList1 = new ArrayList<String>();
+        if (!CollectionUtils.isEmpty((Collection)question1.getChildList())) {
+            int num1 = 0;
+            for (int i = 0; i < question1.getChildList().size(); ++i) {
+                QuestionDetailVO question2 = (QuestionDetailVO)question1.getChildList().get(i);
+                String elementNum2 = "";
+                if (!"\u6bb5\u843d".equals(question2.getLogicTypeName()) || question2.getMergerType() != 1) {
+                    if (!"\u7ec4\u5408".equals(logicTypeName)) {
+                        elementNum2 = this.getQuestionNum(question2, element, fileStyle, officeConfig, elementNumberUtil);
+                    } else if (!"\u5b8c\u5f62".equals(question2.getLogicTypeName()) && !"\u591a\u9009\u591a".equals(question2.getLogicTypeName())) {
+                        if (question1.getMergerType() == 0) {
+                            elementNum2 = this.getQuestionNum(question2, element, fileStyle, officeConfig, elementNumberUtil);
+                        } else {
+                            elementNum2 = "(" + (num1 + 1) + ")";
+                            ++num1;
+                        }
+                    }
+                }
+                numList1.add(elementNum2.replace(".", ""));
+                Integer startIndex2 = this.dealQuestionInfo(contentList, elementNum2, question2, logicTypeName, officeConfig.getTagVO(), fileStyle, 2, editionStr);
+                ArrayList<String> numList2 = new ArrayList<String>();
+                if (!CollectionUtils.isEmpty((Collection)question2.getChildList())) {
+                    int num2 = 0;
+                    for (int j = 0; j < question2.getChildList().size(); ++j) {
+                        QuestionDetailVO question3 = (QuestionDetailVO)question2.getChildList().get(j);
+                        String elementNum3 = "";
+                        if (!"\u6bb5\u843d".equals(question3.getLogicTypeName()) || question3.getMergerType() != 1) {
+                            if ("\u5b8c\u5f62".equals(question3.getLogicTypeName()) || "\u591a\u9009\u591a".equals(question3.getLogicTypeName())) {
+                                elementNum3 = this.getQuestionNum(question3, element, fileStyle, officeConfig, elementNumberUtil);
+                            } else if (question1.getMergerType() == 0) {
+                                elementNum3 = "(" + (num2 + 1) + ")";
+                                ++num2;
+                            } else {
+                                elementNum3 = String.valueOf((char)(9311 + num2 + 1));
+                                ++num2;
+                            }
+                        }
+                        numList2.add(elementNum3.replace(".", ""));
+                        this.dealQuestionInfo(contentList, elementNum3, question3, logicTypeName, officeConfig.getTagVO(), fileStyle, 3, editionStr);
+                    }
+                }
+                if (!editionStr.equals("\u3010\u5b66\u751f\u7248\u3011") && !editionStr.equals("\u3010\u6559\u5e08\u7248\u3011")) continue;
+                if ("\u5b8c\u5f62".equals(question2.getLogicTypeName()) || "\u591a\u9009\u591a".equals(question2.getLogicTypeName())) {
+                    this.updateContentNum(contentList, startIndex2, numList2);
+                }
+                if (!"\u7ec4\u5408".equals(question2.getLogicTypeName())) continue;
+                ArrayList<String> answerList = new ArrayList<String>();
+                ArrayList<String> explanationList = new ArrayList<String>();
+                ArrayList<String> otherList = new ArrayList<String>();
+                boolean lastIsMerge = false;
+                for (int j = startIndex2.intValue(); j < contentList.size(); ++j) {
+                    String content = contentList.get(j);
+                    if (content.contains("\u3010\u7b54\u6848\u3011")) {
+                        content = content.replace("\u3010\u7b54\u6848\u3011", "");
+                        if (CollectionUtils.isEmpty(answerList)) {
+                            answerList.add("\u3010\u7b54\u6848\u3011\u3010\u5408\u5e76\u3011" + elementNum2 + content);
+                        } else if (content.contains("\u3010\u5408\u5e76\u3011") || lastIsMerge) {
+                            answerList.add("\u3010\u7b54\u6848\u3011\u3010\u5408\u5e76\u3011" + content);
+                        } else {
+                            answerList.set(answerList.size() - 1, (String)answerList.get(answerList.size() - 1) + "  " + content);
+                        }
+                        lastIsMerge = content.contains("\u3010\u5408\u5e76\u3011");
+                        continue;
+                    }
+                    if (content.contains("\u3010\u89e3\u6790\u3011")) {
+                        content = content.replace("\u3010\u89e3\u6790\u3011", "");
+                        explanationList.add("\u3010\u89e3\u6790\u3011" + elementNum2 + content);
+                        continue;
+                    }
+                    otherList.add(content);
+                }
+                contentList.subList(startIndex2, contentList.size()).clear();
+                contentList.addAll(otherList);
+                contentList.addAll(answerList);
+                contentList.addAll(explanationList);
+            }
+        }
+        if (editionStr.equals("\u3010\u5b66\u751f\u7248\u3011") || editionStr.equals("\u3010\u6559\u5e08\u7248\u3011")) {
+            if ("\u586b\u7a7a".equals(logicTypeName) && Objects.nonNull(question1.getMergerType()) && question1.getMergerType() == 1 || "\u5b8c\u5f62".equals(logicTypeName) || "\u591a\u9009\u591a".equals(logicTypeName)) {
+                this.updateContentNum(contentList, startIndex1, numList1);
+            }
+            if ("\u7ec4\u5408".equals(question1.getLogicTypeName())) {
+                List<Object> answerList = new ArrayList();
+                ArrayList<String> explanationList = new ArrayList<String>();
+                ArrayList<String> otherList = new ArrayList<String>();
+                boolean lastIsMerge = false;
+                String lastNum = "";
+                for (int i = startIndex1.intValue(); i < contentList.size(); ++i) {
+                    String content = contentList.get(i);
+                    if (content.contains("\u3010\u7b54\u6848\u3011")) {
+                        if (CollectionUtils.isEmpty(answerList)) {
+                            answerList.add(officeConfig.getTagVO().getAnswer() + officeConfig.getTagVO().getDivStart() + (question1.getMergerType() == 0 ? elementNum1 : "") + content.replace("\u3010\u7b54\u6848\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                        } else if (content.contains("\u3010\u5408\u5e76\u3011") || lastIsMerge) {
+                            answerList.add(officeConfig.getTagVO().getDivStart() + (question1.getMergerType() == 0 ? elementNum1 : "") + content.replace("\u3010\u7b54\u6848\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                        } else {
+                            answerList.set(answerList.size() - 1, (String)answerList.get(answerList.size() - 1) + "  " + (question1.getMergerType() == 0 ? elementNum1 : "") + content.replace("\u3010\u7b54\u6848\u3011", ""));
+                        }
+                        lastIsMerge = content.contains("\u3010\u5408\u5e76\u3011");
+                        continue;
+                    }
+                    if (content.contains("\u3010\u89e3\u6790\u3011")) {
+                        String curNum;
+                        String regExp = question1.getMergerType() == 0 ? "^(\\d+\\.)" : "^(\\(\\d+\\))";
+                        Pattern pattern = Pattern.compile(regExp);
+                        Matcher matcher = pattern.matcher(content.replace("\u3010\u89e3\u6790\u3011", ""));
+                        if (CollectionUtils.isEmpty(explanationList)) {
+                            lastNum = matcher.find() ? matcher.group(1) : "";
+                            explanationList.add(officeConfig.getTagVO().getExplanation() + officeConfig.getTagVO().getDivStart() + content.replace("\u3010\u89e3\u6790\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                            continue;
+                        }
+                        String string = curNum = matcher.find() ? matcher.group(1) : "";
+                        if (curNum.equals(lastNum)) {
+                            explanationList.add(officeConfig.getTagVO().getDivStart() + content.replace("\u3010\u89e3\u6790\u3011", "").replaceFirst(Pattern.quote(curNum), "") + officeConfig.getTagVO().getDivEnd());
+                        } else {
+                            explanationList.add(officeConfig.getTagVO().getDivStart() + content.replace("\u3010\u89e3\u6790\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                        }
+                        lastNum = curNum;
+                        continue;
+                    }
+                    otherList.add(content);
+                }
+                answerList = answerList.stream().map(m -> m.replace("\u3010\u5408\u5e76\u3011", "")).collect(Collectors.toList());
+                contentList.subList(startIndex1, contentList.size()).clear();
+                contentList.addAll(otherList);
+                contentList.addAll(answerList);
+                contentList.addAll(explanationList);
+            }
+            if ("\u586b\u7a7a".equals(logicTypeName) && question1.getMergerType() == 1 || "\u5b8c\u5f62".equals(logicTypeName) || "\u591a\u9009\u591a".equals(logicTypeName)) {
+                String lj = "\u5b8c\u5f62".equals(logicTypeName) || "\u591a\u9009\u591a".equals(logicTypeName) ? "  " : "\uff1b";
+                String answer = "";
+                ArrayList<String> explanationList = new ArrayList<String>();
+                ArrayList<String> otherList = new ArrayList<String>();
+                for (int i = startIndex1.intValue(); i < contentList.size(); ++i) {
+                    String content = contentList.get(i);
+                    if (content.contains("\u3010\u7b54\u6848\u3011")) {
+                        content = content.replace("\u3010\u7b54\u6848\u3011", "");
+                        answer = StringUtils.isBlank((CharSequence)answer) ? content : answer + lj + content;
+                        continue;
+                    }
+                    if (content.contains("\u3010\u89e3\u6790\u3011")) {
+                        if (CollectionUtils.isEmpty(explanationList)) {
+                            explanationList.add(officeConfig.getTagVO().getExplanation() + officeConfig.getTagVO().getDivStart() + content.replace("\u3010\u89e3\u6790\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                            continue;
+                        }
+                        explanationList.add(officeConfig.getTagVO().getDivStart() + content.replace("\u3010\u89e3\u6790\u3011", "") + officeConfig.getTagVO().getDivEnd());
+                        continue;
+                    }
+                    otherList.add(content);
+                }
+                contentList.subList(startIndex1, contentList.size()).clear();
+                contentList.addAll(otherList);
+                contentList.add(officeConfig.getTagVO().getAnswer() + officeConfig.getTagVO().getDivStart() + answer + officeConfig.getTagVO().getDivEnd());
+                contentList.addAll(explanationList);
+            }
+        }
+        ArrayList<String> cList = new ArrayList<String>();
+        for (int i = startIndex1.intValue(); i < contentList.size(); ++i) {
+            String content = contentList.get(i);
+            if (!content.contains(editionStr)) continue;
+            content = content.replace("\u3010\u5408\u5e76\u3011", "").replace("\u3010\u5b66\u751f\u7248\u3011", "").replace("\u3010\u6559\u5e08\u7248\u3011", "");
+            if ("\u3010\u6559\u5e08\u7248\u3011".equals(editionStr) || "\u3010\u5b66\u751f\u7248\u3011".equals(editionStr)) {
+                content = content.replace("\u3010\u7b54\u6848\u7248\u3011", "").replace("\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011", "");
+            }
+            cList.add(content);
+        }
+        contentList.subList(startIndex1, contentList.size()).clear();
+        contentList.addAll(cList);
+    }
+
+    private String getQuestionNum(QuestionDetailVO question, OfficeFileElementVO element, OfficeFileStyleVO fileStyle, OfficeConfigVO officeConfig, ElementNumberUtil elementNumberUtil) {
+        ElementNumBO elementNumBO = question.isSystemQuestionNumber() != false ? elementNumberUtil.getElementNum(element, fileStyle, officeConfig.getElementNumStyleMap(), officeConfig.getElementIconMap()) : new ElementNumBO().setStyleElementNum(question.getShowCustomQuestionNumber());
+        return elementNumBO.getStyleElementNum();
+    }
+
+    private Integer dealQuestionInfo(List<String> contentList, String numStr, QuestionDetailVO question, String logicTypeName, TagVO tagVO, OfficeFileStyleVO fileStyle, Integer level, String editionStr) {
+        boolean isAnswerEdition;
+        ArrayList<String> tmpContentList = new ArrayList<String>();
+        boolean bl = isAnswerEdition = "\u3010\u7b54\u6848\u7248\u3011".equals(editionStr) || "\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011".equals(editionStr);
+        if (StringUtils.isNotBlank((CharSequence)question.getContent())) {
+            String content = tagVO.getDivStart() + question.getContent() + tagVO.getDivEnd() + "\u3010\u5b66\u751f\u7248\u3011" + "\u3010\u6559\u5e08\u7248\u3011";
+            if (!isAnswerEdition && level == 1 && CollectionUtils.isNotEmpty((Collection)question.getSourceFeature()) && Objects.nonNull(fileStyle) && fileStyle.getQuestionSourceShowFlag() == 1 && StringUtils.isNotBlank((CharSequence)((QuestionSourceFeatureMetadataDTO)question.getSourceFeature().get(0)).getSourceShortNote())) {
+                String source = "\uff08" + ((QuestionSourceFeatureMetadataDTO)question.getSourceFeature().get(0)).getSourceShortNote() + "\uff09";
+                content = source + content;
+            }
+            if (Boolean.TRUE.equals(question.getIsShowScore()) && !isAnswerEdition) {
+                if (level == 1 && question.getLogicTypeName().equals("\u7ec4\u5408") && Objects.nonNull(question.getMergerType()) && question.getMergerType() == 1) {
+                    BigDecimal score = question.getChildList().stream().map(m -> {
+                        if (CollectionUtils.isNotEmpty((Collection)m.getChildList())) {
+                            return m.getChildList().stream().filter(c2 -> Objects.nonNull(c2.getScore()) && c2.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                        }
+                        return Objects.nonNull(m.getScore()) ? m.getScore() : BigDecimal.ZERO;
+                    }).reduce(BigDecimal.ZERO, BigDecimal::add);
+                    if (score.compareTo(BigDecimal.ZERO) > 0) {
+                        content = "\uff08" + score.stripTrailingZeros().toPlainString() + "\u5206\uff09" + content;
+                    }
+                } else if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                    int questionsNum = 0;
+                    ArrayList<BigDecimal> scoreList = new ArrayList<BigDecimal>();
+                    for (QuestionDetailVO child1 : question.getChildList()) {
+                        if ("\u6bb5\u843d".equals(child1.getLogicTypeName())) continue;
+                        if (CollectionUtils.isNotEmpty((Collection)child1.getChildList())) {
+                            List child1List = child1.getChildList();
+                            questionsNum = child1.getLogicTypeName().equals("\u7ec4\u5408") ? ++questionsNum : (questionsNum += child1List.size());
+                            BigDecimal reduce = child1List.stream().filter(m -> Objects.nonNull(m.getScore()) && m.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                            if (reduce.compareTo(BigDecimal.ZERO) <= 0) continue;
+                            scoreList.add(reduce);
+                            continue;
+                        }
+                        ++questionsNum;
+                        if (!Objects.nonNull(child1.getScore()) || child1.getScore().compareTo(BigDecimal.ZERO) <= 0) continue;
+                        scoreList.add(child1.getScore());
+                    }
+                    BigDecimal sumScore = scoreList.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
+                    if (sumScore.compareTo(BigDecimal.ZERO) > 0) {
+                        HashSet scoreSet = new HashSet(scoreList);
+                        String scoreStr = questionsNum == scoreList.size() && scoreSet.size() == 1 ? "(\u5171" + questionsNum + "\u5c0f\u9898\uff0c\u6bcf\u5c0f\u9898" + ((BigDecimal)scoreList.get(0)).stripTrailingZeros().toPlainString() + "\u5206\uff0c\u6ee1\u5206" + sumScore.stripTrailingZeros().toPlainString() + "\u5206)" : "(\u5171" + questionsNum + "\u5c0f\u9898\uff0c\u6ee1\u5206" + sumScore.stripTrailingZeros().toPlainString() + "\u5206)";
+                        tmpContentList.add(scoreStr + "\u3010\u5b66\u751f\u7248\u3011" + "\u3010\u6559\u5e08\u7248\u3011");
+                    }
+                } else if (Objects.nonNull(question.getScore()) && question.getScore().compareTo(BigDecimal.ZERO) > 0) {
+                    content = "\uff08" + question.getScore().stripTrailingZeros().toPlainString() + "\u5206\uff09" + content;
+                }
+            }
+            tmpContentList.add(numStr + content);
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getOriginalText())) {
+            tmpContentList.add(tagVO.getListeningText() + tagVO.getDivStart() + question.getOriginalText() + tagVO.getDivEnd() + "\u3010\u6559\u5e08\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011" + (isAnswerEdition ? "###\u3010\u4e0d\u5408\u5e76\u3011###" : ""));
+        }
+        if (StringUtils.isNotBlank((CharSequence)question.getDecipherment())) {
+            tmpContentList.add(tagVO.getDecipherment() + tagVO.getDivStart() + question.getDecipherment() + tagVO.getDivEnd() + "\u3010\u6559\u5e08\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011" + (isAnswerEdition ? "###\u3010\u4e0d\u5408\u5e76\u3011###" : ""));
+        }
+        if (!"\u591a\u9009\u591a".equals(question.getLogicTypeName()) || !Objects.isNull(question.getMergerType())) {
+            if ("\u5b8c\u5f62".equals(question.getLogicTypeName())) {
+                this.addOptionNew(tmpContentList, question, tagVO, numStr);
+            } else {
+                this.addOptionNew(tmpContentList, question, tagVO, "");
+            }
+        }
+        this.addEmptyArea(tmpContentList, question.getEmptyLineNum(), question.getHasLine());
+        String answerStr = "";
+        String answerPrefix = "\u3010\u7b54\u6848\u3011";
+        if ("\u89e3\u7b54".equals(question.getLogicTypeName()) || "\u7ec4\u5408".equals(question.getLogicTypeName())) {
+            answerPrefix = "\u3010\u5408\u5e76\u3011\u3010\u7b54\u6848\u3011";
+        }
+        String answer = StringUtils.isBlank((CharSequence)question.getAnswer()) ? "\u6682\u65e0" : question.getAnswer();
+        answer = tagVO.getDivStart() + answer.replace("</p>;<p>", "</p>\uff1b<p>") + tagVO.getDivEnd() + "\u3010\u6559\u5e08\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u3011" + "\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011";
+        if (question.getLogicTypeName().equals("\u5224\u65ad")) {
+            if (question.getTrueFalseType() == 1) {
+                answer = answer.replace("T", "\u221a").replace("F", "\u00d7");
+            } else if (question.getTrueFalseType() == 2) {
+                answer = answer.replace("T", "\u5bf9").replace("F", "\u9519");
+            }
+        }
+        if (!question.getLogicTypeName().equals("\u7ec4\u5408") && !question.getLogicTypeName().equals("\u6bb5\u843d")) {
+            if (!(level != 1 || question.getLogicTypeName().equals("\u586b\u7a7a") && Objects.nonNull(question.getMergerType()) && question.getMergerType() == 1 || question.getLogicTypeName().equals("\u5b8c\u5f62") || question.getLogicTypeName().equals("\u591a\u9009\u591a"))) {
+                answerStr = answerPrefix + (isAnswerEdition ? numStr + " " : "") + answer;
+            } else if (level == 2 && (!"\u591a\u9009\u591a".equals(question.getLogicTypeName()) || "\u591a\u9009\u591a".equals(logicTypeName))) {
+                answerStr = answerPrefix + numStr + (isAnswerEdition ? " " : "") + answer;
+            } else if (level == 3) {
+                answerStr = answerPrefix + numStr + (isAnswerEdition ? " " : "") + answer;
+            }
+        }
+        String answerExplanationStr = "";
+        if (CollectionUtils.isNotEmpty((Collection)question.getAnswerExplanation())) {
+            boolean isLevel1AndNoNum = level == 1 && (!"\u586b\u7a7a".equals(logicTypeName) || !Objects.nonNull(question.getMergerType()) || question.getMergerType() != 1) && !"\u5b8c\u5f62".equals(logicTypeName) && !"\u591a\u9009\u591a".equals(logicTypeName);
+            ArrayList<String> answerExplanationList = new ArrayList<String>();
+            for (String answerExplanationTmp : question.getAnswerExplanation()) {
+                if (!StringUtils.isNotBlank((CharSequence)answerExplanationTmp)) continue;
+                answerExplanationTmp = tagVO.getDivStart() + answerExplanationTmp + tagVO.getDivEnd();
+                if (CollectionUtils.isEmpty(answerExplanationList)) {
+                    answerExplanationList.add(isLevel1AndNoNum | isAnswerEdition ? answerExplanationTmp : numStr + answerExplanationTmp);
+                    continue;
+                }
+                answerExplanationList.add(isAnswerEdition ? "\uff1b" + answerExplanationTmp : "<p>" + answerExplanationTmp + "</p>");
+            }
+            if (CollectionUtils.isNotEmpty(answerExplanationList)) {
+                answerExplanationStr = "\u3010\u89e3\u6790\u3011\u3010\u6559\u5e08\u7248\u3011\u3010\u7b54\u6848\u7248\u3011\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011" + String.join((CharSequence)"", answerExplanationList);
+            }
+        }
+        if (isAnswerEdition) {
+            String string = answerExplanationStr = "\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011".equals(editionStr) ? "" : answerExplanationStr;
+            if ("\u7ec4\u5408".equals(question.getLogicTypeName()) && (level != 1 || !Objects.nonNull(question.getMergerType()) || question.getMergerType() != 0)) {
+                tmpContentList.add("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###\u3010\u7b54\u6848\u7248\u3011\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011" + numStr);
+            }
+            if ("\u89e3\u7b54".equals(question.getLogicTypeName()) && StringUtils.isNotBlank((CharSequence)answerStr) || !"\u89e3\u7b54".equals(question.getLogicTypeName()) && StringUtils.isNotBlank((CharSequence)answerExplanationStr) && StringUtils.isNotBlank((CharSequence)answerStr)) {
+                answerStr = answerStr + "###\u3010\u4e0d\u5408\u5e76\u3011###";
+            }
+            if (StringUtils.isNotBlank((CharSequence)answerStr) || StringUtils.isNotBlank((CharSequence)answerExplanationStr)) {
+                tmpContentList.add(answerStr + ("\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011".equals(editionStr) ? "" : answerExplanationStr));
+            }
+        } else {
+            if (StringUtils.isNotBlank((CharSequence)answerStr)) {
+                tmpContentList.add(answerStr);
+            }
+            if (StringUtils.isNotBlank((CharSequence)answerExplanationStr)) {
+                tmpContentList.add(answerExplanationStr);
+            }
+        }
+        Integer startIndex = contentList.size();
+        contentList.addAll(tmpContentList);
+        return startIndex;
+    }
+
+    private void updateContentNum(List<String> contentList, Integer startIndex, List<String> numList) {
+        if (contentList.get(startIndex).startsWith("(\u5171")) {
+            Integer n = startIndex;
+            Integer n2 = startIndex = Integer.valueOf(startIndex + 1);
+        }
+        Document parse = Jsoup.parseBodyFragment((String)contentList.get(startIndex));
+        parse.outputSettings().prettyPrint(false).indentAmount(0);
+        Elements numberSpans = parse.select("span.tinymce-horizontal-number, span.tinymce-line-number");
+        for (int i = 0; i < numberSpans.size(); ++i) {
+            Element span = (Element)numberSpans.get(i);
+            span.html(span.html().replaceAll("\\d+\\.?", numList.get(i)).replace("&nbsp;", "&ensp;"));
+        }
+        contentList.set(startIndex, parse.body().html());
+    }
+
+    private void addOptionNew(List<String> contentList, QuestionDetailVO question, TagVO tagVO, String numStr) {
+        if (Boolean.TRUE.equals(question.getIsSubjective())) {
+            return;
+        }
+        ArrayList<String> tContentList = new ArrayList<String>();
+        List<String> optionList = this.getOptionList(question, tagVO);
+        if (Objects.nonNull(question.getOptionColumn()) && question.getOptionColumn() > 1) {
+            this.addMultiColumnOptionByTab(tContentList, optionList, question.getOptionColumn());
+        } else {
+            tContentList.addAll(optionList);
+        }
+        contentList.addAll(tContentList.stream().map(m -> numStr + m + "\u3010\u5b66\u751f\u7248\u3011" + "\u3010\u6559\u5e08\u7248\u3011").collect(Collectors.toList()));
+    }
+
+    private void dealAnswerMergeNew(List<String> contentList, List<TitleBO> titleList, String editionStr, TagVO tagVO) {
+        if (CollectionUtils.isNotEmpty(titleList)) {
+            List<Object> newContentList = new ArrayList<String>();
+            int lastIndex = 0;
+            for (int i = 0; i < titleList.size(); ++i) {
+                Integer endIndex;
+                Integer startIndex = titleList.get(i).getIndex();
+                if (Objects.isNull(startIndex)) continue;
+                for (int k = lastIndex; k < startIndex; ++k) {
+                    newContentList.add(contentList.get(k));
+                }
+                if (i < titleList.size() - 1) {
+                    TitleBO nextTitleBO = titleList.get(i + 1);
+                    endIndex = nextTitleBO.getIndex();
+                } else {
+                    endIndex = contentList.size();
+                }
+                boolean lastIsZh = false;
+                boolean lastNotMerge = true;
+                for (int j = startIndex.intValue(); j < endIndex; ++j) {
+                    boolean curNotMerge;
+                    String content = contentList.get(j);
+                    if (!content.contains(editionStr)) {
+                        newContentList.add(content);
+                        curNotMerge = true;
+                    } else {
+                        curNotMerge = content.contains("###\u3010\u4e0d\u5408\u5e76\u3011###");
+                        if (lastIsZh) {
+                            newContentList.set(newContentList.size() - 1, (String)newContentList.get(newContentList.size() - 1) + content);
+                        } else if (content.contains("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###")) {
+                            if (lastNotMerge) {
+                                newContentList.add(content);
+                            } else {
+                                newContentList.set(newContentList.size() - 1, (String)newContentList.get(newContentList.size() - 1) + content);
+                            }
+                        } else if (curNotMerge) {
+                            newContentList.add(content);
+                        } else if (lastNotMerge) {
+                            newContentList.add(content);
+                        } else {
+                            newContentList.set(newContentList.size() - 1, (String)newContentList.get(newContentList.size() - 1) + "    " + content);
+                        }
+                    }
+                    lastNotMerge = curNotMerge;
+                    lastIsZh = content.contains("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###");
+                }
+                lastIndex = endIndex;
+            }
+            for (int k = lastIndex; k < contentList.size(); ++k) {
+                newContentList.add(contentList.get(k));
+            }
+            newContentList = newContentList.stream().map(m -> {
+                if (!m.contains(tagVO.getExplanation()) && m.contains("\u3010\u89e3\u6790\u3011")) {
+                    m = m.replace("\u3010\u89e3\u6790\u3011", tagVO.getExplanation());
+                }
+                return m.replace("\u3010\u7b54\u6848\u7248\u3011", "").replace("\u3010\u7b54\u6848\u7248\u4ec5\u7b54\u6848\u3011", "").replace("\u3010\u7b54\u6848\u3011", "").replace("###\u3010\u4e0d\u5408\u5e76\u3011###", "").replace("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###", "");
+            }).collect(Collectors.toList());
+            contentList.clear();
+            contentList.addAll(newContentList);
+        }
+    }
+
+    private void dealAnswerMergeNew2(List<String> contentList, List<TitleBO> titleList) {
+        if (CollectionUtils.isNotEmpty(titleList)) {
+            List<Object> newContentList = new ArrayList<String>();
+            int lastIndex = 0;
+            for (int i = 0; i < titleList.size(); ++i) {
+                Integer endIndex;
+                Integer startIndex = titleList.get(i).getIndex();
+                if (Objects.isNull(startIndex)) {
+                    startIndex = 0;
+                }
+                for (int k = lastIndex; k < startIndex; ++k) {
+                    newContentList.add(contentList.get(k));
+                }
+                if (i < titleList.size() - 1) {
+                    TitleBO nextTitleBO = titleList.get(i + 1);
+                    endIndex = nextTitleBO.getIndex();
+                } else {
+                    endIndex = contentList.size();
+                }
+                boolean lastElementMerge = false;
+                for (int j = startIndex.intValue(); j < endIndex; ++j) {
+                    String content = contentList.get(j);
+                    if (CollectionUtils.isEmpty(newContentList) || !content.contains("###\u3010\u9898\u76ee\u3011###") || content.contains("###\u3010\u4e0d\u5408\u5e76\u3011###") || content.contains("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###") || lastElementMerge) {
+                        newContentList.add(content);
+                    } else {
+                        newContentList.set(newContentList.size() - 1, FileServiceImpl.joinContent((String)newContentList.get(newContentList.size() - 1), content));
+                    }
+                    lastElementMerge = content.contains("###\u3010\u4e0d\u5408\u5e76\u3011###") || !content.contains("###\u3010\u9898\u76ee\u3011###");
+                }
+                lastIndex = endIndex;
+            }
+            for (int k = lastIndex; k < contentList.size(); ++k) {
+                newContentList.add(contentList.get(k));
+            }
+            newContentList = newContentList.stream().map(m -> m.replace("###\u3010\u4e0d\u5408\u5e76\u3011###", "").replace("###\u3010\u9898\u76ee\u3011###", "").replace("###\u3010\u5408\u5e76\u7ec4\u5408\u3011###", "")).collect(Collectors.toList());
+            contentList.clear();
+            contentList.addAll(newContentList);
+        }
+    }
+
+    private String getContentPrefix(QuestionDetailVO question, OfficeFileStyleVO fileStyle) {
+        boolean isPrefix = false;
+        String questionNumber = question.getShowQuestionNumber();
+        String extraChoose = Boolean.TRUE.equals(question.getIsExtra()) ? "\uff08\u9644\u52a0\u9898\uff09" : "";
+        String scoreStr = "";
+        if (Boolean.TRUE.equals(question.getIsShowScore())) {
+            if (LogicTypeEnum.COMBINATION.getLogicTypeId().equals(question.getLogicTypeId()) && Objects.nonNull(question.getMergerType()) && question.getMergerType() == 1) {
+                BigDecimal score = question.getChildList().stream().map(m -> {
+                    if (CollectionUtils.isNotEmpty((Collection)m.getChildList())) {
+                        return m.getChildList().stream().filter(c2 -> Objects.nonNull(c2.getScore()) && c2.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                    }
+                    return Objects.nonNull(m.getScore()) ? m.getScore() : BigDecimal.ZERO;
+                }).reduce(BigDecimal.ZERO, BigDecimal::add);
+                if (score.compareTo(BigDecimal.ZERO) > 0) {
+                    scoreStr = "\uff08" + score.stripTrailingZeros().toPlainString() + "\u5206\uff09";
+                }
+            } else if (CollectionUtils.isNotEmpty((Collection)question.getChildList())) {
+                isPrefix = true;
+                int questionsNum = 0;
+                ArrayList<BigDecimal> scoreList = new ArrayList<BigDecimal>();
+                for (QuestionDetailVO child1 : question.getChildList()) {
+                    if ("\u6bb5\u843d".equals(child1.getLogicTypeName())) continue;
+                    if (CollectionUtils.isNotEmpty((Collection)child1.getChildList())) {
+                        List child1List = child1.getChildList();
+                        questionsNum = child1.getLogicTypeName().equals("\u7ec4\u5408") ? ++questionsNum : (questionsNum += child1List.size());
+                        BigDecimal reduce = child1List.stream().filter(m -> Objects.nonNull(m.getScore()) && m.getScore().compareTo(BigDecimal.ZERO) > 0).map(QuestionDetailVO::getScore).reduce(BigDecimal.ZERO, BigDecimal::add);
+                        if (reduce.compareTo(BigDecimal.ZERO) <= 0) continue;
+                        scoreList.add(reduce);
+                        continue;
+                    }
+                    ++questionsNum;
+                    if (!Objects.nonNull(child1.getScore()) || child1.getScore().compareTo(BigDecimal.ZERO) <= 0) continue;
+                    scoreList.add(child1.getScore());
+                }
+                BigDecimal sumScore = scoreList.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
+                if (sumScore.compareTo(BigDecimal.ZERO) > 0) {
+                    HashSet scoreSet = new HashSet(scoreList);
+                    scoreStr = questionsNum == scoreList.size() && scoreSet.size() == 1 ? "(\u5171" + questionsNum + "\u5c0f\u9898\uff0c\u6bcf\u5c0f\u9898" + ((BigDecimal)scoreList.get(0)).stripTrailingZeros().toPlainString() + "\u5206\uff0c\u6ee1\u5206" + sumScore.stripTrailingZeros().toPlainString() + "\u5206)" : "(\u5171" + questionsNum + "\u5c0f\u9898\uff0c\u6ee1\u5206" + sumScore.stripTrailingZeros().toPlainString() + "\u5206)";
+                }
+            } else if (Objects.nonNull(question.getScore()) && question.getScore().compareTo(BigDecimal.ZERO) > 0) {
+                scoreStr = "\uff08" + question.getScore().stripTrailingZeros().toPlainString() + "\u5206\uff09";
+            }
+        }
+        String source = "";
+        if (Objects.nonNull(fileStyle) && fileStyle.getQuestionSourceShowFlag() == 1 && CollectionUtils.isNotEmpty((Collection)question.getSourceFeature()) && StringUtils.isNotBlank((CharSequence)((QuestionSourceFeatureMetadataDTO)question.getSourceFeature().get(0)).getSourceShortNote())) {
+            source = "\uff08" + ((QuestionSourceFeatureMetadataDTO)question.getSourceFeature().get(0)).getSourceShortNote() + "\uff09";
+        }
+        if (isPrefix) {
+            return extraChoose + scoreStr + "<br>" + questionNumber + source;
+        }
+        return questionNumber + extraChoose + scoreStr + source;
+    }
+
+    private void addQuestionInfo(Integer edition, QuestionDetailVO question, TagVO tagVO, List<String> contentList, Integer group) {
+        String mergeInfo;
+        String string = mergeInfo = EditionEnum.ANSWER.getEdition().equals(edition) ? "###\u3010\u4e0d\u5408\u5e76\u3011###" : "";
+        if (group == 1 && (EditionEnum.TEACHER.getEdition().equals(edition) || EditionEnum.ANSWER.getEdition().equals(edition)) && StringUtils.isNotBlank((CharSequence)question.getDecipherment())) {
+            contentList.add(tagVO.getDivStart().replace("color: rgba(0, 0, 0, 0.65)", "color: rgba(128, 128, 128)") + tagVO.getDecipherment().replace("font-weight: bold;", "").replace("color: rgba(0, 0, 0, 0.65)", "color: rgb(128, 128, 128)") + "<div style=\"color: rgb(128, 128, 128); font-size: 10.5pt; line-height: 2; \">" + question.getDecipherment().replace("<p>", "").replace("</p>", "") + "</div>" + tagVO.getDivEnd() + mergeInfo);
+        }
+        if (group == 2 && (EditionEnum.TEACHER.getEdition().equals(edition) || EditionEnum.ANSWER.getEdition().equals(edition))) {
+            if (StringUtils.isNotBlank((CharSequence)question.getListeningText())) {
+                contentList.add(tagVO.getListeningText() + tagVO.getDivStart() + question.getListeningText() + tagVO.getDivEnd() + mergeInfo);
+            }
+            if (StringUtils.isNotBlank((CharSequence)question.getChineseText())) {
+                contentList.add(tagVO.getChineseText() + tagVO.getDivStart() + question.getChineseText() + tagVO.getDivEnd() + mergeInfo);
+            }
+        }
+    }
+
+    private static String joinQuestionNum(String numStr, String originalContent) {
+        return Optional.ofNullable(numStr).orElse("") + Optional.ofNullable(originalContent).orElse("");
+    }
+
+    private static String joinQuestionNum2(String numStr, String originalContent) {
+        Document doc = Jsoup.parse((String)originalContent);
+        Elements pNodes = doc.select("p");
+        if (pNodes.isEmpty()) {
+            return numStr + originalContent;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(numStr);
+        for (Element p : pNodes) {
+            String content = p.html();
+            sb.append(content);
+        }
+        return sb.toString();
+    }
+
+    private static String joinContent(String content1, String content2) {
+        String result = Optional.ofNullable(content1).orElse("") + "    " + Optional.ofNullable(content2).orElse("");
+        if (StringUtils.isBlank((CharSequence)result)) {
+            return result;
+        }
+        Document doc = Jsoup.parse((String)result);
+        doc.outputSettings().prettyPrint(false);
+        Elements pNodes = doc.select(TagEnum.P.getName());
+        for (Element p : pNodes) {
+            p.tagName(TagEnum.SPAN.getName());
+        }
+        return doc.body().html();
+    }
+
+    private static boolean checkContentStyle(String content) {
+        String pattern = "^(<div.*?>)?(<p>.*?</p>(;<p>.*?</p>)+)(</div>)?$";
+        return content != null && content.matches(pattern);
+    }
+
+    private static void dealQuestionAnswerExplationStyle(QuestionDetailVO question) {
+        String answerExplanation;
+        String answer = question.getAnswer();
+        String string = answerExplanation = CollectionUtils.isEmpty((Collection)question.getAnswerExplanation()) ? null : (String)question.getAnswerExplanation().get(0);
+        if (FileServiceImpl.checkContentStyle(answer)) {
+            answer = answer.replace("<p>", "<span>").replace("</p>", "</span>");
+            question.setAnswer(answer);
+        }
+        if (FileServiceImpl.checkContentStyle(answerExplanation)) {
+            answerExplanation = answerExplanation.replace("<p>", "<span>").replace("</p>", "</span>");
+            question.setAnswerExplanation(Collections.singletonList(answerExplanation));
+        }
+    }
+}
+
diff --git a/java-src/utils/DigestUtil.java b/java-src/utils/DigestUtil.java
new file mode 100644
index 0000000..117ed67
--- /dev/null
+++ b/java-src/utils/DigestUtil.java
@@ -0,0 +1,112 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.jby.common.util.FileUtil
+ *  org.apache.commons.codec.binary.Hex
+ *  org.apache.commons.codec.digest.DigestUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.stereotype.Component
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.jby.officecore.utils;
+
+import com.jby.common.util.FileUtil;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.MessageDigest;
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.multipart.MultipartFile;
+
+@Component
+public class DigestUtil {
+    private static final Logger log = LoggerFactory.getLogger(DigestUtil.class);
+    private static final String DIGEST_MD5 = "MD5";
+    private static final String DIGEST_SHA1 = "SHA-1";
+
+    public static String getMd5(String str) {
+        if (StringUtils.isBlank((CharSequence)str)) {
+            return null;
+        }
+        try {
+            return DigestUtils.md5Hex((String)str);
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u5b57\u7b26\u4e32MD5\u503c\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+            return null;
+        }
+    }
+
+    public static String getFileMd5(String filePath) {
+        File file = FileUtil.getFile((String)filePath);
+        return DigestUtil.getFileMd5(FileUtil.getMultipartFile((String)file.getName(), (File)file));
+    }
+
+    public static String getFileMd5(MultipartFile file) {
+        return DigestUtil.getDigest(file, DIGEST_MD5);
+    }
+
+    public static String getSha1(String str) {
+        if (StringUtils.isBlank((CharSequence)str)) {
+            return null;
+        }
+        try {
+            return DigestUtils.sha1Hex((String)str);
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u5b57\u7b26\u4e32sha1\u503c\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+            return null;
+        }
+    }
+
+    public static String getFileSha1(String filePath) {
+        File file = FileUtil.getFile((String)filePath);
+        return DigestUtil.getFileSha1(FileUtil.getMultipartFile((String)file.getName(), (File)file));
+    }
+
+    public static String getFileSha1(MultipartFile file) {
+        return DigestUtil.getDigest(file, DIGEST_SHA1);
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    private static String getDigest(MultipartFile file, String digest) {
+        InputStream is = null;
+        try {
+            int length;
+            MessageDigest messageDigest = MessageDigest.getInstance(digest);
+            is = file.getInputStream();
+            byte[] buffer = new byte[8192];
+            while ((length = is.read(buffer)) != -1) {
+                messageDigest.update(buffer, 0, length);
+            }
+            String string = new String(Hex.encodeHex((byte[])messageDigest.digest()));
+            return string;
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u6458\u8981\u503c\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+            String string = null;
+            return string;
+        }
+        finally {
+            try {
+                if (is != null) {
+                    is.close();
+                }
+            }
+            catch (IOException e) {
+                log.error("close error");
+            }
+        }
+    }
+}
+
diff --git a/java-src/utils/EqToLatexUtil.java b/java-src/utils/EqToLatexUtil.java
new file mode 100644
index 0000000..45eb6af
--- /dev/null
+++ b/java-src/utils/EqToLatexUtil.java
@@ -0,0 +1,1034 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.apache.commons.lang3.StringUtils
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.jby.officecore.utils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EqToLatexUtil {
+    private static final Logger log = LoggerFactory.getLogger(EqToLatexUtil.class);
+    private static final Pattern LONG_EQUALS_PATTERN = Pattern.compile("^=+$");
+    private static final int LONG_EQUALS_MIN_LENGTH = 3;
+    private static final Map<String, CommandHandler> COMMAND_HANDLERS = new HashMap<String, CommandHandler>();
+
+    public static String sanitizeInput(String input) {
+        if (input == null) {
+            return "";
+        }
+        HashMap<String, String> replacements = new HashMap<String, String>();
+        replacements.put("\uff08", "(");
+        replacements.put("\uff09", ")");
+        replacements.put("\uff5b", "{");
+        replacements.put("\uff5d", "}");
+        replacements.put("\uff0b", "+");
+        replacements.put("\uff0d", "-");
+        replacements.put("\u2212", "-");
+        replacements.put("\u00d7", " \\times ");
+        replacements.put("\u00f7", " \\div ");
+        replacements.put("\uff1d", "=");
+        replacements.put("\u2260", "\\ne ");
+        replacements.put("\u2248", " \\approx ");
+        replacements.put("\u2264", "\\le ");
+        replacements.put("\u2265", "\\ge ");
+        replacements.put("\uff1c", "<");
+        replacements.put("\uff1e", "> ");
+        replacements.put("\u00b7", " \\cdot ");
+        replacements.put("\u2026", "\\dots ");
+        replacements.put("\uff5e", "~");
+        replacements.put("\uff1b", ";");
+        replacements.put("\uff1a", ":");
+        replacements.put("\uf028", "(");
+        replacements.put("\uf029", ")");
+        replacements.put("~", "\\sim");
+        replacements.put("\u221d", "\\propto");
+        String sanitized = input;
+        for (Map.Entry entry : replacements.entrySet()) {
+            sanitized = sanitized.replace((CharSequence)entry.getKey(), (CharSequence)entry.getValue());
+        }
+        sanitized = sanitized.replaceAll("(?i)eq", "EQ ");
+        return sanitized.trim();
+    }
+
+    private static String getCharFromOpt(String opt, int startIdx, String defaultChar) {
+        if (opt.length() <= startIdx) {
+            return defaultChar;
+        }
+        String charPart = opt.substring(startIdx).trim();
+        if (charPart.isEmpty()) {
+            return defaultChar;
+        }
+        if (charPart.startsWith("\\")) {
+            return charPart.substring(1);
+        }
+        return charPart;
+    }
+
+    private static String escapeChar(String ch) {
+        String specialChars = "\\{}$&#%";
+        if ("\\{}$&#%".contains(ch)) {
+            return "\\" + ch;
+        }
+        if ("~".equals(ch)) {
+            return "\\ ";
+        }
+        return ch;
+    }
+
+    public static String convert(String eqField) {
+        if (eqField == null) {
+            throw new IllegalArgumentException("\u8f93\u5165\u5fc5\u987b\u662f\u5b57\u7b26\u4e32\u7c7b\u578b");
+        }
+        if (eqField.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            String sanitizedField = EqToLatexUtil.sanitizeInput(EqToLatexUtil.stripFormattingMarkers(eqField));
+            String content = sanitizedField.replaceAll("^\\s*\\{?\\s*EQ\\s*|\\s*EQ\\s*|\\s*}\\s*$", "").trim();
+            String result = EqToLatexUtil.parseInstructions(content, new HashMap<String, Object>());
+            result = EqToLatexUtil.replaceJbyuWithMeasurements(result);
+            result = result.replaceAll("JBYU2BEGIN", "\\\\underline{").replaceAll("JBYU2END", "}");
+            result = result.replaceAll("\u2192", "\\\\to ");
+            log.info("\u539fEQ\u516c\u5f0f\uff1a{} \u8f6c\u6362\u540e\u7684Latex\u4ee3\u7801\uff1a{}", (Object)eqField, (Object)result);
+            return result;
+        }
+        catch (Exception error) {
+            System.err.println("\u8f6c\u6362\u8fc7\u7a0b\u4e2d\u51fa\u73b0\u9519\u8bef: " + error.getMessage());
+            error.printStackTrace();
+            return "\\text{\u8f6c\u6362\u9519\u8bef: " + error.getMessage() + "}";
+        }
+    }
+
+    private static String stripFormattingMarkers(String input) {
+        return input.replaceAll("\\\\(?:\\s*\\\\?JBYU\\s*2(?:BEGIN|END))+\\s*(?!(?:[eE][qQ])\\b)(?=[A-Za-z])", Matcher.quoteReplacement("\\")).replaceAll("\\\\?JBYU\\s*2BEGIN", "").replaceAll("\\\\?JBYU\\s*2END", "");
+    }
+
+    private static String parseInstructions(String str, Map<String, Object> context) {
+        ArrayList<String> output = new ArrayList<String>();
+        int index = 0;
+        while (index < str.length()) {
+            int textEnd;
+            char ch = str.charAt(index);
+            if (ch == '\\') {
+                String lastOutput;
+                ParseResult result = EqToLatexUtil.parseCommand(str, index, context);
+                String trimmedOutput = result.output.trim();
+                if ((trimmedOutput.startsWith("^") || trimmedOutput.startsWith("_")) && !output.isEmpty()) {
+                    lastOutput = (String)output.get(output.size() - 1);
+                    if (EqToLatexUtil.isConsecutiveScript(lastOutput, trimmedOutput)) {
+                        output.set(output.size() - 1, EqToLatexUtil.mergeConsecutiveScripts(lastOutput, trimmedOutput));
+                    } else {
+                        output.set(output.size() - 1, lastOutput + result.output);
+                    }
+                } else if ((trimmedOutput.startsWith("\\^") || trimmedOutput.startsWith("\\_")) && !output.isEmpty()) {
+                    lastOutput = (String)output.get(output.size() - 1);
+                    if (EqToLatexUtil.isConsecutiveScript(lastOutput, trimmedOutput)) {
+                        output.set(output.size() - 1, EqToLatexUtil.mergeConsecutiveScripts(lastOutput, trimmedOutput));
+                    } else {
+                        output.set(output.size() - 1, lastOutput + result.output);
+                    }
+                } else if (EqToLatexUtil.isSpecialScriptMarker(trimmedOutput) && !output.isEmpty() && EqToLatexUtil.isSpecialScriptMarker((String)output.get(output.size() - 1))) {
+                    String merged = EqToLatexUtil.mergeSpecialScriptMarkers((String)output.get(output.size() - 1), trimmedOutput);
+                    output.set(output.size() - 1, merged);
+                } else {
+                    output.add(result.output);
+                }
+                index = result.newIndex;
+                continue;
+            }
+            if (ch == '{' || ch == '}') {
+                ++index;
+                continue;
+            }
+            for (textEnd = index; textEnd < str.length() && "\\{}".indexOf(str.charAt(textEnd)) == -1; ++textEnd) {
+            }
+            String text = str.substring(index, textEnd);
+            output.add(text.replaceAll("[&%$#_]", "\\\\$0"));
+            index = textEnd;
+        }
+        String result = String.join((CharSequence)" ", output).replaceAll("\\s+", " ").trim();
+        return EqToLatexUtil.postProcessConsecutiveScripts(result);
+    }
+
+    private static ParseResult parseCommand(String str, int startIndex, Map<String, Object> context) {
+        int argParenStartIndex;
+        String cmdName;
+        int currentIndex = startIndex;
+        ArrayList<String> commandChain = new ArrayList<String>();
+        ArrayList<Integer> commandEndIndices = new ArrayList<Integer>();
+        while (currentIndex < str.length()) {
+            int cmdNameEnd;
+            int tempIndex;
+            for (tempIndex = currentIndex; tempIndex < str.length() && Character.isWhitespace(str.charAt(tempIndex)); ++tempIndex) {
+            }
+            if (tempIndex >= str.length() || str.charAt(tempIndex) != '\\') {
+                currentIndex = tempIndex;
+                break;
+            }
+            currentIndex = tempIndex;
+            for (cmdNameEnd = currentIndex + 1; cmdNameEnd < str.length() && Character.isLetter(str.charAt(cmdNameEnd)); ++cmdNameEnd) {
+            }
+            String cmdName2 = str.substring(currentIndex + 1, cmdNameEnd);
+            String token = "\\" + cmdName2;
+            int argStartIndex = cmdNameEnd;
+            List<String> numericArgCmds = Arrays.asList("co", "vs", "hs", "fo", "ba", "up", "do", "ai", "di");
+            if (numericArgCmds.contains(cmdName2.toLowerCase())) {
+                int numEnd;
+                for (numEnd = argStartIndex; numEnd < str.length() && Character.isDigit(str.charAt(numEnd)); ++numEnd) {
+                }
+                if (numEnd > argStartIndex) {
+                    token = token + str.substring(argStartIndex, numEnd);
+                    argStartIndex = numEnd;
+                }
+            } else if (Arrays.asList("lc", "rc", "bc", "fc", "vc").contains(cmdName2.toLowerCase()) && argStartIndex < str.length()) {
+                if (str.charAt(argStartIndex) == '\\' && argStartIndex + 1 < str.length()) {
+                    token = token + str.substring(argStartIndex, argStartIndex + 2);
+                    argStartIndex += 2;
+                } else {
+                    token = token + str.charAt(argStartIndex);
+                    ++argStartIndex;
+                }
+            }
+            commandChain.add(token);
+            commandEndIndices.add(argStartIndex);
+            currentIndex = argStartIndex;
+        }
+        if (commandChain.isEmpty()) {
+            return new ParseResult(EqToLatexUtil.escapeChar(String.valueOf(str.charAt(startIndex))), startIndex + 1);
+        }
+        CommandHandler mainCommandHandler = null;
+        String mainCommandName = "";
+        String firstToken = (String)commandChain.get(0);
+        Matcher matcher = Pattern.compile("^\\\\([a-zA-Z]+)").matcher(firstToken);
+        if (matcher.find() && COMMAND_HANDLERS.containsKey(cmdName = matcher.group(1).toLowerCase())) {
+            mainCommandHandler = COMMAND_HANDLERS.get(cmdName);
+            mainCommandName = cmdName;
+        }
+        if (mainCommandHandler == null) {
+            return new ParseResult((String)commandChain.get(0), (Integer)commandEndIndices.get(0));
+        }
+        ArrayList<String> args = new ArrayList<String>();
+        for (argParenStartIndex = currentIndex; argParenStartIndex < str.length() && Character.isWhitespace(str.charAt(argParenStartIndex)); ++argParenStartIndex) {
+        }
+        if (argParenStartIndex < str.length() && (str.charAt(argParenStartIndex) == '(' || str.charAt(argParenStartIndex) == '[')) {
+            ArgumentResult argsResult = EqToLatexUtil.extractArguments(str, argParenStartIndex);
+            if (argsResult.success) {
+                List<String> rawArgs = EqToLatexUtil.splitArguments(argsResult.content);
+                HashMap<String, Object> childContext = new HashMap<String, Object>();
+                childContext.put("parentCommand", mainCommandName);
+                for (String arg : rawArgs) {
+                    args.add(EqToLatexUtil.parseInstructions(arg, childContext));
+                }
+                currentIndex = argsResult.endIndex;
+            } else {
+                throw new RuntimeException("Mismatched parentheses starting at index " + argParenStartIndex);
+            }
+        }
+        String output = mainCommandHandler.handle(commandChain, args, mainCommandName, context);
+        return new ParseResult(output, currentIndex);
+    }
+
+    private static ArgumentResult extractArguments(String str, int startIndex) {
+        char openParen = str.charAt(startIndex);
+        char closeParen = openParen == '(' ? (char)')' : ']';
+        int depth = 1;
+        StringBuilder content = new StringBuilder();
+        int index = startIndex + 1;
+        while (index < str.length() && depth > 0) {
+            char ch = str.charAt(index);
+            if (ch == '\\' && index + 1 < str.length()) {
+                content.append(ch).append(str.charAt(index + 1));
+                index += 2;
+                continue;
+            }
+            if (ch == openParen) {
+                if (++depth > 1) {
+                    content.append(ch);
+                }
+                ++index;
+                continue;
+            }
+            if (ch == closeParen) {
+                if (--depth > 0) {
+                    content.append(ch);
+                }
+                ++index;
+                continue;
+            }
+            if (depth > 0) {
+                content.append(ch);
+            }
+            ++index;
+        }
+        return new ArgumentResult(depth == 0, content.toString(), index);
+    }
+
+    private static List<String> splitArguments(String str) {
+        ArrayList<String> args = new ArrayList<String>();
+        StringBuilder current = new StringBuilder();
+        int depth = 0;
+        int i = 0;
+        while (i < str.length()) {
+            char ch = str.charAt(i);
+            if (ch == '\\' && i + 1 < str.length()) {
+                current.append(ch).append(str.charAt(i + 1));
+                i += 2;
+                continue;
+            }
+            if (ch == '(') {
+                ++depth;
+            } else if (ch == ')') {
+                --depth;
+            }
+            if (ch == ',' && depth == 0) {
+                args.add(current.toString().trim());
+                current = new StringBuilder();
+            } else {
+                current.append(ch);
+            }
+            ++i;
+        }
+        if (current.length() > 0) {
+            args.add(current.toString().trim());
+        }
+        return args;
+    }
+
+    private static String handleFraction(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.size() != 2) {
+            return "\\text{\u9519\u8bef\u7684\u5206\u6570\u53c2\u6570}";
+        }
+        return String.format("\\dfrac{%s}{%s}", args.get(0), args.get(1));
+    }
+
+    private static String handleRoot(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() == 1) {
+            return String.format("\\sqrt{%s}", args.get(0));
+        }
+        return String.format("\\sqrt[%s]{%s}", args.get(0), args.get(1));
+    }
+
+    private static String handleIntegral(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String symbol = "\\int";
+        if (options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\su"))) {
+            symbol = "\\sum";
+        } else if (options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\pr"))) {
+            symbol = "\\prod";
+        } else {
+            String fc = options.stream().filter(o -> o.toLowerCase().startsWith("\\fc")).findFirst().orElse(null);
+            String vc = options.stream().filter(o -> o.toLowerCase().startsWith("\\vc")).findFirst().orElse(null);
+            if (fc != null) {
+                symbol = EqToLatexUtil.escapeChar(EqToLatexUtil.getCharFromOpt(fc, 3, ""));
+            } else if (vc != null) {
+                symbol = EqToLatexUtil.escapeChar(EqToLatexUtil.getCharFromOpt(vc, 3, ""));
+            }
+        }
+        if (args.isEmpty()) {
+            return symbol;
+        }
+        String lower = args.get(0);
+        String upper = args.size() > 1 ? args.get(1) : "";
+        String integrand = args.size() > 2 ? args.subList(2, args.size()).stream().collect(Collectors.joining(" ")) : "";
+        String limits = !lower.isEmpty() || !upper.isEmpty() ? String.format("^{%s}_{%s}", upper, lower) : "";
+        return String.format("%s%s %s", symbol, limits, integrand);
+    }
+
+    private static String handleScript(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        ArrayList<String> argsCopy = new ArrayList<String>(args);
+        if (argsCopy.size() > 2) {
+            String arrayContent = String.join((CharSequence)"\\\\", argsCopy);
+            return String.format("\\begin{array}{l}%s\\end{array}", arrayContent);
+        }
+        String up = "";
+        String down = "";
+        boolean doOptExists = options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\do"));
+        if (argsCopy.size() == 2) {
+            up = (String)argsCopy.remove(0);
+            down = (String)argsCopy.remove(0);
+        } else if (argsCopy.size() == 1) {
+            if (doOptExists) {
+                down = (String)argsCopy.remove(0);
+            } else {
+                up = (String)argsCopy.remove(0);
+            }
+        }
+        if ("o".equals(context.get("parentCommand"))) {
+            String upTrimmed = up.trim();
+            if ("\u2192".equals(upTrimmed) || "\\rightarrow".equals(upTrimmed)) {
+                return "OVERSET_ARROW";
+            }
+            if ("^".equals(upTrimmed) || "IS_HAT".equals(upTrimmed)) {
+                return "OVERSET_HAT";
+            }
+            if (!up.isEmpty() && !down.isEmpty()) {
+                return "OVER_UNDER_SCRIPT:" + up + "," + down;
+            }
+            if (!up.isEmpty()) {
+                return "OVER_SCRIPT:" + up;
+            }
+            if (!down.isEmpty()) {
+                return "UNDER_SCRIPT:" + down;
+            }
+        }
+        StringBuilder output = new StringBuilder();
+        if (!up.isEmpty()) {
+            output.append(String.format("^{%s}", up));
+        }
+        if (!down.isEmpty()) {
+            output.append(String.format("_{%s}", down));
+        }
+        return output.toString();
+    }
+
+    private static String handleBrackets(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String content = String.join((CharSequence)",", args);
+        HashMap<String, String> delimiterPairMap = new HashMap<String, String>();
+        delimiterPairMap.put("(", ")");
+        delimiterPairMap.put("[", "]");
+        delimiterPairMap.put("{", "}");
+        delimiterPairMap.put("<", ">");
+        String left = null;
+        String right = null;
+        String bcOpt = options.stream().filter(o -> o.startsWith("\\bc")).findFirst().orElse(null);
+        String lcOpt = options.stream().filter(o -> o.startsWith("\\lc")).findFirst().orElse(null);
+        String rcOpt = options.stream().filter(o -> o.startsWith("\\rc")).findFirst().orElse(null);
+        if (bcOpt != null) {
+            String charStr = EqToLatexUtil.getCharFromOpt(bcOpt, 3, "|");
+            left = EqToLatexUtil.getDelimiter(charStr);
+            right = EqToLatexUtil.getDelimiter(delimiterPairMap.getOrDefault(charStr, charStr));
+        } else {
+            if (lcOpt != null) {
+                left = EqToLatexUtil.getDelimiter(EqToLatexUtil.getCharFromOpt(lcOpt, 3, "("));
+            }
+            if (rcOpt != null) {
+                right = EqToLatexUtil.getDelimiter(EqToLatexUtil.getCharFromOpt(rcOpt, 3, ")"));
+            }
+        }
+        if (bcOpt == null && lcOpt == null && rcOpt == null) {
+            left = "(";
+            right = ")";
+        }
+        return String.format("\\left%s %s \\right%s", StringUtils.isNotBlank((CharSequence)left) ? left : ".", content, StringUtils.isNotBlank((CharSequence)right) ? right : ".");
+    }
+
+    private static String getDelimiter(String ch) {
+        return "{".equals(ch) || "}".equals(ch) ? "\\" + ch : ch;
+    }
+
+    private static String handleArray(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() == 1) {
+            return args.get(0);
+        }
+        int cols = 1;
+        String colAlign = "c";
+        for (String opt : options) {
+            Matcher colMatch = Pattern.compile("^\\\\co(\\d+)$").matcher(opt);
+            if (colMatch.matches()) {
+                cols = Integer.parseInt(colMatch.group(1));
+            }
+            if ("\\al".equals(opt)) {
+                colAlign = "l";
+                continue;
+            }
+            if ("\\ac".equals(opt)) {
+                colAlign = "c";
+                continue;
+            }
+            if (!"\\ar".equals(opt)) continue;
+            colAlign = "r";
+        }
+        StringBuilder alignSpec = new StringBuilder();
+        for (int i = 0; i < cols; ++i) {
+            alignSpec.append(colAlign);
+        }
+        ArrayList<String> matrixRows = new ArrayList<String>();
+        int i = 0;
+        while ((double)i < Math.ceil((double)args.size() / (double)cols)) {
+            ArrayList<String> row = new ArrayList<String>(args.subList(i * cols, Math.min((i + 1) * cols, args.size())));
+            while (row.size() < cols) {
+                row.add("");
+            }
+            matrixRows.add(String.join((CharSequence)" & ", row));
+            ++i;
+        }
+        return String.format("\\begin{array}{%s}%s\\end{array}", alignSpec, String.join((CharSequence)"\\\\", matrixRows));
+    }
+
+    private static String handleBox(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (options.stream().anyMatch(o -> o.equalsIgnoreCase("\\to"))) {
+            return args.isEmpty() ? "\\overline{}" : String.format("\\overline{%s}", args.get(0));
+        }
+        String content = String.join((CharSequence)",", args);
+        return args.isEmpty() ? "\\boxed{}" : String.format("\\boxed{%s}", content);
+    }
+
+    private static String handleList(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.join((CharSequence)",\\ ", args);
+    }
+
+    private static String handleOverstrike(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String limitResult;
+        String firstArg;
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() >= 1 && ("lim".equals(firstArg = args.get(0).trim().toLowerCase()) || "limit".equals(firstArg)) && (limitResult = EqToLatexUtil.handleLimitExpression(args)) != null) {
+            return limitResult;
+        }
+        String chemResult = EqToLatexUtil.handleChemicalSymbols(args, context);
+        if (chemResult != null) {
+            return chemResult;
+        }
+        boolean allArgsAreScriptMarkers = true;
+        for (String arg : args) {
+            if (EqToLatexUtil.isScriptMarker(arg)) continue;
+            allArgsAreScriptMarkers = false;
+            break;
+        }
+        if (allArgsAreScriptMarkers) {
+            boolean hasAlignCenter = options.stream().anyMatch(o -> "\\ac".equalsIgnoreCase((String)o));
+            if (hasAlignCenter) {
+                ArrayList<String> scriptContents = new ArrayList<String>();
+                for (String script2 : args) {
+                    if (!script2.startsWith("OVER_SCRIPT:")) continue;
+                    scriptContents.add(script2.substring("OVER_SCRIPT:".length()).trim());
+                }
+                if (!scriptContents.isEmpty()) {
+                    String result = (String)scriptContents.get(scriptContents.size() - 1);
+                    for (int i = scriptContents.size() - 2; i >= 0; --i) {
+                        result = String.format("\\rlap{%s}{%s}", scriptContents.get(i), result);
+                    }
+                    return String.format("^{%s}", result);
+                }
+            }
+            StringBuilder up = new StringBuilder();
+            StringBuilder down = new StringBuilder();
+            args.forEach(script -> {
+                if (script.startsWith("OVER_UNDER_SCRIPT:")) {
+                    String[] parts = script.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                    up.append(up.length() > 0 ? " " : "").append(parts[0]);
+                    down.append(down.length() > 0 ? " " : "").append(parts[1]);
+                } else if (script.startsWith("OVER_SCRIPT:")) {
+                    up.append(up.length() > 0 ? " " : "").append(script.substring("OVER_SCRIPT:".length()));
+                } else if (script.startsWith("UNDER_SCRIPT:")) {
+                    down.append(down.length() > 0 ? " " : "").append(script.substring("UNDER_SCRIPT:".length()));
+                } else if ("OVERSET_ARROW".equals(script)) {
+                    up.append(up.length() > 0 ? " " : "").append("\\rightarrow");
+                } else if ("OVERSET_HAT".equals(script)) {
+                    up.append(up.length() > 0 ? " " : "").append("^");
+                } else {
+                    MathJaxScripts extracted = EqToLatexUtil.extractMathJaxScripts(script);
+                    if (!extracted.up.isEmpty()) {
+                        up.append(up.length() > 0 ? " " : "").append(extracted.up);
+                    }
+                    if (!extracted.down.isEmpty()) {
+                        down.append(down.length() > 0 ? " " : "").append(extracted.down);
+                    }
+                }
+            });
+            String newUp = up.toString().replaceAll("\\s?OVER_SCRIPT:|\\s?UNDER_SCRIPT:", "");
+            String newDown = down.toString().replaceAll("\\s?OVER_SCRIPT:|\\s?UNDER_SCRIPT:", "");
+            StringBuilder output = new StringBuilder();
+            if (up.length() > 0) {
+                output.append(String.format("^{%s}", newUp));
+            }
+            if (down.length() > 0) {
+                output.append(String.format("_{%s}", newDown));
+            }
+            return output.toString();
+        }
+        int baseIndex = -1;
+        for (int i = 0; i < args.size(); ++i) {
+            if (EqToLatexUtil.isScriptMarker(args.get(i))) continue;
+            baseIndex = i;
+            break;
+        }
+        if (baseIndex == -1) {
+            String result = args.get(0);
+            for (int i = 1; i < args.size(); ++i) {
+                result = String.format("\\rlap{%s}{%s}", args.get(i), result);
+            }
+            return result;
+        }
+        String base = args.get(baseIndex);
+        base = EqToLatexUtil.resolveNestedScripts(base);
+        ArrayList<String> otherArgs = new ArrayList<String>();
+        for (int i = 0; i < args.size(); ++i) {
+            if (i == baseIndex) continue;
+            otherArgs.add(args.get(i));
+        }
+        boolean otherArgsAreScriptMarkers = true;
+        for (String arg : otherArgs) {
+            if (EqToLatexUtil.isScriptMarker(arg)) continue;
+            otherArgsAreScriptMarkers = false;
+            break;
+        }
+        if (!otherArgs.isEmpty() && otherArgsAreScriptMarkers) {
+            StringBuilder over = new StringBuilder();
+            StringBuilder under = new StringBuilder();
+            otherArgs.forEach(script -> {
+                if ("OVERSET_ARROW".equals(script)) {
+                    over.append("\\rightarrow");
+                } else if ("OVERSET_HAT".equals(script)) {
+                    over.append("^");
+                } else if (script.startsWith("OVER_UNDER_SCRIPT:")) {
+                    String[] parts = script.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                    over.append(over.length() > 0 ? " " : "").append(parts[0]);
+                    under.append(under.length() > 0 ? " " : "").append(parts[1]);
+                } else if (script.startsWith("OVER_SCRIPT:")) {
+                    over.append(over.length() > 0 ? " " : "").append(script.substring("OVER_SCRIPT:".length()));
+                } else if (script.startsWith("UNDER_SCRIPT:")) {
+                    under.append(under.length() > 0 ? " " : "").append(script.substring("UNDER_SCRIPT:".length()));
+                }
+            });
+            if ("^".equals(over.toString())) {
+                return String.format("\\hat{%s}", base);
+            }
+            String cleanOver = over.toString().replace(" ", "").replace("\\to", "\\rightarrow").replace("\u2192", "\\rightarrow");
+            if ("\\rightarrow".equals(cleanOver) || cleanOver.contains("\\rightarrow") && (cleanOver.matches(".*[\u2014\u2013\u2212\u2015\u2012\u2010\\-].*") || cleanOver.contains("OVERSET_ARROW"))) {
+                return String.format("\\overrightarrow{%s}", base);
+            }
+            if ("\\rightarrow".equals(over.toString())) {
+                return String.format("\\overrightarrow{%s}", base);
+            }
+            String result = base;
+            if (over.length() > 0) {
+                result = String.format("\\overset{%s}{%s}", over.toString(), result);
+            }
+            if (under.length() > 0) {
+                result = String.format("\\underset{%s}{%s}", under.toString(), result);
+            }
+            return result;
+        }
+        String result = base;
+        for (int i = otherArgs.size() - 1; i >= 0; --i) {
+            result = String.format("\\rlap{%s}{%s}", otherArgs.get(i), result);
+        }
+        return result;
+    }
+
+    private static String handleChemicalSymbols(List<String> args, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return null;
+        }
+        String firstArg = args.get(0).trim();
+        if (LONG_EQUALS_PATTERN.matcher(firstArg).matches() && firstArg.length() >= 3) {
+            return EqToLatexUtil.handleLongEqual(args);
+        }
+        if ((firstArg.contains("\u2192") || firstArg.contains("\\rightarrow")) && !firstArg.contains("\u2190") && !firstArg.contains("\\leftarrow")) {
+            return EqToLatexUtil.handleRightArrow(args);
+        }
+        if (firstArg.matches("^\u2190[\u2015\uff0d\u2014\\-]+$") || firstArg.contains("\u2190") || firstArg.contains("\\leftarrow")) {
+            return EqToLatexUtil.handleLeftArrow(args);
+        }
+        return null;
+    }
+
+    private static String handleLongEqual(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xlongequal[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xlongequal{%s}", upper);
+        }
+        return "\\xlongequal{}";
+    }
+
+    private static String handleRightArrow(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xrightarrow[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xrightarrow{%s}", upper);
+        }
+        if (!lower.isEmpty()) {
+            return String.format("\\xrightarrow[%s]{}", lower);
+        }
+        return "\\xrightarrow{}";
+    }
+
+    private static String handleLeftArrow(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xleftarrow[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xleftarrow{%s}", upper);
+        }
+        if (!lower.isEmpty()) {
+            return String.format("\\xleftarrow[%s]{}", lower);
+        }
+        return "\\xleftarrow{}";
+    }
+
+    private static String handleDisplacement(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        return String.join((CharSequence)" ", args);
+    }
+
+    private static String handleUp(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.format("^{%s}", String.join((CharSequence)",", args));
+    }
+
+    private static String handleDo(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.format("_{%s}", String.join((CharSequence)",", args));
+    }
+
+    public static String replaceJbyuWithMeasurements(String input) {
+        String pattern = "(JBYU1JBYU)+";
+        Matcher matcher = Pattern.compile(pattern).matcher(input);
+        StringBuffer result = new StringBuffer();
+        while (matcher.find()) {
+            String match = matcher.group();
+            int count = match.length() / 4;
+            int groups = (count + 4) / 5;
+            StringBuilder replacement = new StringBuilder();
+            for (int i = 0; i < groups; ++i) {
+                replacement.append("\\\\underline{\\\\qquad}");
+            }
+            matcher.appendReplacement(result, replacement.toString());
+        }
+        matcher.appendTail(result);
+        return result.toString();
+    }
+
+    private static String handleLimitExpression(List<String> args) {
+        Matcher m;
+        if (args.size() < 2) {
+            return null;
+        }
+        String limitArg = args.get(1).trim();
+        Pattern nestedDoPattern = Pattern.compile("\\\\s\\\\do4\\(\\\\s\\\\do4\\(([^)]+)\\)\\)");
+        Matcher match = nestedDoPattern.matcher(limitArg);
+        if (match.find()) {
+            return String.format("\\lim_{%s}", match.group(1));
+        }
+        Pattern singleDoPattern = Pattern.compile("\\\\s\\\\do4\\(([^)]+)\\)");
+        Matcher singleMatch = singleDoPattern.matcher(limitArg);
+        if (singleMatch.find()) {
+            return String.format("\\lim_{%s}", singleMatch.group(1));
+        }
+        if (limitArg.startsWith("_{") && limitArg.endsWith("}")) {
+            return String.format("\\lim_{%s}", limitArg.substring(2, limitArg.length() - 1));
+        }
+        if (limitArg.matches("^_\\{_\\{([^}]+)}}$") && (m = Pattern.compile("^_\\{_\\{([^}]+)}}$").matcher(limitArg)).find()) {
+            return String.format("\\lim_{%s}", m.group(1));
+        }
+        Pattern anySubPattern = Pattern.compile("_\\{([^}]+)}");
+        Matcher anySubMatch = anySubPattern.matcher(limitArg);
+        if (anySubMatch.find()) {
+            Matcher inner;
+            String limitContent = anySubMatch.group(1);
+            if (limitContent.contains("_{") && limitContent.contains("}") && (inner = Pattern.compile("_\\{([^}]+)}").matcher(limitContent)).find()) {
+                limitContent = inner.group(1);
+            }
+            return String.format("\\lim_{%s}", limitContent);
+        }
+        if (!limitArg.isEmpty() && !limitArg.contains("\\")) {
+            return String.format("\\lim_{%s}", limitArg);
+        }
+        return null;
+    }
+
+    private static boolean isConsecutiveScript(String first, String second) {
+        if (first == null || second == null) {
+            return false;
+        }
+        String firstTrimmed = first.trim();
+        String secondTrimmed = second.trim();
+        boolean firstIsSuper = firstTrimmed.matches(".*\\\\?\\^\\{\\s*[^}]*\\s*}$");
+        boolean secondIsSuper = secondTrimmed.matches("^\\s*\\\\?\\^\\{.*");
+        boolean firstIsSub = firstTrimmed.matches(".*\\\\?_\\{\\s*[^}]*\\s*}$");
+        boolean secondIsSub = secondTrimmed.matches("^\\s*\\\\?_\\{.*");
+        return firstIsSuper && secondIsSuper || firstIsSub && secondIsSub;
+    }
+
+    private static String mergeConsecutiveScripts(String first, String second) {
+        if (EqToLatexUtil.isConsecutiveScript(first, second)) {
+            Matcher firstMatch = Pattern.compile("(\\\\?)(\\^|_)\\{([^}]*)}$").matcher(first.trim());
+            if (!firstMatch.find()) {
+                return first + second;
+            }
+            String firstBackslash = firstMatch.group(1);
+            String scriptType = firstMatch.group(2);
+            String firstContent = firstMatch.group(3);
+            Matcher secondMatch = Pattern.compile("^\\s*(\\\\?)(\\^|_)\\{([^}]*)}").matcher(second.trim());
+            if (!secondMatch.find() || !secondMatch.group(2).equals(scriptType)) {
+                return first + second;
+            }
+            String secondContent = secondMatch.group(3);
+            String mergedContent = firstContent + secondContent;
+            String beforeScript = first.replaceAll("(\\\\?)(\\^|_)\\{[^}]*}$", "");
+            return beforeScript + firstBackslash + scriptType + "{" + mergedContent + "}";
+        }
+        return first + second;
+    }
+
+    private static String postProcessConsecutiveScripts(String text) {
+        String previousText;
+        String result = text;
+        do {
+            previousText = result;
+            result = result.replaceAll("(\\\\?)\\^\\{([^}]*?)}\\s+(\\\\?)\\^\\{([^}]*?)}", "$1^{$2$4}");
+        } while (!(result = result.replaceAll("(\\\\?)_\\{([^}]*?)}\\s+(\\\\?)_\\{([^}]*?)}", "$1_{$2$4}")).equals(previousText));
+        return result;
+    }
+
+    private static boolean isScriptMarker(String str) {
+        if (str == null) {
+            return false;
+        }
+        return str.equals("OVERSET_ARROW") || str.equals("OVERSET_HAT") || str.startsWith("OVER_UNDER_SCRIPT:") || str.startsWith("OVER_SCRIPT:") || str.startsWith("UNDER_SCRIPT:") || str.matches("^\\^\\{.*}$") || str.matches("^_\\{.*}$") || str.matches("^(\\^\\{[^}]*})+$") || str.matches("^(_\\{[^}]*})+$") || str.matches("^(\\^\\{[^}]*}|_\\{[^}]*})+$");
+    }
+
+    private static MathJaxScripts extractMathJaxScripts(String mathjaxScript) {
+        MathJaxScripts result = new MathJaxScripts();
+        Matcher upMatcher = Pattern.compile("\\^\\{([^}]*)}").matcher(mathjaxScript);
+        while (upMatcher.find()) {
+            result.up = result.up + upMatcher.group(1);
+        }
+        Matcher downMatcher = Pattern.compile("_\\{([^}]*)}").matcher(mathjaxScript);
+        while (downMatcher.find()) {
+            result.down = result.down + downMatcher.group(1);
+        }
+        return result;
+    }
+
+    private static String resolveNestedScripts(String text) {
+        if (text == null) {
+            return null;
+        }
+        String result = text;
+        result = result.replaceAll("OVERSET_ARROW", "\\\\rightarrow");
+        result = result.replaceAll("OVERSET_HAT", "^");
+        Pattern p = Pattern.compile("OVER_UNDER_SCRIPT:([^ ]+)");
+        Matcher m = p.matcher(result);
+        StringBuffer sb = new StringBuffer();
+        while (m.find()) {
+            String content = m.group(1);
+            String[] parts = content.split(",", 2);
+            String up = parts[0].trim();
+            String down = (parts.length > 1 ? parts[1] : "").trim();
+            m.appendReplacement(sb, "^{" + up + "}_{" + down + "}");
+        }
+        m.appendTail(sb);
+        result = sb.toString();
+        result = result.replaceAll("OVER_SCRIPT:([^ ]+)", "^{$1}");
+        result = result.replaceAll("UNDER_SCRIPT:([^ ]+)", "_{$1}");
+        return result;
+    }
+
+    private static boolean isSpecialScriptMarker(String str) {
+        return EqToLatexUtil.isScriptMarker(str);
+    }
+
+    private static String mergeSpecialScriptMarkers(String first, String second) {
+        String upFirst = "";
+        String downFirst = "";
+        if (first.startsWith("OVER_SCRIPT:")) {
+            upFirst = first.substring("OVER_SCRIPT:".length());
+        } else if (first.startsWith("UNDER_SCRIPT:")) {
+            downFirst = first.substring("UNDER_SCRIPT:".length());
+        } else if (first.startsWith("OVER_UNDER_SCRIPT:")) {
+            String[] parts = first.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+            upFirst = parts[0];
+            downFirst = parts.length > 1 ? parts[1] : "";
+        }
+        String upSecond = "";
+        String downSecond = "";
+        if (second.startsWith("OVER_SCRIPT:")) {
+            upSecond = second.substring("OVER_SCRIPT:".length());
+        } else if (second.startsWith("UNDER_SCRIPT:")) {
+            downSecond = second.substring("UNDER_SCRIPT:".length());
+        } else if (second.startsWith("OVER_UNDER_SCRIPT:")) {
+            String[] parts = second.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+            upSecond = parts[0];
+            downSecond = parts.length > 1 ? parts[1] : "";
+        }
+        String upMerged = (upFirst + upSecond).trim();
+        String downMerged = (downFirst + downSecond).trim();
+        if (!upMerged.isEmpty() && !downMerged.isEmpty()) {
+            return "OVER_UNDER_SCRIPT:" + upMerged + "," + downMerged;
+        }
+        if (!upMerged.isEmpty()) {
+            return "OVER_SCRIPT:" + upMerged;
+        }
+        if (!downMerged.isEmpty()) {
+            return "UNDER_SCRIPT:" + downMerged;
+        }
+        return first;
+    }
+
+    public static void main(String[] args) {
+        EqToLatexUtil.expect("P1-1", "eq \\o\\al(\\s\\up4(\u00b7),\\s\\do4(\u00b7))", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P1-2", "eq \\o(Cl,\\s\\up6(\\s\\up4(\u00b7\u00b7)),\\s\\do4(\\s\\do4(\u00b7\u00b7)))", "\\underset{_{\\cdot \\cdot}}{\\overset{^{\\cdot \\cdot}}{Cl}}");
+        EqToLatexUtil.expect("P1-3", "eq \\o\\al(\\s\\up4(\u00b7),\\s\\do4(\u00b7))", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P3-1", "\\JBYU2BEGINeq \\\\JBYU2END\\JBYU2BEGINo\\al(\\JBYU2END\\JBYU2BEGIN\\s\\up4(\u00b7)\\JBYU2END,\\JBYU2BEGIN\\s\\do4(\u00b7)\\JBYU2END)\\JBYU2END", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P3-2", "\\JBYU2BEGINeq \\\\JBYU2END\\JBYU2BEGINo(Cl,\\s\\up6(\\JBYU2BEGIN\\s\\up4(\u00b7\u00b7)\\JBYU2END),\\s\\do4(\\JBYU2BEGIN\\s\\do4(\u00b7\u00b7)\\JBYU2END))\\JBYU2END", "\\underset{_{\\cdot \\cdot}}{\\overset{^{\\cdot \\cdot}}{Cl}}");
+        EqToLatexUtil.expect("P3-3", "\\JBYU2BEGINeq \\\\JBYU2END\\JBYU2BEGINo\\al(\\JBYU2END\\JBYU2BEGIN\\s\\up4(\u00b7)\\JBYU2END,\\JBYU2BEGIN\\s\\do4(\u00b7)\\JBYU2END)\\JBYU2END", "^{\\cdot}_{\\cdot}");
+        System.out.println("OK");
+    }
+
+    private static void expect(String label, String input, String expected) {
+        String actual = EqToLatexUtil.convert(input);
+        if (!expected.equals(actual)) {
+            throw new AssertionError((Object)(label + " expected " + expected + " but got " + actual));
+        }
+    }
+
+    static {
+        COMMAND_HANDLERS.put("f", EqToLatexUtil::handleFraction);
+        COMMAND_HANDLERS.put("r", EqToLatexUtil::handleRoot);
+        COMMAND_HANDLERS.put("i", EqToLatexUtil::handleIntegral);
+        COMMAND_HANDLERS.put("s", EqToLatexUtil::handleScript);
+        COMMAND_HANDLERS.put("b", EqToLatexUtil::handleBrackets);
+        COMMAND_HANDLERS.put("a", EqToLatexUtil::handleArray);
+        COMMAND_HANDLERS.put("x", EqToLatexUtil::handleBox);
+        COMMAND_HANDLERS.put("l", EqToLatexUtil::handleList);
+        COMMAND_HANDLERS.put("o", EqToLatexUtil::handleOverstrike);
+        COMMAND_HANDLERS.put("d", EqToLatexUtil::handleDisplacement);
+        COMMAND_HANDLERS.put("up", EqToLatexUtil::handleUp);
+        COMMAND_HANDLERS.put("do", EqToLatexUtil::handleDo);
+    }
+
+    private static class MathJaxScripts {
+        String up = "";
+        String down = "";
+
+        private MathJaxScripts() {
+        }
+    }
+
+    private static class ArgumentResult {
+        boolean success;
+        String content;
+        int endIndex;
+
+        ArgumentResult(boolean success, String content, int endIndex) {
+            this.success = success;
+            this.content = content;
+            this.endIndex = endIndex;
+        }
+    }
+
+    private static class ParseResult {
+        String output;
+        int newIndex;
+
+        ParseResult(String output, int newIndex) {
+            this.output = output;
+            this.newIndex = newIndex;
+        }
+    }
+
+    @FunctionalInterface
+    static interface CommandHandler {
+        public String handle(List<String> var1, List<String> var2, String var3, Map<String, Object> var4);
+    }
+}
+
diff --git a/java-src/utils/LatexUtil.java b/java-src/utils/LatexUtil.java
new file mode 100644
index 0000000..28cee3f
--- /dev/null
+++ b/java-src/utils/LatexUtil.java
@@ -0,0 +1,501 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.hutool.core.thread.ThreadUtil
+ *  com.alibaba.fastjson.JSON
+ *  com.alibaba.fastjson.JSONObject
+ *  com.alibaba.fastjson.TypeReference
+ *  com.alibaba.fastjson.parser.Feature
+ *  com.fasterxml.jackson.databind.ObjectMapper
+ *  com.fasterxml.jackson.databind.SerializationFeature
+ *  com.jby.common.util.FileUtil
+ *  com.jby.common.util.HttpClientUtil
+ *  com.jby.common.util.UniqueUtil
+ *  fmath.conversion.ConvertFromLatexToMathML
+ *  fmath.conversion.ConvertFromMathMLToLatex
+ *  org.apache.commons.collections4.MapUtils
+ *  org.apache.commons.exec.CommandLine
+ *  org.apache.commons.exec.DefaultExecutor
+ *  org.apache.commons.exec.ExecuteStreamHandler
+ *  org.apache.commons.exec.PumpStreamHandler
+ *  org.apache.commons.lang3.StringUtils
+ *  org.scilab.forge.jlatexmath.TeXFormula
+ *  org.scilab.forge.jlatexmath.TeXIcon
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Component
+ */
+package com.jby.officecore.utils;
+
+import cn.hutool.core.thread.ThreadUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.alibaba.fastjson.parser.Feature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.jby.common.util.FileUtil;
+import com.jby.common.util.HttpClientUtil;
+import com.jby.common.util.UniqueUtil;
+import com.jby.officecore.config.OfficeCoreConfig;
+import com.jby.officecore.domain.bo.LatexInfoBO;
+import com.jby.officecore.utils.MapUtil;
+import fmath.conversion.ConvertFromLatexToMathML;
+import fmath.conversion.ConvertFromMathMLToLatex;
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.OutputStream;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.imageio.ImageIO;
+import javax.swing.JLabel;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.exec.CommandLine;
+import org.apache.commons.exec.DefaultExecutor;
+import org.apache.commons.exec.ExecuteStreamHandler;
+import org.apache.commons.exec.PumpStreamHandler;
+import org.apache.commons.lang3.StringUtils;
+import org.scilab.forge.jlatexmath.TeXFormula;
+import org.scilab.forge.jlatexmath.TeXIcon;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class LatexUtil {
+    private static final Logger log = LoggerFactory.getLogger(LatexUtil.class);
+    private static final String LATEX_PATTERN_STR = "\\$\\$(.*?)\\$\\$|\\\\\\((.*?)\\\\\\)";
+    private static final Pattern LATEX_PATTERN = Pattern.compile("\\$\\$(.*?)\\$\\$|\\\\\\((.*?)\\\\\\)");
+    private static final String LATEX_SELF_PATTERN_STR = "(?<=\\$\\$)(.*?)(?=\\$\\$)|(?<=\\\\\\()(.*?)(?=\\\\\\))";
+    private static final Pattern LATEX_SELF_PATTERN = Pattern.compile("(?<=\\$\\$)(.*?)(?=\\$\\$)|(?<=\\\\\\()(.*?)(?=\\\\\\))");
+    private static final Pattern CHINESE_PATTERN = Pattern.compile("[\u4e00-\u9fa5]");
+    private static final String LATEX_REPLACE = "@@@";
+    public static final String LATEX_SPLIT = "###";
+    private static OfficeCoreConfig officeCoreConfig;
+    private static final ObjectMapper MAPPER;
+
+    @Autowired
+    public void setOfficeCoreConfig(OfficeCoreConfig officeCoreConfig) {
+        LatexUtil.officeCoreConfig = officeCoreConfig;
+    }
+
+    public static String dealLatexContent(String content, Map<String, LatexInfoBO> latexMap, Boolean newTransferVersion) {
+        String result = content.replaceAll(LATEX_PATTERN_STR, LATEX_REPLACE);
+        Matcher mather = LatexUtil.getLatexMatcher(content);
+        while (mather.find()) {
+            String latex = mather.group();
+            String latexKey = "";
+            if (StringUtils.isNotBlank((CharSequence)latex)) {
+                String cleanLatex;
+                Matcher matcher;
+                latex = latex.replaceAll("&nbsp;", "  ");
+                latex = latex.replaceAll("&gt;", ">");
+                latex = latex.replaceAll("&lt;", "<");
+                latex = latex.replace("<br/>", "").replace("\\&nbsp;", "");
+                if (Boolean.TRUE.equals(newTransferVersion)) {
+                    latexKey = latex.replaceAll(LATEX_SELF_PATTERN_STR, UniqueUtil.getUuid());
+                    matcher = LATEX_SELF_PATTERN.matcher(latex);
+                    if (matcher.find() && StringUtils.isNotBlank((CharSequence)(cleanLatex = matcher.group()))) {
+                        latex = cleanLatex;
+                    }
+                } else {
+                    latex = LatexUtil.formatLatex(latex);
+                    latexKey = latex.replaceAll(LATEX_SELF_PATTERN_STR, UniqueUtil.getUuid());
+                    matcher = LATEX_SELF_PATTERN.matcher(latex);
+                    if (matcher.find() && StringUtils.isNotBlank((CharSequence)(cleanLatex = matcher.group()))) {
+                        latex = cleanLatex;
+                    }
+                    latex = LatexUtil.wrapLatexExpressionWithBraces(latex);
+                }
+                latexMap.put(latexKey, new LatexInfoBO().setLatexKey(latexKey).setLatex(latex));
+            }
+            result = StringUtils.replaceOnce((String)result, (String)LATEX_REPLACE, (String)("&nbsp;###" + latexKey + LATEX_SPLIT + "&nbsp;"));
+        }
+        return result;
+    }
+
+    public static String wrapLatexExpressionWithBraces(String latex) {
+        String[] simpleOperators;
+        String[] limitsOperators;
+        if (StringUtils.isBlank((CharSequence)latex)) {
+            return latex;
+        }
+        latex = latex.replaceAll("\\\\xleftrightarrow\\[([^\\]]+)\\]\\{([^}]+)\\}", "\\\\underset{$1}{\\\\overset{$2}{\\\\longleftrightarrow}}");
+        latex = latex.replaceAll("\\\\xrightleftharpoons\\[([^\\]]+)\\]\\{([^}]+)\\}", "\\\\underset{$1}{\\\\overset{$2}{\\\\mathop{\\\\rightleftharpoons }}}\\\\,");
+        latex = latex.replaceAll("\\\\enclose\\{madruwb\\}\\{([^}]+)\\}", "\\\\left. \\{\\\\underline \\{$1\\}\\} \\\\right|");
+        latex = latex.replaceAll("\\\\enclose\\{actuarial\\}\\{([^}]+)\\}", "\\\\left. \\{\\\\overline \\{$1\\}\\} \\\\right|");
+        String[] operators = new String[]{"prod", "coprod", "sum", "int", "bigcap", "bigcup", "iint", "iiint", "oint"};
+        for (String op : limitsOperators = new String[]{"prod", "coprod", "sum", "bigcap", "bigcup", "iint", "iiint", "oint"}) {
+            latex = latex.replaceAll("(\\\\displaystyle\\\\" + op + "\\\\limits(?:\\s*_\\{[^}]*\\})?(?:\\s*\\^\\{[^}]*\\}|\\s*_\\{[^}]*\\})\\s*)([a-zA-Z0-9]+)(?![a-zA-Z0-9])", "$1{$2}");
+        }
+        for (String op : operators) {
+            latex = latex.replaceAll("(\\\\displaystyle\\\\" + op + "(?:\\s*_\\{[^}]*\\})?(?:\\s*\\^\\{[^}]*\\}|\\s*_\\{[^}]*\\})\\s*)([a-zA-Z0-9]+)(?![a-zA-Z0-9])", "$1{$2}");
+        }
+        for (String op : simpleOperators = new String[]{"iint", "iiint", "oint"}) {
+            latex = latex.replaceAll("(\\\\" + op + "\\s*_\\{[^}]*\\}\\s*)([a-zA-Z0-9]+)(?![a-zA-Z0-9])", "$1{$2}");
+        }
+        return latex;
+    }
+
+    public static String formatLatex(String latex) {
+        if (StringUtils.isBlank((CharSequence)latex)) {
+            return latex;
+        }
+        StringBuilder latexBuilder = new StringBuilder();
+        try {
+            latex = latex.replace("leqslant", "leq");
+            latex = latex.replace("geqslant", "geq");
+            boolean inChinese = false;
+            char[] cArray = latex.toCharArray();
+            int n = cArray.length;
+            for (int i = 0; i < n; ++i) {
+                Character c = Character.valueOf(cArray[i]);
+                Matcher chineseMatch = CHINESE_PATTERN.matcher(c.toString());
+                if (chineseMatch.find()) {
+                    if (inChinese) {
+                        latexBuilder.append(c);
+                        continue;
+                    }
+                    latexBuilder.append("\\mbox{").append(c);
+                    inChinese = true;
+                    continue;
+                }
+                if (inChinese) {
+                    inChinese = false;
+                    latexBuilder.append("}");
+                }
+                latexBuilder.append(c);
+            }
+            if (inChinese) {
+                latexBuilder.append("}");
+            }
+        }
+        catch (Exception e) {
+            log.error("formatLatex error, latex:{}, result:{}", new Object[]{latex, latexBuilder.toString(), e});
+        }
+        return latexBuilder.toString();
+    }
+
+    public static void latexToImg(String latex, String path) {
+        try {
+            TeXFormula formula = new TeXFormula(latex);
+            TeXIcon icon = formula.createTeXIcon(0, 40.0f);
+            icon.setInsets(new Insets(5, 5, 5, 5));
+            BufferedImage bImg = new BufferedImage(icon.getIconWidth(), icon.getIconHeight(), 6);
+            Graphics2D g2d = bImg.createGraphics();
+            g2d.setColor(Color.white);
+            g2d.fillRect(0, 0, icon.getIconWidth(), icon.getIconHeight());
+            JLabel jl = new JLabel();
+            jl.setForeground(new Color(0, 0, 0));
+            icon.paintIcon((java.awt.Component)jl, (Graphics)g2d, 0, 0);
+            File out = FileUtil.getFile((String)path);
+            ImageIO.write((RenderedImage)bImg, "png", out);
+        }
+        catch (Exception e) {
+            log.error("latexToImg error\uff1alatex={}, path={}, ", new Object[]{latex, path, e});
+        }
+    }
+
+    public static void latexToMathML(Map<String, LatexInfoBO> latexMap) {
+        Collection<Map<String, LatexInfoBO>> maps = MapUtil.splitMap(latexMap, 500);
+        HashMap convertMap = new HashMap();
+        maps.forEach(map -> {
+            if (MapUtils.isEmpty((Map)map)) {
+                return;
+            }
+            HashMap convertParam = new HashMap();
+            String result = null;
+            try {
+                HashMap param = new HashMap();
+                map.values().forEach(info -> param.put(info.getLatexKey(), info.getLatex()));
+                convertParam.put("latex", param);
+                long ts = System.currentTimeMillis();
+                result = HttpClientUtil.doPost((String)officeCoreConfig.getForeLatexToMathMlApi(), (String)JSON.toJSONString(convertParam));
+                log.info("latex\u8f6cmathML\u8c03\u7528python\u63a5\u53e3\u6210\u529f, \u8017\u65f6\uff1a{}\u6beb\u79d2", (Object)(System.currentTimeMillis() - ts));
+                Map convertResult = (Map)HttpClientUtil.parseResult((String)result, (TypeReference)new TypeReference<Map<String, String>>(){});
+                if (MapUtils.isNotEmpty((Map)convertResult)) {
+                    convertMap.putAll(convertResult);
+                }
+            }
+            catch (Exception e) {
+                log.error("latex\u8f6cmathML\u8c03\u7528python\u63a5\u53e3\u5f02\u5e38, param:{}, result:{}", new Object[]{JSON.toJSONString(convertParam), result, e});
+            }
+        });
+        latexMap.values().forEach(info -> {
+            String mathMl = (String)convertMap.get(info.getLatexKey());
+            if (StringUtils.isBlank((CharSequence)mathMl)) {
+                try {
+                    mathMl = LatexUtil.convertFromLatexToMathML(info.getLatex());
+                    log.info("latex\u8f6cmathML\u672c\u5730\u8f6c\u6362,latex:{}", (Object)info.getLatex());
+                }
+                catch (Exception e) {
+                    log.error("latex\u8f6cmathML\u672c\u5730\u8f6c\u6362\u5f02\u5e38, info:{}", (Object)JSON.toJSONString((Object)info), (Object)e);
+                }
+            }
+            if (StringUtils.isNotBlank((CharSequence)mathMl)) {
+                mathMl = mathMl.replaceAll("(?i)&#x27C2;", "&#x22A5;");
+            }
+            info.setMathMl(mathMl);
+        });
+    }
+
+    private static String convertFromLatexToMathML(String latex) {
+        String mathMl = ConvertFromLatexToMathML.convertToMathML((String)latex);
+        mathMl = mathMl.replace("\n", "").replaceFirst("<math", "<math xmlns=\"http://www.w3.org/1998/Math/MathML\" ").replace("&lowast;", "\u2217").replace("&there4;", "\u2234").replace("&prop;", "\u221d").replace("&asymp;", "\u2248").replace("&ne;", "\u2260").replace("&ni;", "\u220b").replace("&isin;", "\u2208").replace("&notin;", "\u2209").replace("&alpha;", "\u03b1").replace("&beta;", "\u03b2").replace("&gamma;", "\u03b3").replace("&delta;", "\u03b4").replace("&varepsilon;", "\u03b5").replace("&epsilon;", "\u03f5").replace("&zeta;", "\u03b6").replace("&eta;", "\u03b7").replace("&theta;", "\u03b8").replace("&thetasym;", "\u03d1").replace("&iota;", "\u03b9").replace("&kappa;", "\u03ba").replace("&lambda;", "\u03bb").replace("&mu;", "\u03bc").replace("&nu;", "\u03bd").replace("&rho;", "\u03c1").replace("&sigma;", "\u03c3").replace("&phi;", "\u03d5").replace("&varphi;", "\u03c6").replace("&omega;", "\u03c9").replace("&Lambda;", "\u039b").replace("&Sigma;", "\u03a3").replace("&Omega;", "\u03a9").replace("&sub;", "\u2282").replace("&sup;", "\u2283").replace("&sube;", "\u2286").replace("&supe;", "\u2287").replace("&nabla;", "\u2207").replace("&hellip;", "\u2026").replace("&darr;", "\u2193").replace("&dArr;", "\u21d3").replace("&uarr;", "\u2191").replace("&uArr;", "\u21d1").replace("&rarr;", "\u2192").replace("&rArr;", "\u21d2").replace("&larr;", "\u2190").replace("&lArr;", "\u21d0").replace("&harr;", "\u2194").replace("&hArr;", "\u21d4").replace("&real;", "\u211c").replace("&image;", "\u2111").replace("&part;", "\u2202").replace("&infin;", "\u221e").replace("&alefsym;", "\u2135").replace("&exist;", "\u2203").replace("&empty;", "\u2205").replace("&cup;", "\u222a").replace("&cap;", "\u2229").replace("&deg;", "\u00b0").replace("&ang;", "\u2220").replace("&int;", "\u222b").replace("&prod;", "\u220f").replace("&coprod;", "\u2210");
+        return mathMl;
+    }
+
+    public static void mathMlToLatex(Map<String, String> formulaMap, Path path) {
+        if (!MapUtils.isEmpty(formulaMap)) {
+            log.info("mathML\u8f6clatex\u6570\u91cf:{}", (Object)formulaMap.size());
+        }
+        Collection<Map<String, String>> maps = MapUtil.splitMap(formulaMap, 500);
+        HashMap convertMap = new HashMap();
+        maps.forEach(map -> {
+            block11: {
+                if (MapUtils.isEmpty((Map)map)) {
+                    return;
+                }
+                HashMap<String, Map> convertParam = new HashMap<String, Map>();
+                String result = "";
+                if (Boolean.TRUE.equals(officeCoreConfig.getMathMlToLatexApiSwitch())) {
+                    try {
+                        convertParam.put("mathml_dict", (Map)map);
+                        long ts = System.currentTimeMillis();
+                        result = HttpClientUtil.doPost((String)officeCoreConfig.getMathMlToLatexApi(), convertParam, (int)5000, (int)15000);
+                        log.info("mathML\u8f6clatex\u8c03\u7528python\u63a5\u53e3\u6210\u529f, \u8017\u65f6\uff1a{}\u6beb\u79d2", (Object)(System.currentTimeMillis() - ts));
+                        result = result.replace("<", "\\\\lt ");
+                        Map convertResult = (Map)HttpClientUtil.parseResult((String)result, (TypeReference)new TypeReference<Map<String, String>>(){});
+                        if (MapUtils.isNotEmpty((Map)convertResult)) {
+                            convertMap.putAll(convertResult);
+                        }
+                    }
+                    catch (Exception e) {
+                        log.error("mathML\u8f6clatex\u8c03\u7528python\u63a5\u53e3\u5f02\u5e38, param:{}, result:{}", new Object[]{JSON.toJSONString(convertParam), result, e});
+                    }
+                    ThreadUtil.sleep((long)2000L);
+                } else {
+                    try {
+                        Map convertResult;
+                        JSONObject json;
+                        String data;
+                        convertParam.put("mathml_dict", (Map)map);
+                        File tempFile = File.createTempFile("mathml_input-", ".json", new File(path.toString()));
+                        String absolutePath = tempFile.getAbsolutePath();
+                        if (!StringUtils.isNotBlank((CharSequence)absolutePath) || map.isEmpty()) break block11;
+                        ObjectMapper mapper = new ObjectMapper();
+                        mapper.enable(SerializationFeature.INDENT_OUTPUT);
+                        mapper.writeValue(tempFile, convertParam);
+                        CommandLine cmdLine = CommandLine.parse((String)officeCoreConfig.getPythonCommand());
+                        cmdLine.addArgument(officeCoreConfig.getTransformScriptPath() + "/mathml2latex/batch_converter.py");
+                        cmdLine.addArgument("--input-file=" + absolutePath);
+                        ByteArrayOutputStream output = new ByteArrayOutputStream();
+                        PumpStreamHandler streamHandler = new PumpStreamHandler((OutputStream)output, (OutputStream)output);
+                        DefaultExecutor executor = new DefaultExecutor();
+                        executor.setStreamHandler((ExecuteStreamHandler)streamHandler);
+                        long ts = System.currentTimeMillis();
+                        try {
+                            executor.execute(cmdLine);
+                        }
+                        catch (Exception e) {
+                            log.error("mathml2latex/batch_converter.py error, \n\u8f93\u51fa:{}", (Object)output, (Object)e);
+                        }
+                        log.info("mathml2latex/batch_converter.py end, \u6570\u91cf:{}, \u8017\u65f6:{}\u6beb\u79d2", (Object)map.size(), (Object)(System.currentTimeMillis() - ts));
+                        String fullOutput = output.toString();
+                        CharSequence[] lines = fullOutput.split("\n");
+                        result = String.join((CharSequence)"", lines);
+                        result = result.replace("<", "\\\\lt ");
+                        if (StringUtils.isNotBlank((CharSequence)result) && Objects.nonNull(data = (json = JSONObject.parseObject((String)result)).getString("data")) && MapUtils.isNotEmpty((Map)(convertResult = (Map)JSON.parseObject((String)data, (TypeReference)new TypeReference<Map<String, String>>(){}, (Feature[])new Feature[0])))) {
+                            convertMap.putAll(convertResult);
+                        }
+                    }
+                    catch (Exception e) {
+                        log.error("mathML\u8f6clatex\u8c03\u7528\u672c\u5730python\u7a0b\u5e8f\u5f02\u5e38,param:{}, result:{}", new Object[]{JSON.toJSONString(convertParam), result, e});
+                    }
+                }
+            }
+        });
+        formulaMap.forEach((formulaKey, mathMl) -> {
+            String latex = (String)convertMap.get(formulaKey);
+            if (StringUtils.isBlank((CharSequence)latex)) {
+                try {
+                    latex = ConvertFromMathMLToLatex.convertToLatex((String)mathMl);
+                    log.info("mathML\u8f6clatex\u672c\u5730\u8f6c\u6362,latex:{}", (Object)latex);
+                }
+                catch (Exception e) {
+                    log.error("mathML\u8f6clatex\u672c\u5730\u8f6c\u6362\u5f02\u5e38, mathMl:{}, latex:{}", new Object[]{mathMl, latex, e});
+                }
+            }
+            if (StringUtils.isNotBlank((CharSequence)latex) && latex.length() > 2) {
+                formulaMap.put((String)formulaKey, latex.substring(1, latex.length() - 1));
+            }
+        });
+    }
+
+    public static Matcher getLatexMatcher(String content) {
+        return LATEX_PATTERN.matcher(content);
+    }
+
+    public static void mathMlToLatexIgnoreNull(Map<String, String> formulaMap, String copyrightAddresses, Path path) {
+        Map<String, String> map = formulaMap.entrySet().stream().filter(f -> Objects.nonNull(f.getValue())).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        LatexUtil.mathMlToLatex(map, path);
+        String[] original = copyrightAddresses.split(",");
+        String[] transformed = (String[])Arrays.stream(original).map(s -> s.chars().mapToObj(c -> {
+            if (c == 46) {
+                return ".";
+            }
+            return "\\mathrm{" + (char)c + "}";
+        }).collect(Collectors.joining())).toArray(String[]::new);
+        String[] splits = (String[])Stream.concat(Arrays.stream(original), Arrays.stream(transformed)).toArray(String[]::new);
+        map.replaceAll((key, value) -> {
+            if (value == null) {
+                return null;
+            }
+            return Arrays.stream(splits).anyMatch(value::contains) ? null : value;
+        });
+        formulaMap.putAll(map);
+    }
+
+    public static void ommlAndMathMlToLatex(Map<String, String> formulaMap, Path path) {
+        if (!MapUtils.isEmpty(formulaMap)) {
+            log.info("Omml\u6216MathML\u8f6clatex\u6570\u91cf:{}", (Object)formulaMap.size());
+        }
+        Collection<Map<String, String>> maps = MapUtil.splitMap(formulaMap, 1000);
+        maps.forEach(map -> {
+            block6: {
+                if (MapUtils.isEmpty((Map)map)) {
+                    return;
+                }
+                String result = "";
+                try {
+                    Map convertResult;
+                    File tempFile = File.createTempFile("input-", ".json", new File(path.toString()));
+                    String absolutePath = tempFile.getAbsolutePath();
+                    if (!StringUtils.isNotBlank((CharSequence)absolutePath) || map.isEmpty()) break block6;
+                    ObjectMapper mapper = new ObjectMapper();
+                    mapper.enable(SerializationFeature.INDENT_OUTPUT);
+                    mapper.writeValue(tempFile, map);
+                    CommandLine cmdLine = CommandLine.parse((String)officeCoreConfig.getPythonCommand());
+                    cmdLine.addArgument(officeCoreConfig.getTransformScriptPath() + "/omml_mathml2latex/omml_mathml2latex.py");
+                    cmdLine.addArgument("--json");
+                    cmdLine.addArgument(absolutePath);
+                    ByteArrayOutputStream output = new ByteArrayOutputStream();
+                    PumpStreamHandler streamHandler = new PumpStreamHandler((OutputStream)output, (OutputStream)output);
+                    DefaultExecutor executor = new DefaultExecutor();
+                    executor.setStreamHandler((ExecuteStreamHandler)streamHandler);
+                    long ts = System.currentTimeMillis();
+                    try {
+                        executor.execute(cmdLine);
+                    }
+                    catch (Exception e) {
+                        log.error("/omml_mathml2latex/omml_mathml2latex.py error, \n\u8f93\u51fa:{}", (Object)output, (Object)e);
+                    }
+                    log.info("/omml_mathml2latex/omml_mathml2latex.py end, \u6570\u91cf:{}, \u8017\u65f6:{}\u6beb\u79d2", (Object)map.size(), (Object)(System.currentTimeMillis() - ts));
+                    String fullOutput = output.toString();
+                    CharSequence[] lines = fullOutput.split("\n");
+                    result = String.join((CharSequence)"", lines);
+                    if (StringUtils.isNotBlank((CharSequence)result) && MapUtils.isNotEmpty((Map)(convertResult = (Map)JSON.parseObject((String)result, (TypeReference)new TypeReference<Map<String, String>>(){}, (Feature[])new Feature[0])))) {
+                        formulaMap.putAll(convertResult);
+                    }
+                }
+                catch (Exception e) {
+                    log.error("Omml\u6216MathML\u8f6clatex\u8c03\u7528\u672c\u5730python\u7a0b\u5e8f\u5f02\u5e38,param:{}, result:{}", new Object[]{JSON.toJSONString((Object)map), result, e});
+                }
+            }
+        });
+    }
+
+    public static void ommlMathMlToLatexIgnoreNull(Map<String, String> formulaMap, String copyrightAddresses, Path path) {
+        Map<String, String> map = formulaMap.entrySet().stream().filter(f -> Objects.nonNull(f.getValue())).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        LatexUtil.ommlAndMathMlToLatex(map, path);
+        String[] original = copyrightAddresses.split(",");
+        String[] transformed = (String[])Arrays.stream(original).map(s -> s.chars().mapToObj(c -> {
+            if (c == 46) {
+                return ".";
+            }
+            return "\\mathrm{" + (char)c + "}";
+        }).collect(Collectors.joining())).toArray(String[]::new);
+        String[] splits = (String[])Stream.concat(Arrays.stream(original), Arrays.stream(transformed)).toArray(String[]::new);
+        map.replaceAll((key, value) -> {
+            if (value == null) {
+                return null;
+            }
+            return Arrays.stream(splits).anyMatch(value.replace(" ", "")::contains) ? null : value;
+        });
+        formulaMap.putAll(map);
+    }
+
+    public static void latexAndMathMlToOmml(Map<String, String> latexMathmlMap) {
+        if (!MapUtils.isEmpty(latexMathmlMap)) {
+            log.info("Latex\u6216MathML\u8f6cOmml\u6570\u91cf:{}", (Object)latexMathmlMap.size());
+        }
+        String tempFolder = officeCoreConfig.getTmpPath() + "/download" + File.separator + UniqueUtil.getUuid() + File.separator;
+        Collection<Map<String, String>> maps = MapUtil.splitMap(latexMathmlMap, 1000);
+        maps.forEach(map -> {
+            block10: {
+                if (MapUtils.isEmpty((Map)map)) {
+                    return;
+                }
+                String result = "";
+                try {
+                    Map convertResult;
+                    File tempFile = FileUtil.getFile((String)(tempFolder + UniqueUtil.getUuid() + ".json"));
+                    String absolutePath = tempFile.getAbsolutePath();
+                    if (!StringUtils.isNotBlank((CharSequence)absolutePath) || map.isEmpty()) break block10;
+                    MAPPER.enable(SerializationFeature.INDENT_OUTPUT);
+                    MAPPER.writeValue(tempFile, map);
+                    CommandLine cmdLine = CommandLine.parse((String)officeCoreConfig.getPythonCommand());
+                    cmdLine.addArguments(new String[]{officeCoreConfig.getTransformScriptPath() + "/latex_mathml2omml/latex_mathml2omml.py", "--json", absolutePath}, false);
+                    ByteArrayOutputStream output = new ByteArrayOutputStream();
+                    PumpStreamHandler streamHandler = new PumpStreamHandler((OutputStream)output, (OutputStream)output);
+                    DefaultExecutor executor = new DefaultExecutor();
+                    executor.setStreamHandler((ExecuteStreamHandler)streamHandler);
+                    long ts = System.currentTimeMillis();
+                    try {
+                        executor.execute(cmdLine);
+                    }
+                    catch (Exception e) {
+                        log.error("/latex_mathml2omml/latex_mathml2omml.py error, \n\u8f93\u51fa:{}", (Object)output, (Object)e);
+                    }
+                    log.info("/latex_mathml2omml/latex_mathml2omml.py end, \u6570\u91cf:{}, \u8017\u65f6:{}\u6beb\u79d2", (Object)map.size(), (Object)(System.currentTimeMillis() - ts));
+                    String fullOutput = output.toString();
+                    CharSequence[] lines = fullOutput.split("\n");
+                    result = String.join((CharSequence)"", lines);
+                    if (StringUtils.isNotBlank((CharSequence)result) && MapUtils.isNotEmpty((Map)(convertResult = (Map)JSON.parseObject((String)result, (TypeReference)new TypeReference<Map<String, String>>(){}, (Feature[])new Feature[0])))) {
+                        latexMathmlMap.putAll(convertResult);
+                    }
+                }
+                catch (Exception e) {
+                    log.error("Latex\u6216MathML\u8f6cOmml\u8c03\u7528\u672c\u5730python\u7a0b\u5e8f\u5f02\u5e38,param:{}, result:{}", new Object[]{JSON.toJSONString((Object)map), result, e});
+                }
+                finally {
+                    if (Boolean.TRUE.equals(officeCoreConfig.getDeleteTmpFile())) {
+                        FileUtil.delFolder((String)tempFolder);
+                    }
+                }
+            }
+        });
+    }
+
+    static {
+        MAPPER = new ObjectMapper();
+    }
+}
+
diff --git a/java-src/utils/MathTypeUtil.java b/java-src/utils/MathTypeUtil.java
new file mode 100644
index 0000000..8c5f8a1
--- /dev/null
+++ b/java-src/utils/MathTypeUtil.java
@@ -0,0 +1,131 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.fastjson.JSON
+ *  com.alibaba.fastjson.JSONObject
+ *  org.apache.commons.collections4.MapUtils
+ *  org.apache.commons.exec.CommandLine
+ *  org.apache.commons.exec.DefaultExecutor
+ *  org.apache.commons.exec.ExecuteStreamHandler
+ *  org.apache.commons.exec.PumpStreamHandler
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Component
+ */
+package com.jby.officecore.utils;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.jby.officecore.config.OfficeCoreConfig;
+import com.jby.officecore.utils.MapUtil;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+import java.nio.file.attribute.FileAttribute;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.exec.CommandLine;
+import org.apache.commons.exec.DefaultExecutor;
+import org.apache.commons.exec.ExecuteStreamHandler;
+import org.apache.commons.exec.PumpStreamHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MathTypeUtil {
+    private static final Logger log = LoggerFactory.getLogger(MathTypeUtil.class);
+    private static OfficeCoreConfig officeCoreConfig;
+
+    @Autowired
+    public void setOfficeCoreConfig(OfficeCoreConfig officeCoreConfig) {
+        MathTypeUtil.officeCoreConfig = officeCoreConfig;
+    }
+
+    public static void main(String[] args) {
+        HashMap<String, String> map = new HashMap<String, String>();
+        for (int i = 1; i < 927; ++i) {
+            map.put("jby_" + i, "/Users/hking/test/embeddings/oleObject" + i + ".bin");
+        }
+        MathTypeUtil.mathTypeToMathMl(map);
+        System.out.println(map);
+    }
+
+    public static void mathTypeToMathMl(Map<String, String> formulaMap) {
+        if (!MapUtils.isEmpty(formulaMap)) {
+            log.info("mathtype\u8f6cmathml\u6570\u91cf:{}", (Object)formulaMap.size());
+        }
+        try {
+            Collection<Map<String, String>> maps = MapUtil.splitMap(formulaMap, 500);
+            maps.forEach(m -> {
+                Path tempJsonFile;
+                if (MapUtils.isEmpty((Map)formulaMap)) {
+                    return;
+                }
+                CommandLine cmdLine = CommandLine.parse((String)"ruby");
+                cmdLine.addArgument(officeCoreConfig.getTransformScriptPath() + "/mathtype2mathml/batch_converter.rb");
+                String data = JSONObject.toJSONString((Object)m);
+                try {
+                    tempJsonFile = Files.createTempFile("mathtype_input-", ".json", new FileAttribute[0]);
+                    Files.write(tempJsonFile, data.getBytes(StandardCharsets.UTF_8), new OpenOption[0]);
+                }
+                catch (IOException e) {
+                    log.error("\u521b\u5efa\u4e34\u65f6JSON\u6587\u4ef6\u5931\u8d25", (Throwable)e);
+                    return;
+                }
+                Path finalTempJsonFile = tempJsonFile;
+                cmdLine.addArgument(tempJsonFile.toString());
+                ByteArrayOutputStream output = new ByteArrayOutputStream();
+                PumpStreamHandler streamHandler = new PumpStreamHandler((OutputStream)output, (OutputStream)output);
+                DefaultExecutor executor = new DefaultExecutor();
+                executor.setStreamHandler((ExecuteStreamHandler)streamHandler);
+                long ts = System.currentTimeMillis();
+                try {
+                    executor.execute(cmdLine);
+                }
+                catch (IOException e) {
+                    log.error("/mathtype2mathml/batch_converter.rb error, \n\u547d\u4ee4:{}, \n\u8f93\u51fa:{}", new Object[]{cmdLine, output, e});
+                }
+                finally {
+                    try {
+                        Files.deleteIfExists(finalTempJsonFile);
+                    }
+                    catch (IOException e) {
+                        log.warn("\u5220\u9664JSON\u4e34\u65f6\u6587\u4ef6\u5931\u8d25: {}", (Object)finalTempJsonFile, (Object)e);
+                    }
+                }
+                String fullOutput = output.toString();
+                log.info("/mathtype2mathml/batch_converter.rb end, \u6570\u91cf:{}, \u8017\u65f6:{}\u6beb\u79d2", (Object)m.size(), (Object)(System.currentTimeMillis() - ts));
+                String[] lines = fullOutput.split("\n");
+                String jbyOutput = Arrays.stream(lines).filter(f -> f.startsWith("JBY_RUBY_")).collect(Collectors.joining());
+                String result = jbyOutput.replace("JBY_RUBY_", "");
+                result = result.replace("display=\\\"block\\", "display=\\\"inline\\");
+                result = result.replace("~", "JBYSIMJBY");
+                JSONObject rootObj = JSON.parseObject((String)result);
+                JSONObject results = rootObj.getJSONObject("results");
+                HashMap<String, String> resultMap = new HashMap<String, String>();
+                for (String key : results.keySet()) {
+                    JSONObject item = results.getJSONObject(key);
+                    String mathml = item.getString("mathml");
+                    resultMap.put(key, mathml);
+                }
+                formulaMap.putAll(resultMap);
+            });
+        }
+        catch (Exception e) {
+            log.error("MathType\u8f6cMathMl\u51fa\u73b0\u5f02\u5e38", (Throwable)e);
+        }
+    }
+}
+
diff --git a/java-src/utils/NumPr.java b/java-src/utils/NumPr.java
new file mode 100644
index 0000000..a3ef579
--- /dev/null
+++ b/java-src/utils/NumPr.java
@@ -0,0 +1,109 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.jby.officecore.utils;
+
+import java.math.BigInteger;
+
+public class NumPr {
+    private BigInteger start;
+    private BigInteger current;
+    private String numFmt;
+    private String lvlText;
+
+    public NumPr() {
+    }
+
+    public NumPr(BigInteger start, BigInteger current, String numFmt, String lvlText) {
+        this.start = start;
+        this.current = current;
+        this.numFmt = numFmt;
+        this.lvlText = lvlText;
+    }
+
+    public BigInteger getStart() {
+        return this.start;
+    }
+
+    public BigInteger getCurrent() {
+        return this.current;
+    }
+
+    public String getNumFmt() {
+        return this.numFmt;
+    }
+
+    public String getLvlText() {
+        return this.lvlText;
+    }
+
+    public void setStart(BigInteger start) {
+        this.start = start;
+    }
+
+    public void setCurrent(BigInteger current) {
+        this.current = current;
+    }
+
+    public void setNumFmt(String numFmt) {
+        this.numFmt = numFmt;
+    }
+
+    public void setLvlText(String lvlText) {
+        this.lvlText = lvlText;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof NumPr)) {
+            return false;
+        }
+        NumPr other = (NumPr)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        BigInteger this$start = this.getStart();
+        BigInteger other$start = other.getStart();
+        if (this$start == null ? other$start != null : !((Object)this$start).equals(other$start)) {
+            return false;
+        }
+        BigInteger this$current = this.getCurrent();
+        BigInteger other$current = other.getCurrent();
+        if (this$current == null ? other$current != null : !((Object)this$current).equals(other$current)) {
+            return false;
+        }
+        String this$numFmt = this.getNumFmt();
+        String other$numFmt = other.getNumFmt();
+        if (this$numFmt == null ? other$numFmt != null : !this$numFmt.equals(other$numFmt)) {
+            return false;
+        }
+        String this$lvlText = this.getLvlText();
+        String other$lvlText = other.getLvlText();
+        return !(this$lvlText == null ? other$lvlText != null : !this$lvlText.equals(other$lvlText));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof NumPr;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        BigInteger $start = this.getStart();
+        result = result * 59 + ($start == null ? 43 : ((Object)$start).hashCode());
+        BigInteger $current = this.getCurrent();
+        result = result * 59 + ($current == null ? 43 : ((Object)$current).hashCode());
+        String $numFmt = this.getNumFmt();
+        result = result * 59 + ($numFmt == null ? 43 : $numFmt.hashCode());
+        String $lvlText = this.getLvlText();
+        result = result * 59 + ($lvlText == null ? 43 : $lvlText.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "NumPr(start=" + this.getStart() + ", current=" + this.getCurrent() + ", numFmt=" + this.getNumFmt() + ", lvlText=" + this.getLvlText() + ")";
+    }
+}
+
diff --git a/java-src/utils/OfficeFileUtil.java b/java-src/utils/OfficeFileUtil.java
new file mode 100644
index 0000000..cd58736
--- /dev/null
+++ b/java-src/utils/OfficeFileUtil.java
@@ -0,0 +1,235 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.hutool.core.io.FileUtil
+ *  com.alibaba.fastjson.JSON
+ *  com.alibaba.fastjson.JSONObject
+ *  com.alibaba.fastjson.TypeReference
+ *  com.jby.common.exceptions.BusinessException
+ *  com.jby.common.util.FileUtil
+ *  com.jby.common.util.HttpClientUtil
+ *  com.jby.common.util.RequestHeaderUtil
+ *  com.jby.oss.domain.param.OssParam
+ *  com.jby.system.enums.AttachmentModuleEnum
+ *  org.apache.poi.xwpf.usermodel.XWPFDocument
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Component
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.jby.officecore.utils;
+
+import cn.hutool.core.io.FileUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.jby.common.exceptions.BusinessException;
+import com.jby.common.util.HttpClientUtil;
+import com.jby.common.util.RequestHeaderUtil;
+import com.jby.officecore.config.OfficeCoreConfig;
+import com.jby.officecore.utils.OssServiceUtil;
+import com.jby.oss.domain.param.OssParam;
+import com.jby.system.enums.AttachmentModuleEnum;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.multipart.MultipartFile;
+
+@Component
+public class OfficeFileUtil {
+    private static final Logger log = LoggerFactory.getLogger(OfficeFileUtil.class);
+    private static OfficeCoreConfig officeCoreConfig;
+
+    @Autowired
+    public void setOfficeCoreConfig(OfficeCoreConfig officeCoreConfig) {
+        OfficeFileUtil.officeCoreConfig = officeCoreConfig;
+    }
+
+    public static File writeFile(String content, String savePath) {
+        FileWriter fw = null;
+        BufferedWriter bW = null;
+        try {
+            File file = com.jby.common.util.FileUtil.getFile((String)savePath);
+            fw = new FileWriter(file);
+            bW = new BufferedWriter(fw);
+            bW.write(content);
+            File file2 = file;
+            return file2;
+        }
+        catch (Exception e) {
+            log.error("\u5199\u5165\u6587\u4ef6\u5f02\u5e38, savePath:{}", (Object)savePath, (Object)e);
+            throw new BusinessException("\u5199\u5165\u6587\u4ef6\u5f02\u5e38");
+        }
+        finally {
+            if (bW != null) {
+                try {
+                    bW.close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+            if (fw != null) {
+                try {
+                    fw.close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+        }
+    }
+
+    public static File writeWord(XWPFDocument document, String savePath) {
+        OutputStream os = null;
+        try {
+            File file = com.jby.common.util.FileUtil.getFile((String)savePath);
+            os = Files.newOutputStream(file.toPath(), new OpenOption[0]);
+            document.write(os);
+            File file2 = file;
+            return file2;
+        }
+        catch (Exception e) {
+            log.error("\u751f\u6210word\u6587\u4ef6\u5f02\u5e38, savePath:{}", (Object)savePath, (Object)e);
+            throw new BusinessException("\u751f\u6210word\u6587\u4ef6\u5f02\u5e38\uff01");
+        }
+        finally {
+            if (Objects.nonNull(os)) {
+                try {
+                    os.close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+            if (Objects.nonNull(document)) {
+                try {
+                    document.close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+        }
+    }
+
+    public static File writeFile(MultipartFile file, String savePath) {
+        try {
+            return OfficeFileUtil.writeFile(file.getInputStream(), savePath);
+        }
+        catch (Exception e) {
+            log.error("\u5199\u5165\u6587\u4ef6\u5f02\u5e38, savePath:{}", (Object)savePath, (Object)e);
+            throw new BusinessException("\u5199\u5165\u6587\u4ef6\u5f02\u5e38");
+        }
+    }
+
+    public static File writeFile(InputStream is, String savePath) {
+        FileOutputStream os = null;
+        try {
+            int length;
+            File saveFile = com.jby.common.util.FileUtil.getFile((String)savePath);
+            os = new FileOutputStream(saveFile);
+            byte[] buffer = new byte[15360];
+            while ((length = is.read(buffer)) != -1) {
+                ((OutputStream)os).write(buffer, 0, length);
+            }
+            os.flush();
+            File file = saveFile;
+            return file;
+        }
+        catch (Exception e) {
+            log.error("\u5199\u5165\u6587\u4ef6\u5f02\u5e38, savePath:{}", (Object)savePath, (Object)e);
+            throw new BusinessException("\u5199\u5165\u6587\u4ef6\u5f02\u5e38");
+        }
+        finally {
+            if (is != null) {
+                try {
+                    is.close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+            if (os != null) {
+                try {
+                    ((OutputStream)os).close();
+                }
+                catch (IOException e) {
+                    log.error("close error", (Throwable)e);
+                }
+            }
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    public static String mf2svg(InputStream is, String imgPath) {
+        HashMap<String, Object> params = null;
+        String result = null;
+        try {
+            File localFile = com.jby.common.util.FileUtil.getFile((String)imgPath);
+            FileUtil.writeFromStream((InputStream)is, (File)localFile);
+            String accessUrl = OssServiceUtil.uploadFile(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFile(com.jby.common.util.FileUtil.getMultipartFile((String)localFile.getName(), (File)localFile)));
+            params = new HashMap<String, Object>();
+            params.put("fileUrl", accessUrl);
+            params.put("refreshImg", false);
+            Map headers = RequestHeaderUtil.getAuthHeaders();
+            result = HttpClientUtil.doPost((String)officeCoreConfig.getMf2SvgApi(), params, (Map)headers);
+            JSONObject json = (JSONObject)HttpClientUtil.parseResult((String)result, (TypeReference)new TypeReference<JSONObject>(){});
+            String string = Objects.isNull(json) ? null : json.getString("svgUrl");
+            return string;
+        }
+        catch (Exception e) {
+            log.error("mf2svg exception, imgPath:{}, params:{}, result:{}", new Object[]{imgPath, JSON.toJSONString(params), result, e});
+            String string = null;
+            return string;
+        }
+        finally {
+            if (is != null) {
+                try {
+                    is.close();
+                }
+                catch (IOException e) {
+                    log.error("close error");
+                }
+            }
+        }
+    }
+
+    public static String mf2svg(InputStream is, String ossFolder, String imgName) {
+        HashMap<String, Object> params = null;
+        String result = null;
+        try {
+            String imgUrl = OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(ossFolder).setFileName(imgName).setInputStream(is));
+            params = new HashMap<String, Object>();
+            params.put("fileUrl", imgUrl);
+            params.put("refreshImg", false);
+            Map headers = RequestHeaderUtil.getAuthHeaders();
+            result = HttpClientUtil.doPost((String)officeCoreConfig.getMf2SvgApi(), params, (Map)headers);
+            JSONObject json = (JSONObject)HttpClientUtil.parseResult((String)result, (TypeReference)new TypeReference<JSONObject>(){});
+            return Objects.isNull(json) ? null : json.getString("svgUrl");
+        }
+        catch (Exception e) {
+            log.error("mf2svg exception, ossFolder:{}, imgName:{}, params:{}, result:{}", new Object[]{ossFolder, imgName, JSON.toJSONString(params), result, e});
+            return null;
+        }
+    }
+}
+
diff --git a/java-src/utils/WordParseUtil.java b/java-src/utils/WordParseUtil.java
new file mode 100644
index 0000000..4f3d205
--- /dev/null
+++ b/java-src/utils/WordParseUtil.java
@@ -0,0 +1,1791 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.hutool.core.io.FileUtil
+ *  cn.hutool.core.util.ArrayUtil
+ *  com.alibaba.fastjson.JSONObject
+ *  com.alibaba.fastjson2.JSON
+ *  com.jby.common.exceptions.BizAssert
+ *  com.jby.common.exceptions.BusinessException
+ *  com.jby.common.feign.FeignUtils
+ *  com.jby.common.result.Result
+ *  com.jby.common.util.CloseIoUtil
+ *  com.jby.common.util.FileUtil
+ *  com.jby.common.util.HttpClientUtil
+ *  com.jby.common.util.SpringContextHolder
+ *  com.jby.common.util.UniqueUtil
+ *  com.jby.office.constant.Constants
+ *  com.jby.office.domain.param.OfficeFileParseRecordParam
+ *  com.jby.office.domain.vo.OfficeFileParseRecordVO
+ *  com.jby.oss.domain.param.OssParam
+ *  com.jby.system.enums.AttachmentModuleEnum
+ *  javax.annotation.Nullable
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.collections4.MapUtils
+ *  org.apache.commons.io.FilenameUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.apache.poi.ooxml.POIXMLDocumentPart
+ *  org.apache.poi.openxml4j.util.ZipSecureFile
+ *  org.apache.poi.xwpf.usermodel.XWPFDocument
+ *  org.apache.poi.xwpf.usermodel.XWPFParagraph
+ *  org.apache.poi.xwpf.usermodel.XWPFPictureData
+ *  org.apache.xmlbeans.XmlException
+ *  org.apache.xmlbeans.XmlObject
+ *  org.docx4j.Docx4J
+ *  org.docx4j.TextUtils
+ *  org.docx4j.TraversalUtil
+ *  org.docx4j.TraversalUtil$Callback
+ *  org.docx4j.XmlUtils
+ *  org.docx4j.convert.out.HTMLSettings
+ *  org.docx4j.model.listnumbering.ListNumberingDefinition
+ *  org.docx4j.openpackaging.packages.OpcPackage
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart
+ *  org.docx4j.openpackaging.parts.WordprocessingML.NumberingDefinitionsPart
+ *  org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart
+ *  org.docx4j.wml.Body
+ *  org.docx4j.wml.Document
+ *  org.docx4j.wml.Lvl$LvlText
+ *  org.docx4j.wml.P
+ *  org.jsoup.Jsoup
+ *  org.jsoup.nodes.Document
+ *  org.jsoup.nodes.Element
+ *  org.jsoup.nodes.Node
+ *  org.jsoup.nodes.TextNode
+ *  org.jsoup.select.Elements
+ *  org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath
+ *  org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara
+ *  org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.BeansException
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.context.ApplicationContext
+ *  org.springframework.context.ApplicationContextAware
+ *  org.springframework.stereotype.Component
+ *  org.springframework.util.StopWatch
+ *  org.springframework.util.StopWatch$TaskInfo
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.jby.officecore.utils;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.ArrayUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
+import com.jby.common.exceptions.BizAssert;
+import com.jby.common.exceptions.BusinessException;
+import com.jby.common.feign.FeignUtils;
+import com.jby.common.result.Result;
+import com.jby.common.util.CloseIoUtil;
+import com.jby.common.util.HttpClientUtil;
+import com.jby.common.util.SpringContextHolder;
+import com.jby.common.util.UniqueUtil;
+import com.jby.office.constant.Constants;
+import com.jby.office.domain.param.OfficeFileParseRecordParam;
+import com.jby.office.domain.vo.OfficeFileParseRecordVO;
+import com.jby.officecore.config.OfficeCoreConfig;
+import com.jby.officecore.domain.bo.ImageBO;
+import com.jby.officecore.domain.bo.ParseBO;
+import com.jby.officecore.domain.bo.TagStyleBO;
+import com.jby.officecore.domain.param.ParseParam;
+import com.jby.officecore.enums.AttrEnum;
+import com.jby.officecore.enums.TagEnum;
+import com.jby.officecore.feign.FileServiceFeign;
+import com.jby.officecore.pool.OMml2MmlTransformerPool;
+import com.jby.officecore.utils.DigestUtil;
+import com.jby.officecore.utils.LatexUtil;
+import com.jby.officecore.utils.MathTypeUtil;
+import com.jby.officecore.utils.NumPr;
+import com.jby.officecore.utils.OfficeFileUtil;
+import com.jby.officecore.utils.OssServiceUtil;
+import com.jby.officecore.utils.WordExportUtil;
+import com.jby.officecore.utils.WpsConvertUtil;
+import com.jby.officecore.utils.finder.CtObjectFinder;
+import com.jby.officecore.utils.finder.CtTextBoxFinder;
+import com.jby.officecore.utils.finder.CtoMathFinder;
+import com.jby.officecore.utils.finder.DrawingPictFinder;
+import com.jby.oss.domain.param.OssParam;
+import com.jby.system.enums.AttachmentModuleEnum;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+import javax.annotation.Nullable;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.stream.ImageInputStream;
+import javax.xml.bind.JAXBElement;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ooxml.POIXMLDocumentPart;
+import org.apache.poi.openxml4j.util.ZipSecureFile;
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.apache.poi.xwpf.usermodel.XWPFParagraph;
+import org.apache.poi.xwpf.usermodel.XWPFPictureData;
+import org.apache.xmlbeans.XmlException;
+import org.apache.xmlbeans.XmlObject;
+import org.docx4j.Docx4J;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.convert.out.HTMLSettings;
+import org.docx4j.model.listnumbering.ListNumberingDefinition;
+import org.docx4j.openpackaging.packages.OpcPackage;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
+import org.docx4j.openpackaging.parts.WordprocessingML.NumberingDefinitionsPart;
+import org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart;
+import org.docx4j.wml.Body;
+import org.docx4j.wml.Document;
+import org.docx4j.wml.Lvl;
+import org.docx4j.wml.P;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Element;
+import org.jsoup.nodes.Node;
+import org.jsoup.nodes.TextNode;
+import org.jsoup.select.Elements;
+import org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath;
+import org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StopWatch;
+import org.springframework.web.multipart.MultipartFile;
+
+@Component
+public class WordParseUtil
+implements ApplicationContextAware {
+    private static final Logger log = LoggerFactory.getLogger(WordParseUtil.class);
+    private static final String TEXT_PATTERN_STR = "^(?:\\s*[\u4e00-\u9fa2]{0,10}[\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d\u5341]+(?:\u3001|\\s+).+)|(?:(?:[\u3010\u3016\\[])[\u4e00-\u9fa2]{2,20}(?:[\u3011\u3017\\]]))$";
+    private static final Pattern TEXT_PATTERN = Pattern.compile("^(?:\\s*[\u4e00-\u9fa2]{0,10}[\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d\u5341]+(?:\u3001|\\s+).+)|(?:(?:[\u3010\u3016\\[])[\u4e00-\u9fa2]{2,20}(?:[\u3011\u3017\\]]))$");
+    private static final String MATH_PLACEHOLDER = "<w:rPr><w:rFonts w:hint=\"eastAsia\" /><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" /></w:rPr><w:t>%s</w:t>";
+    private static final String[] SYMBOL = new String[]{"\\ue0fc", "\\ue100", "\\ue101"};
+    private static OfficeCoreConfig officeCoreConfig;
+    private static FileServiceFeign fileServiceFeign;
+    private static ApplicationContext applicationContext;
+    private static volatile Executor batchDealPicExecutor;
+
+    @Autowired
+    public void setOfficeCoreConfig(OfficeCoreConfig officeCoreConfig) {
+        WordParseUtil.officeCoreConfig = officeCoreConfig;
+    }
+
+    @Autowired
+    public void setFileServiceFeign(FileServiceFeign fileServiceFeign) {
+        WordParseUtil.fileServiceFeign = fileServiceFeign;
+    }
+
+    public void setApplicationContext(@Nullable ApplicationContext ctx) throws BeansException {
+        applicationContext = ctx;
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     * Enabled force condition propagation
+     * Lifted jumps to return sites
+     */
+    private static Executor getBatchDealPicExecutor() {
+        if (!Objects.isNull(batchDealPicExecutor)) return batchDealPicExecutor;
+        Class<WordParseUtil> clazz = WordParseUtil.class;
+        synchronized (WordParseUtil.class) {
+            if (!Objects.isNull(batchDealPicExecutor)) return batchDealPicExecutor;
+            batchDealPicExecutor = (Executor)applicationContext.getBean("batchDealPicExecutor", Executor.class);
+            // ** MonitorExit[var0] (shouldn't be in output)
+            return batchDealPicExecutor;
+        }
+    }
+
+    public static String parseByUrl(ParseParam param) {
+        String fileUrl = param.getSourceUrl();
+        BizAssert.isNotBlank((String)fileUrl, (String)"\u6e90\u6587\u4ef6Url\u4e3a\u7a7a\uff01");
+        ParseBO parseBO = new ParseBO().setLatexReplaceList(param.getLatexReplaceList());
+        parseBO.setSourceFileUrl(fileUrl);
+        File sourceFile = null;
+        try {
+            WordParseUtil.createTempDir(parseBO);
+            String fileName = FileUtil.getName((String)fileUrl);
+            BizAssert.isNotBlank((String)fileName, (String)"\u6e90\u6587\u4ef6\u5730\u5740\u5f02\u5e38");
+            parseBO.setSourceFilePath(parseBO.getTempDir().resolve(fileName).toString());
+            com.jby.common.util.FileUtil.downloadNetworkFile((String)fileUrl, (String)parseBO.getSourceFilePath());
+            sourceFile = com.jby.common.util.FileUtil.getFile((String)parseBO.getSourceFilePath());
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)fileUrl, (Object)e);
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        BizAssert.isTrue((sourceFile.length() != 0L ? 1 : 0) != 0, (String)"\u6587\u6863\u5185\u5bb9\u4e3a\u7a7a\uff01");
+        try {
+            WordParseUtil.checkSuffixAndSize(sourceFile, null);
+            String e = WordParseUtil.parse(parseBO);
+            return e;
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)fileUrl, (Object)e);
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        finally {
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+        }
+    }
+
+    public static String parseByFile(ParseParam param) {
+        MultipartFile file = param.getSourceFile();
+        WordParseUtil.checkSuffixAndSize(file, null);
+        ParseBO parseBO = new ParseBO().setLatexReplaceList(param.getLatexReplaceList()).setNewParseVersion(param.getNewParseVersion()).setFileId(param.getFileId());
+        try {
+            WordParseUtil.createTempDir(parseBO);
+            String fileName = file.getOriginalFilename();
+            BizAssert.isNotBlank((String)fileName, (String)"\u6e90\u6587\u4ef6\u5730\u5740\u5f02\u5e38");
+            assert (fileName != null);
+            parseBO.setSourceFilePath(parseBO.getTempDir().resolve(fileName).toString());
+            FileUtil.writeFromStream((InputStream)file.getInputStream(), (File)com.jby.common.util.FileUtil.getFile((String)parseBO.getSourceFilePath()));
+            String string = WordParseUtil.parse(parseBO);
+            return string;
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        finally {
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+        }
+    }
+
+    public static String parse(ParseBO parseBO) {
+        String string;
+        String preHtml;
+        if (Boolean.TRUE.equals(officeCoreConfig.getNewParseVersion())) {
+            parseBO.setNewParseVersion(true);
+        }
+        String md5 = DigestUtil.getFileMd5(parseBO.getSourceFilePath());
+        BizAssert.isNotBlank((String)md5, (String)"\u8ba1\u7b97\u6e90\u6587\u4ef6md5\u5f02\u5e38\uff01");
+        parseBO.setSourceFileMd5(md5);
+        if (Boolean.TRUE.equals(officeCoreConfig.getOpenParseCache()) && StringUtils.isNotBlank((CharSequence)(preHtml = WordParseUtil.getFileParseResult(parseBO, md5)))) {
+            return preHtml;
+        }
+        if (StringUtils.isBlank((CharSequence)parseBO.getSourceFileUrl())) {
+            String sourceFileBakPath = parseBO.getSourceFilePath() + ".JBY_BAK";
+            com.jby.common.util.FileUtil.copyFile((String)parseBO.getSourceFilePath(), (String)sourceFileBakPath, (boolean)true);
+            parseBO.setSourceFileBakPath(sourceFileBakPath);
+        }
+        if (WordParseUtil.checkIsWps(parseBO)) {
+            String newSourceFilePath = WpsConvertUtil.convertFile(parseBO.getSourceFilePath(), parseBO.getTempDir().toString(), "docx", 5L);
+            if (StringUtils.isEmpty((CharSequence)newSourceFilePath)) {
+                throw new BusinessException("wps\u8f6cdocx\u5931\u8d25\uff01");
+            }
+            parseBO.setSourceFilePath(newSourceFilePath);
+        }
+        WordParseUtil.handleFormat(parseBO);
+        parseBO.setTransformer(OMml2MmlTransformerPool.INSTANCE.borrowObject());
+        FileOutputStream os = null;
+        try {
+            StopWatch sw = new StopWatch("\u89e3\u6790word");
+            ZipSecureFile.setMinInflateRatio((double)0.001);
+            sw.start("\u52a0\u8f7d\u6e90\u6587\u4ef6");
+            File sourceFile = com.jby.common.util.FileUtil.getFile((String)parseBO.getSourceFilePath());
+            WordprocessingMLPackage wordMlPackage = WordprocessingMLPackage.load((File)sourceFile);
+            sw.stop();
+            sw.start("\u81ea\u5b9a\u4e49\u89e3\u6790");
+            WordParseUtil.customParse(wordMlPackage, parseBO);
+            sw.stop();
+            sw.start("\u8f6c\u6362\u8bbe\u7f6e");
+            HTMLSettings htmlSettings = Docx4J.createHTMLSettings();
+            htmlSettings.setImageDirPath(parseBO.getImagesDir());
+            htmlSettings.setImageTargetUri("images");
+            htmlSettings.setOpcPackage((OpcPackage)wordMlPackage);
+            sw.stop();
+            sw.start("\u6267\u884c\u8f6c\u6362");
+            os = new FileOutputStream(new File(parseBO.getHtmlPath()));
+            Docx4J.toHTML((HTMLSettings)htmlSettings, (OutputStream)os, (int)1);
+            sw.stop();
+            sw.start("\u5904\u7406\u56fe\u7247\u4e0a\u4f20OSS\u53ca\u8f6csvg");
+            WordParseUtil.dealImg(parseBO);
+            sw.stop();
+            sw.start("\u5904\u7406\u6210\u5728\u7ebf\u6587\u6863\u652f\u6301\u7684html");
+            String html = new String(Files.readAllBytes(Paths.get(parseBO.getHtmlPath(), new String[0])), StandardCharsets.UTF_8);
+            html = WordParseUtil.customParseOfficeHtml(html, parseBO);
+            sw.stop();
+            WordParseUtil.saveParseResult(parseBO, html);
+            log.info(WordParseUtil.formatAsMillis(sw));
+            string = html;
+        }
+        catch (Exception e) {
+            try {
+                log.error("wordToHtml exception:{}", (Object)e.getMessage(), (Object)e);
+                throw new BusinessException("word\u89e3\u6790\u5f02\u5e38");
+            }
+            catch (Throwable throwable) {
+                CloseIoUtil.closeAll((Closeable[])new Closeable[]{os});
+                OMml2MmlTransformerPool.INSTANCE.returnObject(parseBO.getTransformer());
+                throw throwable;
+            }
+        }
+        CloseIoUtil.closeAll((Closeable[])new Closeable[]{os});
+        OMml2MmlTransformerPool.INSTANCE.returnObject(parseBO.getTransformer());
+        return string;
+    }
+
+    private static boolean checkIsWps(ParseBO parseBO) {
+        String sourceFilePath = parseBO.getSourceFilePath();
+        File file = new File(sourceFilePath);
+        String fileName = file.getName().toLowerCase();
+        String fileSuffix = com.jby.common.util.FileUtil.getFileSuffix((String)fileName);
+        return "wps".equals(fileSuffix);
+    }
+
+    private static String uploadFileToOss(File file, String module, String folderName, String fileName) {
+        return OssServiceUtil.uploadFile(new OssParam().setModule(module).setFolder(folderName).setFile(com.jby.common.util.FileUtil.getMultipartFile((String)fileName, (File)file)));
+    }
+
+    private static void customParse(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) throws Exception {
+        NumberingDefinitionsPart numberingDefinitionsPart;
+        MainDocumentPart mainDocumentPart = wordMlPackage.getMainDocumentPart();
+        StyleDefinitionsPart styleDefinitionsPart = mainDocumentPart.getStyleDefinitionsPart();
+        if (Objects.nonNull(styleDefinitionsPart)) {
+            parseBO.setStyleDefinitionsPart(styleDefinitionsPart);
+        }
+        if (Objects.nonNull(numberingDefinitionsPart = mainDocumentPart.getNumberingDefinitionsPart())) {
+            HashMap numDefines = numberingDefinitionsPart.getInstanceListDefinitions();
+            parseBO.getNumberingDefinitionsMap().putAll(numDefines.entrySet().stream().flatMap(m1 -> ((ListNumberingDefinition)m1.getValue()).getAbstractListDefinition().getAbstractNumNode().getLvl().stream().filter(f -> Objects.nonNull(f.getStart())).map(m2 -> {
+                NumPr numPr = new NumPr();
+                numPr.setStart(m2.getStart().getVal());
+                numPr.setCurrent(numPr.getStart().subtract(BigInteger.ONE));
+                numPr.setNumFmt(Optional.ofNullable(m2.getNumFmt()).map(m -> m.getVal().toString()).orElse(""));
+                numPr.setLvlText(Optional.ofNullable(m2.getLvlText()).map(Lvl.LvlText::getVal).orElse(""));
+                return new AbstractMap.SimpleEntry<String, NumPr>((String)m1.getKey() + "_" + m2.getIlvl(), numPr);
+            })).collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)));
+        }
+        Body body = ((Document)mainDocumentPart.getJaxbElement()).getBody();
+        try {
+            CtObjectFinder ctObjectFinder = new CtObjectFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctObjectFinder);
+            MathTypeUtil.mathTypeToMathMl(parseBO.getMathTypeMap());
+            if (Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+                parseBO.getMathTypeMap().values().forEach(m -> {
+                    m = m.replace("JBYSIMJBY", "~");
+                });
+                LatexUtil.ommlMathMlToLatexIgnoreNull(parseBO.getMathTypeMap(), officeCoreConfig.getCopyrightAddresses(), parseBO.getTempDir());
+            } else {
+                LatexUtil.mathMlToLatexIgnoreNull(parseBO.getMathTypeMap(), officeCoreConfig.getCopyrightAddresses(), parseBO.getTempDir());
+            }
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790MathType\u516c\u5f0f\u5f02\u5e38", (Throwable)e);
+        }
+        try {
+            DrawingPictFinder drawingPictFinder = new DrawingPictFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)drawingPictFinder);
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u56fe\u7247\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+        }
+        try {
+            CtoMathFinder ctoMathFinder = new CtoMathFinder(parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctoMathFinder);
+            if (Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+                LatexUtil.ommlAndMathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+            } else {
+                LatexUtil.mathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+            }
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u5fae\u8f6f\u6216\u57df\u516c\u5f0f\u5f02\u5e38", (Throwable)e);
+        }
+        try {
+            CtTextBoxFinder ctTextBoxFinder = new CtTextBoxFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctTextBoxFinder);
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u6587\u672c\u6846\u5f02\u5e38", (Throwable)e);
+        }
+        for (Object object : body.getContent()) {
+            List contentList;
+            P p;
+            String pText;
+            if (!(object instanceof P) || !StringUtils.isNotBlank((CharSequence)(pText = TextUtils.getText((Object)(p = (P)object)))) || !pText.contains("JBY_TEXTBOX_JBY") || !CollectionUtils.isNotEmpty((Collection)(contentList = p.getContent()))) continue;
+            ArrayList matchedItems = new ArrayList();
+            ArrayList unmatchedItems = new ArrayList();
+            for (Object obj : contentList) {
+                if (TextUtils.getText(obj).contains("JBY_TEXTBOX_JBY")) {
+                    matchedItems.add(obj);
+                    continue;
+                }
+                unmatchedItems.add(obj);
+            }
+            contentList.clear();
+            contentList.addAll(unmatchedItems);
+            contentList.addAll(matchedItems);
+        }
+    }
+
+    private static void uploadImgToOss(ParseBO parseBO) {
+        File folder = new File(parseBO.getImagesDir());
+        if (!folder.exists() || !folder.isDirectory()) {
+            log.info("\u672c\u5730\u6587\u4ef6\u5939\u4e0d\u5b58\u5728\u6216\u4e0d\u662f\u4e00\u4e2a\u6587\u4ef6\u5939:{}", (Object)parseBO.getImagesDir());
+            return;
+        }
+        Object[] files = folder.listFiles();
+        if (ArrayUtil.isEmpty((Object[])files)) {
+            return;
+        }
+        HashMap<String, String> tifFileNameMap = new HashMap<String, String>();
+        for (Object file : files) {
+            String fileName;
+            String suffix;
+            if (!((File)file).isFile() || StringUtils.isBlank((CharSequence)(suffix = FileUtil.getSuffix((String)(fileName = ((File)file).getName())))) || !"tif".equals(suffix = suffix.toLowerCase()) && !"tiff".equals(suffix)) continue;
+            WordParseUtil.tifToPng((File)file);
+            String baseName = FilenameUtils.getBaseName((String)fileName);
+            tifFileNameMap.put(baseName + ".png", fileName);
+        }
+        files = folder.listFiles();
+        assert (files != null);
+        for (Object file : files) {
+            String suffix;
+            if (!((File)file).isFile() || StringUtils.isBlank((CharSequence)(suffix = FileUtil.getSuffix((String)((File)file).getName())))) continue;
+            if ("wmf".equals(suffix = suffix.toLowerCase()) || "emf".equals(suffix)) {
+                byte[] fileData = new byte[]{};
+                try {
+                    fileData = Files.readAllBytes(((File)file).toPath());
+                }
+                catch (IOException e) {
+                    log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)((File)file).toPath(), (Object)e);
+                    throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+                }
+                String svgUrl = OfficeFileUtil.mf2svg(new ByteArrayInputStream(fileData), parseBO.getOssFolder(), ((File)file).getName());
+                String tifName = (String)tifFileNameMap.get(((File)file).getName());
+                String imgKey = "images/" + (StringUtils.isBlank((CharSequence)tifName) ? ((File)file).getName() : tifName);
+                parseBO.getImgMap().put(imgKey, svgUrl);
+                continue;
+            }
+            if ("tif".equals(suffix) || "tiff".equals(suffix)) continue;
+            String imgUrl = OssServiceUtil.uploadFile(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setFile(com.jby.common.util.FileUtil.getMultipartFile((String)((File)file).getName(), (File)file)));
+            String tifName = (String)tifFileNameMap.get(((File)file).getName());
+            String imgKey = "images/" + (StringUtils.isBlank((CharSequence)tifName) ? ((File)file).getName() : tifName);
+            parseBO.getImgMap().put(imgKey, imgUrl);
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    public static File tifToPng(File tiffFile) {
+        File file;
+        File pngFile;
+        BufferedImage image;
+        ImageInputStream imageInputStream;
+        FileInputStream is;
+        block6: {
+            is = null;
+            imageInputStream = null;
+            is = new FileInputStream(tiffFile);
+            imageInputStream = ImageIO.createImageInputStream(is);
+            Iterator<ImageReader> readers = ImageIO.getImageReaders(imageInputStream);
+            if (!readers.hasNext()) {
+                throw new BusinessException("No suitable ImageReader found for " + tiffFile.getAbsolutePath());
+            }
+            ImageReader reader = readers.next();
+            reader.setInput(imageInputStream);
+            String baseName = FilenameUtils.getBaseName((String)tiffFile.getAbsolutePath());
+            String parentFolder = tiffFile.getParentFile().getAbsolutePath();
+            image = reader.read(0);
+            pngFile = new File(parentFolder, baseName + ".png");
+            if (image.getType() != 0 && image.getType() != 0) break block6;
+            boolean hasAlpha = image.getColorModel().hasAlpha();
+            int newType = hasAlpha ? 2 : 1;
+            BufferedImage convertedImage = new BufferedImage(image.getWidth(), image.getHeight(), newType);
+            Graphics2D graphics2D = convertedImage.createGraphics();
+            graphics2D.drawImage((Image)image, 0, 0, null);
+            graphics2D.dispose();
+            ImageIO.write((RenderedImage)convertedImage, "png", pngFile);
+            File file2 = pngFile;
+            CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+            return file2;
+        }
+        try {
+            ImageIO.write((RenderedImage)image, "png", pngFile);
+            file = pngFile;
+        }
+        catch (Exception e) {
+            File file3;
+            try {
+                log.error("tifToPng error:{}", (Object)e.getMessage(), (Object)e);
+                file3 = null;
+            }
+            catch (Throwable throwable) {
+                CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+                throw throwable;
+            }
+            CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+            return file3;
+        }
+        CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+        return file;
+    }
+
+    private static void customParse(XWPFDocument document, ParseBO parseBO) {
+        if (CollectionUtils.isEmpty((Collection)document.getParagraphs())) {
+            return;
+        }
+        for (XWPFParagraph paragraph : document.getParagraphs()) {
+            org.jsoup.nodes.Document pDocument = Jsoup.parse((String)paragraph.getCTP().xmlText());
+            boolean updateXml = false;
+            if (WordParseUtil.parseOpenOfficeXml(parseBO, paragraph, pDocument)) {
+                updateXml = true;
+            }
+            if (!updateXml) continue;
+            WordParseUtil.overrideParagraph(paragraph, pDocument);
+        }
+        LatexUtil.mathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+    }
+
+    private static boolean parseOpenOfficeXml(ParseBO parseBO, XWPFParagraph paragraph, org.jsoup.nodes.Document pDocument) {
+        boolean updateXml = false;
+        ArrayList<String> placeholderList = new ArrayList<String>();
+        for (CTOMathPara ctoMathPara : paragraph.getCTP().getOMathParaList()) {
+            for (CTOMath ctoMath : ctoMathPara.getOMathList()) {
+                String placeholder = parseBO.getOpenOfficeXmlPlaceholder();
+                parseBO.getOpenOfficeXmlMap().put(placeholder, WordParseUtil.getMathMl(ctoMath, parseBO.getTransformer()));
+                placeholderList.add(placeholder);
+            }
+        }
+        for (CTOMath ctoMath : paragraph.getCTP().getOMathList()) {
+            String placeholder = parseBO.getOpenOfficeXmlPlaceholder();
+            parseBO.getOpenOfficeXmlMap().put(placeholder, WordParseUtil.getMathMl(ctoMath, parseBO.getTransformer()));
+            placeholderList.add(placeholder);
+        }
+        Elements oMathElements = pDocument.getElementsByTag("m:oMath");
+        if (oMathElements.size() == placeholderList.size()) {
+            for (int i = 0; i < oMathElements.size(); ++i) {
+                Element element = (Element)oMathElements.get(i);
+                Element wr = new Element("w:r");
+                wr.append(String.format(MATH_PLACEHOLDER, placeholderList.get(i)));
+                element.replaceWith((Node)wr);
+                updateXml = true;
+            }
+        }
+        return updateXml;
+    }
+
+    private static boolean parseMathType(ParseBO parseBO, org.jsoup.nodes.Document pDocument) {
+        boolean updateXml = false;
+        Elements imageDataElements = pDocument.getElementsByTag("v:imagedata");
+        for (Element element : imageDataElements) {
+            String svgUrl = parseBO.getImgMap().get(element.attr("r:id"));
+            List<TagStyleBO> styleList = TagEnum.getStyleList(element.parent());
+            Map<String, String> styleMap = styleList.stream().collect(Collectors.toMap(TagStyleBO::getAttr, TagStyleBO::getValue, (l, r) -> l));
+            double width = WordExportUtil.getPtValue(styleMap.get(AttrEnum.WIDTH.getAttr()));
+            double height = WordExportUtil.getPtValue(styleMap.get(AttrEnum.HEIGHT.getAttr()));
+            if (!StringUtils.isNotBlank((CharSequence)svgUrl)) continue;
+            Element imgElement = new Element(TagEnum.IMG.getName());
+            imgElement.attr(AttrEnum.SRC.getAttr(), svgUrl);
+            imgElement.attr(AttrEnum.WIDTH.getAttr(), width + "pt");
+            imgElement.attr(AttrEnum.HEIGHT.getAttr(), height + "pt");
+            WordParseUtil.addImgAttr(imgElement);
+            String placeholder = parseBO.getMathTypePlaceholder();
+            parseBO.getMathTypeMap().put(placeholder, imgElement.outerHtml());
+            Element parent = element.parent().parent().parent();
+            Element wr = new Element("w:r");
+            wr.append(String.format(MATH_PLACEHOLDER, placeholder));
+            parent.replaceWith((Node)wr);
+            updateXml = true;
+        }
+        return updateXml;
+    }
+
+    private static void overrideParagraph(XWPFParagraph paragraph, org.jsoup.nodes.Document pDocument) {
+        String xml = pDocument.body().html();
+        try {
+            xml = xml.replace("&nbsp;", " ");
+            CTP ctp = (CTP)CTP.Factory.parse(xml);
+            paragraph.getCTP().set((XmlObject)ctp);
+        }
+        catch (XmlException e) {
+            log.error("\u91cd\u5199\u6bb5\u843d\u5f02\u5e38, xml:{}", (Object)xml, (Object)e);
+        }
+    }
+
+    public static String getMathMl(JAXBElement<?> ctoMathEle, Transformer transformer) {
+        String oml = XmlUtils.marshaltoString(ctoMathEle, (boolean)true, (boolean)false);
+        StringReader reader = new StringReader(oml);
+        StreamSource source = new StreamSource(reader);
+        return WordParseUtil.sourceToMathMl(source, transformer);
+    }
+
+    private static String getMathMl(CTOMath ctoMath, Transformer transformer) {
+        org.w3c.dom.Node node = ctoMath.getDomNode();
+        DOMSource source = new DOMSource(node);
+        return WordParseUtil.sourceToMathMl(source, transformer);
+    }
+
+    private static String sourceToMathMl(Source source, Transformer transformer) {
+        String mathMl;
+        StringWriter stringwriter = new StringWriter();
+        StreamResult result = new StreamResult(stringwriter);
+        try {
+            transformer.transform(source, result);
+            mathMl = stringwriter.toString();
+            stringwriter.close();
+        }
+        catch (Exception e) {
+            log.error("word\u5185\u516c\u5f0f\u89e3\u6790\u5f02\u5e38\uff1a" + e.getMessage(), (Throwable)e);
+            throw new BusinessException("\u516c\u5f0f\u89e3\u6790\u5f02\u5e38\uff01");
+        }
+        mathMl = mathMl.substring(mathMl.indexOf("=\"http://www.w3.org/1998/Math/MathML\""));
+        mathMl = "<math display=\"inline\" xmlns" + mathMl;
+        mathMl = mathMl.replaceAll("mml:", "");
+        mathMl = mathMl.replaceAll("\u00a0", "~");
+        return mathMl;
+    }
+
+    private static void parsePictures(List<XWPFPictureData> pictureList, ParseBO parseBO) {
+        if (CollectionUtils.isEmpty(pictureList)) {
+            return;
+        }
+        String folderName = parseBO.getOssFolder();
+        String uniquePath = officeCoreConfig.getTmpPath() + File.separator + folderName;
+        for (XWPFPictureData picture : pictureList) {
+            String suffix;
+            if (ArrayUtil.isEmpty((byte[])picture.getData()) || StringUtils.isBlank((CharSequence)picture.getFileName()) || !Constants.IMG_SET.contains(suffix = StringUtils.isBlank((CharSequence)(suffix = com.jby.common.util.FileUtil.getFileSuffix((String)picture.getFileName()))) ? "" : suffix.toLowerCase())) continue;
+            if ("wmf".equals(suffix) || "emf".equals(suffix)) {
+                String localFilePath = uniquePath + File.separator + picture.getFileName();
+                String svgUrl = OfficeFileUtil.mf2svg(new ByteArrayInputStream(picture.getData()), parseBO.getOssFolder(), picture.getFileName());
+                parseBO.getImgMap().put(picture.getParent().getRelationId((POIXMLDocumentPart)picture), svgUrl);
+                parseBO.getImgMap().put(picture.getFileName(), svgUrl);
+                continue;
+            }
+            if ("tif".equals(suffix) || "tiff".equals(suffix)) {
+                String fileName = picture.getFileName().substring(0, picture.getFileName().lastIndexOf(".") + 1) + "png";
+                String imgUrl = WordParseUtil.tif2Png(new ByteArrayInputStream(picture.getData()), folderName, fileName);
+                parseBO.getImgMap().put(picture.getFileName(), imgUrl);
+                continue;
+            }
+            String imgUrl = WordParseUtil.uploadImg(new ByteArrayInputStream(picture.getData()), folderName, picture.getFileName());
+            parseBO.getImgMap().put(picture.getFileName(), imgUrl);
+        }
+    }
+
+    private static String uploadImg(InputStream is, String folderName, String fileName) {
+        return OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(folderName).setFileName(fileName).setInputStream(is));
+    }
+
+    private static String tif2Png(InputStream is, String folderName, String fileName) {
+        String uniquePath = officeCoreConfig.getTmpPath() + File.separator + folderName;
+        String localFilePath = uniquePath + File.separator + fileName;
+        File file = OfficeFileUtil.writeFile(is, localFilePath);
+        String imgUrl = null;
+        if (Objects.nonNull(file)) {
+            imgUrl = OssServiceUtil.uploadFile(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(folderName).setFile(com.jby.common.util.FileUtil.getMultipartFile((String)fileName, (File)file)));
+        }
+        return imgUrl;
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    private static File tif2Png(InputStream is, String imgPath) {
+        try {
+            BufferedImage image = ImageIO.read(is);
+            if (image == null) {
+                File file = null;
+                return file;
+            }
+            File file = com.jby.common.util.FileUtil.getFile((String)imgPath);
+            ImageIO.write((RenderedImage)image, "png", file);
+            image.flush();
+            File e = file;
+            return e;
+        }
+        catch (Exception e) {
+            log.error("tif2Png exception, imgPath:{}", (Object)imgPath, (Object)e);
+            File file = null;
+            return file;
+        }
+        finally {
+            if (is != null) {
+                try {
+                    is.close();
+                }
+                catch (IOException e) {
+                    log.error("close error");
+                }
+            }
+        }
+    }
+
+    private static String customParseOfficeHtml(String html, ParseBO parseBO) {
+        html = html.replaceAll("text-decoration: underline;", "");
+        html = html.replaceAll("text-decoration: jby-underline;", "text-decoration: underline;");
+        org.jsoup.nodes.Document doc = Jsoup.parse((String)html);
+        doc.outputSettings().prettyPrint(false);
+        WordParseUtil.dealUderlineSubSup(doc);
+        WordParseUtil.dealTitle(doc);
+        WordParseUtil.dealUnderlineAndLineThrough(doc);
+        WordParseUtil.dealUnderline(doc);
+        WordParseUtil.dealCustomTextDecoration(doc);
+        WordParseUtil.dealLi(doc);
+        WordParseUtil.dealSubSup(doc);
+        WordParseUtil.cleanDocument(doc);
+        WordParseUtil.dealNoSPanWhiteSpace((Element)doc);
+        WordParseUtil.dealLineHeight((Element)doc);
+        return WordParseUtil.dealPlaceholder(parseBO, doc);
+    }
+
+    private static void dealUderlineSubSup(org.jsoup.nodes.Document doc) {
+        try {
+            Elements spansWithSupSub = doc.select("span:has(sup), span:has(sub)");
+            for (Element span : spansWithSupSub) {
+                String style = span.attr("style");
+                if (style == null || !style.contains("text-decoration: underline;")) continue;
+                Elements supSubElements = span.select("sup, sub");
+                Element previousSpan = span.previousElementSibling();
+                if (previousSpan == null || !"span".equals(previousSpan.tagName())) continue;
+                for (Element supSub : supSubElements) {
+                    previousSpan.appendChild((Node)supSub);
+                }
+                span.remove();
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u5e26\u4e0b\u5212\u7ebf\u7684\u4e0a\u6807\u4e0b\u6807\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealLineHeight(Element doc) {
+        String[] patterns = new String[]{"line-height:\\s*([0-9]*\\.?[0-9]+)%", "line-height:\\s*([0-9]*\\.?[0-9]+)", "line-height:\\s*([0-9]+(?:\\.[0-9]+)?em)"};
+        Elements elements = doc.select("[style*=\"line-height\"]");
+        for (Element element : elements) {
+            String style;
+            String newStyle = style = element.attr("style");
+            for (String pStr : patterns) {
+                Pattern pattern = Pattern.compile(pStr);
+                Matcher matcher = pattern.matcher(newStyle);
+                StringBuffer sb = new StringBuffer();
+                while (matcher.find()) {
+                    double lineHeightValue;
+                    String originalValue = matcher.group(1);
+                    try {
+                        String numericValue = originalValue.replaceAll("[^0-9.]", "");
+                        lineHeightValue = Double.parseDouble(numericValue);
+                        if (pStr.contains("%")) {
+                            lineHeightValue /= 100.0;
+                        }
+                    }
+                    catch (NumberFormatException e) {
+                        lineHeightValue = 0.0;
+                    }
+                    if (lineHeightValue < 2.0) {
+                        String replacement = pStr.contains("%") ? "line-height: 200%" : (pStr.contains("em") ? "line-height: 2.0em" : "line-height: 2.0");
+                        matcher.appendReplacement(sb, replacement);
+                        continue;
+                    }
+                    matcher.appendReplacement(sb, matcher.group(0));
+                }
+                matcher.appendTail(sb);
+                newStyle = sb.toString();
+            }
+            if (newStyle.equals(style)) continue;
+            element.attr("style", newStyle);
+        }
+    }
+
+    private static void dealNoSPanWhiteSpace(Element doc) {
+        for (Node node : doc.childNodes()) {
+            if (node instanceof TextNode) {
+                TextNode textNode = (TextNode)node;
+                String text = textNode.getWholeText();
+                if (!text.contains("\u00a0")) continue;
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < text.length(); ++i) {
+                    char c = text.charAt(i);
+                    sb.append(c);
+                    if (c != '\u00a0' || i == text.length() - 1 || text.charAt(i + 1) != '\u00a0') continue;
+                    sb.append(" ");
+                }
+                text = sb.toString();
+                if (!textNode.parent().nodeName().equals("span")) {
+                    Element span = new Element("span");
+                    span.text(text);
+                    textNode.replaceWith((Node)span);
+                    continue;
+                }
+                textNode.text(text);
+                continue;
+            }
+            if (!(node instanceof Element)) continue;
+            WordParseUtil.dealNoSPanWhiteSpace((Element)node);
+        }
+    }
+
+    private static void dealWhiteSpace(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span");
+            for (Element span : elements) {
+                WordParseUtil.processSpanContent((Node)span);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u7a7a\u683c\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void processSpanContent(Node node) {
+        if (node.childNodeSize() > 0) {
+            for (Node childNode : node.childNodes()) {
+                WordParseUtil.processSpanContent(childNode);
+            }
+        } else if (node instanceof TextNode) {
+            TextNode textNode = (TextNode)node;
+            textNode.text(textNode.getWholeText().replaceAll(" ", "JBY_nbsp;"));
+        }
+    }
+
+    private static void dealTitle(org.jsoup.nodes.Document doc) {
+        try {
+            Map<String, List<Map<String, String>>> pStyleMap = WordParseUtil.parseCssRulesToMap(doc);
+            Elements elements = doc.select("p, li");
+            for (Element p : elements) {
+                String classAttr = p.attr("class");
+                if (!StringUtils.isNotBlank((CharSequence)classAttr)) continue;
+                HashMap<String, String> finalStyles = new HashMap<String, String>();
+                String existingStyle = p.attr("style");
+                HashSet<String> existingStyleKeys = new HashSet<String>();
+                if (StringUtils.isNotBlank((CharSequence)existingStyle)) {
+                    String[] stylePairs;
+                    for (String pair : stylePairs = existingStyle.split(";")) {
+                        String[] parts = pair.split(":", 2);
+                        if (parts.length != 2) continue;
+                        String string = parts[0].trim();
+                        String value = parts[1].trim();
+                        finalStyles.put(string, value);
+                        existingStyleKeys.add(string);
+                    }
+                }
+                String[] classNames = classAttr.split("\\s+");
+                ArrayList<String> orderedClassNames = new ArrayList<String>();
+                block4: for (String selector : pStyleMap.keySet()) {
+                    String className = selector.substring(1);
+                    for (String currentClass : classNames) {
+                        if (!className.equals(currentClass)) continue;
+                        orderedClassNames.add(currentClass);
+                        continue block4;
+                    }
+                }
+                for (String className : orderedClassNames) {
+                    if (!pStyleMap.containsKey("." + className)) continue;
+                    List<Map<String, String>> classStyles = pStyleMap.get("." + className);
+                    for (Map map : classStyles) {
+                        for (Map.Entry entry : map.entrySet()) {
+                            if (existingStyleKeys.contains(entry.getKey())) continue;
+                            finalStyles.put((String)entry.getKey(), (String)entry.getValue());
+                        }
+                    }
+                }
+                if (finalStyles.isEmpty()) continue;
+                StringBuilder styleBuilder = new StringBuilder();
+                for (Map.Entry entry : finalStyles.entrySet()) {
+                    styleBuilder.append((String)entry.getKey()).append(": ").append((String)entry.getValue()).append("; ");
+                }
+                p.attr("style", styleBuilder.toString().trim());
+            }
+        }
+        catch (NumberFormatException e) {
+            log.error("\u5904\u7406\u6807\u9898\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static Map<String, List<Map<String, String>>> parseCssRulesToMap(org.jsoup.nodes.Document doc) {
+        Element styleElement = doc.selectFirst("style");
+        String cssContent = styleElement.html();
+        LinkedHashMap<String, List<Map<String, String>>> cssMap = new LinkedHashMap<String, List<Map<String, String>>>();
+        if (StringUtils.isBlank((CharSequence)cssContent)) {
+            return cssMap;
+        }
+        Pattern sectionPattern = Pattern.compile("/\\* PARAGRAPH STYLES \\*/(.*?)/\\* CHARACTER STYLES \\*/", 32);
+        Matcher sectionMatcher = sectionPattern.matcher(cssContent);
+        String targetContent = "";
+        targetContent = sectionMatcher.find() ? sectionMatcher.group(1) : cssContent;
+        Pattern cssRulePattern = Pattern.compile("([^\\{]+)\\{([^\\}]+)\\}");
+        Matcher matcher = cssRulePattern.matcher(targetContent);
+        ArrayList<String> selectorOrder = new ArrayList<String>();
+        while (matcher.find()) {
+            String[] propertyPairs;
+            String selector2 = matcher.group(1).trim();
+            String properties = matcher.group(2).trim();
+            ArrayList propertyList = new ArrayList();
+            for (String propertyPair : propertyPairs = properties.split(";")) {
+                String[] parts;
+                if (!StringUtils.isNotBlank((CharSequence)propertyPair) || (parts = propertyPair.split(":", 2)).length != 2) continue;
+                HashMap<String, String> propertyMap = new HashMap<String, String>();
+                String key = parts[0].trim();
+                String value = parts[1].trim();
+                propertyMap.put(key, value);
+                propertyList.add(propertyMap);
+            }
+            cssMap.put(selector2, propertyList);
+            selectorOrder.add(selector2);
+        }
+        return selectorOrder.stream().filter(selector -> selector.startsWith(".") && cssMap.containsKey(selector)).collect(Collectors.toMap(Function.identity(), cssMap::get, (existing, replacement) -> existing, LinkedHashMap::new));
+    }
+
+    private static void cleanDocument(org.jsoup.nodes.Document doc) {
+        try {
+            Element docElement = doc.selectFirst(".document");
+            if (Objects.isNull(docElement)) {
+                return;
+            }
+            log.info("\u53bb\u9664\u975e\u5fc5\u8981\u6837\u5f0f\u914d\u7f6e\u4fe1\u606f:{}", (Object)JSON.toJSONString(officeCoreConfig.getCleanStyleMap()));
+            Elements allElements = docElement.select("*");
+            for (Element el : allElements) {
+                WordParseUtil.cleanClass(el, docElement);
+                WordParseUtil.cleanStyle(el);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u6e05\u6d01\u6587\u6863\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void cleanClass(Element el, Element docElement) {
+        if (el == docElement) {
+            return;
+        }
+        String className = Optional.ofNullable(el.className()).orElse("");
+        for (String retainClass : Constants.RETAIN_CLASS_VALUE_SET) {
+            if (!className.contains(retainClass)) continue;
+            return;
+        }
+        el.attributes().remove(AttrEnum.CLASS.getAttr());
+    }
+
+    private static void cleanStyle(Element el) {
+        if (MapUtils.isEmpty(officeCoreConfig.getCleanStyleMap())) {
+            return;
+        }
+        String oldStyle = el.attr(AttrEnum.STYLE.getAttr());
+        if (StringUtils.isBlank((CharSequence)oldStyle)) {
+            return;
+        }
+        String[] originalStyle = new String[]{oldStyle};
+        officeCoreConfig.getCleanStyleMap().forEach((tagName, styles) -> {
+            if (StringUtils.isBlank((CharSequence)tagName) || CollectionUtils.isEmpty((Collection)styles)) {
+                return;
+            }
+            styles.forEach(style -> {
+                if (StringUtils.isBlank((CharSequence)style)) {
+                    return;
+                }
+                if (tagName.equals(el.tagName())) {
+                    originalStyle[0] = originalStyle[0].replaceAll((String)style, "");
+                }
+            });
+            if (StringUtils.isBlank((CharSequence)originalStyle[0])) {
+                el.removeAttr(AttrEnum.STYLE.getAttr());
+                return;
+            }
+            String newStyle = Arrays.stream(originalStyle[0].split(";")).filter(StringUtils::isNotBlank).map(e -> e.trim() + "; ").collect(Collectors.joining()).trim();
+            el.attr(AttrEnum.STYLE.getAttr(), newStyle);
+        });
+    }
+
+    private static void dealSubSup(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style~=(?:vertical-align: (sub|super);font-size: smaller;)]");
+            for (Element span : elements) {
+                List<TagStyleBO> styles = TagEnum.getStyleList(span);
+                boolean isSub = styles.stream().anyMatch(e -> AttrEnum.VERTICAL_ALIGN.getAttr().equals(e.getAttr()) && TagEnum.SUB.getName().equals(e.getValue()));
+                Element suElement = new Element(isSub ? TagEnum.SUB.getName() : TagEnum.SUP.getName()).html(span.html());
+                if (suElement.childNodeSize() == 0) {
+                    span.remove();
+                    continue;
+                }
+                span.html(suElement.outerHtml());
+                String styleValue = styles.stream().filter(e -> !AttrEnum.VERTICAL_ALIGN.getAttr().equals(e.getAttr()) && !AttrEnum.FONT_SIZE.getAttr().equals(e.getAttr())).map(e -> e.getAttr() + ": " + e.getValue()).collect(Collectors.joining(";"));
+                if (StringUtils.isBlank((CharSequence)styleValue)) {
+                    span.removeAttr(AttrEnum.STYLE.getAttr());
+                    continue;
+                }
+                span.attr(AttrEnum.STYLE.getAttr(), styleValue);
+            }
+        }
+        catch (Exception e2) {
+            log.error("\u5904\u7406\u4e0a\u6807\u3001\u4e0b\u6807\u5f02\u5e38", (Throwable)e2);
+        }
+    }
+
+    private static void dealImg(ParseBO parseBO, org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("img[src]");
+            if (MapUtils.isNotEmpty(parseBO.getImgMap())) {
+                for (Element img : elements) {
+                    String src = img.attr(AttrEnum.SRC.getAttr());
+                    String srcUrl = parseBO.getImgMap().get(src);
+                    if (StringUtils.isNotBlank((CharSequence)srcUrl)) {
+                        img.attr(AttrEnum.SRC.getAttr(), srcUrl);
+                    }
+                    WordParseUtil.adjustWidthHeight(img);
+                    WordParseUtil.addImgAttr(img);
+                }
+            }
+            Elements elementImgNot = doc.select("img:not([src])");
+            elementImgNot.remove();
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u56fe\u7247\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void adjustWidthHeight(Element img) {
+        try {
+            String heightStr;
+            String widthStr;
+            String style = img.attr("style");
+            if (style != null && !style.isEmpty()) {
+                String widthValue = WordParseUtil.extractDimensionFromStyle(style, "width");
+                String heightValue = WordParseUtil.extractDimensionFromStyle(style, "height");
+                String newStyle = "";
+                if (widthValue != null) {
+                    String widthPx = WordParseUtil.convertToPx(widthValue);
+                    if (widthPx != null) {
+                        img.attr("width", widthPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = WordParseUtil.removeDimensionFromStyle(style, "width");
+                }
+                if (heightValue != null) {
+                    String heightPx = WordParseUtil.convertToPx(heightValue);
+                    if (heightPx != null) {
+                        img.attr("height", heightPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = WordParseUtil.removeDimensionFromStyle(newStyle, "height");
+                }
+                if (StringUtils.isBlank((CharSequence)newStyle)) {
+                    img.removeAttr("style");
+                } else {
+                    img.attr("style", newStyle);
+                }
+            }
+            if (StringUtils.isNotBlank((CharSequence)(widthStr = img.attr(AttrEnum.WIDTH.getAttr())))) {
+                double width = Double.parseDouble(Objects.requireNonNull(WordParseUtil.convertToPx(widthStr)));
+                img.attr(AttrEnum.WIDTH.getAttr(), Double.toString((double)Math.round((width /= officeCoreConfig.getImageScalingFactor().doubleValue()) * 100.0) / 100.0));
+            }
+            if (StringUtils.isNotBlank((CharSequence)(heightStr = img.attr(AttrEnum.HEIGHT.getAttr())))) {
+                double height = Double.parseDouble(Objects.requireNonNull(WordParseUtil.convertToPx(heightStr)));
+                img.attr(AttrEnum.HEIGHT.getAttr(), Double.toString((double)Math.round((height /= officeCoreConfig.getImageScalingFactor().doubleValue()) * 100.0) / 100.0));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u8c03\u6574\u5bbd\u9ad8\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static String convertToPx(String value) {
+        if (StringUtils.isBlank((CharSequence)value)) {
+            return null;
+        }
+        value = value.trim().toLowerCase();
+        Pattern pattern = Pattern.compile("([0-9.]+)\\s*([a-z%]*)");
+        Matcher matcher = pattern.matcher(value);
+        if (matcher.matches()) {
+            String unit;
+            double numericValue = Double.parseDouble(matcher.group(1));
+            switch (unit = matcher.group(2)) {
+                case "pt": {
+                    return String.valueOf(Math.round(numericValue * 4.0 / 3.0));
+                }
+                case "in": {
+                    return String.valueOf(Math.round(numericValue * 96.0));
+                }
+                case "cm": {
+                    return String.valueOf(Math.round(numericValue * 96.0 / 2.54));
+                }
+                case "mm": {
+                    return String.valueOf(Math.round(numericValue * 96.0 / 25.4));
+                }
+                case "": {
+                    return String.valueOf(Math.round(numericValue));
+                }
+            }
+            return String.valueOf(Math.round(numericValue));
+        }
+        return null;
+    }
+
+    private static String extractDimensionFromStyle(String style, String dimension) {
+        String value;
+        if (StringUtils.isBlank((CharSequence)style) || StringUtils.isBlank((CharSequence)dimension)) {
+            return null;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*([^;]+)(?:;|$)");
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find() && WordParseUtil.isValidDimensionValue(value = matcher.group(1).trim())) {
+            return value;
+        }
+        return null;
+    }
+
+    private static boolean isValidDimensionValue(String value) {
+        if (StringUtils.isBlank((CharSequence)value)) {
+            return false;
+        }
+        Pattern pattern = Pattern.compile("^[0-9]+(\\.[0-9]+)?\\s*(px|pt|in|cm|mm|%|em|rem|ex|ch|vw|vh|vmin|vmax)?$");
+        return pattern.matcher(value).matches();
+    }
+
+    private static String removeDimensionFromStyle(String style, String dimension) {
+        if (StringUtils.isBlank((CharSequence)style) || StringUtils.isBlank((CharSequence)dimension)) {
+            return style;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*[^;]+;?");
+        Matcher matcher = pattern.matcher(style);
+        String result = matcher.replaceAll("");
+        result = result.replaceAll(";;", ";").replaceAll("^;|;$", "");
+        return result;
+    }
+
+    private static void dealLi(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.getElementsByTag(TagEnum.LI.getName());
+            for (Element li : elements) {
+                String style = li.attr(AttrEnum.STYLE.getAttr()) + "line-height: 2;";
+                li.tagName(TagEnum.P.getName()).attr(AttrEnum.STYLE.getAttr(), style);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u5217\u8868\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealBookTitle(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select(":matchesOwn(\u300a|\u300b)");
+            for (int i = 0; i < elements.size(); ++i) {
+                Node node;
+                int j;
+                Element end;
+                Element start = (Element)elements.get(i);
+                if (!start.text().contains("\u300a") || i + 1 >= elements.size() || !(end = (Element)elements.get(i + 1)).text().contains("\u300b")) continue;
+                if (Objects.nonNull(start.parent()) && start.parent().equals((Object)end.parent())) {
+                    List siblings = start.parent().childNodes();
+                    int startIndex = siblings.indexOf(start);
+                    int endIndex = siblings.indexOf(end);
+                    if (startIndex == -1 || endIndex == -1 || startIndex > endIndex) continue;
+                    StringBuilder content = new StringBuilder();
+                    ArrayList<Node> deleteList = new ArrayList<Node>();
+                    for (j = startIndex; j <= endIndex; ++j) {
+                        node = (Node)siblings.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode)node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element)node).text());
+                        }
+                        if (j <= startIndex) continue;
+                        deleteList.add(node);
+                    }
+                    start.text(content.toString());
+                    deleteList.forEach(Node::remove);
+                    continue;
+                }
+                if (!Objects.nonNull(start.parent()) || !Objects.nonNull(start.parent().parent()) || !start.parent().parent().equals((Object)end.parent()) || start.parent().siblingIndex() >= end.siblingIndex()) continue;
+                StringBuilder content = new StringBuilder();
+                ArrayList<Node> deleteList = new ArrayList<Node>();
+                Element startParent = start.parent();
+                List parentChild = startParent.childNodes();
+                int startIndex = parentChild.indexOf(start);
+                if (startIndex != -1) {
+                    for (j = startIndex + 1; j < parentChild.size(); ++j) {
+                        node = (Node)parentChild.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode)node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element)node).text());
+                        }
+                        deleteList.add(node);
+                    }
+                }
+                Element grandParent = start.parent().parent();
+                List grandSiblings = grandParent.childNodes();
+                int parentIdx = grandSiblings.indexOf(startParent);
+                int endIdx = grandSiblings.indexOf(end);
+                if (parentIdx != -1 && endIdx != -1 && parentIdx < endIdx) {
+                    for (int j2 = parentIdx + 1; j2 <= endIdx; ++j2) {
+                        Node node2 = (Node)grandSiblings.get(j2);
+                        if (node2 instanceof TextNode) {
+                            content.append(((TextNode)node2).getWholeText());
+                        } else if (node2 instanceof Element) {
+                            content.append(((Element)node2).text());
+                        }
+                        deleteList.add(node2);
+                    }
+                }
+                start.text(content.toString());
+                deleteList.forEach(Node::remove);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e66\u540d\u53f7\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealUnderline(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='text-decoration: underline']");
+            for (Element u : elements) {
+                String style = u.attr("style");
+                if (!style.matches(".*text-decoration:\\s*underline\\s*(;|$).*")) continue;
+                u.tagName(TagEnum.U.getName());
+                WordParseUtil.processSpanContent((Node)u);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e0b\u5212\u7ebf\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealCustomTextDecoration(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='background-image: repeating-linear-gradient']");
+            for (Element span : elements) {
+                LinkedHashMap<String, TagStyleBO> styleMap = new LinkedHashMap<String, TagStyleBO>();
+                List<String> styles = Arrays.asList(span.attr("style").split(";"));
+                styles.forEach(style -> {
+                    if (StringUtils.isBlank((CharSequence)style)) {
+                        return;
+                    }
+                    String[] split = style.split(":");
+                    if (split.length < 2) {
+                        return;
+                    }
+                    TagStyleBO tagStyleBO = new TagStyleBO().setTagName(span.tagName()).setAttr(split[0].trim()).setValue(split[1].trim());
+                    styleMap.put(tagStyleBO.getAttr(), tagStyleBO);
+                });
+                if (!styleMap.containsKey("background-size")) {
+                    return;
+                }
+                span.addClass(((TagStyleBO)styleMap.get("background-size")).getValue().contains("11px") ? "custom-text-decoration-double-dot-dashed" : "custom-text-decoration-dot-dashed");
+                ArrayList newStyleList = new ArrayList();
+                styleMap.forEach((key, value) -> {
+                    if (!Constants.DOT_DASHED_STYLE_SET.contains(key)) {
+                        newStyleList.add(value.getAttr() + ": " + value.getValue() + ";");
+                    }
+                });
+                if (CollectionUtils.isEmpty(newStyleList)) {
+                    span.removeAttr(AttrEnum.STYLE.getAttr());
+                    continue;
+                }
+                span.attr(AttrEnum.STYLE.getAttr(), String.join((CharSequence)" ", newStyleList));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u81ea\u5b9a\u4e49\u6587\u672c\u88c5\u9970\uff08\u70b9\u5212\u7ebf\uff09\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealUnderlineAndLineThrough(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='jby-line-through: true']");
+            for (int i = elements.size() - 1; i >= 0; --i) {
+                Element span = (Element)elements.get(i);
+                Element wrapper = new Element("span");
+                wrapper.attr("style", "text-decoration: line-through");
+                span.replaceWith((Node)wrapper);
+                wrapper.appendChild((Node)span);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e0b\u5212\u7ebf\u548c\u5220\u9664\u5e76\u5b58\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static String dealPlaceholder(ParseBO parseBO, org.jsoup.nodes.Document doc) {
+        String result = doc.html();
+        if (MapUtils.isNotEmpty(parseBO.getImageMap())) {
+            for (Map.Entry<String, ImageBO> entry : parseBO.getImageMap().entrySet()) {
+                String imgUrl = entry.getValue().getPictureUrl();
+                Element element = new Element(TagEnum.IMG.getName());
+                element.attr(AttrEnum.SRC.getAttr(), imgUrl);
+                element.attr(AttrEnum.WIDTH.getAttr(), String.valueOf(entry.getValue().getWidth().intValue()));
+                element.attr(AttrEnum.HEIGHT.getAttr(), String.valueOf(entry.getValue().getHeight().intValue()));
+                WordParseUtil.addImgAttr(element);
+                result = result.replace(entry.getKey(), element.outerHtml());
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getOpenOfficeXmlMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getOpenOfficeXmlMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getMathTypeMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getMathTypeMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getEqLatexMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getEqLatexMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, true);
+            }
+        }
+        result = result.replaceAll("JBY_nbsp;", "&nbsp;");
+        result = result.replaceAll("font-style: italic;", "font-style: italic; z-index: 1;");
+        result = result.replaceAll("border-color: #auto;", "border-color: transparent;");
+        result = result.replaceAll("JBY_TEXTBOX_JBYBR", "<br/>");
+        result = result.replaceAll("JBY_TEXTBOX_JBY", "");
+        result = result.replaceAll(">\\s+(?=<(?!/span))", ">");
+        result = result.replaceAll("(background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;)\\s*background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;", "$1");
+        for (Iterator<Map.Entry<String, Object>> iterator : SYMBOL) {
+            Element imgElement = new Element(TagEnum.IMG.getName());
+            imgElement.attr(AttrEnum.SRC.getAttr(), "https://resource.xinjiaoyu.com/prod/office/unicode-symbol/" + ((String)((Object)iterator)).substring(2).toUpperCase() + ".svg");
+            imgElement.attr(AttrEnum.WIDTH.getAttr(), "14");
+            imgElement.attr(AttrEnum.HEIGHT.getAttr(), "14");
+            result = result.replace("@@@" + ((String)((Object)iterator)).substring(2).toUpperCase() + "@@@", imgElement.outerHtml());
+            result = result.replace("\ue225\ue226", "\\(\\rightleftharpoons\\)");
+        }
+        WordParseUtil.writeHtml(result);
+        return result;
+    }
+
+    private static String dealPlaceholder(ParseBO parseBO, Map.Entry<String, String> entry, String html, Boolean isEq) {
+        String value = entry.getValue();
+        if (isEq.booleanValue() || !Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+            value = WordParseUtil.latexReplace(parseBO.getLatexReplaceList(), value);
+        }
+        if (!value.startsWith("<img") && !entry.getKey().endsWith("JBYEQNUM")) {
+            value = "\\(" + value + "\\)";
+        }
+        html = html.replace(entry.getKey(), value);
+        log.info("latexReplace,\u66ff\u6362\u524d{},\u66ff\u6362\u540e{}", (Object)entry.getValue(), (Object)value);
+        return html;
+    }
+
+    private static String latexReplace(List<JSONObject> latexReplaceList, String latex) {
+        try {
+            if (StringUtils.isBlank((CharSequence)latex)) {
+                return latex;
+            }
+            if (CollectionUtils.isEmpty(latexReplaceList)) {
+                return latex;
+            }
+            if (latex.startsWith("<img")) {
+                return latex;
+            }
+            for (JSONObject latexReplace : latexReplaceList) {
+                String key = latexReplace.getString("key");
+                String value = latexReplace.getString("value");
+                if (StringUtils.isBlank((CharSequence)key) || StringUtils.isBlank((CharSequence)value)) continue;
+                latex = latex.replaceAll(key, value);
+            }
+            return WordParseUtil.wrapTextColorWithBraces(latex);
+        }
+        catch (Exception e) {
+            log.error("latex\u516c\u5f0f\u89c4\u8303\u6b63\u5219\u66ff\u6362\u5904\u7406\u5f02\u5e38:{}", (Object)latex, (Object)e);
+            return latex;
+        }
+    }
+
+    public static String wrapTextColorWithBraces(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        Pattern pattern = Pattern.compile("\\\\textcolor\\[rgb\\]\\{[^}]*\\}\\{");
+        ArrayList<int[]> matches = new ArrayList<int[]>();
+        Matcher matcher = pattern.matcher(input);
+        int start = 0;
+        while (matcher.find(start)) {
+            int contentStart = matcher.end() - 1;
+            int depth = 0;
+            for (int pos = contentStart; pos < input.length(); ++pos) {
+                char c = input.charAt(pos);
+                if (c == '{') {
+                    ++depth;
+                    continue;
+                }
+                if (c != '}' || --depth != 0) continue;
+                matches.add(new int[]{matcher.start(), pos});
+                break;
+            }
+            start = matcher.start() + 1;
+        }
+        matches.sort(Comparator.comparingInt(a -> -a[0]));
+        StringBuilder sb = new StringBuilder(input);
+        for (int[] match : matches) {
+            int s = match[0];
+            int e = match[1];
+            sb.insert(e + 1, '}');
+            sb.insert(s, '{');
+        }
+        return sb.toString();
+    }
+
+    public static Element getMatchParent(Element element, String cssQuery) {
+        if (element == null) {
+            return null;
+        }
+        if (element.is(cssQuery)) {
+            return element;
+        }
+        return WordParseUtil.getMatchParent(element.parent(), cssQuery);
+    }
+
+    public static void addImgAttr(Element img) {
+        img.attr("data-default-src", img.attr(AttrEnum.SRC.getAttr()));
+        img.attr(AttrEnum.CLASS.getAttr(), "img-t");
+        img.attr("data-mce-resize", "false");
+    }
+
+    public static void checkSuffixAndSize(File file, Integer checkSize) {
+        WordParseUtil.validSuffix(file.getName());
+        WordParseUtil.validSize(file.length(), checkSize);
+    }
+
+    public static void checkSuffixAndSize(MultipartFile file, Integer checkSize) {
+        WordParseUtil.validSuffix(file.getOriginalFilename());
+        WordParseUtil.validSize(file.getSize(), checkSize);
+    }
+
+    private static void validSuffix(String filename) {
+        if (StringUtils.isBlank((CharSequence)filename)) {
+            throw new BusinessException("\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff01");
+        }
+        String suffix = com.jby.common.util.FileUtil.getFileSuffix((String)filename);
+        BizAssert.isTrue(("docx".equalsIgnoreCase(suffix) || "wps".equalsIgnoreCase(suffix) ? 1 : 0) != 0, (String)"\u4ec5\u652f\u6301docx\u683c\u5f0f\u548cwps\u6587\u6863\u89e3\u6790\uff01");
+    }
+
+    public static void validSize(double fileSize, Integer checkSize) {
+        if (checkSize == null || checkSize <= 0) {
+            checkSize = officeCoreConfig.getCheckSize();
+        }
+        BizAssert.isTrue(((fileSize /= 1048576.0) <= (double)checkSize.intValue() ? 1 : 0) != 0, (String)"\u6587\u4ef6\u5927\u5c0f\u8d85\u51fa\u9650\u5b9a\u503c\uff01");
+    }
+
+    private static void createTempDir(ParseBO parseBO) {
+        try {
+            Path tempDir = Files.createTempDirectory(Paths.get(officeCoreConfig.getTmpPath(), new String[0]), "parse-", new FileAttribute[0]);
+            parseBO.setTempDir(tempDir);
+            parseBO.setImagesDir(tempDir.resolve("images").toString());
+            parseBO.setHtmlPath(tempDir.resolve("output.html").toString());
+            parseBO.setOssFolder(tempDir.getFileName().toString());
+        }
+        catch (IOException e) {
+            log.error("\u521b\u5efa\u4e34\u65f6\u6587\u4ef6\u5939\u5f02\u5e38");
+        }
+    }
+
+    private static void writeHtml(String html) {
+        if (!"local".equals(SpringContextHolder.getActiveProfile())) {
+            return;
+        }
+        String savePath = officeCoreConfig.getTmpPath() + "/upload" + File.separator + UniqueUtil.getUuid() + "." + "html";
+        File file = OfficeFileUtil.writeFile(html, savePath);
+        log.info("==========================================\u672c\u5730html\u6587\u4ef6\u8def\u5f84\uff1a{}", (Object)file.getPath());
+    }
+
+    private static void handleFormat(ParseBO parseBO) {
+        String tempDir = parseBO.getTempDir() + "/temp";
+        try {
+            WordParseUtil.unzipDocx(parseBO.getSourceFilePath(), tempDir);
+            String content = "";
+            Path path = Paths.get(tempDir + "/word/document.xml", new String[0]);
+            try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8);){
+                content = reader.lines().collect(Collectors.joining(System.lineSeparator()));
+                if (content.contains("<w:b w:val=\"off\"")) {
+                    content = content.replace("<w:b w:val=\"off\"", "<w:b w:val=\"0\"");
+                }
+                if (content.contains("<w:i w:val=\"off\"")) {
+                    content = content.replace("<w:i w:val=\"off\"", "<w:i w:val=\"0\"");
+                }
+                content = content.replaceAll("[\\u200B\\u200C\\u200D]", "");
+                content = content.replaceAll("\\u00A0", " ");
+                content = content.replaceAll("\\uf028", "(");
+                content = content.replaceAll("\\uf029", ")");
+                for (String sl : SYMBOL) {
+                    content = content.replaceAll(sl, "@@@" + sl.substring(2).toUpperCase() + "@@@");
+                }
+                content = content.replace("<w:shd w:val=\"pct15\" w:color=\"auto\" w:fill=\"FFFFFF\"/>", "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"D9D9D9\"/>");
+                content = content.replace("<w:shd w:val=\"pct10\" w:color=\"auto\" w:fill=\"FFFFFF\"/>", "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"E5E5E5\"/>");
+            }
+            catch (IOException e) {
+                log.error("\u5904\u7406\u6e90\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff1a{}", (Object)e.getMessage(), (Object)e);
+            }
+            Files.write(path, content.getBytes(StandardCharsets.UTF_8), new OpenOption[0]);
+            WordParseUtil.zipToDocx(tempDir, parseBO.getSourceFilePath());
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u6e90\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff1a{}", (Object)e.getMessage(), (Object)e);
+        }
+    }
+
+    private static void unzipDocx(String docxPath, String outputDir) throws IOException {
+        File dir = new File(outputDir);
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+        try (ZipFile zipFile = new ZipFile(docxPath);){
+            Enumeration<? extends ZipEntry> entries = zipFile.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                File entryFile = new File(outputDir, entry.getName());
+                if (entry.isDirectory()) {
+                    entryFile.mkdirs();
+                    continue;
+                }
+                entryFile.getParentFile().mkdirs();
+                InputStream is = zipFile.getInputStream(entry);
+                Throwable throwable = null;
+                try {
+                    FileOutputStream fos = new FileOutputStream(entryFile);
+                    Throwable throwable2 = null;
+                    try {
+                        int len;
+                        byte[] buffer = new byte[1024];
+                        while ((len = is.read(buffer)) > 0) {
+                            fos.write(buffer, 0, len);
+                        }
+                    }
+                    catch (Throwable throwable3) {
+                        throwable2 = throwable3;
+                        throw throwable3;
+                    }
+                    finally {
+                        if (fos == null) continue;
+                        if (throwable2 != null) {
+                            try {
+                                fos.close();
+                            }
+                            catch (Throwable throwable4) {
+                                throwable2.addSuppressed(throwable4);
+                            }
+                            continue;
+                        }
+                        fos.close();
+                    }
+                }
+                catch (Throwable throwable5) {
+                    throwable = throwable5;
+                    throw throwable5;
+                }
+                finally {
+                    if (is == null) continue;
+                    if (throwable != null) {
+                        try {
+                            is.close();
+                        }
+                        catch (Throwable throwable6) {
+                            throwable.addSuppressed(throwable6);
+                        }
+                        continue;
+                    }
+                    is.close();
+                }
+            }
+        }
+    }
+
+    private static void zipToDocx(String sourceDir, String outputDocx) throws IOException {
+        try (FileOutputStream fos = new FileOutputStream(outputDocx);
+             ZipOutputStream zos = new ZipOutputStream(fos);){
+            File rootDir = new File(sourceDir);
+            WordParseUtil.addFolderToZip(rootDir, rootDir, zos);
+        }
+    }
+
+    private static void addFolderToZip(File rootDir, File folder, ZipOutputStream zos) throws IOException {
+        for (File file : Objects.requireNonNull(folder.listFiles())) {
+            if (file.isDirectory()) {
+                WordParseUtil.addFolderToZip(rootDir, file, zos);
+                continue;
+            }
+            String entryName = rootDir.toPath().relativize(file.toPath()).toString().replace(File.separator, "/");
+            ZipEntry zipEntry = new ZipEntry(entryName);
+            zos.putNextEntry(zipEntry);
+            try (FileInputStream fis = new FileInputStream(file);){
+                int len;
+                byte[] buffer = new byte[1024];
+                while ((len = fis.read(buffer)) > 0) {
+                    zos.write(buffer, 0, len);
+                }
+            }
+            zos.closeEntry();
+        }
+    }
+
+    private static String getFileParseResult(ParseBO parseBO, String md5) {
+        try {
+            OfficeFileParseRecordVO officeFileParseRecord = (OfficeFileParseRecordVO)FeignUtils.parse((Result)fileServiceFeign.getOfficeFileParseRecordByMd5(md5));
+            if (Objects.nonNull(officeFileParseRecord)) {
+                log.info("\u6587\u4ef6\u5df2\u88ab\u89e3\u6790\u8fc7,MD5: {}", (Object)md5);
+                OfficeFileParseRecordParam officeFileParseRecordParam = new OfficeFileParseRecordParam().setFileUrl(officeFileParseRecord.getFileUrl()).setFileMd5(officeFileParseRecord.getFileMd5()).setFileParseUrl(officeFileParseRecord.getFileParseUrl()).setFileId(parseBO.getFileId());
+                FeignUtils.parse((Result)fileServiceFeign.saveOfficeFileParseRecord(officeFileParseRecordParam));
+                return HttpClientUtil.doGet((String)com.jby.common.util.FileUtil.encodeUrl((String)officeFileParseRecord.getFileParseUrl()));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u5386\u53f2\u89e3\u6790\u7ed3\u679c\u5f02\u5e38, md5: {}", (Object)md5, (Object)e);
+        }
+        return null;
+    }
+
+    private static void saveParseResult(ParseBO parseBO, String html) {
+        try {
+            String sourceFilePath = parseBO.getSourceFilePath();
+            String sourceFileBakPath = parseBO.getSourceFileBakPath();
+            if (StringUtils.isBlank((CharSequence)parseBO.getSourceFileUrl()) && StringUtils.isNotBlank((CharSequence)sourceFileBakPath)) {
+                File bakFile = new File(sourceFileBakPath);
+                String fileName = StringUtils.removeEnd((String)bakFile.getName(), (String)".JBY_BAK");
+                parseBO.setSourceFileUrl(WordParseUtil.uploadFileToOss(bakFile, "office/file/parse", parseBO.getOssFolder(), fileName));
+            }
+            String resultFilePath = sourceFilePath.substring(0, sourceFilePath.lastIndexOf(46)) + ".html";
+            File resultFile = OfficeFileUtil.writeFile(html, resultFilePath);
+            String fileParseUrl = WordParseUtil.uploadFileToOss(resultFile, "office/file/parse", parseBO.getOssFolder(), resultFile.getName());
+            if (StringUtils.isNotBlank((CharSequence)parseBO.getSourceFileUrl()) && StringUtils.isNotBlank((CharSequence)parseBO.getSourceFileMd5()) && StringUtils.isNotBlank((CharSequence)fileParseUrl)) {
+                OfficeFileParseRecordParam param = new OfficeFileParseRecordParam();
+                param.setFileUrl(parseBO.getSourceFileUrl());
+                param.setFileMd5(parseBO.getSourceFileMd5());
+                param.setFileParseUrl(fileParseUrl);
+                param.setFileId(parseBO.getFileId());
+                FeignUtils.parse((Result)fileServiceFeign.saveOfficeFileParseRecord(param));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u4e0a\u4f20oss\u6216\u4fdd\u5b58\u89e3\u6790\u8bb0\u5f55\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealImg(ParseBO parseBO) {
+        HashMap<String, String> imgMap = new HashMap<String, String>();
+        HashMap urlToUuidMap = new HashMap();
+        HashMap keyToImgMap = new HashMap();
+        parseBO.getImageMap().forEach((key, value) -> {
+            if (value != null && value.getPictureUrl() != null) {
+                String url = value.getPictureUrl();
+                String uuid = urlToUuidMap.computeIfAbsent(url, k -> UniqueUtil.getUuid());
+                imgMap.put(uuid, url);
+                keyToImgMap.put(key, uuid);
+            }
+        });
+        ArrayList futuresOss = new ArrayList();
+        imgMap.forEach((key, value) -> {
+            CompletionStage future = CompletableFuture.runAsync(() -> {
+                try {
+                    String imgUrl;
+                    String fullPath = parseBO.getTempDir() + "/temp" + value;
+                    String fileName = fullPath.substring(fullPath.lastIndexOf("/") + 1);
+                    String fileSuffix = com.jby.common.util.FileUtil.getFileSuffix((String)fullPath).toLowerCase();
+                    if ("tif".equals(fileSuffix) || "tiff".equals(fileSuffix)) {
+                        WordParseUtil.tifToPng(new File(fullPath));
+                        fullPath = fullPath.replaceAll("(?i)" + Pattern.quote(fileSuffix) + "$", "png");
+                        fileName = fileName.replaceAll("(?i)" + Pattern.quote(fileSuffix) + "$", "png");
+                        imgUrl = OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setInputStream(Files.newInputStream(Paths.get(fullPath, new String[0]), new OpenOption[0])).setFileName(fileName));
+                    } else {
+                        imgUrl = "wmf".equals(fileSuffix) || "emf".equals(fileSuffix) ? OfficeFileUtil.mf2svg(new ByteArrayInputStream(FileUtil.readBytes((String)fullPath)), fullPath) : OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setInputStream(Files.newInputStream(Paths.get(fullPath, new String[0]), new OpenOption[0])).setFileName(fileName));
+                    }
+                    imgMap.put((String)key, StringUtils.isNotBlank((CharSequence)imgUrl) ? imgUrl : fullPath);
+                }
+                catch (IOException e) {
+                    log.error("\u5904\u7406\u56fe\u7247\u5931\u8d25, key: {}, value: {}", new Object[]{key, value, e});
+                }
+            }, WordParseUtil.getBatchDealPicExecutor()).exceptionally(throwable -> {
+                log.error("\u5904\u7406\u56fe\u7247\u5f02\u5e38", throwable);
+                return null;
+            });
+            futuresOss.add(future);
+        });
+        if (CollectionUtils.isNotEmpty(futuresOss)) {
+            try {
+                CompletableFuture.allOf(futuresOss.toArray(new CompletableFuture[0])).get(5L, TimeUnit.MINUTES);
+                log.info("\u56fe\u7247\u5904\u7406\u5b8c\u6210");
+            }
+            catch (TimeoutException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u8d85\u65f6", (Throwable)e);
+            }
+            catch (InterruptedException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u88ab\u4e2d\u65ad", (Throwable)e);
+                Thread.currentThread().interrupt();
+            }
+            catch (ExecutionException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u5f02\u5e38", e.getCause());
+            }
+        }
+        parseBO.getImageMap().forEach((key, value) -> value.setPictureUrl((String)imgMap.get(keyToImgMap.get(key))));
+    }
+
+    public static String formatAsMillis(StopWatch sw) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(sw.getId()).append("\n");
+        sb.append("---------------------------------------------\n");
+        sb.append(String.format("%-10s %-6s %s%n", "ms", "%", "Task name"));
+        sb.append("---------------------------------------------\n");
+        long totalMillis = Math.max(1L, sw.getTotalTimeMillis());
+        for (StopWatch.TaskInfo task : sw.getTaskInfo()) {
+            long ms = task.getTimeMillis();
+            int pct = (int)Math.round(100.0 * (double)ms / (double)totalMillis);
+            sb.append(String.format("%-10d %-6s %s%n", ms, pct + "%", task.getTaskName()));
+        }
+        return sb.toString();
+    }
+}
+
diff --git a/java-src/utils/finder/CtObjectFinder.java b/java-src/utils/finder/CtObjectFinder.java
new file mode 100644
index 0000000..37fb985
--- /dev/null
+++ b/java-src/utils/finder/CtObjectFinder.java
@@ -0,0 +1,46 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ */
+package com.jby.officecore.utils.finder;
+
+import com.jby.officecore.domain.bo.ParseBO;
+import java.util.List;
+import java.util.Objects;
+import org.docx4j.TraversalUtil;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+
+public class CtObjectFinder
+extends TraversalUtil.CallbackImpl {
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+
+    public CtObjectFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof CTOLEObject) {
+            CTOLEObject ctoleObject = (CTOLEObject)o;
+            RelationshipsPart rsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            if (Objects.nonNull(ctoleObject.getId())) {
+                Part part = rsPart.getPart(ctoleObject.getId());
+                String binFilePath = part.getPartName().getURI().getPath();
+                String placeholder = this.parseBO.getMathTypePlaceholder(ctoleObject.getId());
+                this.parseBO.getMathTypeMap().put(placeholder, this.parseBO.getTempDir() + "/temp" + binFilePath);
+            }
+        }
+        return null;
+    }
+}
+
diff --git a/java-src/utils/finder/CtTextBoxFinder.java b/java-src/utils/finder/CtTextBoxFinder.java
new file mode 100644
index 0000000..4777ccc
--- /dev/null
+++ b/java-src/utils/finder/CtTextBoxFinder.java
@@ -0,0 +1,121 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TextUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.mce.AlternateContent
+ *  org.docx4j.mce.AlternateContent$Fallback
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.vml.CTGroup
+ *  org.docx4j.vml.CTRoundRect
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.CTTextbox
+ *  org.docx4j.vml.VmlShapeElements
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.jby.officecore.utils.finder;
+
+import com.jby.officecore.domain.bo.ParseBO;
+import java.util.List;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.mce.AlternateContent;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.vml.CTGroup;
+import org.docx4j.vml.CTRoundRect;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.CTTextbox;
+import org.docx4j.vml.VmlShapeElements;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CtTextBoxFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtTextBoxFinder.class);
+    private WordprocessingMLPackage wordMlPackage;
+    private ParseBO parseBO;
+
+    public CtTextBoxFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof Pict) {
+            boolean isFirstRun = true;
+            ObjectFactory factory = new ObjectFactory();
+            StringBuilder stringBuilder = new StringBuilder();
+            R sourceR = factory.createR();
+            Pict pict = (Pict)o;
+            List anyAndAny = pict.getAnyAndAny();
+            for (Object object : anyAndAny) {
+                if (!(object instanceof JAXBElement)) continue;
+                JAXBElement jbe = (JAXBElement)object;
+                this.findTextBox(jbe.getValue(), stringBuilder, isFirstRun, sourceR);
+            }
+            if (StringUtils.isNotBlank((CharSequence)stringBuilder.toString())) {
+                AlternateContent.Fallback fallback = (AlternateContent.Fallback)pict.getParent();
+                AlternateContent alternateContent = (AlternateContent)fallback.getParent();
+                R r = (R)alternateContent.getParent();
+                Text text = factory.createText();
+                text.setValue(stringBuilder + "JBY_TEXTBOX_JBY");
+                r.getContent().set(0, text);
+                r.setRPr(sourceR.getRPr());
+            }
+        }
+        return null;
+    }
+
+    private void findTextBox(Object object, StringBuilder sb, boolean isFirstRun, R sourceR) {
+        block8: {
+            List egShapeElements;
+            if (object instanceof CTShape || object instanceof CTRoundRect) {
+                VmlShapeElements vmlShapeElements = (VmlShapeElements)object;
+                egShapeElements = vmlShapeElements.getEGShapeElements();
+                for (JAXBElement egShapeElement : egShapeElements) {
+                    if (!(egShapeElement.getValue() instanceof CTTextbox)) continue;
+                    CTTextbox ctTextbox = (CTTextbox)egShapeElement.getValue();
+                    CTTxbxContent txbxContent = ctTextbox.getTxbxContent();
+                    for (int i = 0; i < txbxContent.getContent().size(); ++i) {
+                        Object obj = txbxContent.getContent().get(i);
+                        String text = TextUtils.getText(obj);
+                        if (txbxContent.getContent().size() > 1 && i != txbxContent.getContent().size() - 1) {
+                            text = text + "JBY_TEXTBOX_JBYBR";
+                        }
+                        sb.append(text);
+                    }
+                }
+            }
+            if (!(object instanceof CTGroup)) break block8;
+            CTGroup ctGroup = (CTGroup)object;
+            egShapeElements = ctGroup.getEGShapeElements();
+            boolean isCtShape = egShapeElements.stream().anyMatch(f -> f.getValue() instanceof CTShape);
+            if (isCtShape) {
+                for (int i = egShapeElements.size() - 1; i >= 0; --i) {
+                    this.findTextBox(((JAXBElement)egShapeElements.get(i)).getValue(), sb, isFirstRun, sourceR);
+                }
+            } else {
+                for (JAXBElement egShapeElement : egShapeElements) {
+                    this.findTextBox(egShapeElement.getValue(), sb, isFirstRun, sourceR);
+                }
+            }
+        }
+    }
+}
+
diff --git a/java-src/utils/finder/CtoMathFinder.java b/java-src/utils/finder/CtoMathFinder.java
new file mode 100644
index 0000000..20e41c1
--- /dev/null
+++ b/java-src/utils/finder/CtoMathFinder.java
@@ -0,0 +1,427 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.XmlUtils
+ *  org.docx4j.com.microsoft.schemas.office.word.x2010.wordprocessingShape.CTTextboxInfo
+ *  org.docx4j.math.CTOMath
+ *  org.docx4j.math.CTOMathPara
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.CTVerticalAlignRun
+ *  org.docx4j.wml.FldChar
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.P
+ *  org.docx4j.wml.PPr
+ *  org.docx4j.wml.PPrBase$NumPr
+ *  org.docx4j.wml.PPrBase$NumPr$Ilvl
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.RPrAbstract
+ *  org.docx4j.wml.STFldCharType
+ *  org.docx4j.wml.Style
+ *  org.docx4j.wml.Text
+ *  org.docx4j.wml.U
+ *  org.docx4j.wml.UnderlineEnumeration
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.jby.officecore.utils.finder;
+
+import com.jby.officecore.domain.bo.ParseBO;
+import com.jby.officecore.utils.EqToLatexUtil;
+import com.jby.officecore.utils.NumPr;
+import com.jby.officecore.utils.WordParseUtil;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.com.microsoft.schemas.office.word.x2010.wordprocessingShape.CTTextboxInfo;
+import org.docx4j.math.CTOMath;
+import org.docx4j.math.CTOMathPara;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.CTVerticalAlignRun;
+import org.docx4j.wml.FldChar;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.P;
+import org.docx4j.wml.PPr;
+import org.docx4j.wml.PPrBase;
+import org.docx4j.wml.R;
+import org.docx4j.wml.RPrAbstract;
+import org.docx4j.wml.STFldCharType;
+import org.docx4j.wml.Style;
+import org.docx4j.wml.Text;
+import org.docx4j.wml.U;
+import org.docx4j.wml.UnderlineEnumeration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CtoMathFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtoMathFinder.class);
+    private ParseBO parseBO;
+    private static final Pattern CIRCLED_NUMBER_PATTERN = Pattern.compile("^\\s*eq\\s*\\\\o\\((?:\u25cb,\\\\s\\\\up\\d+\\((\\d+)\\)|\\\\s\\\\up\\d+\\((\\d+)\\),\u25cb)\\)");
+
+    public CtoMathFinder(ParseBO parseBO) {
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof P) {
+            Text text;
+            Style style;
+            CTTxbxContent ctTxbxContent;
+            StringBuilder eqCode = new StringBuilder();
+            StringBuilder originEqCode = new StringBuilder();
+            boolean inFiled = false;
+            boolean isEq = false;
+            boolean superScriptFlag = false;
+            boolean subScriptFlag = false;
+            ArrayList<Integer> fieldRunIndexs = new ArrayList<Integer>();
+            P paragraph = (P)o;
+            ObjectFactory factory = new ObjectFactory();
+            boolean isNumPr = true;
+            if (paragraph.getParent() instanceof CTTxbxContent && (ctTxbxContent = (CTTxbxContent)paragraph.getParent()).getParent() instanceof CTTextboxInfo) {
+                isNumPr = false;
+            }
+            PPr pPr = paragraph.getPPr();
+            PPrBase.NumPr numPr = null;
+            if (Objects.nonNull(pPr)) {
+                numPr = pPr.getNumPr();
+            }
+            if (Objects.isNull(numPr) && Objects.nonNull(pPr) && Objects.nonNull(pPr.getPStyle()) && Objects.nonNull(style = this.parseBO.getStyleDefinitionsPart().getStyleById(pPr.getPStyle().getVal())) && Objects.nonNull(style.getPPr()) && Objects.nonNull(style.getPPr().getNumPr()) && Objects.isNull((numPr = style.getPPr().getNumPr()).getIlvl())) {
+                PPrBase.NumPr.Ilvl ilvl = new PPrBase.NumPr.Ilvl();
+                ilvl.setVal(BigInteger.ZERO);
+                numPr.setIlvl(ilvl);
+            }
+            if (isNumPr && Objects.nonNull(numPr) && Objects.nonNull(numPr.getNumId()) && Objects.nonNull(numPr.getIlvl())) {
+                String numPrKey = numPr.getNumId().getVal() + "_" + numPr.getIlvl().getVal();
+                Map<String, NumPr> numberingDefinitionsMap = this.parseBO.getNumberingDefinitionsMap();
+                if (numberingDefinitionsMap.containsKey(numPrKey)) {
+                    NumPr currentNumPr = numberingDefinitionsMap.get(numPrKey);
+                    String lvlText = currentNumPr.getLvlText();
+                    for (int i = 0; i <= numPr.getIlvl().getVal().intValue(); ++i) {
+                        NumPr numPrDefine;
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            currentNumPr.setCurrent(currentNumPr.getCurrent().add(BigInteger.ONE));
+                        }
+                        String rep = String.valueOf((numPrDefine = numberingDefinitionsMap.get(numPr.getNumId().getVal() + "_" + i)).getCurrent().compareTo(BigInteger.ZERO) == 0 ? numPrDefine.getStart() : numPrDefine.getCurrent());
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            switch (currentNumPr.getNumFmt()) {
+                                case "UPPER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep);
+                                    break;
+                                }
+                                case "DECIMAL_ZERO": {
+                                    rep = CtoMathFinder.strToDecimalZero(rep);
+                                    break;
+                                }
+                                case "LOWER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep);
+                                    break;
+                                }
+                                case "UPPER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep).toUpperCase();
+                                    break;
+                                }
+                                case "LOWER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep).toLowerCase();
+                                    break;
+                                }
+                                case "CHINESE_COUNTING": 
+                                case "CHINESE_COUNTING_THOUSAND": {
+                                    rep = this.strToChineseCounting(rep);
+                                    break;
+                                }
+                            }
+                        }
+                        lvlText = lvlText.replace("%" + (i + 1), rep);
+                    }
+                    if (StringUtils.isNotBlank((CharSequence)lvlText)) {
+                        R run = factory.createR();
+                        text = factory.createText();
+                        text.setValue(lvlText + "  ");
+                        run.getContent().add(text);
+                        paragraph.getContent().add(0, run);
+                    }
+                }
+            }
+            for (int i = 0; i < paragraph.getContent().size(); ++i) {
+                JAXBElement jaxbElement;
+                Object content = paragraph.getContent().get(i);
+                if (content instanceof JAXBElement && ((jaxbElement = (JAXBElement)content).getValue() instanceof CTOMath || jaxbElement.getValue() instanceof CTOMathPara)) {
+                    String placeholder = "";
+                    if (Boolean.TRUE.equals(this.parseBO.getNewParseVersion())) {
+                        String omml = XmlUtils.marshaltoString((Object)jaxbElement);
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, omml);
+                    } else {
+                        String mathMl = WordParseUtil.getMathMl(jaxbElement, this.parseBO.getTransformer());
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, mathMl);
+                    }
+                    R run = factory.createR();
+                    text = factory.createText();
+                    text.setValue(placeholder);
+                    run.getContent().add(text);
+                    paragraph.getContent().set(i, run);
+                }
+                if (!(content instanceof R)) continue;
+                R run = (R)content;
+                for (int j = 0; j < run.getContent().size(); ++j) {
+                    Object runC = run.getContent().get(j);
+                    if (!(runC instanceof JAXBElement)) continue;
+                    JAXBElement runCj = (JAXBElement)runC;
+                    if (runCj.getValue() instanceof FldChar) {
+                        FldChar fldChar = (FldChar)runCj.getValue();
+                        if (fldChar.getFldCharType().equals((Object)STFldCharType.BEGIN)) {
+                            eqCode = new StringBuilder();
+                            originEqCode = new StringBuilder();
+                            inFiled = true;
+                            isEq = false;
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                            fieldRunIndexs = new ArrayList();
+                            fieldRunIndexs.add(i);
+                            continue;
+                        }
+                        if (inFiled && fldChar.getFldCharType().equals((Object)STFldCharType.END)) {
+                            if (isEq) {
+                                String placeholder;
+                                Matcher matcher = CIRCLED_NUMBER_PATTERN.matcher(originEqCode);
+                                if (matcher.matches()) {
+                                    String numStr = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
+                                    placeholder = this.parseBO.getEqLatexPlaceholder() + "JBYEQNUM";
+                                    this.parseBO.getEqLatexMap().put(placeholder, CtoMathFinder.getCircledNumber(numStr));
+                                    R runN = factory.createR();
+                                    Text text2 = factory.createText();
+                                    text2.setValue(placeholder);
+                                    runN.getContent().add(text2);
+                                    paragraph.getContent().set(i, runN);
+                                } else if (StringUtils.isNotBlank((CharSequence)eqCode.toString())) {
+                                    String latex = EqToLatexUtil.convert(eqCode.toString());
+                                    latex = latex.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+                                    placeholder = this.parseBO.getEqLatexPlaceholder();
+                                    this.parseBO.getEqLatexMap().put(placeholder, latex);
+                                    R runN = factory.createR();
+                                    Text text3 = factory.createText();
+                                    text3.setValue(placeholder);
+                                    runN.getContent().add(text3);
+                                    paragraph.getContent().set(i, runN);
+                                }
+                            }
+                            inFiled = false;
+                            isEq = false;
+                            fieldRunIndexs.clear();
+                            continue;
+                        }
+                        if (inFiled && isEq && !fldChar.getFldCharType().value().equals("separate")) continue;
+                    }
+                    if (!inFiled || !(runCj.getValue() instanceof Text)) continue;
+                    CTVerticalAlignRun vertAlign = Optional.ofNullable(run.getRPr()).map(RPrAbstract::getVertAlign).orElse(null);
+                    String value = ((Text)runCj.getValue()).getValue();
+                    originEqCode.append(value);
+                    U u = Optional.ofNullable(run.getRPr()).filter(f -> Objects.nonNull(f.getU()) && !UnderlineEnumeration.NONE.equals((Object)f.getU().getVal()) && Objects.nonNull(f.getU().getVal())).map(RPrAbstract::getU).orElse(null);
+                    if (StringUtils.isBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = value.replace("\u3000", "JBYU1JBYU").replace(" ", "JBYU1JBYU");
+                    } else if (StringUtils.isNotBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = "JBYU2BEGIN" + value + "JBYU2END";
+                    } else if (StringUtils.isBlank((CharSequence)value)) {
+                        // empty if block
+                    }
+                    String trimmedOrigin = CtoMathFinder.extractEqPrefix(originEqCode);
+                    if (trimmedOrigin.startsWith("eq")) {
+                        isEq = true;
+                    }
+                    if (isEq) {
+                        if (CollectionUtils.isNotEmpty(fieldRunIndexs)) {
+                            fieldRunIndexs.forEach(m -> paragraph.getContent().set((int)m, factory.createR()));
+                            fieldRunIndexs.clear();
+                        }
+                        if (Objects.nonNull(vertAlign)) {
+                            String newContent;
+                            String tmp;
+                            if ("superscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (superScriptFlag && (start = eqCode.lastIndexOf("\\s\\up4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\up4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\up4(" + value + ")";
+                                }
+                                superScriptFlag = true;
+                                subScriptFlag = false;
+                            } else if ("subscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (subScriptFlag && (start = eqCode.lastIndexOf("\\s\\do4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\do4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\do4(" + value + ")";
+                                }
+                                subScriptFlag = true;
+                                superScriptFlag = false;
+                            } else {
+                                superScriptFlag = false;
+                                subScriptFlag = false;
+                            }
+                        } else {
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                        }
+                        eqCode.append(value);
+                        paragraph.getContent().set(i, factory.createR());
+                        continue;
+                    }
+                    if (trimmedOrigin.length() < 2 || "eq".startsWith(trimmedOrigin)) {
+                        eqCode.append(value);
+                        fieldRunIndexs.add(i);
+                        continue;
+                    }
+                    inFiled = false;
+                    fieldRunIndexs.clear();
+                }
+            }
+        }
+        return null;
+    }
+
+    private String strToUpperRoman(String str) {
+        int num = Integer.parseInt(str);
+        if (num < 1 || num > 3999) {
+            return "I";
+        }
+        int[] values = new int[]{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        String[] symbols = new String[]{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+        StringBuilder roman = new StringBuilder();
+        for (int i = 0; i < values.length; ++i) {
+            while (num >= values[i]) {
+                roman.append(symbols[i]);
+                num -= values[i];
+            }
+        }
+        return roman.toString();
+    }
+
+    private static String strToDecimalZero(String str) {
+        if (str.length() == 1) {
+            return "0" + str;
+        }
+        return str;
+    }
+
+    private static String strToLowerLetter(String str) {
+        int n = Integer.parseInt(str);
+        int length = (n - 1) / 26 + 1;
+        char baseChar = (char)(97 + (n - 1) % 26);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; ++i) {
+            sb.append(baseChar);
+        }
+        return sb.toString();
+    }
+
+    public String strToChineseCounting(String str) {
+        String s;
+        int num = Integer.parseInt(str);
+        if (num < 0 || num >= 1000000000) {
+            throw new IllegalArgumentException("\u4ec5\u652f\u6301 0 \u5230 999,999,999");
+        }
+        if (num == 0) {
+            return "\u3007";
+        }
+        char[] digits = new char[]{'\u3007', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d'};
+        String[] units = new String[]{"", "\u5341", "\u767e", "\u5343"};
+        String[] bigUnits = new String[]{"", "\u4e07", "\u4ebf"};
+        StringBuilder result = new StringBuilder();
+        int yi = num / 100000000;
+        int wan = num / 10000 % 10000;
+        int ge = num % 10000;
+        if (yi > 0) {
+            result.append(CtoMathFinder.convertSegment(yi, digits, units)).append(bigUnits[2]);
+            if (wan == 0 && ge > 0) {
+                result.append('\u3007');
+            }
+        }
+        if (wan > 0) {
+            result.append(CtoMathFinder.convertSegment(wan, digits, units)).append(bigUnits[1]);
+            if (ge > 0 && ge < 1000) {
+                result.append('\u3007');
+            }
+        }
+        if (ge > 0) {
+            result.append(CtoMathFinder.convertSegment(ge, digits, units));
+        }
+        if ((s = result.toString()).startsWith("\u4e00\u5341")) {
+            s = s.substring(1);
+        }
+        return s;
+    }
+
+    private static String convertSegment(int n, char[] digits, String[] units) {
+        if (n == 0) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 4; ++i) {
+            int power = 3 - i;
+            int base = (int)Math.pow(10.0, power);
+            int digit = n / base % 10;
+            if (digit != 0) {
+                sb.append(digits[digit]).append(units[power]);
+                continue;
+            }
+            if (sb.length() <= 0 || n % base == 0 || power <= 0) continue;
+            sb.append('\u3007');
+        }
+        return sb.toString();
+    }
+
+    private static String getCircledNumber(String num) {
+        int n = Integer.parseInt(num);
+        if (n >= 1 && n <= 20) {
+            return String.valueOf((char)(9312 + n - 1));
+        }
+        if (n >= 21 && n <= 35) {
+            return String.valueOf((char)(12881 + n - 21));
+        }
+        if (n >= 36 && n <= 40) {
+            return String.valueOf((char)(12977 + n - 36));
+        }
+        if (n >= 41 && n <= 50) {
+            return String.valueOf((char)(12982 + n - 41));
+        }
+        log.info("\u83b7\u53d6\u5e26\u5708\u5b57\u7b26\u5931\u8d25 {}", (Object)num);
+        return "";
+    }
+
+    private static String extractEqPrefix(StringBuilder originEqCode) {
+        int i;
+        String s = originEqCode.toString().trim();
+        for (i = 0; i < s.length() && s.charAt(i) == '{'; ++i) {
+        }
+        return s.substring(i).trim().toLowerCase();
+    }
+}
+
diff --git a/java-src/utils/finder/DrawingPictFinder.java b/java-src/utils/finder/DrawingPictFinder.java
new file mode 100644
index 0000000..5180650
--- /dev/null
+++ b/java-src/utils/finder/DrawingPictFinder.java
@@ -0,0 +1,434 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.excel.util.StringUtils
+ *  com.jby.common.util.UniqueUtil
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.dml.GraphicData
+ *  org.docx4j.dml.picture.Pic
+ *  org.docx4j.dml.wordprocessingDrawing.Anchor
+ *  org.docx4j.dml.wordprocessingDrawing.Inline
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.CTImageData
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ *  org.docx4j.wml.CTObject
+ *  org.docx4j.wml.Drawing
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.jby.officecore.utils.finder;
+
+import com.alibaba.excel.util.StringUtils;
+import com.jby.common.util.UniqueUtil;
+import com.jby.officecore.domain.bo.ImageBO;
+import com.jby.officecore.domain.bo.ParseBO;
+import com.jby.officecore.enums.AttrEnum;
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.imageio.ImageIO;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.dml.GraphicData;
+import org.docx4j.dml.picture.Pic;
+import org.docx4j.dml.wordprocessingDrawing.Anchor;
+import org.docx4j.dml.wordprocessingDrawing.Inline;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.CTImageData;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+import org.docx4j.wml.CTObject;
+import org.docx4j.wml.Drawing;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DrawingPictFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(DrawingPictFinder.class);
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+    private static final double CROP_SCALE = 1.52587890625;
+
+    public DrawingPictFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        List contentList;
+        List anyAndAny;
+        R r;
+        if (o instanceof Drawing && ((Drawing)o).getParent() instanceof R) {
+            RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            Drawing drawing = (Drawing)o;
+            List anchorOrInline = drawing.getAnchorOrInline();
+            if (CollectionUtils.isNotEmpty((Collection)anchorOrInline)) {
+                Object anchorOrInlineObj = anchorOrInline.get(0);
+                GraphicData graphicData = null;
+                long cx = 0L;
+                long cy = 0L;
+                if (anchorOrInlineObj instanceof Inline) {
+                    Inline inline = (Inline)anchorOrInlineObj;
+                    graphicData = inline.getGraphic().getGraphicData();
+                    cx = inline.getExtent().getCx();
+                    cy = inline.getExtent().getCy();
+                } else if (anchorOrInlineObj instanceof Anchor) {
+                    Anchor anchor = (Anchor)anchorOrInlineObj;
+                    graphicData = anchor.getGraphic().getGraphicData();
+                    cx = anchor.getExtent().getCx();
+                    cy = anchor.getExtent().getCy();
+                }
+                if (Objects.nonNull(graphicData) && "http://schemas.openxmlformats.org/drawingml/2006/picture".equals(graphicData.getUri())) {
+                    for (Object object : graphicData.getAny()) {
+                        String path;
+                        JAXBElement jaxbElement;
+                        if (!(object instanceof JAXBElement) || !((jaxbElement = (JAXBElement)object).getValue() instanceof Pic)) continue;
+                        Pic pic = (Pic)jaxbElement.getValue();
+                        String imageDataId = null;
+                        int cropLeft = 0;
+                        int cropTop = 0;
+                        int cropRight = 0;
+                        int cropBottom = 0;
+                        int rotation = 0;
+                        if (Objects.nonNull(pic.getBlipFill())) {
+                            if (Objects.nonNull(pic.getBlipFill().getBlip())) {
+                                imageDataId = pic.getBlipFill().getBlip().getEmbed();
+                            }
+                            if (Objects.nonNull(pic.getBlipFill().getSrcRect())) {
+                                cropLeft = pic.getBlipFill().getSrcRect().getL();
+                                cropTop = pic.getBlipFill().getSrcRect().getT();
+                                cropRight = pic.getBlipFill().getSrcRect().getR();
+                                cropBottom = pic.getBlipFill().getSrcRect().getB();
+                            }
+                            if (Objects.nonNull(pic.getSpPr()) && Objects.nonNull(pic.getSpPr().getXfrm())) {
+                                rotation = pic.getSpPr().getXfrm().getRot();
+                            }
+                        }
+                        Map<String, Object> map = this.dealCropRotate(imageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                        Object widthObj = map.get(AttrEnum.WIDTH.getAttr());
+                        Object heightObj = map.get(AttrEnum.HEIGHT.getAttr());
+                        Object pathObj = map.get("imagePath");
+                        double width = Objects.nonNull(widthObj) ? Double.parseDouble(widthObj.toString()) : (double)Math.round((double)cx / 9525.0);
+                        double height = Objects.nonNull(heightObj) ? Double.parseDouble(heightObj.toString()) : (double)Math.round((double)cy / 9525.0);
+                        Part part = relationshipsPart.getPart(imageDataId);
+                        if (Objects.nonNull(pathObj)) {
+                            path = String.valueOf(pathObj);
+                        } else if (Objects.nonNull(part)) {
+                            path = part.getPartName().getURI().getPath();
+                        } else {
+                            log.warn("\u65e0\u6cd5\u83b7\u53d6\u56fe\u7247Part\uff0cimageDataId={}", (Object)imageDataId);
+                            continue;
+                        }
+                        String imagePlaceholder = this.parseBO.getImagePlaceholder(imageDataId);
+                        ImageBO imageBO = new ImageBO().setWidth(width).setHeight(height).setPictureUrl(path);
+                        this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                        R r2 = (R)drawing.getParent();
+                        List contentList2 = r2.getContent();
+                        int drawingIndex = contentList2.indexOf(drawing);
+                        if (drawingIndex != -1) {
+                            Text text = new ObjectFactory().createText();
+                            text.setValue(imagePlaceholder);
+                            contentList2.set(drawingIndex, text);
+                            continue;
+                        }
+                        log.warn("\u672a\u627e\u5230drawing\u5bf9\u8c61\u5728\u7236\u5143\u7d20\u4e2d\u7684\u7d22\u5f15\uff0c\u8df3\u8fc7\u66ff\u6362\u64cd\u4f5c");
+                    }
+                }
+            }
+        }
+        if (o instanceof Pict && ((Pict)o).getParent() instanceof R) {
+            Pict pict = (Pict)o;
+            r = (R)pict.getParent();
+            anyAndAny = pict.getAnyAndAny();
+            contentList = r.getContent();
+            int pictIndex = contentList.indexOf(pict);
+            if (pictIndex != -1) {
+                this.dealCtShape(anyAndAny, r, pictIndex);
+            }
+        }
+        if (o instanceof CTObject && ((CTObject)o).getParent() instanceof R) {
+            CTObject ctObject = (CTObject)o;
+            r = (R)ctObject.getParent();
+            anyAndAny = ctObject.getAnyAndAny();
+            contentList = r.getContent();
+            int ctObjectIndex = contentList.indexOf(ctObject);
+            if (ctObjectIndex != -1) {
+                this.dealCtShape(anyAndAny, r, ctObjectIndex);
+            }
+        }
+        return null;
+    }
+
+    private String extractValue(String style, String property) {
+        if (style == null || property == null) {
+            return null;
+        }
+        String regex = "\\b" + Pattern.quote(property) + "\\s*:\\s*([\\d.]+[a-zA-Z]*)";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+
+    private void dealCtShape(List<Object> anyAndAny, R r, int pictIndex) {
+        String ctOleObjectRid = anyAndAny.stream().filter(f -> f instanceof JAXBElement && ((JAXBElement)f).getValue() instanceof CTOLEObject).map(f -> ((CTOLEObject)((JAXBElement)f).getValue()).getId()).filter(Objects::nonNull).findFirst().orElse(null);
+        if (Objects.nonNull(ctOleObjectRid) && Objects.nonNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            Text text = new ObjectFactory().createText();
+            text.setValue(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            r.getContent().set(pictIndex, text);
+        } else if (Objects.isNull(ctOleObjectRid) || Objects.isNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            if (Objects.nonNull(ctOleObjectRid)) {
+                this.parseBO.getMathTypeMap().remove(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            }
+            for (Object object : anyAndAny) {
+                String path;
+                double heightPx;
+                double widthPx;
+                if (!(object instanceof JAXBElement) || !(((JAXBElement)object).getValue() instanceof CTShape)) continue;
+                CTShape ctShape = (CTShape)((JAXBElement)object).getValue();
+                String width = this.extractValue(ctShape.getStyle(), "width");
+                String height = this.extractValue(ctShape.getStyle(), "height");
+                CTImageData ctImageData = ctShape.getEGShapeElements().stream().filter(f -> f.getValue() instanceof CTImageData).map(m -> (CTImageData)m.getValue()).findFirst().orElse(null);
+                if (!Objects.nonNull(ctImageData) || !StringUtils.isNotBlank((CharSequence)width) || !StringUtils.isNotBlank((CharSequence)height)) continue;
+                String ctImageDataId = ctImageData.getId();
+                long cx = 0L;
+                try {
+                    double widthPtIn = Double.parseDouble(width.substring(0, width.length() - 2));
+                    if (width.endsWith("pt")) {
+                        cx = Math.round(widthPtIn * 12700.0);
+                    } else if (width.endsWith("in")) {
+                        cx = Math.round(widthPtIn * 914400.0);
+                    }
+                }
+                catch (NumberFormatException ignored) {
+                    log.error("extractWidth error");
+                }
+                int cropLeft = this.parseVmlCrop(ctImageData.getCropleft());
+                int cropTop = this.parseVmlCrop(ctImageData.getCroptop());
+                int cropRight = this.parseVmlCrop(ctImageData.getCropright());
+                int cropBottom = this.parseVmlCrop(ctImageData.getCropbottom());
+                String rotRaw = this.extractValue(ctShape.getStyle(), "rotation");
+                int rotation = rotRaw == null ? 0 : (int)Math.round((double)Long.parseLong(rotRaw.replaceAll("[^\\d-]", "")) * 0.91552734375);
+                Map<String, Object> map = this.dealCropRotate(ctImageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                Object widthObj = map.get(AttrEnum.WIDTH.getAttr());
+                Object heightObj = map.get(AttrEnum.HEIGHT.getAttr());
+                Object pathObj = map.get("imagePath");
+                if (Objects.nonNull(widthObj) && Objects.nonNull(heightObj)) {
+                    widthPx = (Double)map.get(AttrEnum.WIDTH.getAttr());
+                    heightPx = (Double)map.get(AttrEnum.HEIGHT.getAttr());
+                } else {
+                    widthPx = Double.parseDouble(width.replaceAll("pt|in", ""));
+                    if (width.endsWith("pt")) {
+                        widthPx = Math.round(widthPx * 96.0 / 72.0);
+                    } else if (width.endsWith("in")) {
+                        widthPx = Math.round(widthPx * 96.0);
+                    }
+                    heightPx = Double.parseDouble(height.replaceAll("pt|in", ""));
+                    if (height.endsWith("pt")) {
+                        heightPx = heightPx * 96.0 / 72.0;
+                    } else if (height.endsWith("in")) {
+                        heightPx *= 96.0;
+                    }
+                }
+                RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                Part part = relationshipsPart.getPart(ctImageDataId);
+                if (Objects.nonNull(pathObj)) {
+                    path = String.valueOf(pathObj);
+                } else if (Objects.nonNull(part)) {
+                    path = part.getPartName().getURI().getPath();
+                } else {
+                    log.warn("\u65e0\u6cd5\u83b7\u53d6\u8001\u7248VML\u56fe\u7247Part\uff0cctImageDataId={}", (Object)ctImageDataId);
+                    continue;
+                }
+                ImageBO imageBO = new ImageBO().setWidth(widthPx).setHeight(heightPx).setPictureUrl(path);
+                String imagePlaceholder = this.parseBO.getImagePlaceholder(ctImageDataId);
+                this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                Text text = new ObjectFactory().createText();
+                text.setValue(imagePlaceholder);
+                r.getContent().set(pictIndex, text);
+                break;
+            }
+        }
+    }
+
+    private Map<String, Object> dealCropRotate(String imageDataId, long cx, int cropLeft, int cropTop, int cropRight, int cropBottom, int rotation) {
+        HashMap<String, Object> result = new HashMap<String, Object>();
+        try {
+            if (Objects.nonNull(imageDataId)) {
+                boolean isRotate;
+                boolean isCrop = cropLeft > 0 || cropTop > 0 || cropRight > 0 || cropBottom > 0;
+                boolean bl = isRotate = rotation != 0;
+                if (isCrop || isRotate) {
+                    RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                    Part part = relationshipsPart.getPart(imageDataId);
+                    BinaryPartAbstractImage imagePart = (BinaryPartAbstractImage)part;
+                    BufferedImage targetImage = ImageIO.read(new ByteArrayInputStream(imagePart.getBytes()));
+                    if (isCrop) {
+                        targetImage = this.cropImage(targetImage, cropLeft, cropTop, cropRight, cropBottom);
+                    }
+                    if (isRotate) {
+                        targetImage = this.rotateImage(targetImage, rotation, cx, result);
+                    }
+                    if (Objects.nonNull(targetImage)) {
+                        String formatName = this.getFormatName(imagePart);
+                        String path = "/word/media/" + UniqueUtil.getUuid() + "." + formatName;
+                        ImageIO.write((RenderedImage)targetImage, formatName, new File(this.parseBO.getTempDir() + "/temp" + path));
+                        result.put("imagePath", path);
+                    }
+                }
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u56fe\u7247\u88c1\u526a\u4e0e\u65cb\u8f6c\u5f02\u5e38", (Throwable)e);
+        }
+        return result;
+    }
+
+    private String getFormatName(BinaryPartAbstractImage imagePart) {
+        String contentType = imagePart.getContentType();
+        String formatName = contentType.contains("png") ? "png" : (contentType.contains("jpeg") ? "jpeg" : (contentType.contains("gif") ? "gif" : (contentType.contains("bmp") ? "bmp" : "png")));
+        return formatName;
+    }
+
+    public BufferedImage cropImage(BufferedImage originalImage, int srcRectL, int srcRectT, int srcRectR, int srcRectB) {
+        double leftRatio = srcRectL < 0 ? 0.0 : (double)srcRectL / 100000.0;
+        double topRatio = srcRectT < 0 ? 0.0 : (double)srcRectT / 100000.0;
+        double rightRatio = srcRectR < 0 ? 0.0 : (double)srcRectR / 100000.0;
+        double bottomRatio = srcRectB < 0 ? 0.0 : (double)srcRectB / 100000.0;
+        int originalWidth = originalImage.getWidth();
+        int originalHeight = originalImage.getHeight();
+        int left = (int)Math.floor(leftRatio * (double)originalWidth);
+        int top = (int)Math.floor(topRatio * (double)originalHeight);
+        int right = (int)Math.floor(rightRatio * (double)originalWidth);
+        int bottom = (int)Math.floor(bottomRatio * (double)originalHeight);
+        int cropWidth = Math.max(1, originalWidth - left - right);
+        int cropHeight = Math.max(1, originalHeight - top - bottom);
+        if (left < 0 || top < 0 || left + cropWidth > originalWidth || top + cropHeight > originalHeight) {
+            log.error("\u88c1\u526a\u533a\u57df\u65e0\u6548\u6216\u8d85\u51fa\u56fe\u7247\u8fb9\u754c");
+        }
+        return originalImage.getSubimage(left, top, cropWidth, cropHeight);
+    }
+
+    private BufferedImage rotateImage(BufferedImage originalImage, long rotation, long currentCx, Map<String, Object> result) {
+        int origWidth = originalImage.getWidth();
+        int origHeight = originalImage.getHeight();
+        if (origWidth <= 0 || origHeight <= 0) {
+            log.error("\u56fe\u7247\u533a\u57df\u65e0\u6548");
+        }
+        double emuPerPx = (double)currentCx / (double)origWidth;
+        if (currentCx == 0L) {
+            emuPerPx = 9525.0;
+        }
+        double degrees = (double)rotation / 60000.0;
+        double radians = Math.toRadians(degrees);
+        double sin = Math.abs(Math.sin(radians));
+        double cos = Math.abs(Math.cos(radians));
+        double TOLERANCE = 1.0E-10;
+        if (sin < 1.0E-10) {
+            sin = 0.0;
+        }
+        if (cos < 1.0E-10) {
+            cos = 0.0;
+        }
+        int newWidth = (int)Math.ceil((double)origWidth * cos + (double)origHeight * sin);
+        int newHeight = (int)Math.ceil((double)origWidth * sin + (double)origHeight * cos);
+        newWidth = Math.max(1, newWidth);
+        newHeight = Math.max(1, newHeight);
+        int superSampleFactor = 4;
+        int ssWidth = origWidth * superSampleFactor;
+        int ssHeight = origHeight * superSampleFactor;
+        int ssNewW = newWidth * superSampleFactor;
+        int ssNewH = newHeight * superSampleFactor;
+        int imgType1 = originalImage.getType() == 0 ? 2 : originalImage.getType();
+        BufferedImage highResOriginal = new BufferedImage(ssWidth, ssHeight, imgType1);
+        Graphics2D g2dHighRes = highResOriginal.createGraphics();
+        this.configureGraphics2D(g2dHighRes);
+        g2dHighRes.drawImage(originalImage, 0, 0, ssWidth, ssHeight, null);
+        g2dHighRes.dispose();
+        int imgType2 = highResOriginal.getType() == 0 ? 2 : highResOriginal.getType();
+        BufferedImage rotatedSuperSample = new BufferedImage(ssNewW, ssNewH, imgType2);
+        Graphics2D g2dRotated = rotatedSuperSample.createGraphics();
+        if (highResOriginal.getType() == 2) {
+            g2dRotated.setComposite(AlphaComposite.Clear);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+            g2dRotated.setComposite(AlphaComposite.SrcOver);
+        } else {
+            g2dRotated.setColor(Color.WHITE);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+        }
+        g2dRotated.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g2dRotated.translate((double)ssNewW / 2.0, (double)ssNewH / 2.0);
+        g2dRotated.rotate(radians);
+        g2dRotated.drawImage((Image)highResOriginal, -ssWidth / 2, -ssHeight / 2, null);
+        g2dRotated.dispose();
+        BufferedImage rotatedImage = new BufferedImage(newWidth, newHeight, rotatedSuperSample.getType() == 0 ? 2 : rotatedSuperSample.getType());
+        Graphics2D g2dFinal = rotatedImage.createGraphics();
+        this.configureGraphics2D(g2dFinal);
+        g2dFinal.drawImage(rotatedSuperSample, 0, 0, newWidth, newHeight, null);
+        g2dFinal.dispose();
+        long newCx = Math.round((double)newWidth * emuPerPx);
+        long newCy = Math.round((double)newHeight * emuPerPx);
+        double newWidthPx = Math.round((double)newCx / 9525.0);
+        double newHeightPx = Math.round((double)newCy / 9525.0);
+        result.put(AttrEnum.WIDTH.getAttr(), newWidthPx);
+        result.put(AttrEnum.HEIGHT.getAttr(), newHeightPx);
+        return rotatedImage;
+    }
+
+    private void configureGraphics2D(Graphics2D g2d) {
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+    }
+
+    private int parseVmlCrop(String vmlCrop) {
+        if (vmlCrop == null || StringUtils.isBlank((CharSequence)vmlCrop)) {
+            return 0;
+        }
+        String clean = vmlCrop.trim().replaceAll("[fF]$", "");
+        try {
+            int value = Integer.parseInt(clean);
+            return (int)Math.round((double)value * 1.52587890625);
+        }
+        catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+}
+
diff --git a/java-svc-jdk8/pom.xml b/java-svc-jdk8/pom.xml
new file mode 100644
index 0000000..4f38621
--- /dev/null
+++ b/java-svc-jdk8/pom.xml
@@ -0,0 +1,102 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.wordparse</groupId>
+    <artifactId>word-file-parse-jdk8</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    <name>WordFileParse JDK8</name>
+
+    <properties>
+        <java.version>1.8</java.version>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <!-- Docx4J 3.3.7 (matches jby) -->
+        <dependency>
+            <groupId>org.docx4j</groupId>
+            <artifactId>docx4j</artifactId>
+            <version>3.3.7</version>
+        </dependency>
+
+        <!-- Jsoup -->
+        <dependency>
+            <groupId>org.jsoup</groupId>
+            <artifactId>jsoup</artifactId>
+            <version>1.17.2</version>
+        </dependency>
+
+        <!-- Apache Commons -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.14.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.4</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.16.1</version>
+        </dependency>
+
+        <!-- FastJSON -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>2.0.51</version>
+        </dependency>
+    </dependencies>
+
+    <repositories>
+        <repository>
+            <id>aliyun</id>
+            <url>https://maven.aliyun.com/repository/public</url>
+        </repository>
+    </repositories>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.3.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.wordparse.core.WordParseUtil</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+            <!-- Shade plugin for fat JAR -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.5.2</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals><goal>shade</goal></goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/AttrEnum.java b/java-svc-jdk8/src/main/java/com/wordparse/core/AttrEnum.java
new file mode 100644
index 0000000..d6e8a2a
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/AttrEnum.java
@@ -0,0 +1,79 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.wordparse.core;
+
+public enum AttrEnum {
+    STYLE("style"),
+    COLOR("color"),
+    BACKGROUND_COLOR("background-color"),
+    BACKGROUND("background"),
+    FONT_WEIGHT("font-weight"),
+    FONT_SIZE("font-size"),
+    MIN_HEIGHT("min-height"),
+    LINE_HEIGHT("line-height"),
+    TEXT_ALIGN("text-align"),
+    PADDING("padding"),
+    PADDING_TOP("padding-top"),
+    PADDING_RIGHT("padding-right"),
+    PADDING_BOTTOM("padding-bottom"),
+    PADDING_LEFT("padding-left"),
+    TEXT_INDENT("text-indent"),
+    MARGIN("margin"),
+    MARGIN_TOP("margin-top"),
+    MARGIN_RIGHT("margin-right"),
+    MARGIN_BOTTOM("margin-bottom"),
+    MARGIN_LEFT("margin-left"),
+    VERTICAL_ALIGN("vertical-align"),
+    FONT_FAMILY("font-family"),
+    FONT_STYLE("font-style"),
+    FACE("face"),
+    SIZE("size"),
+    HREF("href"),
+    SRC("src"),
+    WIDTH("width"),
+    HEIGHT("height"),
+    CLASS("class"),
+    BORDER_STYLE("border-style"),
+    COLSPAN("colspan"),
+    ROWSPAN("rowspan"),
+    TEXT_DECORATION("text-decoration"),
+    BACKGROUND_IMAGE("background-image"),
+    TINYMCE_HORIZONTAL_LINE("tinymce-horizontal-line"),
+    TINYMCE_LINE_NUMBER("tinymce-line-number"),
+    TEXT_EMPHASIS_POSITION("text-emphasis-position"),
+    DATA_TYPE("data-type"),
+    SEGMENT("segment"),
+    BUSINESS("business"),
+    LIST_STYLE_TYPE("list-style-type"),
+    ALT("alt"),
+    NAME("name"),
+    DATA_HREF("data-href"),
+    DATA_File_SUFFIX("data-file-suffix"),
+    TINYMCE_LINK("tinymce-link"),
+    DATA_RESOURCE_URL("data-resource-url"),
+    DATA_COURSE_NETWORK_LESSON_RESOURCE_NAME("data-course-network-lesson-resource-name"),
+    TINYMCE_HOLLOWOUT("tinymce-hollowOut"),
+    TINYMCE_HIDDENONLY("tinymce-hiddenOnly"),
+    TINYMCE_HIDDENANDANSWER("tinymce-hiddenAndAnswer"),
+    BORDER("border"),
+    BORDER_LEFT("border-left"),
+    BORDER_BOTTOM("border-bottom"),
+    BORDER_RIGHT("border-right"),
+    BORDER_TOP("border-top"),
+    BORDER_LEFT_COLOR("border-left-color"),
+    BORDER_BOTTOM_COLOR("border-bottom-color"),
+    BORDER_RIGHT_COLOR("border-right-color"),
+    BORDER_TOP_COLOR("border-top-color");
+
+    private final String attr;
+
+    public String getAttr() {
+        return this.attr;
+    }
+
+    private AttrEnum(String attr) {
+        this.attr = attr;
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/CtObjectFinder.java b/java-svc-jdk8/src/main/java/com/wordparse/core/CtObjectFinder.java
new file mode 100644
index 0000000..5fdb071
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/CtObjectFinder.java
@@ -0,0 +1,46 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import java.util.List;
+import java.util.Objects;
+import org.docx4j.TraversalUtil;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+
+public class CtObjectFinder
+extends TraversalUtil.CallbackImpl {
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+
+    public CtObjectFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof CTOLEObject) {
+            CTOLEObject ctoleObject = (CTOLEObject)o;
+            RelationshipsPart rsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            if (Objects.nonNull(ctoleObject.getId())) {
+                Part part = rsPart.getPart(ctoleObject.getId());
+                String binFilePath = part.getPartName().getURI().getPath();
+                String placeholder = this.parseBO.getMathTypePlaceholder(ctoleObject.getId());
+                this.parseBO.getMathTypeMap().put(placeholder, this.parseBO.getTempDir() + "/temp" + binFilePath);
+            }
+        }
+        return null;
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/CtTextBoxFinder.java b/java-svc-jdk8/src/main/java/com/wordparse/core/CtTextBoxFinder.java
new file mode 100644
index 0000000..9686376
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/CtTextBoxFinder.java
@@ -0,0 +1,121 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TextUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.mce.AlternateContent
+ *  org.docx4j.mce.AlternateContent$Fallback
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.vml.CTGroup
+ *  org.docx4j.vml.CTRoundRect
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.CTTextbox
+ *  org.docx4j.vml.VmlShapeElements
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import java.util.List;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.mce.AlternateContent;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.vml.CTGroup;
+import org.docx4j.vml.CTRoundRect;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.CTTextbox;
+import org.docx4j.vml.VmlShapeElements;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CtTextBoxFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtTextBoxFinder.class);
+    private WordprocessingMLPackage wordMlPackage;
+    private ParseBO parseBO;
+
+    public CtTextBoxFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof Pict) {
+            boolean isFirstRun = true;
+            ObjectFactory factory = new ObjectFactory();
+            StringBuilder stringBuilder = new StringBuilder();
+            R sourceR = factory.createR();
+            Pict pict = (Pict)o;
+            List anyAndAny = pict.getAnyAndAny();
+            for (Object object : anyAndAny) {
+                if (!(object instanceof JAXBElement)) continue;
+                JAXBElement jbe = (JAXBElement)object;
+                this.findTextBox(jbe.getValue(), stringBuilder, isFirstRun, sourceR);
+            }
+            if (StringUtils.isNotBlank((CharSequence)stringBuilder.toString())) {
+                AlternateContent.Fallback fallback = (AlternateContent.Fallback)pict.getParent();
+                AlternateContent alternateContent = (AlternateContent)fallback.getParent();
+                R r = (R)alternateContent.getParent();
+                Text text = factory.createText();
+                text.setValue(stringBuilder + "JBY_TEXTBOX_JBY");
+                r.getContent().set(0, text);
+                r.setRPr(sourceR.getRPr());
+            }
+        }
+        return null;
+    }
+
+    private void findTextBox(Object object, StringBuilder sb, boolean isFirstRun, R sourceR) {
+        block8: {
+            List egShapeElements;
+            if (object instanceof CTShape || object instanceof CTRoundRect) {
+                VmlShapeElements vmlShapeElements = (VmlShapeElements)object;
+                egShapeElements = vmlShapeElements.getEGShapeElements();
+                for (JAXBElement egShapeElement : egShapeElements) {
+                    if (!(egShapeElement.getValue() instanceof CTTextbox)) continue;
+                    CTTextbox ctTextbox = (CTTextbox)egShapeElement.getValue();
+                    CTTxbxContent txbxContent = ctTextbox.getTxbxContent();
+                    for (int i = 0; i < txbxContent.getContent().size(); ++i) {
+                        Object obj = txbxContent.getContent().get(i);
+                        String text = TextUtils.getText(obj);
+                        if (txbxContent.getContent().size() > 1 && i != txbxContent.getContent().size() - 1) {
+                            text = text + "JBY_TEXTBOX_JBYBR";
+                        }
+                        sb.append(text);
+                    }
+                }
+            }
+            if (!(object instanceof CTGroup)) break block8;
+            CTGroup ctGroup = (CTGroup)object;
+            egShapeElements = ctGroup.getEGShapeElements();
+            boolean isCtShape = egShapeElements.stream().anyMatch(f -> f.getValue() instanceof CTShape);
+            if (isCtShape) {
+                for (int i = egShapeElements.size() - 1; i >= 0; --i) {
+                    this.findTextBox(((JAXBElement)egShapeElements.get(i)).getValue(), sb, isFirstRun, sourceR);
+                }
+            } else {
+                for (JAXBElement egShapeElement : egShapeElements) {
+                    this.findTextBox(egShapeElement.getValue(), sb, isFirstRun, sourceR);
+                }
+            }
+        }
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/CtoMathFinder.java b/java-svc-jdk8/src/main/java/com/wordparse/core/CtoMathFinder.java
new file mode 100644
index 0000000..4c7b836
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/CtoMathFinder.java
@@ -0,0 +1,427 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.XmlUtils
+ *  org.docx4j.com.microsoft.schemas.office.word.x2010.wordprocessingShape.CTTextboxInfo
+ *  org.docx4j.math.CTOMath
+ *  org.docx4j.math.CTOMathPara
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.CTVerticalAlignRun
+ *  org.docx4j.wml.FldChar
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.P
+ *  org.docx4j.wml.PPr
+ *  org.docx4j.wml.PPrBase$NumPr
+ *  org.docx4j.wml.PPrBase$NumPr$Ilvl
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.RPrAbstract
+ *  org.docx4j.wml.STFldCharType
+ *  org.docx4j.wml.Style
+ *  org.docx4j.wml.Text
+ *  org.docx4j.wml.U
+ *  org.docx4j.wml.UnderlineEnumeration
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import com.wordparse.core.EqToLatexUtil;
+import com.wordparse.core.NumPr;
+import com.wordparse.core.WordParseUtil;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.com.microsoft.schemas.office.word.x2010.wordprocessingShape.CTTextboxInfo;
+import org.docx4j.math.CTOMath;
+import org.docx4j.math.CTOMathPara;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.CTVerticalAlignRun;
+import org.docx4j.wml.FldChar;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.P;
+import org.docx4j.wml.PPr;
+import org.docx4j.wml.PPrBase;
+import org.docx4j.wml.R;
+import org.docx4j.wml.RPrAbstract;
+import org.docx4j.wml.STFldCharType;
+import org.docx4j.wml.Style;
+import org.docx4j.wml.Text;
+import org.docx4j.wml.U;
+import org.docx4j.wml.UnderlineEnumeration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CtoMathFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtoMathFinder.class);
+    private ParseBO parseBO;
+    private static final Pattern CIRCLED_NUMBER_PATTERN = Pattern.compile("^\\s*eq\\s*\\\\o\\((?:\u25cb,\\\\s\\\\up\\d+\\((\\d+)\\)|\\\\s\\\\up\\d+\\((\\d+)\\),\u25cb)\\)");
+
+    public CtoMathFinder(ParseBO parseBO) {
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof P) {
+            Text text;
+            Style style;
+            CTTxbxContent ctTxbxContent;
+            StringBuilder eqCode = new StringBuilder();
+            StringBuilder originEqCode = new StringBuilder();
+            boolean inFiled = false;
+            boolean isEq = false;
+            boolean superScriptFlag = false;
+            boolean subScriptFlag = false;
+            ArrayList<Integer> fieldRunIndexs = new ArrayList<Integer>();
+            P paragraph = (P)o;
+            ObjectFactory factory = new ObjectFactory();
+            boolean isNumPr = true;
+            if (paragraph.getParent() instanceof CTTxbxContent && (ctTxbxContent = (CTTxbxContent)paragraph.getParent()).getParent() instanceof CTTextboxInfo) {
+                isNumPr = false;
+            }
+            PPr pPr = paragraph.getPPr();
+            PPrBase.NumPr numPr = null;
+            if (Objects.nonNull(pPr)) {
+                numPr = pPr.getNumPr();
+            }
+            if (Objects.isNull(numPr) && Objects.nonNull(pPr) && Objects.nonNull(pPr.getPStyle()) && Objects.nonNull(style = this.parseBO.getStyleDefinitionsPart().getStyleById(pPr.getPStyle().getVal())) && Objects.nonNull(style.getPPr()) && Objects.nonNull(style.getPPr().getNumPr()) && Objects.isNull((numPr = style.getPPr().getNumPr()).getIlvl())) {
+                PPrBase.NumPr.Ilvl ilvl = new PPrBase.NumPr.Ilvl();
+                ilvl.setVal(BigInteger.ZERO);
+                numPr.setIlvl(ilvl);
+            }
+            if (isNumPr && Objects.nonNull(numPr) && Objects.nonNull(numPr.getNumId()) && Objects.nonNull(numPr.getIlvl())) {
+                String numPrKey = numPr.getNumId().getVal() + "_" + numPr.getIlvl().getVal();
+                Map<String, NumPr> numberingDefinitionsMap = this.parseBO.getNumberingDefinitionsMap();
+                if (numberingDefinitionsMap.containsKey(numPrKey)) {
+                    NumPr currentNumPr = numberingDefinitionsMap.get(numPrKey);
+                    String lvlText = currentNumPr.getLvlText();
+                    for (int i = 0; i <= numPr.getIlvl().getVal().intValue(); ++i) {
+                        NumPr numPrDefine;
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            currentNumPr.setCurrent(currentNumPr.getCurrent().add(BigInteger.ONE));
+                        }
+                        String rep = String.valueOf((numPrDefine = numberingDefinitionsMap.get(numPr.getNumId().getVal() + "_" + i)).getCurrent().compareTo(BigInteger.ZERO) == 0 ? numPrDefine.getStart() : numPrDefine.getCurrent());
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            switch (currentNumPr.getNumFmt()) {
+                                case "UPPER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep);
+                                    break;
+                                }
+                                case "DECIMAL_ZERO": {
+                                    rep = CtoMathFinder.strToDecimalZero(rep);
+                                    break;
+                                }
+                                case "LOWER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep);
+                                    break;
+                                }
+                                case "UPPER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep).toUpperCase();
+                                    break;
+                                }
+                                case "LOWER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep).toLowerCase();
+                                    break;
+                                }
+                                case "CHINESE_COUNTING": 
+                                case "CHINESE_COUNTING_THOUSAND": {
+                                    rep = this.strToChineseCounting(rep);
+                                    break;
+                                }
+                            }
+                        }
+                        lvlText = lvlText.replace("%" + (i + 1), rep);
+                    }
+                    if (StringUtils.isNotBlank((CharSequence)lvlText)) {
+                        R run = factory.createR();
+                        text = factory.createText();
+                        text.setValue(lvlText + "  ");
+                        run.getContent().add(text);
+                        paragraph.getContent().add(0, run);
+                    }
+                }
+            }
+            for (int i = 0; i < paragraph.getContent().size(); ++i) {
+                JAXBElement jaxbElement;
+                Object content = paragraph.getContent().get(i);
+                if (content instanceof JAXBElement && ((jaxbElement = (JAXBElement)content).getValue() instanceof CTOMath || jaxbElement.getValue() instanceof CTOMathPara)) {
+                    String placeholder = "";
+                    if (Boolean.TRUE.equals(this.parseBO.getNewParseVersion())) {
+                        String omml = XmlUtils.marshaltoString((Object)jaxbElement);
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, omml);
+                    } else {
+                        String mathMl = WordParseUtil.getMathMl(jaxbElement, this.parseBO.getTransformer());
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, mathMl);
+                    }
+                    R run = factory.createR();
+                    text = factory.createText();
+                    text.setValue(placeholder);
+                    run.getContent().add(text);
+                    paragraph.getContent().set(i, run);
+                }
+                if (!(content instanceof R)) continue;
+                R run = (R)content;
+                for (int j = 0; j < run.getContent().size(); ++j) {
+                    Object runC = run.getContent().get(j);
+                    if (!(runC instanceof JAXBElement)) continue;
+                    JAXBElement runCj = (JAXBElement)runC;
+                    if (runCj.getValue() instanceof FldChar) {
+                        FldChar fldChar = (FldChar)runCj.getValue();
+                        if (fldChar.getFldCharType().equals((Object)STFldCharType.BEGIN)) {
+                            eqCode = new StringBuilder();
+                            originEqCode = new StringBuilder();
+                            inFiled = true;
+                            isEq = false;
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                            fieldRunIndexs = new ArrayList();
+                            fieldRunIndexs.add(i);
+                            continue;
+                        }
+                        if (inFiled && fldChar.getFldCharType().equals((Object)STFldCharType.END)) {
+                            if (isEq) {
+                                String placeholder;
+                                Matcher matcher = CIRCLED_NUMBER_PATTERN.matcher(originEqCode);
+                                if (matcher.matches()) {
+                                    String numStr = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
+                                    placeholder = this.parseBO.getEqLatexPlaceholder() + "JBYEQNUM";
+                                    this.parseBO.getEqLatexMap().put(placeholder, CtoMathFinder.getCircledNumber(numStr));
+                                    R runN = factory.createR();
+                                    Text text2 = factory.createText();
+                                    text2.setValue(placeholder);
+                                    runN.getContent().add(text2);
+                                    paragraph.getContent().set(i, runN);
+                                } else if (StringUtils.isNotBlank((CharSequence)eqCode.toString())) {
+                                    String latex = EqToLatexUtil.convert(eqCode.toString());
+                                    latex = latex.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+                                    placeholder = this.parseBO.getEqLatexPlaceholder();
+                                    this.parseBO.getEqLatexMap().put(placeholder, latex);
+                                    R runN = factory.createR();
+                                    Text text3 = factory.createText();
+                                    text3.setValue(placeholder);
+                                    runN.getContent().add(text3);
+                                    paragraph.getContent().set(i, runN);
+                                }
+                            }
+                            inFiled = false;
+                            isEq = false;
+                            fieldRunIndexs.clear();
+                            continue;
+                        }
+                        if (inFiled && isEq && !fldChar.getFldCharType().value().equals("separate")) continue;
+                    }
+                    if (!inFiled || !(runCj.getValue() instanceof Text)) continue;
+                    CTVerticalAlignRun vertAlign = Optional.ofNullable(run.getRPr()).map(RPrAbstract::getVertAlign).orElse(null);
+                    String value = ((Text)runCj.getValue()).getValue();
+                    originEqCode.append(value);
+                    U u = Optional.ofNullable(run.getRPr()).filter(f -> Objects.nonNull(f.getU()) && !UnderlineEnumeration.NONE.equals((Object)f.getU().getVal()) && Objects.nonNull(f.getU().getVal())).map(RPrAbstract::getU).orElse(null);
+                    if (StringUtils.isBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = value.replace("\u3000", "JBYU1JBYU").replace(" ", "JBYU1JBYU");
+                    } else if (StringUtils.isNotBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = "JBYU2BEGIN" + value + "JBYU2END";
+                    } else if (StringUtils.isBlank((CharSequence)value)) {
+                        // empty if block
+                    }
+                    String trimmedOrigin = CtoMathFinder.extractEqPrefix(originEqCode);
+                    if (trimmedOrigin.startsWith("eq")) {
+                        isEq = true;
+                    }
+                    if (isEq) {
+                        if (CollectionUtils.isNotEmpty(fieldRunIndexs)) {
+                            fieldRunIndexs.forEach(m -> paragraph.getContent().set((int)m, factory.createR()));
+                            fieldRunIndexs.clear();
+                        }
+                        if (Objects.nonNull(vertAlign)) {
+                            String newContent;
+                            String tmp;
+                            if ("superscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (superScriptFlag && (start = eqCode.lastIndexOf("\\s\\up4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\up4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\up4(" + value + ")";
+                                }
+                                superScriptFlag = true;
+                                subScriptFlag = false;
+                            } else if ("subscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (subScriptFlag && (start = eqCode.lastIndexOf("\\s\\do4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\do4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\do4(" + value + ")";
+                                }
+                                subScriptFlag = true;
+                                superScriptFlag = false;
+                            } else {
+                                superScriptFlag = false;
+                                subScriptFlag = false;
+                            }
+                        } else {
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                        }
+                        eqCode.append(value);
+                        paragraph.getContent().set(i, factory.createR());
+                        continue;
+                    }
+                    if (trimmedOrigin.length() < 2 || "eq".startsWith(trimmedOrigin)) {
+                        eqCode.append(value);
+                        fieldRunIndexs.add(i);
+                        continue;
+                    }
+                    inFiled = false;
+                    fieldRunIndexs.clear();
+                }
+            }
+        }
+        return null;
+    }
+
+    private String strToUpperRoman(String str) {
+        int num = Integer.parseInt(str);
+        if (num < 1 || num > 3999) {
+            return "I";
+        }
+        int[] values = new int[]{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        String[] symbols = new String[]{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+        StringBuilder roman = new StringBuilder();
+        for (int i = 0; i < values.length; ++i) {
+            while (num >= values[i]) {
+                roman.append(symbols[i]);
+                num -= values[i];
+            }
+        }
+        return roman.toString();
+    }
+
+    private static String strToDecimalZero(String str) {
+        if (str.length() == 1) {
+            return "0" + str;
+        }
+        return str;
+    }
+
+    private static String strToLowerLetter(String str) {
+        int n = Integer.parseInt(str);
+        int length = (n - 1) / 26 + 1;
+        char baseChar = (char)(97 + (n - 1) % 26);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; ++i) {
+            sb.append(baseChar);
+        }
+        return sb.toString();
+    }
+
+    public String strToChineseCounting(String str) {
+        String s;
+        int num = Integer.parseInt(str);
+        if (num < 0 || num >= 1000000000) {
+            throw new IllegalArgumentException("\u4ec5\u652f\u6301 0 \u5230 999,999,999");
+        }
+        if (num == 0) {
+            return "\u3007";
+        }
+        char[] digits = new char[]{'\u3007', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d'};
+        String[] units = new String[]{"", "\u5341", "\u767e", "\u5343"};
+        String[] bigUnits = new String[]{"", "\u4e07", "\u4ebf"};
+        StringBuilder result = new StringBuilder();
+        int yi = num / 100000000;
+        int wan = num / 10000 % 10000;
+        int ge = num % 10000;
+        if (yi > 0) {
+            result.append(CtoMathFinder.convertSegment(yi, digits, units)).append(bigUnits[2]);
+            if (wan == 0 && ge > 0) {
+                result.append('\u3007');
+            }
+        }
+        if (wan > 0) {
+            result.append(CtoMathFinder.convertSegment(wan, digits, units)).append(bigUnits[1]);
+            if (ge > 0 && ge < 1000) {
+                result.append('\u3007');
+            }
+        }
+        if (ge > 0) {
+            result.append(CtoMathFinder.convertSegment(ge, digits, units));
+        }
+        if ((s = result.toString()).startsWith("\u4e00\u5341")) {
+            s = s.substring(1);
+        }
+        return s;
+    }
+
+    private static String convertSegment(int n, char[] digits, String[] units) {
+        if (n == 0) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 4; ++i) {
+            int power = 3 - i;
+            int base = (int)Math.pow(10.0, power);
+            int digit = n / base % 10;
+            if (digit != 0) {
+                sb.append(digits[digit]).append(units[power]);
+                continue;
+            }
+            if (sb.length() <= 0 || n % base == 0 || power <= 0) continue;
+            sb.append('\u3007');
+        }
+        return sb.toString();
+    }
+
+    private static String getCircledNumber(String num) {
+        int n = Integer.parseInt(num);
+        if (n >= 1 && n <= 20) {
+            return String.valueOf((char)(9312 + n - 1));
+        }
+        if (n >= 21 && n <= 35) {
+            return String.valueOf((char)(12881 + n - 21));
+        }
+        if (n >= 36 && n <= 40) {
+            return String.valueOf((char)(12977 + n - 36));
+        }
+        if (n >= 41 && n <= 50) {
+            return String.valueOf((char)(12982 + n - 41));
+        }
+        log.info("\u83b7\u53d6\u5e26\u5708\u5b57\u7b26\u5931\u8d25 {}", (Object)num);
+        return "";
+    }
+
+    private static String extractEqPrefix(StringBuilder originEqCode) {
+        int i;
+        String s = originEqCode.toString().trim();
+        for (i = 0; i < s.length() && s.charAt(i) == '{'; ++i) {
+        }
+        return s.substring(i).trim().toLowerCase();
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/DrawingPictFinder.java b/java-svc-jdk8/src/main/java/com/wordparse/core/DrawingPictFinder.java
new file mode 100644
index 0000000..0a0668a
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/DrawingPictFinder.java
@@ -0,0 +1,434 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.excel.util.StringUtils
+ *  com.wordparse.core.UniqueUtil
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.dml.GraphicData
+ *  org.docx4j.dml.picture.Pic
+ *  org.docx4j.dml.wordprocessingDrawing.Anchor
+ *  org.docx4j.dml.wordprocessingDrawing.Inline
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.CTImageData
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ *  org.docx4j.wml.CTObject
+ *  org.docx4j.wml.Drawing
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import com.alibaba.excel.util.StringUtils;
+import com.wordparse.core.UniqueUtil;
+import com.wordparse.core.ImageBO;
+import com.wordparse.core.ParseBO;
+import com.wordparse.core.AttrEnum;
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.imageio.ImageIO;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.dml.GraphicData;
+import org.docx4j.dml.picture.Pic;
+import org.docx4j.dml.wordprocessingDrawing.Anchor;
+import org.docx4j.dml.wordprocessingDrawing.Inline;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.CTImageData;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+import org.docx4j.wml.CTObject;
+import org.docx4j.wml.Drawing;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DrawingPictFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(DrawingPictFinder.class);
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+    private static final double CROP_SCALE = 1.52587890625;
+
+    public DrawingPictFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        List contentList;
+        List anyAndAny;
+        R r;
+        if (o instanceof Drawing && ((Drawing)o).getParent() instanceof R) {
+            RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            Drawing drawing = (Drawing)o;
+            List anchorOrInline = drawing.getAnchorOrInline();
+            if (CollectionUtils.isNotEmpty((Collection)anchorOrInline)) {
+                Object anchorOrInlineObj = anchorOrInline.get(0);
+                GraphicData graphicData = null;
+                long cx = 0L;
+                long cy = 0L;
+                if (anchorOrInlineObj instanceof Inline) {
+                    Inline inline = (Inline)anchorOrInlineObj;
+                    graphicData = inline.getGraphic().getGraphicData();
+                    cx = inline.getExtent().getCx();
+                    cy = inline.getExtent().getCy();
+                } else if (anchorOrInlineObj instanceof Anchor) {
+                    Anchor anchor = (Anchor)anchorOrInlineObj;
+                    graphicData = anchor.getGraphic().getGraphicData();
+                    cx = anchor.getExtent().getCx();
+                    cy = anchor.getExtent().getCy();
+                }
+                if (Objects.nonNull(graphicData) && "http://schemas.openxmlformats.org/drawingml/2006/picture".equals(graphicData.getUri())) {
+                    for (Object object : graphicData.getAny()) {
+                        String path;
+                        JAXBElement jaxbElement;
+                        if (!(object instanceof JAXBElement) || !((jaxbElement = (JAXBElement)object).getValue() instanceof Pic)) continue;
+                        Pic pic = (Pic)jaxbElement.getValue();
+                        String imageDataId = null;
+                        int cropLeft = 0;
+                        int cropTop = 0;
+                        int cropRight = 0;
+                        int cropBottom = 0;
+                        int rotation = 0;
+                        if (Objects.nonNull(pic.getBlipFill())) {
+                            if (Objects.nonNull(pic.getBlipFill().getBlip())) {
+                                imageDataId = pic.getBlipFill().getBlip().getEmbed();
+                            }
+                            if (Objects.nonNull(pic.getBlipFill().getSrcRect())) {
+                                cropLeft = pic.getBlipFill().getSrcRect().getL();
+                                cropTop = pic.getBlipFill().getSrcRect().getT();
+                                cropRight = pic.getBlipFill().getSrcRect().getR();
+                                cropBottom = pic.getBlipFill().getSrcRect().getB();
+                            }
+                            if (Objects.nonNull(pic.getSpPr()) && Objects.nonNull(pic.getSpPr().getXfrm())) {
+                                rotation = pic.getSpPr().getXfrm().getRot();
+                            }
+                        }
+                        Map<String, Object> map = this.dealCropRotate(imageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                        Object widthObj = map.get(AttrEnum.WIDTH.getAttr());
+                        Object heightObj = map.get(AttrEnum.HEIGHT.getAttr());
+                        Object pathObj = map.get("imagePath");
+                        double width = Objects.nonNull(widthObj) ? Double.parseDouble(widthObj.toString()) : (double)Math.round((double)cx / 9525.0);
+                        double height = Objects.nonNull(heightObj) ? Double.parseDouble(heightObj.toString()) : (double)Math.round((double)cy / 9525.0);
+                        Part part = relationshipsPart.getPart(imageDataId);
+                        if (Objects.nonNull(pathObj)) {
+                            path = String.valueOf(pathObj);
+                        } else if (Objects.nonNull(part)) {
+                            path = part.getPartName().getURI().getPath();
+                        } else {
+                            log.warn("\u65e0\u6cd5\u83b7\u53d6\u56fe\u7247Part\uff0cimageDataId={}", (Object)imageDataId);
+                            continue;
+                        }
+                        String imagePlaceholder = this.parseBO.getImagePlaceholder(imageDataId);
+                        ImageBO imageBO = new ImageBO().setWidth(width).setHeight(height).setPictureUrl(path);
+                        this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                        R r2 = (R)drawing.getParent();
+                        List contentList2 = r2.getContent();
+                        int drawingIndex = contentList2.indexOf(drawing);
+                        if (drawingIndex != -1) {
+                            Text text = new ObjectFactory().createText();
+                            text.setValue(imagePlaceholder);
+                            contentList2.set(drawingIndex, text);
+                            continue;
+                        }
+                        log.warn("\u672a\u627e\u5230drawing\u5bf9\u8c61\u5728\u7236\u5143\u7d20\u4e2d\u7684\u7d22\u5f15\uff0c\u8df3\u8fc7\u66ff\u6362\u64cd\u4f5c");
+                    }
+                }
+            }
+        }
+        if (o instanceof Pict && ((Pict)o).getParent() instanceof R) {
+            Pict pict = (Pict)o;
+            r = (R)pict.getParent();
+            anyAndAny = pict.getAnyAndAny();
+            contentList = r.getContent();
+            int pictIndex = contentList.indexOf(pict);
+            if (pictIndex != -1) {
+                this.dealCtShape(anyAndAny, r, pictIndex);
+            }
+        }
+        if (o instanceof CTObject && ((CTObject)o).getParent() instanceof R) {
+            CTObject ctObject = (CTObject)o;
+            r = (R)ctObject.getParent();
+            anyAndAny = ctObject.getAnyAndAny();
+            contentList = r.getContent();
+            int ctObjectIndex = contentList.indexOf(ctObject);
+            if (ctObjectIndex != -1) {
+                this.dealCtShape(anyAndAny, r, ctObjectIndex);
+            }
+        }
+        return null;
+    }
+
+    private String extractValue(String style, String property) {
+        if (style == null || property == null) {
+            return null;
+        }
+        String regex = "\\b" + Pattern.quote(property) + "\\s*:\\s*([\\d.]+[a-zA-Z]*)";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+
+    private void dealCtShape(List<Object> anyAndAny, R r, int pictIndex) {
+        String ctOleObjectRid = anyAndAny.stream().filter(f -> f instanceof JAXBElement && ((JAXBElement)f).getValue() instanceof CTOLEObject).map(f -> ((CTOLEObject)((JAXBElement)f).getValue()).getId()).filter(Objects::nonNull).findFirst().orElse(null);
+        if (Objects.nonNull(ctOleObjectRid) && Objects.nonNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            Text text = new ObjectFactory().createText();
+            text.setValue(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            r.getContent().set(pictIndex, text);
+        } else if (Objects.isNull(ctOleObjectRid) || Objects.isNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            if (Objects.nonNull(ctOleObjectRid)) {
+                this.parseBO.getMathTypeMap().remove(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            }
+            for (Object object : anyAndAny) {
+                String path;
+                double heightPx;
+                double widthPx;
+                if (!(object instanceof JAXBElement) || !(((JAXBElement)object).getValue() instanceof CTShape)) continue;
+                CTShape ctShape = (CTShape)((JAXBElement)object).getValue();
+                String width = this.extractValue(ctShape.getStyle(), "width");
+                String height = this.extractValue(ctShape.getStyle(), "height");
+                CTImageData ctImageData = ctShape.getEGShapeElements().stream().filter(f -> f.getValue() instanceof CTImageData).map(m -> (CTImageData)m.getValue()).findFirst().orElse(null);
+                if (!Objects.nonNull(ctImageData) || !StringUtils.isNotBlank((CharSequence)width) || !StringUtils.isNotBlank((CharSequence)height)) continue;
+                String ctImageDataId = ctImageData.getId();
+                long cx = 0L;
+                try {
+                    double widthPtIn = Double.parseDouble(width.substring(0, width.length() - 2));
+                    if (width.endsWith("pt")) {
+                        cx = Math.round(widthPtIn * 12700.0);
+                    } else if (width.endsWith("in")) {
+                        cx = Math.round(widthPtIn * 914400.0);
+                    }
+                }
+                catch (NumberFormatException ignored) {
+                    log.error("extractWidth error");
+                }
+                int cropLeft = this.parseVmlCrop(ctImageData.getCropleft());
+                int cropTop = this.parseVmlCrop(ctImageData.getCroptop());
+                int cropRight = this.parseVmlCrop(ctImageData.getCropright());
+                int cropBottom = this.parseVmlCrop(ctImageData.getCropbottom());
+                String rotRaw = this.extractValue(ctShape.getStyle(), "rotation");
+                int rotation = rotRaw == null ? 0 : (int)Math.round((double)Long.parseLong(rotRaw.replaceAll("[^\\d-]", "")) * 0.91552734375);
+                Map<String, Object> map = this.dealCropRotate(ctImageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                Object widthObj = map.get(AttrEnum.WIDTH.getAttr());
+                Object heightObj = map.get(AttrEnum.HEIGHT.getAttr());
+                Object pathObj = map.get("imagePath");
+                if (Objects.nonNull(widthObj) && Objects.nonNull(heightObj)) {
+                    widthPx = (Double)map.get(AttrEnum.WIDTH.getAttr());
+                    heightPx = (Double)map.get(AttrEnum.HEIGHT.getAttr());
+                } else {
+                    widthPx = Double.parseDouble(width.replaceAll("pt|in", ""));
+                    if (width.endsWith("pt")) {
+                        widthPx = Math.round(widthPx * 96.0 / 72.0);
+                    } else if (width.endsWith("in")) {
+                        widthPx = Math.round(widthPx * 96.0);
+                    }
+                    heightPx = Double.parseDouble(height.replaceAll("pt|in", ""));
+                    if (height.endsWith("pt")) {
+                        heightPx = heightPx * 96.0 / 72.0;
+                    } else if (height.endsWith("in")) {
+                        heightPx *= 96.0;
+                    }
+                }
+                RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                Part part = relationshipsPart.getPart(ctImageDataId);
+                if (Objects.nonNull(pathObj)) {
+                    path = String.valueOf(pathObj);
+                } else if (Objects.nonNull(part)) {
+                    path = part.getPartName().getURI().getPath();
+                } else {
+                    log.warn("\u65e0\u6cd5\u83b7\u53d6\u8001\u7248VML\u56fe\u7247Part\uff0cctImageDataId={}", (Object)ctImageDataId);
+                    continue;
+                }
+                ImageBO imageBO = new ImageBO().setWidth(widthPx).setHeight(heightPx).setPictureUrl(path);
+                String imagePlaceholder = this.parseBO.getImagePlaceholder(ctImageDataId);
+                this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                Text text = new ObjectFactory().createText();
+                text.setValue(imagePlaceholder);
+                r.getContent().set(pictIndex, text);
+                break;
+            }
+        }
+    }
+
+    private Map<String, Object> dealCropRotate(String imageDataId, long cx, int cropLeft, int cropTop, int cropRight, int cropBottom, int rotation) {
+        HashMap<String, Object> result = new HashMap<String, Object>();
+        try {
+            if (Objects.nonNull(imageDataId)) {
+                boolean isRotate;
+                boolean isCrop = cropLeft > 0 || cropTop > 0 || cropRight > 0 || cropBottom > 0;
+                boolean bl = isRotate = rotation != 0;
+                if (isCrop || isRotate) {
+                    RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                    Part part = relationshipsPart.getPart(imageDataId);
+                    BinaryPartAbstractImage imagePart = (BinaryPartAbstractImage)part;
+                    BufferedImage targetImage = ImageIO.read(new ByteArrayInputStream(imagePart.getBytes()));
+                    if (isCrop) {
+                        targetImage = this.cropImage(targetImage, cropLeft, cropTop, cropRight, cropBottom);
+                    }
+                    if (isRotate) {
+                        targetImage = this.rotateImage(targetImage, rotation, cx, result);
+                    }
+                    if (Objects.nonNull(targetImage)) {
+                        String formatName = this.getFormatName(imagePart);
+                        String path = "/word/media/" + UniqueUtil.getUuid() + "." + formatName;
+                        ImageIO.write((RenderedImage)targetImage, formatName, new File(this.parseBO.getTempDir() + "/temp" + path));
+                        result.put("imagePath", path);
+                    }
+                }
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u56fe\u7247\u88c1\u526a\u4e0e\u65cb\u8f6c\u5f02\u5e38", (Throwable)e);
+        }
+        return result;
+    }
+
+    private String getFormatName(BinaryPartAbstractImage imagePart) {
+        String contentType = imagePart.getContentType();
+        String formatName = contentType.contains("png") ? "png" : (contentType.contains("jpeg") ? "jpeg" : (contentType.contains("gif") ? "gif" : (contentType.contains("bmp") ? "bmp" : "png")));
+        return formatName;
+    }
+
+    public BufferedImage cropImage(BufferedImage originalImage, int srcRectL, int srcRectT, int srcRectR, int srcRectB) {
+        double leftRatio = srcRectL < 0 ? 0.0 : (double)srcRectL / 100000.0;
+        double topRatio = srcRectT < 0 ? 0.0 : (double)srcRectT / 100000.0;
+        double rightRatio = srcRectR < 0 ? 0.0 : (double)srcRectR / 100000.0;
+        double bottomRatio = srcRectB < 0 ? 0.0 : (double)srcRectB / 100000.0;
+        int originalWidth = originalImage.getWidth();
+        int originalHeight = originalImage.getHeight();
+        int left = (int)Math.floor(leftRatio * (double)originalWidth);
+        int top = (int)Math.floor(topRatio * (double)originalHeight);
+        int right = (int)Math.floor(rightRatio * (double)originalWidth);
+        int bottom = (int)Math.floor(bottomRatio * (double)originalHeight);
+        int cropWidth = Math.max(1, originalWidth - left - right);
+        int cropHeight = Math.max(1, originalHeight - top - bottom);
+        if (left < 0 || top < 0 || left + cropWidth > originalWidth || top + cropHeight > originalHeight) {
+            log.error("\u88c1\u526a\u533a\u57df\u65e0\u6548\u6216\u8d85\u51fa\u56fe\u7247\u8fb9\u754c");
+        }
+        return originalImage.getSubimage(left, top, cropWidth, cropHeight);
+    }
+
+    private BufferedImage rotateImage(BufferedImage originalImage, long rotation, long currentCx, Map<String, Object> result) {
+        int origWidth = originalImage.getWidth();
+        int origHeight = originalImage.getHeight();
+        if (origWidth <= 0 || origHeight <= 0) {
+            log.error("\u56fe\u7247\u533a\u57df\u65e0\u6548");
+        }
+        double emuPerPx = (double)currentCx / (double)origWidth;
+        if (currentCx == 0L) {
+            emuPerPx = 9525.0;
+        }
+        double degrees = (double)rotation / 60000.0;
+        double radians = Math.toRadians(degrees);
+        double sin = Math.abs(Math.sin(radians));
+        double cos = Math.abs(Math.cos(radians));
+        double TOLERANCE = 1.0E-10;
+        if (sin < 1.0E-10) {
+            sin = 0.0;
+        }
+        if (cos < 1.0E-10) {
+            cos = 0.0;
+        }
+        int newWidth = (int)Math.ceil((double)origWidth * cos + (double)origHeight * sin);
+        int newHeight = (int)Math.ceil((double)origWidth * sin + (double)origHeight * cos);
+        newWidth = Math.max(1, newWidth);
+        newHeight = Math.max(1, newHeight);
+        int superSampleFactor = 4;
+        int ssWidth = origWidth * superSampleFactor;
+        int ssHeight = origHeight * superSampleFactor;
+        int ssNewW = newWidth * superSampleFactor;
+        int ssNewH = newHeight * superSampleFactor;
+        int imgType1 = originalImage.getType() == 0 ? 2 : originalImage.getType();
+        BufferedImage highResOriginal = new BufferedImage(ssWidth, ssHeight, imgType1);
+        Graphics2D g2dHighRes = highResOriginal.createGraphics();
+        this.configureGraphics2D(g2dHighRes);
+        g2dHighRes.drawImage(originalImage, 0, 0, ssWidth, ssHeight, null);
+        g2dHighRes.dispose();
+        int imgType2 = highResOriginal.getType() == 0 ? 2 : highResOriginal.getType();
+        BufferedImage rotatedSuperSample = new BufferedImage(ssNewW, ssNewH, imgType2);
+        Graphics2D g2dRotated = rotatedSuperSample.createGraphics();
+        if (highResOriginal.getType() == 2) {
+            g2dRotated.setComposite(AlphaComposite.Clear);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+            g2dRotated.setComposite(AlphaComposite.SrcOver);
+        } else {
+            g2dRotated.setColor(Color.WHITE);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+        }
+        g2dRotated.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g2dRotated.translate((double)ssNewW / 2.0, (double)ssNewH / 2.0);
+        g2dRotated.rotate(radians);
+        g2dRotated.drawImage((Image)highResOriginal, -ssWidth / 2, -ssHeight / 2, null);
+        g2dRotated.dispose();
+        BufferedImage rotatedImage = new BufferedImage(newWidth, newHeight, rotatedSuperSample.getType() == 0 ? 2 : rotatedSuperSample.getType());
+        Graphics2D g2dFinal = rotatedImage.createGraphics();
+        this.configureGraphics2D(g2dFinal);
+        g2dFinal.drawImage(rotatedSuperSample, 0, 0, newWidth, newHeight, null);
+        g2dFinal.dispose();
+        long newCx = Math.round((double)newWidth * emuPerPx);
+        long newCy = Math.round((double)newHeight * emuPerPx);
+        double newWidthPx = Math.round((double)newCx / 9525.0);
+        double newHeightPx = Math.round((double)newCy / 9525.0);
+        result.put(AttrEnum.WIDTH.getAttr(), newWidthPx);
+        result.put(AttrEnum.HEIGHT.getAttr(), newHeightPx);
+        return rotatedImage;
+    }
+
+    private void configureGraphics2D(Graphics2D g2d) {
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+    }
+
+    private int parseVmlCrop(String vmlCrop) {
+        if (vmlCrop == null || StringUtils.isBlank((CharSequence)vmlCrop)) {
+            return 0;
+        }
+        String clean = vmlCrop.trim().replaceAll("[fF]$", "");
+        try {
+            int value = Integer.parseInt(clean);
+            return (int)Math.round((double)value * 1.52587890625);
+        }
+        catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/ImageBO.java b/java-svc-jdk8/src/main/java/com/wordparse/core/ImageBO.java
new file mode 100644
index 0000000..7c26df4
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/ImageBO.java
@@ -0,0 +1,123 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.wordparse.core;
+
+import java.io.InputStream;
+import java.io.Serializable;
+
+public class ImageBO
+implements Serializable {
+    private static final long serialVersionUID = 6640950035295880234L;
+    private InputStream is;
+    private Double width;
+    private Double height;
+    private Integer pictureType;
+    private String pictureUrl;
+
+    public InputStream getIs() {
+        return this.is;
+    }
+
+    public Double getWidth() {
+        return this.width;
+    }
+
+    public Double getHeight() {
+        return this.height;
+    }
+
+    public Integer getPictureType() {
+        return this.pictureType;
+    }
+
+    public String getPictureUrl() {
+        return this.pictureUrl;
+    }
+
+    public ImageBO setIs(InputStream is) {
+        this.is = is;
+        return this;
+    }
+
+    public ImageBO setWidth(Double width) {
+        this.width = width;
+        return this;
+    }
+
+    public ImageBO setHeight(Double height) {
+        this.height = height;
+        return this;
+    }
+
+    public ImageBO setPictureType(Integer pictureType) {
+        this.pictureType = pictureType;
+        return this;
+    }
+
+    public ImageBO setPictureUrl(String pictureUrl) {
+        this.pictureUrl = pictureUrl;
+        return this;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof ImageBO)) {
+            return false;
+        }
+        ImageBO other = (ImageBO)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        InputStream this$is = this.getIs();
+        InputStream other$is = other.getIs();
+        if (this$is == null ? other$is != null : !this$is.equals(other$is)) {
+            return false;
+        }
+        Double this$width = this.getWidth();
+        Double other$width = other.getWidth();
+        if (this$width == null ? other$width != null : !((Object)this$width).equals(other$width)) {
+            return false;
+        }
+        Double this$height = this.getHeight();
+        Double other$height = other.getHeight();
+        if (this$height == null ? other$height != null : !((Object)this$height).equals(other$height)) {
+            return false;
+        }
+        Integer this$pictureType = this.getPictureType();
+        Integer other$pictureType = other.getPictureType();
+        if (this$pictureType == null ? other$pictureType != null : !((Object)this$pictureType).equals(other$pictureType)) {
+            return false;
+        }
+        String this$pictureUrl = this.getPictureUrl();
+        String other$pictureUrl = other.getPictureUrl();
+        return !(this$pictureUrl == null ? other$pictureUrl != null : !this$pictureUrl.equals(other$pictureUrl));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof ImageBO;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        InputStream $is = this.getIs();
+        result = result * 59 + ($is == null ? 43 : $is.hashCode());
+        Double $width = this.getWidth();
+        result = result * 59 + ($width == null ? 43 : ((Object)$width).hashCode());
+        Double $height = this.getHeight();
+        result = result * 59 + ($height == null ? 43 : ((Object)$height).hashCode());
+        Integer $pictureType = this.getPictureType();
+        result = result * 59 + ($pictureType == null ? 43 : ((Object)$pictureType).hashCode());
+        String $pictureUrl = this.getPictureUrl();
+        result = result * 59 + ($pictureUrl == null ? 43 : $pictureUrl.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "ImageBO(is=" + this.getIs() + ", width=" + this.getWidth() + ", height=" + this.getHeight() + ", pictureType=" + this.getPictureType() + ", pictureUrl=" + this.getPictureUrl() + ")";
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/NumPr.java b/java-svc-jdk8/src/main/java/com/wordparse/core/NumPr.java
new file mode 100644
index 0000000..cfe074c
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/NumPr.java
@@ -0,0 +1,109 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.wordparse.core;
+
+import java.math.BigInteger;
+
+public class NumPr {
+    private BigInteger start;
+    private BigInteger current;
+    private String numFmt;
+    private String lvlText;
+
+    public NumPr() {
+    }
+
+    public NumPr(BigInteger start, BigInteger current, String numFmt, String lvlText) {
+        this.start = start;
+        this.current = current;
+        this.numFmt = numFmt;
+        this.lvlText = lvlText;
+    }
+
+    public BigInteger getStart() {
+        return this.start;
+    }
+
+    public BigInteger getCurrent() {
+        return this.current;
+    }
+
+    public String getNumFmt() {
+        return this.numFmt;
+    }
+
+    public String getLvlText() {
+        return this.lvlText;
+    }
+
+    public void setStart(BigInteger start) {
+        this.start = start;
+    }
+
+    public void setCurrent(BigInteger current) {
+        this.current = current;
+    }
+
+    public void setNumFmt(String numFmt) {
+        this.numFmt = numFmt;
+    }
+
+    public void setLvlText(String lvlText) {
+        this.lvlText = lvlText;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof NumPr)) {
+            return false;
+        }
+        NumPr other = (NumPr)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        BigInteger this$start = this.getStart();
+        BigInteger other$start = other.getStart();
+        if (this$start == null ? other$start != null : !((Object)this$start).equals(other$start)) {
+            return false;
+        }
+        BigInteger this$current = this.getCurrent();
+        BigInteger other$current = other.getCurrent();
+        if (this$current == null ? other$current != null : !((Object)this$current).equals(other$current)) {
+            return false;
+        }
+        String this$numFmt = this.getNumFmt();
+        String other$numFmt = other.getNumFmt();
+        if (this$numFmt == null ? other$numFmt != null : !this$numFmt.equals(other$numFmt)) {
+            return false;
+        }
+        String this$lvlText = this.getLvlText();
+        String other$lvlText = other.getLvlText();
+        return !(this$lvlText == null ? other$lvlText != null : !this$lvlText.equals(other$lvlText));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof NumPr;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        BigInteger $start = this.getStart();
+        result = result * 59 + ($start == null ? 43 : ((Object)$start).hashCode());
+        BigInteger $current = this.getCurrent();
+        result = result * 59 + ($current == null ? 43 : ((Object)$current).hashCode());
+        String $numFmt = this.getNumFmt();
+        result = result * 59 + ($numFmt == null ? 43 : $numFmt.hashCode());
+        String $lvlText = this.getLvlText();
+        result = result * 59 + ($lvlText == null ? 43 : $lvlText.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "NumPr(start=" + this.getStart() + ", current=" + this.getCurrent() + ", numFmt=" + this.getNumFmt() + ", lvlText=" + this.getLvlText() + ")";
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/ParseBO.java b/java-svc-jdk8/src/main/java/com/wordparse/core/ParseBO.java
new file mode 100644
index 0000000..6871bfc
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/ParseBO.java
@@ -0,0 +1,455 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.fastjson.JSONObject
+ *  org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart
+ */
+package com.wordparse.core;
+
+import com.alibaba.fastjson.JSONObject;
+import com.wordparse.core.ImageBO;
+import com.wordparse.core.NumPr;
+import java.io.Serializable;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.xml.transform.Transformer;
+import org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart;
+
+public class ParseBO
+implements Serializable {
+    private static final long serialVersionUID = -1386361606482288851L;
+    public static final String IMAGES = "images";
+    public static final String PARSE_ = "parse-";
+    public static final String OUTPUT_HTML = "output.html";
+    private static final String JBY_OPEN_OFFICE_XML_ = "JBY_OPEN_OFFICE_XML_";
+    private static final String JBY_IMAGE_DATA_ = "JBY_IMAGE_DATA_";
+    private static final String PLACEHOLDER_SUFFIX = "_END";
+    private static final String IMAGE_ = "image_";
+    private static final String JBY_EQ_LATEX_ = "JBY_EQ_LATEX_";
+    public static final String JBY_TEXTBOX = "JBY_TEXTBOX_JBY";
+    private static final String JBY_MATHTYPE_DATA_ = "JBY_MATHTYPE_DATA_";
+    private Path tempDir;
+    private String sourceFilePath;
+    private String sourceFileUrl;
+    private String sourceFileMd5;
+    private String sourceFileBakPath;
+    private String htmlPath;
+    private String imagesDir;
+    private String ossFolder;
+    private Transformer transformer;
+    private List<JSONObject> latexReplaceList;
+    private Map<String, String> imgMap = new HashMap<String, String>();
+    private Map<String, String> shapeImgMap;
+    private Map<String, String> openOfficeXmlMap = new HashMap<String, String>();
+    private Map<String, String> mathTypeMap = new HashMap<String, String>();
+    private Map<String, String> eqLatexMap = new HashMap<String, String>();
+    private StyleDefinitionsPart styleDefinitionsPart;
+    private Map<String, NumPr> numberingDefinitionsMap = new HashMap<String, NumPr>();
+    private Map<String, ImageBO> imageMap;
+    private Boolean newParseVersion;
+    private Integer count = 0;
+    private Long fileId;
+
+    public ParseBO() {
+        this.shapeImgMap = new HashMap<String, String>();
+        this.imageMap = new HashMap<String, ImageBO>();
+    }
+
+    private Integer incrCount() {
+        this.count = this.count + 1;
+        return this.count;
+    }
+
+    public String getOpenOfficeXmlPlaceholder() {
+        return JBY_OPEN_OFFICE_XML_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getMathTypePlaceholder() {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getMathTypePlaceholder(String ctOleObjectRid) {
+        return JBY_MATHTYPE_DATA_ + ctOleObjectRid + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getImgName() {
+        return IMAGE_ + this.incrCount();
+    }
+
+    public String getEqLatexPlaceholder() {
+        return JBY_EQ_LATEX_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getShapeImgPlaceholder() {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public String getImagePlaceholder(String rid) {
+        return JBY_IMAGE_DATA_ + this.incrCount() + PLACEHOLDER_SUFFIX;
+    }
+
+    public Path getTempDir() {
+        return this.tempDir;
+    }
+
+    public String getSourceFilePath() {
+        return this.sourceFilePath;
+    }
+
+    public String getSourceFileUrl() {
+        return this.sourceFileUrl;
+    }
+
+    public String getSourceFileMd5() {
+        return this.sourceFileMd5;
+    }
+
+    public String getSourceFileBakPath() {
+        return this.sourceFileBakPath;
+    }
+
+    public String getHtmlPath() {
+        return this.htmlPath;
+    }
+
+    public String getImagesDir() {
+        return this.imagesDir;
+    }
+
+    public String getOssFolder() {
+        return this.ossFolder;
+    }
+
+    public Transformer getTransformer() {
+        return this.transformer;
+    }
+
+    public List<JSONObject> getLatexReplaceList() {
+        return this.latexReplaceList;
+    }
+
+    public Map<String, String> getImgMap() {
+        return this.imgMap;
+    }
+
+    public Map<String, String> getShapeImgMap() {
+        return this.shapeImgMap;
+    }
+
+    public Map<String, String> getOpenOfficeXmlMap() {
+        return this.openOfficeXmlMap;
+    }
+
+    public Map<String, String> getMathTypeMap() {
+        return this.mathTypeMap;
+    }
+
+    public Map<String, String> getEqLatexMap() {
+        return this.eqLatexMap;
+    }
+
+    public StyleDefinitionsPart getStyleDefinitionsPart() {
+        return this.styleDefinitionsPart;
+    }
+
+    public Map<String, NumPr> getNumberingDefinitionsMap() {
+        return this.numberingDefinitionsMap;
+    }
+
+    public Map<String, ImageBO> getImageMap() {
+        return this.imageMap;
+    }
+
+    public Boolean getNewParseVersion() {
+        return this.newParseVersion;
+    }
+
+    public Integer getCount() {
+        return this.count;
+    }
+
+    public Long getFileId() {
+        return this.fileId;
+    }
+
+    public ParseBO setTempDir(Path tempDir) {
+        this.tempDir = tempDir;
+        return this;
+    }
+
+    public ParseBO setSourceFilePath(String sourceFilePath) {
+        this.sourceFilePath = sourceFilePath;
+        return this;
+    }
+
+    public ParseBO setSourceFileUrl(String sourceFileUrl) {
+        this.sourceFileUrl = sourceFileUrl;
+        return this;
+    }
+
+    public ParseBO setSourceFileMd5(String sourceFileMd5) {
+        this.sourceFileMd5 = sourceFileMd5;
+        return this;
+    }
+
+    public ParseBO setSourceFileBakPath(String sourceFileBakPath) {
+        this.sourceFileBakPath = sourceFileBakPath;
+        return this;
+    }
+
+    public ParseBO setHtmlPath(String htmlPath) {
+        this.htmlPath = htmlPath;
+        return this;
+    }
+
+    public ParseBO setImagesDir(String imagesDir) {
+        this.imagesDir = imagesDir;
+        return this;
+    }
+
+    public ParseBO setOssFolder(String ossFolder) {
+        this.ossFolder = ossFolder;
+        return this;
+    }
+
+    public ParseBO setTransformer(Transformer transformer) {
+        this.transformer = transformer;
+        return this;
+    }
+
+    public ParseBO setLatexReplaceList(List<JSONObject> latexReplaceList) {
+        this.latexReplaceList = latexReplaceList;
+        return this;
+    }
+
+    public ParseBO setImgMap(Map<String, String> imgMap) {
+        this.imgMap = imgMap;
+        return this;
+    }
+
+    public ParseBO setShapeImgMap(Map<String, String> shapeImgMap) {
+        this.shapeImgMap = shapeImgMap;
+        return this;
+    }
+
+    public ParseBO setOpenOfficeXmlMap(Map<String, String> openOfficeXmlMap) {
+        this.openOfficeXmlMap = openOfficeXmlMap;
+        return this;
+    }
+
+    public ParseBO setMathTypeMap(Map<String, String> mathTypeMap) {
+        this.mathTypeMap = mathTypeMap;
+        return this;
+    }
+
+    public ParseBO setEqLatexMap(Map<String, String> eqLatexMap) {
+        this.eqLatexMap = eqLatexMap;
+        return this;
+    }
+
+    public ParseBO setStyleDefinitionsPart(StyleDefinitionsPart styleDefinitionsPart) {
+        this.styleDefinitionsPart = styleDefinitionsPart;
+        return this;
+    }
+
+    public ParseBO setNumberingDefinitionsMap(Map<String, NumPr> numberingDefinitionsMap) {
+        this.numberingDefinitionsMap = numberingDefinitionsMap;
+        return this;
+    }
+
+    public ParseBO setImageMap(Map<String, ImageBO> imageMap) {
+        this.imageMap = imageMap;
+        return this;
+    }
+
+    public ParseBO setNewParseVersion(Boolean newParseVersion) {
+        this.newParseVersion = newParseVersion;
+        return this;
+    }
+
+    public ParseBO setCount(Integer count) {
+        this.count = count;
+        return this;
+    }
+
+    public ParseBO setFileId(Long fileId) {
+        this.fileId = fileId;
+        return this;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof ParseBO)) {
+            return false;
+        }
+        ParseBO other = (ParseBO)o;
+        if (!other.canEqual(this)) {
+            return false;
+        }
+        Path this$tempDir = this.getTempDir();
+        Path other$tempDir = other.getTempDir();
+        if (this$tempDir == null ? other$tempDir != null : !((Object)this$tempDir).equals(other$tempDir)) {
+            return false;
+        }
+        String this$sourceFilePath = this.getSourceFilePath();
+        String other$sourceFilePath = other.getSourceFilePath();
+        if (this$sourceFilePath == null ? other$sourceFilePath != null : !this$sourceFilePath.equals(other$sourceFilePath)) {
+            return false;
+        }
+        String this$sourceFileUrl = this.getSourceFileUrl();
+        String other$sourceFileUrl = other.getSourceFileUrl();
+        if (this$sourceFileUrl == null ? other$sourceFileUrl != null : !this$sourceFileUrl.equals(other$sourceFileUrl)) {
+            return false;
+        }
+        String this$sourceFileMd5 = this.getSourceFileMd5();
+        String other$sourceFileMd5 = other.getSourceFileMd5();
+        if (this$sourceFileMd5 == null ? other$sourceFileMd5 != null : !this$sourceFileMd5.equals(other$sourceFileMd5)) {
+            return false;
+        }
+        String this$sourceFileBakPath = this.getSourceFileBakPath();
+        String other$sourceFileBakPath = other.getSourceFileBakPath();
+        if (this$sourceFileBakPath == null ? other$sourceFileBakPath != null : !this$sourceFileBakPath.equals(other$sourceFileBakPath)) {
+            return false;
+        }
+        String this$htmlPath = this.getHtmlPath();
+        String other$htmlPath = other.getHtmlPath();
+        if (this$htmlPath == null ? other$htmlPath != null : !this$htmlPath.equals(other$htmlPath)) {
+            return false;
+        }
+        String this$imagesDir = this.getImagesDir();
+        String other$imagesDir = other.getImagesDir();
+        if (this$imagesDir == null ? other$imagesDir != null : !this$imagesDir.equals(other$imagesDir)) {
+            return false;
+        }
+        String this$ossFolder = this.getOssFolder();
+        String other$ossFolder = other.getOssFolder();
+        if (this$ossFolder == null ? other$ossFolder != null : !this$ossFolder.equals(other$ossFolder)) {
+            return false;
+        }
+        Transformer this$transformer = this.getTransformer();
+        Transformer other$transformer = other.getTransformer();
+        if (this$transformer == null ? other$transformer != null : !this$transformer.equals(other$transformer)) {
+            return false;
+        }
+        List<JSONObject> this$latexReplaceList = this.getLatexReplaceList();
+        List<JSONObject> other$latexReplaceList = other.getLatexReplaceList();
+        if (this$latexReplaceList == null ? other$latexReplaceList != null : !((Object)this$latexReplaceList).equals(other$latexReplaceList)) {
+            return false;
+        }
+        Map<String, String> this$imgMap = this.getImgMap();
+        Map<String, String> other$imgMap = other.getImgMap();
+        if (this$imgMap == null ? other$imgMap != null : !((Object)this$imgMap).equals(other$imgMap)) {
+            return false;
+        }
+        Map<String, String> this$shapeImgMap = this.getShapeImgMap();
+        Map<String, String> other$shapeImgMap = other.getShapeImgMap();
+        if (this$shapeImgMap == null ? other$shapeImgMap != null : !((Object)this$shapeImgMap).equals(other$shapeImgMap)) {
+            return false;
+        }
+        Map<String, String> this$openOfficeXmlMap = this.getOpenOfficeXmlMap();
+        Map<String, String> other$openOfficeXmlMap = other.getOpenOfficeXmlMap();
+        if (this$openOfficeXmlMap == null ? other$openOfficeXmlMap != null : !((Object)this$openOfficeXmlMap).equals(other$openOfficeXmlMap)) {
+            return false;
+        }
+        Map<String, String> this$mathTypeMap = this.getMathTypeMap();
+        Map<String, String> other$mathTypeMap = other.getMathTypeMap();
+        if (this$mathTypeMap == null ? other$mathTypeMap != null : !((Object)this$mathTypeMap).equals(other$mathTypeMap)) {
+            return false;
+        }
+        Map<String, String> this$eqLatexMap = this.getEqLatexMap();
+        Map<String, String> other$eqLatexMap = other.getEqLatexMap();
+        if (this$eqLatexMap == null ? other$eqLatexMap != null : !((Object)this$eqLatexMap).equals(other$eqLatexMap)) {
+            return false;
+        }
+        StyleDefinitionsPart this$styleDefinitionsPart = this.getStyleDefinitionsPart();
+        StyleDefinitionsPart other$styleDefinitionsPart = other.getStyleDefinitionsPart();
+        if (this$styleDefinitionsPart == null ? other$styleDefinitionsPart != null : !this$styleDefinitionsPart.equals(other$styleDefinitionsPart)) {
+            return false;
+        }
+        Map<String, NumPr> this$numberingDefinitionsMap = this.getNumberingDefinitionsMap();
+        Map<String, NumPr> other$numberingDefinitionsMap = other.getNumberingDefinitionsMap();
+        if (this$numberingDefinitionsMap == null ? other$numberingDefinitionsMap != null : !((Object)this$numberingDefinitionsMap).equals(other$numberingDefinitionsMap)) {
+            return false;
+        }
+        Map<String, ImageBO> this$imageMap = this.getImageMap();
+        Map<String, ImageBO> other$imageMap = other.getImageMap();
+        if (this$imageMap == null ? other$imageMap != null : !((Object)this$imageMap).equals(other$imageMap)) {
+            return false;
+        }
+        Boolean this$newParseVersion = this.getNewParseVersion();
+        Boolean other$newParseVersion = other.getNewParseVersion();
+        if (this$newParseVersion == null ? other$newParseVersion != null : !((Object)this$newParseVersion).equals(other$newParseVersion)) {
+            return false;
+        }
+        Integer this$count = this.getCount();
+        Integer other$count = other.getCount();
+        if (this$count == null ? other$count != null : !((Object)this$count).equals(other$count)) {
+            return false;
+        }
+        Long this$fileId = this.getFileId();
+        Long other$fileId = other.getFileId();
+        return !(this$fileId == null ? other$fileId != null : !((Object)this$fileId).equals(other$fileId));
+    }
+
+    protected boolean canEqual(Object other) {
+        return other instanceof ParseBO;
+    }
+
+    public int hashCode() {
+        int PRIME = 59;
+        int result = 1;
+        Path $tempDir = this.getTempDir();
+        result = result * 59 + ($tempDir == null ? 43 : ((Object)$tempDir).hashCode());
+        String $sourceFilePath = this.getSourceFilePath();
+        result = result * 59 + ($sourceFilePath == null ? 43 : $sourceFilePath.hashCode());
+        String $sourceFileUrl = this.getSourceFileUrl();
+        result = result * 59 + ($sourceFileUrl == null ? 43 : $sourceFileUrl.hashCode());
+        String $sourceFileMd5 = this.getSourceFileMd5();
+        result = result * 59 + ($sourceFileMd5 == null ? 43 : $sourceFileMd5.hashCode());
+        String $sourceFileBakPath = this.getSourceFileBakPath();
+        result = result * 59 + ($sourceFileBakPath == null ? 43 : $sourceFileBakPath.hashCode());
+        String $htmlPath = this.getHtmlPath();
+        result = result * 59 + ($htmlPath == null ? 43 : $htmlPath.hashCode());
+        String $imagesDir = this.getImagesDir();
+        result = result * 59 + ($imagesDir == null ? 43 : $imagesDir.hashCode());
+        String $ossFolder = this.getOssFolder();
+        result = result * 59 + ($ossFolder == null ? 43 : $ossFolder.hashCode());
+        Transformer $transformer = this.getTransformer();
+        result = result * 59 + ($transformer == null ? 43 : $transformer.hashCode());
+        List<JSONObject> $latexReplaceList = this.getLatexReplaceList();
+        result = result * 59 + ($latexReplaceList == null ? 43 : ((Object)$latexReplaceList).hashCode());
+        Map<String, String> $imgMap = this.getImgMap();
+        result = result * 59 + ($imgMap == null ? 43 : ((Object)$imgMap).hashCode());
+        Map<String, String> $shapeImgMap = this.getShapeImgMap();
+        result = result * 59 + ($shapeImgMap == null ? 43 : ((Object)$shapeImgMap).hashCode());
+        Map<String, String> $openOfficeXmlMap = this.getOpenOfficeXmlMap();
+        result = result * 59 + ($openOfficeXmlMap == null ? 43 : ((Object)$openOfficeXmlMap).hashCode());
+        Map<String, String> $mathTypeMap = this.getMathTypeMap();
+        result = result * 59 + ($mathTypeMap == null ? 43 : ((Object)$mathTypeMap).hashCode());
+        Map<String, String> $eqLatexMap = this.getEqLatexMap();
+        result = result * 59 + ($eqLatexMap == null ? 43 : ((Object)$eqLatexMap).hashCode());
+        StyleDefinitionsPart $styleDefinitionsPart = this.getStyleDefinitionsPart();
+        result = result * 59 + ($styleDefinitionsPart == null ? 43 : $styleDefinitionsPart.hashCode());
+        Map<String, NumPr> $numberingDefinitionsMap = this.getNumberingDefinitionsMap();
+        result = result * 59 + ($numberingDefinitionsMap == null ? 43 : ((Object)$numberingDefinitionsMap).hashCode());
+        Map<String, ImageBO> $imageMap = this.getImageMap();
+        result = result * 59 + ($imageMap == null ? 43 : ((Object)$imageMap).hashCode());
+        Boolean $newParseVersion = this.getNewParseVersion();
+        result = result * 59 + ($newParseVersion == null ? 43 : ((Object)$newParseVersion).hashCode());
+        Integer $count = this.getCount();
+        result = result * 59 + ($count == null ? 43 : ((Object)$count).hashCode());
+        Long $fileId = this.getFileId();
+        result = result * 59 + ($fileId == null ? 43 : ((Object)$fileId).hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "ParseBO(tempDir=" + this.getTempDir() + ", sourceFilePath=" + this.getSourceFilePath() + ", sourceFileUrl=" + this.getSourceFileUrl() + ", sourceFileMd5=" + this.getSourceFileMd5() + ", sourceFileBakPath=" + this.getSourceFileBakPath() + ", htmlPath=" + this.getHtmlPath() + ", imagesDir=" + this.getImagesDir() + ", ossFolder=" + this.getOssFolder() + ", transformer=" + this.getTransformer() + ", latexReplaceList=" + this.getLatexReplaceList() + ", imgMap=" + this.getImgMap() + ", shapeImgMap=" + this.getShapeImgMap() + ", openOfficeXmlMap=" + this.getOpenOfficeXmlMap() + ", mathTypeMap=" + this.getMathTypeMap() + ", eqLatexMap=" + this.getEqLatexMap() + ", styleDefinitionsPart=" + this.getStyleDefinitionsPart() + ", numberingDefinitionsMap=" + this.getNumberingDefinitionsMap() + ", imageMap=" + this.getImageMap() + ", newParseVersion=" + this.getNewParseVersion() + ", count=" + this.getCount() + ", fileId=" + this.getFileId() + ")";
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/TagEnum.java b/java-svc-jdk8/src/main/java/com/wordparse/core/TagEnum.java
new file mode 100644
index 0000000..40a9bdc
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/TagEnum.java
@@ -0,0 +1,140 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.wordparse.core.DistinctUtils
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.jsoup.nodes.Element
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.DistinctUtils;
+import com.wordparse.core.TagStyleBO;
+import com.wordparse.core.AttrEnum;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.jsoup.nodes.Element;
+
+public enum TagEnum {
+    H1("h1", true, null),
+    H2("h2", true, null),
+    H3("h3", true, null),
+    H4("h4", true, null),
+    P("p", false, null),
+    DIV("div", false, null),
+    FONT("font", false, Stream.of(AttrEnum.FACE, AttrEnum.SIZE, AttrEnum.COLOR).collect(Collectors.toList())),
+    STRIKE("strike", true, null),
+    BR("br", false, null),
+    PBR("pbr", false, null),
+    HR("hr", false, null),
+    U("u", true, null),
+    I("i", true, null),
+    SUB("sub", true, null),
+    SUP("sup", true, null),
+    WAVE("wave", true, null),
+    DOT("dot", true, null),
+    B("b", true, null),
+    A("a", false, Stream.of(AttrEnum.HREF).collect(Collectors.toList())),
+    TABLE("table", false, null),
+    UL("ul", false, null),
+    OL("ol", false, null),
+    LI("li", false, null),
+    IMG("img", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    IMQ("imq", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    VIDEO("video", false, Stream.of(AttrEnum.WIDTH, AttrEnum.HEIGHT).collect(Collectors.toList())),
+    SOURCE("source", false, null),
+    MATH("math", false, null),
+    TAB("tab", false, null),
+    TEXT("#text", false, null),
+    SPAN("span", false, Stream.of(AttrEnum.CLASS).collect(Collectors.toList())),
+    EM("em", true, null),
+    STRONG("strong", true, null);
+
+    private final String name;
+    private final Boolean dealTagStyle;
+    private final List<AttrEnum> attrList;
+    public static final Set<String> H_P_SET;
+    public static final Set<String> H_SET;
+    public static final Set<String> UL_OL_SET;
+    private static final Map<String, TagEnum> MAP;
+
+    public static TagEnum getTagEnum(String tagName) {
+        return MAP.get(tagName);
+    }
+
+    public static List<TagStyleBO> getStyleList(Element element) {
+        ArrayList<TagStyleBO> styleList = new ArrayList<TagStyleBO>();
+        TagEnum tagEnum = TagEnum.getTagEnum(element.tagName());
+        if (Objects.nonNull((Object)tagEnum) && Boolean.TRUE.equals(tagEnum.dealTagStyle)) {
+            styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(tagEnum.getName()).setValue(tagEnum.getName()));
+        }
+        if (Objects.nonNull((Object)tagEnum) && CollectionUtils.isNotEmpty(tagEnum.getAttrList())) {
+            for (AttrEnum attrEnum : tagEnum.getAttrList()) {
+                if (!StringUtils.isNotBlank((CharSequence)element.attr(attrEnum.getAttr())) || "null".equals(element.attr(attrEnum.getAttr()))) continue;
+                styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(attrEnum.getAttr()).setValue(element.attr(attrEnum.getAttr())));
+            }
+        }
+        List<String> styles = StringUtils.isBlank((CharSequence)element.attr(AttrEnum.STYLE.getAttr())) ? Collections.emptyList() : Arrays.asList(element.attr(AttrEnum.STYLE.getAttr()).split(";"));
+        styles.forEach(style -> {
+            if (StringUtils.isBlank((CharSequence)style)) {
+                return;
+            }
+            String[] split = style.split(":");
+            if (split.length < 2) {
+                return;
+            }
+            String attr = split[0].trim();
+            String value = split[1].trim();
+            if (StringUtils.isBlank((CharSequence)value) || "null".equals(value) || StringUtils.isBlank((CharSequence)attr) || "null".equals(attr)) {
+                return;
+            }
+            styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(attr).setValue(value));
+        });
+        return styleList.stream().filter(DistinctUtils.distinctByKey(TagStyleBO::getAttr)).filter(e -> !e.getValue().contains("auto")).collect(Collectors.toList());
+    }
+
+    public static Map<String, String> getStyleMap(Element element) {
+        List<TagStyleBO> styleList = TagEnum.getStyleList(element);
+        return styleList.stream().collect(Collectors.toMap(TagStyleBO::getAttr, TagStyleBO::getValue, (l, r) -> l));
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public Boolean getDealTagStyle() {
+        return this.dealTagStyle;
+    }
+
+    public List<AttrEnum> getAttrList() {
+        return this.attrList;
+    }
+
+    private TagEnum(String name, Boolean dealTagStyle, List<AttrEnum> attrList) {
+        this.name = name;
+        this.dealTagStyle = dealTagStyle;
+        this.attrList = attrList;
+    }
+
+    static {
+        H_P_SET = Stream.of(H1.getName(), H2.getName(), H3.getName(), H4.getName(), P.getName()).collect(Collectors.toSet());
+        H_SET = Stream.of(H1.getName(), H2.getName(), H3.getName(), H4.getName()).collect(Collectors.toSet());
+        UL_OL_SET = Stream.of(UL.getName(), OL.getName()).collect(Collectors.toSet());
+        MAP = new HashMap<String, TagEnum>();
+        for (TagEnum tagEnum : TagEnum.values()) {
+            MAP.put(tagEnum.getName(), tagEnum);
+        }
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/TagStyleBO.java b/java-svc-jdk8/src/main/java/com/wordparse/core/TagStyleBO.java
new file mode 100644
index 0000000..4249704
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/TagStyleBO.java
@@ -0,0 +1,42 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.wordparse.core;
+
+import java.io.Serializable;
+
+public class TagStyleBO
+implements Serializable {
+    private static final long serialVersionUID = -5541312317983576319L;
+    private String tagName;
+    private String attr;
+    private String value;
+
+    public String getTagName() {
+        return this.tagName;
+    }
+
+    public String getAttr() {
+        return this.attr;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    public TagStyleBO setTagName(String tagName) {
+        this.tagName = tagName;
+        return this;
+    }
+
+    public TagStyleBO setAttr(String attr) {
+        this.attr = attr;
+        return this;
+    }
+
+    public TagStyleBO setValue(String value) {
+        this.value = value;
+        return this;
+    }
+}
+
diff --git a/java-svc-jdk8/src/main/java/com/wordparse/core/WordParseUtil.java b/java-svc-jdk8/src/main/java/com/wordparse/core/WordParseUtil.java
new file mode 100644
index 0000000..cd57bd8
--- /dev/null
+++ b/java-svc-jdk8/src/main/java/com/wordparse/core/WordParseUtil.java
@@ -0,0 +1,1791 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.hutool.core.io.FileUtil
+ *  cn.hutool.core.util.ArrayUtil
+ *  com.alibaba.fastjson.JSONObject
+ *  com.alibaba.fastjson2.JSON
+ *  com.wordparse.core.BizAssert
+ *  com.wordparse.core.BusinessException
+ *  com.wordparse.core.FeignUtils
+ *  com.wordparse.core.Result
+ *  com.wordparse.core.CloseIoUtil
+ *  com.wordparse.core.FileUtil
+ *  com.wordparse.core.HttpClientUtil
+ *  com.wordparse.core.SpringContextHolder
+ *  com.wordparse.core.UniqueUtil
+ *  com.wordparse.core.Constants
+ *  com.wordparse.core.OfficeFileParseRecordParam
+ *  com.wordparse.core.OfficeFileParseRecordVO
+ *  com.wordparse.core.OssParam
+ *  com.wordparse.core.AttachmentModuleEnum
+ *  javax.annotation.Nullable
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.collections4.MapUtils
+ *  org.apache.commons.io.FilenameUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.apache.poi.ooxml.POIXMLDocumentPart
+ *  org.apache.poi.openxml4j.util.ZipSecureFile
+ *  org.apache.poi.xwpf.usermodel.XWPFDocument
+ *  org.apache.poi.xwpf.usermodel.XWPFParagraph
+ *  org.apache.poi.xwpf.usermodel.XWPFPictureData
+ *  org.apache.xmlbeans.XmlException
+ *  org.apache.xmlbeans.XmlObject
+ *  org.docx4j.Docx4J
+ *  org.docx4j.TextUtils
+ *  org.docx4j.TraversalUtil
+ *  org.docx4j.TraversalUtil$Callback
+ *  org.docx4j.XmlUtils
+ *  org.docx4j.convert.out.HTMLSettings
+ *  org.docx4j.model.listnumbering.ListNumberingDefinition
+ *  org.docx4j.openpackaging.packages.OpcPackage
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart
+ *  org.docx4j.openpackaging.parts.WordprocessingML.NumberingDefinitionsPart
+ *  org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart
+ *  org.docx4j.wml.Body
+ *  org.docx4j.wml.Document
+ *  org.docx4j.wml.Lvl$LvlText
+ *  org.docx4j.wml.P
+ *  org.jsoup.Jsoup
+ *  org.jsoup.nodes.Document
+ *  org.jsoup.nodes.Element
+ *  org.jsoup.nodes.Node
+ *  org.jsoup.nodes.TextNode
+ *  org.jsoup.select.Elements
+ *  org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath
+ *  org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara
+ *  org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.BeansException
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.context.ApplicationContext
+ *  org.springframework.context.ApplicationContextAware
+ *  org.springframework.stereotype.Component
+ *  org.springframework.util.StopWatch
+ *  org.springframework.util.StopWatch$TaskInfo
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package com.wordparse.core;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.ArrayUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
+import com.wordparse.core.BizAssert;
+import com.wordparse.core.BusinessException;
+import com.wordparse.core.FeignUtils;
+import com.wordparse.core.Result;
+import com.wordparse.core.CloseIoUtil;
+import com.wordparse.core.HttpClientUtil;
+import com.wordparse.core.SpringContextHolder;
+import com.wordparse.core.UniqueUtil;
+import com.wordparse.core.Constants;
+import com.wordparse.core.OfficeFileParseRecordParam;
+import com.wordparse.core.OfficeFileParseRecordVO;
+import com.wordparse.core.OfficeCoreConfig;
+import com.wordparse.core.ImageBO;
+import com.wordparse.core.ParseBO;
+import com.wordparse.core.TagStyleBO;
+import com.wordparse.core.ParseParam;
+import com.wordparse.core.AttrEnum;
+import com.wordparse.core.TagEnum;
+import com.wordparse.core.FileServiceFeign;
+import com.wordparse.core.OMml2MmlTransformerPool;
+import com.wordparse.core.DigestUtil;
+import com.wordparse.core.LatexUtil;
+import com.wordparse.core.MathTypeUtil;
+import com.wordparse.core.NumPr;
+import com.wordparse.core.OfficeFileUtil;
+import com.wordparse.core.OssServiceUtil;
+import com.wordparse.core.WordExportUtil;
+import com.wordparse.core.WpsConvertUtil;
+import com.wordparse.core.CtObjectFinder;
+import com.wordparse.core.CtTextBoxFinder;
+import com.wordparse.core.CtoMathFinder;
+import com.wordparse.core.DrawingPictFinder;
+import com.wordparse.core.OssParam;
+import com.wordparse.core.AttachmentModuleEnum;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+import javax.annotation.Nullable;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.stream.ImageInputStream;
+import javax.xml.bind.JAXBElement;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ooxml.POIXMLDocumentPart;
+import org.apache.poi.openxml4j.util.ZipSecureFile;
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.apache.poi.xwpf.usermodel.XWPFParagraph;
+import org.apache.poi.xwpf.usermodel.XWPFPictureData;
+import org.apache.xmlbeans.XmlException;
+import org.apache.xmlbeans.XmlObject;
+import org.docx4j.Docx4J;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.convert.out.HTMLSettings;
+import org.docx4j.model.listnumbering.ListNumberingDefinition;
+import org.docx4j.openpackaging.packages.OpcPackage;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
+import org.docx4j.openpackaging.parts.WordprocessingML.NumberingDefinitionsPart;
+import org.docx4j.openpackaging.parts.WordprocessingML.StyleDefinitionsPart;
+import org.docx4j.wml.Body;
+import org.docx4j.wml.Document;
+import org.docx4j.wml.Lvl;
+import org.docx4j.wml.P;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Element;
+import org.jsoup.nodes.Node;
+import org.jsoup.nodes.TextNode;
+import org.jsoup.select.Elements;
+import org.openxmlformats.schemas.officeDocument.x2006.math.CTOMath;
+import org.openxmlformats.schemas.officeDocument.x2006.math.CTOMathPara;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StopWatch;
+import org.springframework.web.multipart.MultipartFile;
+
+@Component
+public class WordParseUtil
+implements ApplicationContextAware {
+    private static final Logger log = LoggerFactory.getLogger(WordParseUtil.class);
+    private static final String TEXT_PATTERN_STR = "^(?:\\s*[\u4e00-\u9fa2]{0,10}[\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d\u5341]+(?:\u3001|\\s+).+)|(?:(?:[\u3010\u3016\\[])[\u4e00-\u9fa2]{2,20}(?:[\u3011\u3017\\]]))$";
+    private static final Pattern TEXT_PATTERN = Pattern.compile("^(?:\\s*[\u4e00-\u9fa2]{0,10}[\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d\u5341]+(?:\u3001|\\s+).+)|(?:(?:[\u3010\u3016\\[])[\u4e00-\u9fa2]{2,20}(?:[\u3011\u3017\\]]))$");
+    private static final String MATH_PLACEHOLDER = "<w:rPr><w:rFonts w:hint=\"eastAsia\" /><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" /></w:rPr><w:t>%s</w:t>";
+    private static final String[] SYMBOL = new String[]{"\\ue0fc", "\\ue100", "\\ue101"};
+    private static OfficeCoreConfig officeCoreConfig;
+    private static FileServiceFeign fileServiceFeign;
+    private static ApplicationContext applicationContext;
+    private static volatile Executor batchDealPicExecutor;
+
+    @Autowired
+    public void setOfficeCoreConfig(OfficeCoreConfig officeCoreConfig) {
+        WordParseUtil.officeCoreConfig = officeCoreConfig;
+    }
+
+    @Autowired
+    public void setFileServiceFeign(FileServiceFeign fileServiceFeign) {
+        WordParseUtil.fileServiceFeign = fileServiceFeign;
+    }
+
+    public void setApplicationContext(@Nullable ApplicationContext ctx) throws BeansException {
+        applicationContext = ctx;
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     * Enabled force condition propagation
+     * Lifted jumps to return sites
+     */
+    private static Executor getBatchDealPicExecutor() {
+        if (!Objects.isNull(batchDealPicExecutor)) return batchDealPicExecutor;
+        Class<WordParseUtil> clazz = WordParseUtil.class;
+        synchronized (WordParseUtil.class) {
+            if (!Objects.isNull(batchDealPicExecutor)) return batchDealPicExecutor;
+            batchDealPicExecutor = (Executor)applicationContext.getBean("batchDealPicExecutor", Executor.class);
+            // ** MonitorExit[var0] (shouldn't be in output)
+            return batchDealPicExecutor;
+        }
+    }
+
+    public static String parseByUrl(ParseParam param) {
+        String fileUrl = param.getSourceUrl();
+        BizAssert.isNotBlank((String)fileUrl, (String)"\u6e90\u6587\u4ef6Url\u4e3a\u7a7a\uff01");
+        ParseBO parseBO = new ParseBO().setLatexReplaceList(param.getLatexReplaceList());
+        parseBO.setSourceFileUrl(fileUrl);
+        File sourceFile = null;
+        try {
+            WordParseUtil.createTempDir(parseBO);
+            String fileName = FileUtil.getName((String)fileUrl);
+            BizAssert.isNotBlank((String)fileName, (String)"\u6e90\u6587\u4ef6\u5730\u5740\u5f02\u5e38");
+            parseBO.setSourceFilePath(parseBO.getTempDir().resolve(fileName).toString());
+            com.wordparse.core.FileUtil.downloadNetworkFile((String)fileUrl, (String)parseBO.getSourceFilePath());
+            sourceFile = com.wordparse.core.FileUtil.getFile((String)parseBO.getSourceFilePath());
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)fileUrl, (Object)e);
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        BizAssert.isTrue((sourceFile.length() != 0L ? 1 : 0) != 0, (String)"\u6587\u6863\u5185\u5bb9\u4e3a\u7a7a\uff01");
+        try {
+            WordParseUtil.checkSuffixAndSize(sourceFile, null);
+            String e = WordParseUtil.parse(parseBO);
+            return e;
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)fileUrl, (Object)e);
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        finally {
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+        }
+    }
+
+    public static String parseByFile(ParseParam param) {
+        MultipartFile file = param.getSourceFile();
+        WordParseUtil.checkSuffixAndSize(file, null);
+        ParseBO parseBO = new ParseBO().setLatexReplaceList(param.getLatexReplaceList()).setNewParseVersion(param.getNewParseVersion()).setFileId(param.getFileId());
+        try {
+            WordParseUtil.createTempDir(parseBO);
+            String fileName = file.getOriginalFilename();
+            BizAssert.isNotBlank((String)fileName, (String)"\u6e90\u6587\u4ef6\u5730\u5740\u5f02\u5e38");
+            assert (fileName != null);
+            parseBO.setSourceFilePath(parseBO.getTempDir().resolve(fileName).toString());
+            FileUtil.writeFromStream((InputStream)file.getInputStream(), (File)com.wordparse.core.FileUtil.getFile((String)parseBO.getSourceFilePath()));
+            String string = WordParseUtil.parse(parseBO);
+            return string;
+        }
+        catch (Exception e) {
+            log.error("\u89e3\u6790\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+            throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+        }
+        finally {
+            if (Objects.nonNull(parseBO.getTempDir())) {
+                FileUtil.del((Path)parseBO.getTempDir());
+            }
+        }
+    }
+
+    public static String parse(ParseBO parseBO) {
+        String string;
+        String preHtml;
+        if (Boolean.TRUE.equals(officeCoreConfig.getNewParseVersion())) {
+            parseBO.setNewParseVersion(true);
+        }
+        String md5 = DigestUtil.getFileMd5(parseBO.getSourceFilePath());
+        BizAssert.isNotBlank((String)md5, (String)"\u8ba1\u7b97\u6e90\u6587\u4ef6md5\u5f02\u5e38\uff01");
+        parseBO.setSourceFileMd5(md5);
+        if (Boolean.TRUE.equals(officeCoreConfig.getOpenParseCache()) && StringUtils.isNotBlank((CharSequence)(preHtml = WordParseUtil.getFileParseResult(parseBO, md5)))) {
+            return preHtml;
+        }
+        if (StringUtils.isBlank((CharSequence)parseBO.getSourceFileUrl())) {
+            String sourceFileBakPath = parseBO.getSourceFilePath() + ".JBY_BAK";
+            com.wordparse.core.FileUtil.copyFile((String)parseBO.getSourceFilePath(), (String)sourceFileBakPath, (boolean)true);
+            parseBO.setSourceFileBakPath(sourceFileBakPath);
+        }
+        if (WordParseUtil.checkIsWps(parseBO)) {
+            String newSourceFilePath = WpsConvertUtil.convertFile(parseBO.getSourceFilePath(), parseBO.getTempDir().toString(), "docx", 5L);
+            if (StringUtils.isEmpty((CharSequence)newSourceFilePath)) {
+                throw new BusinessException("wps\u8f6cdocx\u5931\u8d25\uff01");
+            }
+            parseBO.setSourceFilePath(newSourceFilePath);
+        }
+        WordParseUtil.handleFormat(parseBO);
+        parseBO.setTransformer(OMml2MmlTransformerPool.INSTANCE.borrowObject());
+        FileOutputStream os = null;
+        try {
+            StopWatch sw = new StopWatch("\u89e3\u6790word");
+            ZipSecureFile.setMinInflateRatio((double)0.001);
+            sw.start("\u52a0\u8f7d\u6e90\u6587\u4ef6");
+            File sourceFile = com.wordparse.core.FileUtil.getFile((String)parseBO.getSourceFilePath());
+            WordprocessingMLPackage wordMlPackage = WordprocessingMLPackage.load((File)sourceFile);
+            sw.stop();
+            sw.start("\u81ea\u5b9a\u4e49\u89e3\u6790");
+            WordParseUtil.customParse(wordMlPackage, parseBO);
+            sw.stop();
+            sw.start("\u8f6c\u6362\u8bbe\u7f6e");
+            HTMLSettings htmlSettings = Docx4J.createHTMLSettings();
+            htmlSettings.setImageDirPath(parseBO.getImagesDir());
+            htmlSettings.setImageTargetUri("images");
+            htmlSettings.setOpcPackage((OpcPackage)wordMlPackage);
+            sw.stop();
+            sw.start("\u6267\u884c\u8f6c\u6362");
+            os = new FileOutputStream(new File(parseBO.getHtmlPath()));
+            Docx4J.toHTML((HTMLSettings)htmlSettings, (OutputStream)os, (int)1);
+            sw.stop();
+            sw.start("\u5904\u7406\u56fe\u7247\u4e0a\u4f20OSS\u53ca\u8f6csvg");
+            WordParseUtil.dealImg(parseBO);
+            sw.stop();
+            sw.start("\u5904\u7406\u6210\u5728\u7ebf\u6587\u6863\u652f\u6301\u7684html");
+            String html = new String(Files.readAllBytes(Paths.get(parseBO.getHtmlPath(), new String[0])), StandardCharsets.UTF_8);
+            html = WordParseUtil.customParseOfficeHtml(html, parseBO);
+            sw.stop();
+            WordParseUtil.saveParseResult(parseBO, html);
+            log.info(WordParseUtil.formatAsMillis(sw));
+            string = html;
+        }
+        catch (Exception e) {
+            try {
+                log.error("wordToHtml exception:{}", (Object)e.getMessage(), (Object)e);
+                throw new BusinessException("word\u89e3\u6790\u5f02\u5e38");
+            }
+            catch (Throwable throwable) {
+                CloseIoUtil.closeAll((Closeable[])new Closeable[]{os});
+                OMml2MmlTransformerPool.INSTANCE.returnObject(parseBO.getTransformer());
+                throw throwable;
+            }
+        }
+        CloseIoUtil.closeAll((Closeable[])new Closeable[]{os});
+        OMml2MmlTransformerPool.INSTANCE.returnObject(parseBO.getTransformer());
+        return string;
+    }
+
+    private static boolean checkIsWps(ParseBO parseBO) {
+        String sourceFilePath = parseBO.getSourceFilePath();
+        File file = new File(sourceFilePath);
+        String fileName = file.getName().toLowerCase();
+        String fileSuffix = com.wordparse.core.FileUtil.getFileSuffix((String)fileName);
+        return "wps".equals(fileSuffix);
+    }
+
+    private static String uploadFileToOss(File file, String module, String folderName, String fileName) {
+        return OssServiceUtil.uploadFile(new OssParam().setModule(module).setFolder(folderName).setFile(com.wordparse.core.FileUtil.getMultipartFile((String)fileName, (File)file)));
+    }
+
+    private static void customParse(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) throws Exception {
+        NumberingDefinitionsPart numberingDefinitionsPart;
+        MainDocumentPart mainDocumentPart = wordMlPackage.getMainDocumentPart();
+        StyleDefinitionsPart styleDefinitionsPart = mainDocumentPart.getStyleDefinitionsPart();
+        if (Objects.nonNull(styleDefinitionsPart)) {
+            parseBO.setStyleDefinitionsPart(styleDefinitionsPart);
+        }
+        if (Objects.nonNull(numberingDefinitionsPart = mainDocumentPart.getNumberingDefinitionsPart())) {
+            HashMap numDefines = numberingDefinitionsPart.getInstanceListDefinitions();
+            parseBO.getNumberingDefinitionsMap().putAll(numDefines.entrySet().stream().flatMap(m1 -> ((ListNumberingDefinition)m1.getValue()).getAbstractListDefinition().getAbstractNumNode().getLvl().stream().filter(f -> Objects.nonNull(f.getStart())).map(m2 -> {
+                NumPr numPr = new NumPr();
+                numPr.setStart(m2.getStart().getVal());
+                numPr.setCurrent(numPr.getStart().subtract(BigInteger.ONE));
+                numPr.setNumFmt(Optional.ofNullable(m2.getNumFmt()).map(m -> m.getVal().toString()).orElse(""));
+                numPr.setLvlText(Optional.ofNullable(m2.getLvlText()).map(Lvl.LvlText::getVal).orElse(""));
+                return new AbstractMap.SimpleEntry<String, NumPr>((String)m1.getKey() + "_" + m2.getIlvl(), numPr);
+            })).collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)));
+        }
+        Body body = ((Document)mainDocumentPart.getJaxbElement()).getBody();
+        try {
+            CtObjectFinder ctObjectFinder = new CtObjectFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctObjectFinder);
+            MathTypeUtil.mathTypeToMathMl(parseBO.getMathTypeMap());
+            if (Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+                parseBO.getMathTypeMap().values().forEach(m -> {
+                    m = m.replace("JBYSIMJBY", "~");
+                });
+                LatexUtil.ommlMathMlToLatexIgnoreNull(parseBO.getMathTypeMap(), officeCoreConfig.getCopyrightAddresses(), parseBO.getTempDir());
+            } else {
+                LatexUtil.mathMlToLatexIgnoreNull(parseBO.getMathTypeMap(), officeCoreConfig.getCopyrightAddresses(), parseBO.getTempDir());
+            }
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790MathType\u516c\u5f0f\u5f02\u5e38", (Throwable)e);
+        }
+        try {
+            DrawingPictFinder drawingPictFinder = new DrawingPictFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)drawingPictFinder);
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u56fe\u7247\u5f02\u5e38:{}", (Object)e.getMessage(), (Object)e);
+        }
+        try {
+            CtoMathFinder ctoMathFinder = new CtoMathFinder(parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctoMathFinder);
+            if (Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+                LatexUtil.ommlAndMathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+            } else {
+                LatexUtil.mathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+            }
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u5fae\u8f6f\u6216\u57df\u516c\u5f0f\u5f02\u5e38", (Throwable)e);
+        }
+        try {
+            CtTextBoxFinder ctTextBoxFinder = new CtTextBoxFinder(wordMlPackage, parseBO);
+            new TraversalUtil((Object)body.getContent(), (TraversalUtil.Callback)ctTextBoxFinder);
+        }
+        catch (Exception e) {
+            log.error("\u81ea\u5b9a\u4e49\u89e3\u6790\u6587\u672c\u6846\u5f02\u5e38", (Throwable)e);
+        }
+        for (Object object : body.getContent()) {
+            List contentList;
+            P p;
+            String pText;
+            if (!(object instanceof P) || !StringUtils.isNotBlank((CharSequence)(pText = TextUtils.getText((Object)(p = (P)object)))) || !pText.contains("JBY_TEXTBOX_JBY") || !CollectionUtils.isNotEmpty((Collection)(contentList = p.getContent()))) continue;
+            ArrayList matchedItems = new ArrayList();
+            ArrayList unmatchedItems = new ArrayList();
+            for (Object obj : contentList) {
+                if (TextUtils.getText(obj).contains("JBY_TEXTBOX_JBY")) {
+                    matchedItems.add(obj);
+                    continue;
+                }
+                unmatchedItems.add(obj);
+            }
+            contentList.clear();
+            contentList.addAll(unmatchedItems);
+            contentList.addAll(matchedItems);
+        }
+    }
+
+    private static void uploadImgToOss(ParseBO parseBO) {
+        File folder = new File(parseBO.getImagesDir());
+        if (!folder.exists() || !folder.isDirectory()) {
+            log.info("\u672c\u5730\u6587\u4ef6\u5939\u4e0d\u5b58\u5728\u6216\u4e0d\u662f\u4e00\u4e2a\u6587\u4ef6\u5939:{}", (Object)parseBO.getImagesDir());
+            return;
+        }
+        Object[] files = folder.listFiles();
+        if (ArrayUtil.isEmpty((Object[])files)) {
+            return;
+        }
+        HashMap<String, String> tifFileNameMap = new HashMap<String, String>();
+        for (Object file : files) {
+            String fileName;
+            String suffix;
+            if (!((File)file).isFile() || StringUtils.isBlank((CharSequence)(suffix = FileUtil.getSuffix((String)(fileName = ((File)file).getName())))) || !"tif".equals(suffix = suffix.toLowerCase()) && !"tiff".equals(suffix)) continue;
+            WordParseUtil.tifToPng((File)file);
+            String baseName = FilenameUtils.getBaseName((String)fileName);
+            tifFileNameMap.put(baseName + ".png", fileName);
+        }
+        files = folder.listFiles();
+        assert (files != null);
+        for (Object file : files) {
+            String suffix;
+            if (!((File)file).isFile() || StringUtils.isBlank((CharSequence)(suffix = FileUtil.getSuffix((String)((File)file).getName())))) continue;
+            if ("wmf".equals(suffix = suffix.toLowerCase()) || "emf".equals(suffix)) {
+                byte[] fileData = new byte[]{};
+                try {
+                    fileData = Files.readAllBytes(((File)file).toPath());
+                }
+                catch (IOException e) {
+                    log.error("\u89e3\u6790\u5f02\u5e38, fileUrl:{}", (Object)((File)file).toPath(), (Object)e);
+                    throw new BusinessException("\u89e3\u6790\u5f02\u5e38");
+                }
+                String svgUrl = OfficeFileUtil.mf2svg(new ByteArrayInputStream(fileData), parseBO.getOssFolder(), ((File)file).getName());
+                String tifName = (String)tifFileNameMap.get(((File)file).getName());
+                String imgKey = "images/" + (StringUtils.isBlank((CharSequence)tifName) ? ((File)file).getName() : tifName);
+                parseBO.getImgMap().put(imgKey, svgUrl);
+                continue;
+            }
+            if ("tif".equals(suffix) || "tiff".equals(suffix)) continue;
+            String imgUrl = OssServiceUtil.uploadFile(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setFile(com.wordparse.core.FileUtil.getMultipartFile((String)((File)file).getName(), (File)file)));
+            String tifName = (String)tifFileNameMap.get(((File)file).getName());
+            String imgKey = "images/" + (StringUtils.isBlank((CharSequence)tifName) ? ((File)file).getName() : tifName);
+            parseBO.getImgMap().put(imgKey, imgUrl);
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    public static File tifToPng(File tiffFile) {
+        File file;
+        File pngFile;
+        BufferedImage image;
+        ImageInputStream imageInputStream;
+        FileInputStream is;
+        block6: {
+            is = null;
+            imageInputStream = null;
+            is = new FileInputStream(tiffFile);
+            imageInputStream = ImageIO.createImageInputStream(is);
+            Iterator<ImageReader> readers = ImageIO.getImageReaders(imageInputStream);
+            if (!readers.hasNext()) {
+                throw new BusinessException("No suitable ImageReader found for " + tiffFile.getAbsolutePath());
+            }
+            ImageReader reader = readers.next();
+            reader.setInput(imageInputStream);
+            String baseName = FilenameUtils.getBaseName((String)tiffFile.getAbsolutePath());
+            String parentFolder = tiffFile.getParentFile().getAbsolutePath();
+            image = reader.read(0);
+            pngFile = new File(parentFolder, baseName + ".png");
+            if (image.getType() != 0 && image.getType() != 0) break block6;
+            boolean hasAlpha = image.getColorModel().hasAlpha();
+            int newType = hasAlpha ? 2 : 1;
+            BufferedImage convertedImage = new BufferedImage(image.getWidth(), image.getHeight(), newType);
+            Graphics2D graphics2D = convertedImage.createGraphics();
+            graphics2D.drawImage((Image)image, 0, 0, null);
+            graphics2D.dispose();
+            ImageIO.write((RenderedImage)convertedImage, "png", pngFile);
+            File file2 = pngFile;
+            CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+            return file2;
+        }
+        try {
+            ImageIO.write((RenderedImage)image, "png", pngFile);
+            file = pngFile;
+        }
+        catch (Exception e) {
+            File file3;
+            try {
+                log.error("tifToPng error:{}", (Object)e.getMessage(), (Object)e);
+                file3 = null;
+            }
+            catch (Throwable throwable) {
+                CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+                throw throwable;
+            }
+            CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+            return file3;
+        }
+        CloseIoUtil.closeAll((Closeable[])new Closeable[]{imageInputStream, is});
+        return file;
+    }
+
+    private static void customParse(XWPFDocument document, ParseBO parseBO) {
+        if (CollectionUtils.isEmpty((Collection)document.getParagraphs())) {
+            return;
+        }
+        for (XWPFParagraph paragraph : document.getParagraphs()) {
+            org.jsoup.nodes.Document pDocument = Jsoup.parse((String)paragraph.getCTP().xmlText());
+            boolean updateXml = false;
+            if (WordParseUtil.parseOpenOfficeXml(parseBO, paragraph, pDocument)) {
+                updateXml = true;
+            }
+            if (!updateXml) continue;
+            WordParseUtil.overrideParagraph(paragraph, pDocument);
+        }
+        LatexUtil.mathMlToLatex(parseBO.getOpenOfficeXmlMap(), parseBO.getTempDir());
+    }
+
+    private static boolean parseOpenOfficeXml(ParseBO parseBO, XWPFParagraph paragraph, org.jsoup.nodes.Document pDocument) {
+        boolean updateXml = false;
+        ArrayList<String> placeholderList = new ArrayList<String>();
+        for (CTOMathPara ctoMathPara : paragraph.getCTP().getOMathParaList()) {
+            for (CTOMath ctoMath : ctoMathPara.getOMathList()) {
+                String placeholder = parseBO.getOpenOfficeXmlPlaceholder();
+                parseBO.getOpenOfficeXmlMap().put(placeholder, WordParseUtil.getMathMl(ctoMath, parseBO.getTransformer()));
+                placeholderList.add(placeholder);
+            }
+        }
+        for (CTOMath ctoMath : paragraph.getCTP().getOMathList()) {
+            String placeholder = parseBO.getOpenOfficeXmlPlaceholder();
+            parseBO.getOpenOfficeXmlMap().put(placeholder, WordParseUtil.getMathMl(ctoMath, parseBO.getTransformer()));
+            placeholderList.add(placeholder);
+        }
+        Elements oMathElements = pDocument.getElementsByTag("m:oMath");
+        if (oMathElements.size() == placeholderList.size()) {
+            for (int i = 0; i < oMathElements.size(); ++i) {
+                Element element = (Element)oMathElements.get(i);
+                Element wr = new Element("w:r");
+                wr.append(String.format(MATH_PLACEHOLDER, placeholderList.get(i)));
+                element.replaceWith((Node)wr);
+                updateXml = true;
+            }
+        }
+        return updateXml;
+    }
+
+    private static boolean parseMathType(ParseBO parseBO, org.jsoup.nodes.Document pDocument) {
+        boolean updateXml = false;
+        Elements imageDataElements = pDocument.getElementsByTag("v:imagedata");
+        for (Element element : imageDataElements) {
+            String svgUrl = parseBO.getImgMap().get(element.attr("r:id"));
+            List<TagStyleBO> styleList = TagEnum.getStyleList(element.parent());
+            Map<String, String> styleMap = styleList.stream().collect(Collectors.toMap(TagStyleBO::getAttr, TagStyleBO::getValue, (l, r) -> l));
+            double width = WordExportUtil.getPtValue(styleMap.get(AttrEnum.WIDTH.getAttr()));
+            double height = WordExportUtil.getPtValue(styleMap.get(AttrEnum.HEIGHT.getAttr()));
+            if (!StringUtils.isNotBlank((CharSequence)svgUrl)) continue;
+            Element imgElement = new Element(TagEnum.IMG.getName());
+            imgElement.attr(AttrEnum.SRC.getAttr(), svgUrl);
+            imgElement.attr(AttrEnum.WIDTH.getAttr(), width + "pt");
+            imgElement.attr(AttrEnum.HEIGHT.getAttr(), height + "pt");
+            WordParseUtil.addImgAttr(imgElement);
+            String placeholder = parseBO.getMathTypePlaceholder();
+            parseBO.getMathTypeMap().put(placeholder, imgElement.outerHtml());
+            Element parent = element.parent().parent().parent();
+            Element wr = new Element("w:r");
+            wr.append(String.format(MATH_PLACEHOLDER, placeholder));
+            parent.replaceWith((Node)wr);
+            updateXml = true;
+        }
+        return updateXml;
+    }
+
+    private static void overrideParagraph(XWPFParagraph paragraph, org.jsoup.nodes.Document pDocument) {
+        String xml = pDocument.body().html();
+        try {
+            xml = xml.replace("&nbsp;", " ");
+            CTP ctp = (CTP)CTP.Factory.parse(xml);
+            paragraph.getCTP().set((XmlObject)ctp);
+        }
+        catch (XmlException e) {
+            log.error("\u91cd\u5199\u6bb5\u843d\u5f02\u5e38, xml:{}", (Object)xml, (Object)e);
+        }
+    }
+
+    public static String getMathMl(JAXBElement<?> ctoMathEle, Transformer transformer) {
+        String oml = XmlUtils.marshaltoString(ctoMathEle, (boolean)true, (boolean)false);
+        StringReader reader = new StringReader(oml);
+        StreamSource source = new StreamSource(reader);
+        return WordParseUtil.sourceToMathMl(source, transformer);
+    }
+
+    private static String getMathMl(CTOMath ctoMath, Transformer transformer) {
+        org.w3c.dom.Node node = ctoMath.getDomNode();
+        DOMSource source = new DOMSource(node);
+        return WordParseUtil.sourceToMathMl(source, transformer);
+    }
+
+    private static String sourceToMathMl(Source source, Transformer transformer) {
+        String mathMl;
+        StringWriter stringwriter = new StringWriter();
+        StreamResult result = new StreamResult(stringwriter);
+        try {
+            transformer.transform(source, result);
+            mathMl = stringwriter.toString();
+            stringwriter.close();
+        }
+        catch (Exception e) {
+            log.error("word\u5185\u516c\u5f0f\u89e3\u6790\u5f02\u5e38\uff1a" + e.getMessage(), (Throwable)e);
+            throw new BusinessException("\u516c\u5f0f\u89e3\u6790\u5f02\u5e38\uff01");
+        }
+        mathMl = mathMl.substring(mathMl.indexOf("=\"http://www.w3.org/1998/Math/MathML\""));
+        mathMl = "<math display=\"inline\" xmlns" + mathMl;
+        mathMl = mathMl.replaceAll("mml:", "");
+        mathMl = mathMl.replaceAll("\u00a0", "~");
+        return mathMl;
+    }
+
+    private static void parsePictures(List<XWPFPictureData> pictureList, ParseBO parseBO) {
+        if (CollectionUtils.isEmpty(pictureList)) {
+            return;
+        }
+        String folderName = parseBO.getOssFolder();
+        String uniquePath = officeCoreConfig.getTmpPath() + File.separator + folderName;
+        for (XWPFPictureData picture : pictureList) {
+            String suffix;
+            if (ArrayUtil.isEmpty((byte[])picture.getData()) || StringUtils.isBlank((CharSequence)picture.getFileName()) || !Constants.IMG_SET.contains(suffix = StringUtils.isBlank((CharSequence)(suffix = com.wordparse.core.FileUtil.getFileSuffix((String)picture.getFileName()))) ? "" : suffix.toLowerCase())) continue;
+            if ("wmf".equals(suffix) || "emf".equals(suffix)) {
+                String localFilePath = uniquePath + File.separator + picture.getFileName();
+                String svgUrl = OfficeFileUtil.mf2svg(new ByteArrayInputStream(picture.getData()), parseBO.getOssFolder(), picture.getFileName());
+                parseBO.getImgMap().put(picture.getParent().getRelationId((POIXMLDocumentPart)picture), svgUrl);
+                parseBO.getImgMap().put(picture.getFileName(), svgUrl);
+                continue;
+            }
+            if ("tif".equals(suffix) || "tiff".equals(suffix)) {
+                String fileName = picture.getFileName().substring(0, picture.getFileName().lastIndexOf(".") + 1) + "png";
+                String imgUrl = WordParseUtil.tif2Png(new ByteArrayInputStream(picture.getData()), folderName, fileName);
+                parseBO.getImgMap().put(picture.getFileName(), imgUrl);
+                continue;
+            }
+            String imgUrl = WordParseUtil.uploadImg(new ByteArrayInputStream(picture.getData()), folderName, picture.getFileName());
+            parseBO.getImgMap().put(picture.getFileName(), imgUrl);
+        }
+    }
+
+    private static String uploadImg(InputStream is, String folderName, String fileName) {
+        return OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(folderName).setFileName(fileName).setInputStream(is));
+    }
+
+    private static String tif2Png(InputStream is, String folderName, String fileName) {
+        String uniquePath = officeCoreConfig.getTmpPath() + File.separator + folderName;
+        String localFilePath = uniquePath + File.separator + fileName;
+        File file = OfficeFileUtil.writeFile(is, localFilePath);
+        String imgUrl = null;
+        if (Objects.nonNull(file)) {
+            imgUrl = OssServiceUtil.uploadFile(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(folderName).setFile(com.wordparse.core.FileUtil.getMultipartFile((String)fileName, (File)file)));
+        }
+        return imgUrl;
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    private static File tif2Png(InputStream is, String imgPath) {
+        try {
+            BufferedImage image = ImageIO.read(is);
+            if (image == null) {
+                File file = null;
+                return file;
+            }
+            File file = com.wordparse.core.FileUtil.getFile((String)imgPath);
+            ImageIO.write((RenderedImage)image, "png", file);
+            image.flush();
+            File e = file;
+            return e;
+        }
+        catch (Exception e) {
+            log.error("tif2Png exception, imgPath:{}", (Object)imgPath, (Object)e);
+            File file = null;
+            return file;
+        }
+        finally {
+            if (is != null) {
+                try {
+                    is.close();
+                }
+                catch (IOException e) {
+                    log.error("close error");
+                }
+            }
+        }
+    }
+
+    private static String customParseOfficeHtml(String html, ParseBO parseBO) {
+        html = html.replaceAll("text-decoration: underline;", "");
+        html = html.replaceAll("text-decoration: jby-underline;", "text-decoration: underline;");
+        org.jsoup.nodes.Document doc = Jsoup.parse((String)html);
+        doc.outputSettings().prettyPrint(false);
+        WordParseUtil.dealUderlineSubSup(doc);
+        WordParseUtil.dealTitle(doc);
+        WordParseUtil.dealUnderlineAndLineThrough(doc);
+        WordParseUtil.dealUnderline(doc);
+        WordParseUtil.dealCustomTextDecoration(doc);
+        WordParseUtil.dealLi(doc);
+        WordParseUtil.dealSubSup(doc);
+        WordParseUtil.cleanDocument(doc);
+        WordParseUtil.dealNoSPanWhiteSpace((Element)doc);
+        WordParseUtil.dealLineHeight((Element)doc);
+        return WordParseUtil.dealPlaceholder(parseBO, doc);
+    }
+
+    private static void dealUderlineSubSup(org.jsoup.nodes.Document doc) {
+        try {
+            Elements spansWithSupSub = doc.select("span:has(sup), span:has(sub)");
+            for (Element span : spansWithSupSub) {
+                String style = span.attr("style");
+                if (style == null || !style.contains("text-decoration: underline;")) continue;
+                Elements supSubElements = span.select("sup, sub");
+                Element previousSpan = span.previousElementSibling();
+                if (previousSpan == null || !"span".equals(previousSpan.tagName())) continue;
+                for (Element supSub : supSubElements) {
+                    previousSpan.appendChild((Node)supSub);
+                }
+                span.remove();
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u5e26\u4e0b\u5212\u7ebf\u7684\u4e0a\u6807\u4e0b\u6807\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealLineHeight(Element doc) {
+        String[] patterns = new String[]{"line-height:\\s*([0-9]*\\.?[0-9]+)%", "line-height:\\s*([0-9]*\\.?[0-9]+)", "line-height:\\s*([0-9]+(?:\\.[0-9]+)?em)"};
+        Elements elements = doc.select("[style*=\"line-height\"]");
+        for (Element element : elements) {
+            String style;
+            String newStyle = style = element.attr("style");
+            for (String pStr : patterns) {
+                Pattern pattern = Pattern.compile(pStr);
+                Matcher matcher = pattern.matcher(newStyle);
+                StringBuffer sb = new StringBuffer();
+                while (matcher.find()) {
+                    double lineHeightValue;
+                    String originalValue = matcher.group(1);
+                    try {
+                        String numericValue = originalValue.replaceAll("[^0-9.]", "");
+                        lineHeightValue = Double.parseDouble(numericValue);
+                        if (pStr.contains("%")) {
+                            lineHeightValue /= 100.0;
+                        }
+                    }
+                    catch (NumberFormatException e) {
+                        lineHeightValue = 0.0;
+                    }
+                    if (lineHeightValue < 2.0) {
+                        String replacement = pStr.contains("%") ? "line-height: 200%" : (pStr.contains("em") ? "line-height: 2.0em" : "line-height: 2.0");
+                        matcher.appendReplacement(sb, replacement);
+                        continue;
+                    }
+                    matcher.appendReplacement(sb, matcher.group(0));
+                }
+                matcher.appendTail(sb);
+                newStyle = sb.toString();
+            }
+            if (newStyle.equals(style)) continue;
+            element.attr("style", newStyle);
+        }
+    }
+
+    private static void dealNoSPanWhiteSpace(Element doc) {
+        for (Node node : doc.childNodes()) {
+            if (node instanceof TextNode) {
+                TextNode textNode = (TextNode)node;
+                String text = textNode.getWholeText();
+                if (!text.contains("\u00a0")) continue;
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < text.length(); ++i) {
+                    char c = text.charAt(i);
+                    sb.append(c);
+                    if (c != '\u00a0' || i == text.length() - 1 || text.charAt(i + 1) != '\u00a0') continue;
+                    sb.append(" ");
+                }
+                text = sb.toString();
+                if (!textNode.parent().nodeName().equals("span")) {
+                    Element span = new Element("span");
+                    span.text(text);
+                    textNode.replaceWith((Node)span);
+                    continue;
+                }
+                textNode.text(text);
+                continue;
+            }
+            if (!(node instanceof Element)) continue;
+            WordParseUtil.dealNoSPanWhiteSpace((Element)node);
+        }
+    }
+
+    private static void dealWhiteSpace(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span");
+            for (Element span : elements) {
+                WordParseUtil.processSpanContent((Node)span);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u7a7a\u683c\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void processSpanContent(Node node) {
+        if (node.childNodeSize() > 0) {
+            for (Node childNode : node.childNodes()) {
+                WordParseUtil.processSpanContent(childNode);
+            }
+        } else if (node instanceof TextNode) {
+            TextNode textNode = (TextNode)node;
+            textNode.text(textNode.getWholeText().replaceAll(" ", "JBY_nbsp;"));
+        }
+    }
+
+    private static void dealTitle(org.jsoup.nodes.Document doc) {
+        try {
+            Map<String, List<Map<String, String>>> pStyleMap = WordParseUtil.parseCssRulesToMap(doc);
+            Elements elements = doc.select("p, li");
+            for (Element p : elements) {
+                String classAttr = p.attr("class");
+                if (!StringUtils.isNotBlank((CharSequence)classAttr)) continue;
+                HashMap<String, String> finalStyles = new HashMap<String, String>();
+                String existingStyle = p.attr("style");
+                HashSet<String> existingStyleKeys = new HashSet<String>();
+                if (StringUtils.isNotBlank((CharSequence)existingStyle)) {
+                    String[] stylePairs;
+                    for (String pair : stylePairs = existingStyle.split(";")) {
+                        String[] parts = pair.split(":", 2);
+                        if (parts.length != 2) continue;
+                        String string = parts[0].trim();
+                        String value = parts[1].trim();
+                        finalStyles.put(string, value);
+                        existingStyleKeys.add(string);
+                    }
+                }
+                String[] classNames = classAttr.split("\\s+");
+                ArrayList<String> orderedClassNames = new ArrayList<String>();
+                block4: for (String selector : pStyleMap.keySet()) {
+                    String className = selector.substring(1);
+                    for (String currentClass : classNames) {
+                        if (!className.equals(currentClass)) continue;
+                        orderedClassNames.add(currentClass);
+                        continue block4;
+                    }
+                }
+                for (String className : orderedClassNames) {
+                    if (!pStyleMap.containsKey("." + className)) continue;
+                    List<Map<String, String>> classStyles = pStyleMap.get("." + className);
+                    for (Map map : classStyles) {
+                        for (Map.Entry entry : map.entrySet()) {
+                            if (existingStyleKeys.contains(entry.getKey())) continue;
+                            finalStyles.put((String)entry.getKey(), (String)entry.getValue());
+                        }
+                    }
+                }
+                if (finalStyles.isEmpty()) continue;
+                StringBuilder styleBuilder = new StringBuilder();
+                for (Map.Entry entry : finalStyles.entrySet()) {
+                    styleBuilder.append((String)entry.getKey()).append(": ").append((String)entry.getValue()).append("; ");
+                }
+                p.attr("style", styleBuilder.toString().trim());
+            }
+        }
+        catch (NumberFormatException e) {
+            log.error("\u5904\u7406\u6807\u9898\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static Map<String, List<Map<String, String>>> parseCssRulesToMap(org.jsoup.nodes.Document doc) {
+        Element styleElement = doc.selectFirst("style");
+        String cssContent = styleElement.html();
+        LinkedHashMap<String, List<Map<String, String>>> cssMap = new LinkedHashMap<String, List<Map<String, String>>>();
+        if (StringUtils.isBlank((CharSequence)cssContent)) {
+            return cssMap;
+        }
+        Pattern sectionPattern = Pattern.compile("/\\* PARAGRAPH STYLES \\*/(.*?)/\\* CHARACTER STYLES \\*/", 32);
+        Matcher sectionMatcher = sectionPattern.matcher(cssContent);
+        String targetContent = "";
+        targetContent = sectionMatcher.find() ? sectionMatcher.group(1) : cssContent;
+        Pattern cssRulePattern = Pattern.compile("([^\\{]+)\\{([^\\}]+)\\}");
+        Matcher matcher = cssRulePattern.matcher(targetContent);
+        ArrayList<String> selectorOrder = new ArrayList<String>();
+        while (matcher.find()) {
+            String[] propertyPairs;
+            String selector2 = matcher.group(1).trim();
+            String properties = matcher.group(2).trim();
+            ArrayList propertyList = new ArrayList();
+            for (String propertyPair : propertyPairs = properties.split(";")) {
+                String[] parts;
+                if (!StringUtils.isNotBlank((CharSequence)propertyPair) || (parts = propertyPair.split(":", 2)).length != 2) continue;
+                HashMap<String, String> propertyMap = new HashMap<String, String>();
+                String key = parts[0].trim();
+                String value = parts[1].trim();
+                propertyMap.put(key, value);
+                propertyList.add(propertyMap);
+            }
+            cssMap.put(selector2, propertyList);
+            selectorOrder.add(selector2);
+        }
+        return selectorOrder.stream().filter(selector -> selector.startsWith(".") && cssMap.containsKey(selector)).collect(Collectors.toMap(Function.identity(), cssMap::get, (existing, replacement) -> existing, LinkedHashMap::new));
+    }
+
+    private static void cleanDocument(org.jsoup.nodes.Document doc) {
+        try {
+            Element docElement = doc.selectFirst(".document");
+            if (Objects.isNull(docElement)) {
+                return;
+            }
+            log.info("\u53bb\u9664\u975e\u5fc5\u8981\u6837\u5f0f\u914d\u7f6e\u4fe1\u606f:{}", (Object)JSON.toJSONString(officeCoreConfig.getCleanStyleMap()));
+            Elements allElements = docElement.select("*");
+            for (Element el : allElements) {
+                WordParseUtil.cleanClass(el, docElement);
+                WordParseUtil.cleanStyle(el);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u6e05\u6d01\u6587\u6863\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void cleanClass(Element el, Element docElement) {
+        if (el == docElement) {
+            return;
+        }
+        String className = Optional.ofNullable(el.className()).orElse("");
+        for (String retainClass : Constants.RETAIN_CLASS_VALUE_SET) {
+            if (!className.contains(retainClass)) continue;
+            return;
+        }
+        el.attributes().remove(AttrEnum.CLASS.getAttr());
+    }
+
+    private static void cleanStyle(Element el) {
+        if (MapUtils.isEmpty(officeCoreConfig.getCleanStyleMap())) {
+            return;
+        }
+        String oldStyle = el.attr(AttrEnum.STYLE.getAttr());
+        if (StringUtils.isBlank((CharSequence)oldStyle)) {
+            return;
+        }
+        String[] originalStyle = new String[]{oldStyle};
+        officeCoreConfig.getCleanStyleMap().forEach((tagName, styles) -> {
+            if (StringUtils.isBlank((CharSequence)tagName) || CollectionUtils.isEmpty((Collection)styles)) {
+                return;
+            }
+            styles.forEach(style -> {
+                if (StringUtils.isBlank((CharSequence)style)) {
+                    return;
+                }
+                if (tagName.equals(el.tagName())) {
+                    originalStyle[0] = originalStyle[0].replaceAll((String)style, "");
+                }
+            });
+            if (StringUtils.isBlank((CharSequence)originalStyle[0])) {
+                el.removeAttr(AttrEnum.STYLE.getAttr());
+                return;
+            }
+            String newStyle = Arrays.stream(originalStyle[0].split(";")).filter(StringUtils::isNotBlank).map(e -> e.trim() + "; ").collect(Collectors.joining()).trim();
+            el.attr(AttrEnum.STYLE.getAttr(), newStyle);
+        });
+    }
+
+    private static void dealSubSup(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style~=(?:vertical-align: (sub|super);font-size: smaller;)]");
+            for (Element span : elements) {
+                List<TagStyleBO> styles = TagEnum.getStyleList(span);
+                boolean isSub = styles.stream().anyMatch(e -> AttrEnum.VERTICAL_ALIGN.getAttr().equals(e.getAttr()) && TagEnum.SUB.getName().equals(e.getValue()));
+                Element suElement = new Element(isSub ? TagEnum.SUB.getName() : TagEnum.SUP.getName()).html(span.html());
+                if (suElement.childNodeSize() == 0) {
+                    span.remove();
+                    continue;
+                }
+                span.html(suElement.outerHtml());
+                String styleValue = styles.stream().filter(e -> !AttrEnum.VERTICAL_ALIGN.getAttr().equals(e.getAttr()) && !AttrEnum.FONT_SIZE.getAttr().equals(e.getAttr())).map(e -> e.getAttr() + ": " + e.getValue()).collect(Collectors.joining(";"));
+                if (StringUtils.isBlank((CharSequence)styleValue)) {
+                    span.removeAttr(AttrEnum.STYLE.getAttr());
+                    continue;
+                }
+                span.attr(AttrEnum.STYLE.getAttr(), styleValue);
+            }
+        }
+        catch (Exception e2) {
+            log.error("\u5904\u7406\u4e0a\u6807\u3001\u4e0b\u6807\u5f02\u5e38", (Throwable)e2);
+        }
+    }
+
+    private static void dealImg(ParseBO parseBO, org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("img[src]");
+            if (MapUtils.isNotEmpty(parseBO.getImgMap())) {
+                for (Element img : elements) {
+                    String src = img.attr(AttrEnum.SRC.getAttr());
+                    String srcUrl = parseBO.getImgMap().get(src);
+                    if (StringUtils.isNotBlank((CharSequence)srcUrl)) {
+                        img.attr(AttrEnum.SRC.getAttr(), srcUrl);
+                    }
+                    WordParseUtil.adjustWidthHeight(img);
+                    WordParseUtil.addImgAttr(img);
+                }
+            }
+            Elements elementImgNot = doc.select("img:not([src])");
+            elementImgNot.remove();
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u56fe\u7247\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void adjustWidthHeight(Element img) {
+        try {
+            String heightStr;
+            String widthStr;
+            String style = img.attr("style");
+            if (style != null && !style.isEmpty()) {
+                String widthValue = WordParseUtil.extractDimensionFromStyle(style, "width");
+                String heightValue = WordParseUtil.extractDimensionFromStyle(style, "height");
+                String newStyle = "";
+                if (widthValue != null) {
+                    String widthPx = WordParseUtil.convertToPx(widthValue);
+                    if (widthPx != null) {
+                        img.attr("width", widthPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = WordParseUtil.removeDimensionFromStyle(style, "width");
+                }
+                if (heightValue != null) {
+                    String heightPx = WordParseUtil.convertToPx(heightValue);
+                    if (heightPx != null) {
+                        img.attr("height", heightPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = WordParseUtil.removeDimensionFromStyle(newStyle, "height");
+                }
+                if (StringUtils.isBlank((CharSequence)newStyle)) {
+                    img.removeAttr("style");
+                } else {
+                    img.attr("style", newStyle);
+                }
+            }
+            if (StringUtils.isNotBlank((CharSequence)(widthStr = img.attr(AttrEnum.WIDTH.getAttr())))) {
+                double width = Double.parseDouble(Objects.requireNonNull(WordParseUtil.convertToPx(widthStr)));
+                img.attr(AttrEnum.WIDTH.getAttr(), Double.toString((double)Math.round((width /= officeCoreConfig.getImageScalingFactor().doubleValue()) * 100.0) / 100.0));
+            }
+            if (StringUtils.isNotBlank((CharSequence)(heightStr = img.attr(AttrEnum.HEIGHT.getAttr())))) {
+                double height = Double.parseDouble(Objects.requireNonNull(WordParseUtil.convertToPx(heightStr)));
+                img.attr(AttrEnum.HEIGHT.getAttr(), Double.toString((double)Math.round((height /= officeCoreConfig.getImageScalingFactor().doubleValue()) * 100.0) / 100.0));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u8c03\u6574\u5bbd\u9ad8\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static String convertToPx(String value) {
+        if (StringUtils.isBlank((CharSequence)value)) {
+            return null;
+        }
+        value = value.trim().toLowerCase();
+        Pattern pattern = Pattern.compile("([0-9.]+)\\s*([a-z%]*)");
+        Matcher matcher = pattern.matcher(value);
+        if (matcher.matches()) {
+            String unit;
+            double numericValue = Double.parseDouble(matcher.group(1));
+            switch (unit = matcher.group(2)) {
+                case "pt": {
+                    return String.valueOf(Math.round(numericValue * 4.0 / 3.0));
+                }
+                case "in": {
+                    return String.valueOf(Math.round(numericValue * 96.0));
+                }
+                case "cm": {
+                    return String.valueOf(Math.round(numericValue * 96.0 / 2.54));
+                }
+                case "mm": {
+                    return String.valueOf(Math.round(numericValue * 96.0 / 25.4));
+                }
+                case "": {
+                    return String.valueOf(Math.round(numericValue));
+                }
+            }
+            return String.valueOf(Math.round(numericValue));
+        }
+        return null;
+    }
+
+    private static String extractDimensionFromStyle(String style, String dimension) {
+        String value;
+        if (StringUtils.isBlank((CharSequence)style) || StringUtils.isBlank((CharSequence)dimension)) {
+            return null;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*([^;]+)(?:;|$)");
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find() && WordParseUtil.isValidDimensionValue(value = matcher.group(1).trim())) {
+            return value;
+        }
+        return null;
+    }
+
+    private static boolean isValidDimensionValue(String value) {
+        if (StringUtils.isBlank((CharSequence)value)) {
+            return false;
+        }
+        Pattern pattern = Pattern.compile("^[0-9]+(\\.[0-9]+)?\\s*(px|pt|in|cm|mm|%|em|rem|ex|ch|vw|vh|vmin|vmax)?$");
+        return pattern.matcher(value).matches();
+    }
+
+    private static String removeDimensionFromStyle(String style, String dimension) {
+        if (StringUtils.isBlank((CharSequence)style) || StringUtils.isBlank((CharSequence)dimension)) {
+            return style;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*[^;]+;?");
+        Matcher matcher = pattern.matcher(style);
+        String result = matcher.replaceAll("");
+        result = result.replaceAll(";;", ";").replaceAll("^;|;$", "");
+        return result;
+    }
+
+    private static void dealLi(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.getElementsByTag(TagEnum.LI.getName());
+            for (Element li : elements) {
+                String style = li.attr(AttrEnum.STYLE.getAttr()) + "line-height: 2;";
+                li.tagName(TagEnum.P.getName()).attr(AttrEnum.STYLE.getAttr(), style);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u5217\u8868\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealBookTitle(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select(":matchesOwn(\u300a|\u300b)");
+            for (int i = 0; i < elements.size(); ++i) {
+                Node node;
+                int j;
+                Element end;
+                Element start = (Element)elements.get(i);
+                if (!start.text().contains("\u300a") || i + 1 >= elements.size() || !(end = (Element)elements.get(i + 1)).text().contains("\u300b")) continue;
+                if (Objects.nonNull(start.parent()) && start.parent().equals((Object)end.parent())) {
+                    List siblings = start.parent().childNodes();
+                    int startIndex = siblings.indexOf(start);
+                    int endIndex = siblings.indexOf(end);
+                    if (startIndex == -1 || endIndex == -1 || startIndex > endIndex) continue;
+                    StringBuilder content = new StringBuilder();
+                    ArrayList<Node> deleteList = new ArrayList<Node>();
+                    for (j = startIndex; j <= endIndex; ++j) {
+                        node = (Node)siblings.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode)node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element)node).text());
+                        }
+                        if (j <= startIndex) continue;
+                        deleteList.add(node);
+                    }
+                    start.text(content.toString());
+                    deleteList.forEach(Node::remove);
+                    continue;
+                }
+                if (!Objects.nonNull(start.parent()) || !Objects.nonNull(start.parent().parent()) || !start.parent().parent().equals((Object)end.parent()) || start.parent().siblingIndex() >= end.siblingIndex()) continue;
+                StringBuilder content = new StringBuilder();
+                ArrayList<Node> deleteList = new ArrayList<Node>();
+                Element startParent = start.parent();
+                List parentChild = startParent.childNodes();
+                int startIndex = parentChild.indexOf(start);
+                if (startIndex != -1) {
+                    for (j = startIndex + 1; j < parentChild.size(); ++j) {
+                        node = (Node)parentChild.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode)node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element)node).text());
+                        }
+                        deleteList.add(node);
+                    }
+                }
+                Element grandParent = start.parent().parent();
+                List grandSiblings = grandParent.childNodes();
+                int parentIdx = grandSiblings.indexOf(startParent);
+                int endIdx = grandSiblings.indexOf(end);
+                if (parentIdx != -1 && endIdx != -1 && parentIdx < endIdx) {
+                    for (int j2 = parentIdx + 1; j2 <= endIdx; ++j2) {
+                        Node node2 = (Node)grandSiblings.get(j2);
+                        if (node2 instanceof TextNode) {
+                            content.append(((TextNode)node2).getWholeText());
+                        } else if (node2 instanceof Element) {
+                            content.append(((Element)node2).text());
+                        }
+                        deleteList.add(node2);
+                    }
+                }
+                start.text(content.toString());
+                deleteList.forEach(Node::remove);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e66\u540d\u53f7\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealUnderline(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='text-decoration: underline']");
+            for (Element u : elements) {
+                String style = u.attr("style");
+                if (!style.matches(".*text-decoration:\\s*underline\\s*(;|$).*")) continue;
+                u.tagName(TagEnum.U.getName());
+                WordParseUtil.processSpanContent((Node)u);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e0b\u5212\u7ebf\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealCustomTextDecoration(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='background-image: repeating-linear-gradient']");
+            for (Element span : elements) {
+                LinkedHashMap<String, TagStyleBO> styleMap = new LinkedHashMap<String, TagStyleBO>();
+                List<String> styles = Arrays.asList(span.attr("style").split(";"));
+                styles.forEach(style -> {
+                    if (StringUtils.isBlank((CharSequence)style)) {
+                        return;
+                    }
+                    String[] split = style.split(":");
+                    if (split.length < 2) {
+                        return;
+                    }
+                    TagStyleBO tagStyleBO = new TagStyleBO().setTagName(span.tagName()).setAttr(split[0].trim()).setValue(split[1].trim());
+                    styleMap.put(tagStyleBO.getAttr(), tagStyleBO);
+                });
+                if (!styleMap.containsKey("background-size")) {
+                    return;
+                }
+                span.addClass(((TagStyleBO)styleMap.get("background-size")).getValue().contains("11px") ? "custom-text-decoration-double-dot-dashed" : "custom-text-decoration-dot-dashed");
+                ArrayList newStyleList = new ArrayList();
+                styleMap.forEach((key, value) -> {
+                    if (!Constants.DOT_DASHED_STYLE_SET.contains(key)) {
+                        newStyleList.add(value.getAttr() + ": " + value.getValue() + ";");
+                    }
+                });
+                if (CollectionUtils.isEmpty(newStyleList)) {
+                    span.removeAttr(AttrEnum.STYLE.getAttr());
+                    continue;
+                }
+                span.attr(AttrEnum.STYLE.getAttr(), String.join((CharSequence)" ", newStyleList));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u81ea\u5b9a\u4e49\u6587\u672c\u88c5\u9970\uff08\u70b9\u5212\u7ebf\uff09\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealUnderlineAndLineThrough(org.jsoup.nodes.Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='jby-line-through: true']");
+            for (int i = elements.size() - 1; i >= 0; --i) {
+                Element span = (Element)elements.get(i);
+                Element wrapper = new Element("span");
+                wrapper.attr("style", "text-decoration: line-through");
+                span.replaceWith((Node)wrapper);
+                wrapper.appendChild((Node)span);
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u4e0b\u5212\u7ebf\u548c\u5220\u9664\u5e76\u5b58\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static String dealPlaceholder(ParseBO parseBO, org.jsoup.nodes.Document doc) {
+        String result = doc.html();
+        if (MapUtils.isNotEmpty(parseBO.getImageMap())) {
+            for (Map.Entry<String, ImageBO> entry : parseBO.getImageMap().entrySet()) {
+                String imgUrl = entry.getValue().getPictureUrl();
+                Element element = new Element(TagEnum.IMG.getName());
+                element.attr(AttrEnum.SRC.getAttr(), imgUrl);
+                element.attr(AttrEnum.WIDTH.getAttr(), String.valueOf(entry.getValue().getWidth().intValue()));
+                element.attr(AttrEnum.HEIGHT.getAttr(), String.valueOf(entry.getValue().getHeight().intValue()));
+                WordParseUtil.addImgAttr(element);
+                result = result.replace(entry.getKey(), element.outerHtml());
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getOpenOfficeXmlMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getOpenOfficeXmlMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getMathTypeMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getMathTypeMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(parseBO.getEqLatexMap())) {
+            for (Map.Entry<String, Object> entry : parseBO.getEqLatexMap().entrySet()) {
+                result = WordParseUtil.dealPlaceholder(parseBO, entry, result, true);
+            }
+        }
+        result = result.replaceAll("JBY_nbsp;", "&nbsp;");
+        result = result.replaceAll("font-style: italic;", "font-style: italic; z-index: 1;");
+        result = result.replaceAll("border-color: #auto;", "border-color: transparent;");
+        result = result.replaceAll("JBY_TEXTBOX_JBYBR", "<br/>");
+        result = result.replaceAll("JBY_TEXTBOX_JBY", "");
+        result = result.replaceAll(">\\s+(?=<(?!/span))", ">");
+        result = result.replaceAll("(background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;)\\s*background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;", "$1");
+        for (Iterator<Map.Entry<String, Object>> iterator : SYMBOL) {
+            Element imgElement = new Element(TagEnum.IMG.getName());
+            imgElement.attr(AttrEnum.SRC.getAttr(), "https://resource.xinjiaoyu.com/prod/office/unicode-symbol/" + ((String)((Object)iterator)).substring(2).toUpperCase() + ".svg");
+            imgElement.attr(AttrEnum.WIDTH.getAttr(), "14");
+            imgElement.attr(AttrEnum.HEIGHT.getAttr(), "14");
+            result = result.replace("@@@" + ((String)((Object)iterator)).substring(2).toUpperCase() + "@@@", imgElement.outerHtml());
+            result = result.replace("\ue225\ue226", "\\(\\rightleftharpoons\\)");
+        }
+        WordParseUtil.writeHtml(result);
+        return result;
+    }
+
+    private static String dealPlaceholder(ParseBO parseBO, Map.Entry<String, String> entry, String html, Boolean isEq) {
+        String value = entry.getValue();
+        if (isEq.booleanValue() || !Boolean.TRUE.equals(parseBO.getNewParseVersion())) {
+            value = WordParseUtil.latexReplace(parseBO.getLatexReplaceList(), value);
+        }
+        if (!value.startsWith("<img") && !entry.getKey().endsWith("JBYEQNUM")) {
+            value = "\\(" + value + "\\)";
+        }
+        html = html.replace(entry.getKey(), value);
+        log.info("latexReplace,\u66ff\u6362\u524d{},\u66ff\u6362\u540e{}", (Object)entry.getValue(), (Object)value);
+        return html;
+    }
+
+    private static String latexReplace(List<JSONObject> latexReplaceList, String latex) {
+        try {
+            if (StringUtils.isBlank((CharSequence)latex)) {
+                return latex;
+            }
+            if (CollectionUtils.isEmpty(latexReplaceList)) {
+                return latex;
+            }
+            if (latex.startsWith("<img")) {
+                return latex;
+            }
+            for (JSONObject latexReplace : latexReplaceList) {
+                String key = latexReplace.getString("key");
+                String value = latexReplace.getString("value");
+                if (StringUtils.isBlank((CharSequence)key) || StringUtils.isBlank((CharSequence)value)) continue;
+                latex = latex.replaceAll(key, value);
+            }
+            return WordParseUtil.wrapTextColorWithBraces(latex);
+        }
+        catch (Exception e) {
+            log.error("latex\u516c\u5f0f\u89c4\u8303\u6b63\u5219\u66ff\u6362\u5904\u7406\u5f02\u5e38:{}", (Object)latex, (Object)e);
+            return latex;
+        }
+    }
+
+    public static String wrapTextColorWithBraces(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        Pattern pattern = Pattern.compile("\\\\textcolor\\[rgb\\]\\{[^}]*\\}\\{");
+        ArrayList<int[]> matches = new ArrayList<int[]>();
+        Matcher matcher = pattern.matcher(input);
+        int start = 0;
+        while (matcher.find(start)) {
+            int contentStart = matcher.end() - 1;
+            int depth = 0;
+            for (int pos = contentStart; pos < input.length(); ++pos) {
+                char c = input.charAt(pos);
+                if (c == '{') {
+                    ++depth;
+                    continue;
+                }
+                if (c != '}' || --depth != 0) continue;
+                matches.add(new int[]{matcher.start(), pos});
+                break;
+            }
+            start = matcher.start() + 1;
+        }
+        matches.sort(Comparator.comparingInt(a -> -a[0]));
+        StringBuilder sb = new StringBuilder(input);
+        for (int[] match : matches) {
+            int s = match[0];
+            int e = match[1];
+            sb.insert(e + 1, '}');
+            sb.insert(s, '{');
+        }
+        return sb.toString();
+    }
+
+    public static Element getMatchParent(Element element, String cssQuery) {
+        if (element == null) {
+            return null;
+        }
+        if (element.is(cssQuery)) {
+            return element;
+        }
+        return WordParseUtil.getMatchParent(element.parent(), cssQuery);
+    }
+
+    public static void addImgAttr(Element img) {
+        img.attr("data-default-src", img.attr(AttrEnum.SRC.getAttr()));
+        img.attr(AttrEnum.CLASS.getAttr(), "img-t");
+        img.attr("data-mce-resize", "false");
+    }
+
+    public static void checkSuffixAndSize(File file, Integer checkSize) {
+        WordParseUtil.validSuffix(file.getName());
+        WordParseUtil.validSize(file.length(), checkSize);
+    }
+
+    public static void checkSuffixAndSize(MultipartFile file, Integer checkSize) {
+        WordParseUtil.validSuffix(file.getOriginalFilename());
+        WordParseUtil.validSize(file.getSize(), checkSize);
+    }
+
+    private static void validSuffix(String filename) {
+        if (StringUtils.isBlank((CharSequence)filename)) {
+            throw new BusinessException("\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff01");
+        }
+        String suffix = com.wordparse.core.FileUtil.getFileSuffix((String)filename);
+        BizAssert.isTrue(("docx".equalsIgnoreCase(suffix) || "wps".equalsIgnoreCase(suffix) ? 1 : 0) != 0, (String)"\u4ec5\u652f\u6301docx\u683c\u5f0f\u548cwps\u6587\u6863\u89e3\u6790\uff01");
+    }
+
+    public static void validSize(double fileSize, Integer checkSize) {
+        if (checkSize == null || checkSize <= 0) {
+            checkSize = officeCoreConfig.getCheckSize();
+        }
+        BizAssert.isTrue(((fileSize /= 1048576.0) <= (double)checkSize.intValue() ? 1 : 0) != 0, (String)"\u6587\u4ef6\u5927\u5c0f\u8d85\u51fa\u9650\u5b9a\u503c\uff01");
+    }
+
+    private static void createTempDir(ParseBO parseBO) {
+        try {
+            Path tempDir = Files.createTempDirectory(Paths.get(officeCoreConfig.getTmpPath(), new String[0]), "parse-", new FileAttribute[0]);
+            parseBO.setTempDir(tempDir);
+            parseBO.setImagesDir(tempDir.resolve("images").toString());
+            parseBO.setHtmlPath(tempDir.resolve("output.html").toString());
+            parseBO.setOssFolder(tempDir.getFileName().toString());
+        }
+        catch (IOException e) {
+            log.error("\u521b\u5efa\u4e34\u65f6\u6587\u4ef6\u5939\u5f02\u5e38");
+        }
+    }
+
+    private static void writeHtml(String html) {
+        if (!"local".equals(SpringContextHolder.getActiveProfile())) {
+            return;
+        }
+        String savePath = officeCoreConfig.getTmpPath() + "/upload" + File.separator + UniqueUtil.getUuid() + "." + "html";
+        File file = OfficeFileUtil.writeFile(html, savePath);
+        log.info("==========================================\u672c\u5730html\u6587\u4ef6\u8def\u5f84\uff1a{}", (Object)file.getPath());
+    }
+
+    private static void handleFormat(ParseBO parseBO) {
+        String tempDir = parseBO.getTempDir() + "/temp";
+        try {
+            WordParseUtil.unzipDocx(parseBO.getSourceFilePath(), tempDir);
+            String content = "";
+            Path path = Paths.get(tempDir + "/word/document.xml", new String[0]);
+            try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8);){
+                content = reader.lines().collect(Collectors.joining(System.lineSeparator()));
+                if (content.contains("<w:b w:val=\"off\"")) {
+                    content = content.replace("<w:b w:val=\"off\"", "<w:b w:val=\"0\"");
+                }
+                if (content.contains("<w:i w:val=\"off\"")) {
+                    content = content.replace("<w:i w:val=\"off\"", "<w:i w:val=\"0\"");
+                }
+                content = content.replaceAll("[\\u200B\\u200C\\u200D]", "");
+                content = content.replaceAll("\\u00A0", " ");
+                content = content.replaceAll("\\uf028", "(");
+                content = content.replaceAll("\\uf029", ")");
+                for (String sl : SYMBOL) {
+                    content = content.replaceAll(sl, "@@@" + sl.substring(2).toUpperCase() + "@@@");
+                }
+                content = content.replace("<w:shd w:val=\"pct15\" w:color=\"auto\" w:fill=\"FFFFFF\"/>", "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"D9D9D9\"/>");
+                content = content.replace("<w:shd w:val=\"pct10\" w:color=\"auto\" w:fill=\"FFFFFF\"/>", "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"E5E5E5\"/>");
+            }
+            catch (IOException e) {
+                log.error("\u5904\u7406\u6e90\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff1a{}", (Object)e.getMessage(), (Object)e);
+            }
+            Files.write(path, content.getBytes(StandardCharsets.UTF_8), new OpenOption[0]);
+            WordParseUtil.zipToDocx(tempDir, parseBO.getSourceFilePath());
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u6e90\u6587\u4ef6\u683c\u5f0f\u5f02\u5e38\uff1a{}", (Object)e.getMessage(), (Object)e);
+        }
+    }
+
+    private static void unzipDocx(String docxPath, String outputDir) throws IOException {
+        File dir = new File(outputDir);
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+        try (ZipFile zipFile = new ZipFile(docxPath);){
+            Enumeration<? extends ZipEntry> entries = zipFile.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                File entryFile = new File(outputDir, entry.getName());
+                if (entry.isDirectory()) {
+                    entryFile.mkdirs();
+                    continue;
+                }
+                entryFile.getParentFile().mkdirs();
+                InputStream is = zipFile.getInputStream(entry);
+                Throwable throwable = null;
+                try {
+                    FileOutputStream fos = new FileOutputStream(entryFile);
+                    Throwable throwable2 = null;
+                    try {
+                        int len;
+                        byte[] buffer = new byte[1024];
+                        while ((len = is.read(buffer)) > 0) {
+                            fos.write(buffer, 0, len);
+                        }
+                    }
+                    catch (Throwable throwable3) {
+                        throwable2 = throwable3;
+                        throw throwable3;
+                    }
+                    finally {
+                        if (fos == null) continue;
+                        if (throwable2 != null) {
+                            try {
+                                fos.close();
+                            }
+                            catch (Throwable throwable4) {
+                                throwable2.addSuppressed(throwable4);
+                            }
+                            continue;
+                        }
+                        fos.close();
+                    }
+                }
+                catch (Throwable throwable5) {
+                    throwable = throwable5;
+                    throw throwable5;
+                }
+                finally {
+                    if (is == null) continue;
+                    if (throwable != null) {
+                        try {
+                            is.close();
+                        }
+                        catch (Throwable throwable6) {
+                            throwable.addSuppressed(throwable6);
+                        }
+                        continue;
+                    }
+                    is.close();
+                }
+            }
+        }
+    }
+
+    private static void zipToDocx(String sourceDir, String outputDocx) throws IOException {
+        try (FileOutputStream fos = new FileOutputStream(outputDocx);
+             ZipOutputStream zos = new ZipOutputStream(fos);){
+            File rootDir = new File(sourceDir);
+            WordParseUtil.addFolderToZip(rootDir, rootDir, zos);
+        }
+    }
+
+    private static void addFolderToZip(File rootDir, File folder, ZipOutputStream zos) throws IOException {
+        for (File file : Objects.requireNonNull(folder.listFiles())) {
+            if (file.isDirectory()) {
+                WordParseUtil.addFolderToZip(rootDir, file, zos);
+                continue;
+            }
+            String entryName = rootDir.toPath().relativize(file.toPath()).toString().replace(File.separator, "/");
+            ZipEntry zipEntry = new ZipEntry(entryName);
+            zos.putNextEntry(zipEntry);
+            try (FileInputStream fis = new FileInputStream(file);){
+                int len;
+                byte[] buffer = new byte[1024];
+                while ((len = fis.read(buffer)) > 0) {
+                    zos.write(buffer, 0, len);
+                }
+            }
+            zos.closeEntry();
+        }
+    }
+
+    private static String getFileParseResult(ParseBO parseBO, String md5) {
+        try {
+            OfficeFileParseRecordVO officeFileParseRecord = (OfficeFileParseRecordVO)FeignUtils.parse((Result)fileServiceFeign.getOfficeFileParseRecordByMd5(md5));
+            if (Objects.nonNull(officeFileParseRecord)) {
+                log.info("\u6587\u4ef6\u5df2\u88ab\u89e3\u6790\u8fc7,MD5: {}", (Object)md5);
+                OfficeFileParseRecordParam officeFileParseRecordParam = new OfficeFileParseRecordParam().setFileUrl(officeFileParseRecord.getFileUrl()).setFileMd5(officeFileParseRecord.getFileMd5()).setFileParseUrl(officeFileParseRecord.getFileParseUrl()).setFileId(parseBO.getFileId());
+                FeignUtils.parse((Result)fileServiceFeign.saveOfficeFileParseRecord(officeFileParseRecordParam));
+                return HttpClientUtil.doGet((String)com.wordparse.core.FileUtil.encodeUrl((String)officeFileParseRecord.getFileParseUrl()));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u83b7\u53d6\u5386\u53f2\u89e3\u6790\u7ed3\u679c\u5f02\u5e38, md5: {}", (Object)md5, (Object)e);
+        }
+        return null;
+    }
+
+    private static void saveParseResult(ParseBO parseBO, String html) {
+        try {
+            String sourceFilePath = parseBO.getSourceFilePath();
+            String sourceFileBakPath = parseBO.getSourceFileBakPath();
+            if (StringUtils.isBlank((CharSequence)parseBO.getSourceFileUrl()) && StringUtils.isNotBlank((CharSequence)sourceFileBakPath)) {
+                File bakFile = new File(sourceFileBakPath);
+                String fileName = StringUtils.removeEnd((String)bakFile.getName(), (String)".JBY_BAK");
+                parseBO.setSourceFileUrl(WordParseUtil.uploadFileToOss(bakFile, "office/file/parse", parseBO.getOssFolder(), fileName));
+            }
+            String resultFilePath = sourceFilePath.substring(0, sourceFilePath.lastIndexOf(46)) + ".html";
+            File resultFile = OfficeFileUtil.writeFile(html, resultFilePath);
+            String fileParseUrl = WordParseUtil.uploadFileToOss(resultFile, "office/file/parse", parseBO.getOssFolder(), resultFile.getName());
+            if (StringUtils.isNotBlank((CharSequence)parseBO.getSourceFileUrl()) && StringUtils.isNotBlank((CharSequence)parseBO.getSourceFileMd5()) && StringUtils.isNotBlank((CharSequence)fileParseUrl)) {
+                OfficeFileParseRecordParam param = new OfficeFileParseRecordParam();
+                param.setFileUrl(parseBO.getSourceFileUrl());
+                param.setFileMd5(parseBO.getSourceFileMd5());
+                param.setFileParseUrl(fileParseUrl);
+                param.setFileId(parseBO.getFileId());
+                FeignUtils.parse((Result)fileServiceFeign.saveOfficeFileParseRecord(param));
+            }
+        }
+        catch (Exception e) {
+            log.error("\u4e0a\u4f20oss\u6216\u4fdd\u5b58\u89e3\u6790\u8bb0\u5f55\u5f02\u5e38", (Throwable)e);
+        }
+    }
+
+    private static void dealImg(ParseBO parseBO) {
+        HashMap<String, String> imgMap = new HashMap<String, String>();
+        HashMap urlToUuidMap = new HashMap();
+        HashMap keyToImgMap = new HashMap();
+        parseBO.getImageMap().forEach((key, value) -> {
+            if (value != null && value.getPictureUrl() != null) {
+                String url = value.getPictureUrl();
+                String uuid = urlToUuidMap.computeIfAbsent(url, k -> UniqueUtil.getUuid());
+                imgMap.put(uuid, url);
+                keyToImgMap.put(key, uuid);
+            }
+        });
+        ArrayList futuresOss = new ArrayList();
+        imgMap.forEach((key, value) -> {
+            CompletionStage future = CompletableFuture.runAsync(() -> {
+                try {
+                    String imgUrl;
+                    String fullPath = parseBO.getTempDir() + "/temp" + value;
+                    String fileName = fullPath.substring(fullPath.lastIndexOf("/") + 1);
+                    String fileSuffix = com.wordparse.core.FileUtil.getFileSuffix((String)fullPath).toLowerCase();
+                    if ("tif".equals(fileSuffix) || "tiff".equals(fileSuffix)) {
+                        WordParseUtil.tifToPng(new File(fullPath));
+                        fullPath = fullPath.replaceAll("(?i)" + Pattern.quote(fileSuffix) + "$", "png");
+                        fileName = fileName.replaceAll("(?i)" + Pattern.quote(fileSuffix) + "$", "png");
+                        imgUrl = OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setInputStream(Files.newInputStream(Paths.get(fullPath, new String[0]), new OpenOption[0])).setFileName(fileName));
+                    } else {
+                        imgUrl = "wmf".equals(fileSuffix) || "emf".equals(fileSuffix) ? OfficeFileUtil.mf2svg(new ByteArrayInputStream(FileUtil.readBytes((String)fullPath)), fullPath) : OssServiceUtil.uploadStream(new OssParam().setModule(AttachmentModuleEnum.OFFICE_IMG.getModule()).setFolder(parseBO.getOssFolder()).setInputStream(Files.newInputStream(Paths.get(fullPath, new String[0]), new OpenOption[0])).setFileName(fileName));
+                    }
+                    imgMap.put((String)key, StringUtils.isNotBlank((CharSequence)imgUrl) ? imgUrl : fullPath);
+                }
+                catch (IOException e) {
+                    log.error("\u5904\u7406\u56fe\u7247\u5931\u8d25, key: {}, value: {}", new Object[]{key, value, e});
+                }
+            }, WordParseUtil.getBatchDealPicExecutor()).exceptionally(throwable -> {
+                log.error("\u5904\u7406\u56fe\u7247\u5f02\u5e38", throwable);
+                return null;
+            });
+            futuresOss.add(future);
+        });
+        if (CollectionUtils.isNotEmpty(futuresOss)) {
+            try {
+                CompletableFuture.allOf(futuresOss.toArray(new CompletableFuture[0])).get(5L, TimeUnit.MINUTES);
+                log.info("\u56fe\u7247\u5904\u7406\u5b8c\u6210");
+            }
+            catch (TimeoutException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u8d85\u65f6", (Throwable)e);
+            }
+            catch (InterruptedException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u88ab\u4e2d\u65ad", (Throwable)e);
+                Thread.currentThread().interrupt();
+            }
+            catch (ExecutionException e) {
+                log.error("\u56fe\u7247\u5904\u7406\u5f02\u5e38", e.getCause());
+            }
+        }
+        parseBO.getImageMap().forEach((key, value) -> value.setPictureUrl((String)imgMap.get(keyToImgMap.get(key))));
+    }
+
+    public static String formatAsMillis(StopWatch sw) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(sw.getId()).append("\n");
+        sb.append("---------------------------------------------\n");
+        sb.append(String.format("%-10s %-6s %s%n", "ms", "%", "Task name"));
+        sb.append("---------------------------------------------\n");
+        long totalMillis = Math.max(1L, sw.getTotalTimeMillis());
+        for (StopWatch.TaskInfo task : sw.getTaskInfo()) {
+            long ms = task.getTimeMillis();
+            int pct = (int)Math.round(100.0 * (double)ms / (double)totalMillis);
+            sb.append(String.format("%-10d %-6s %s%n", ms, pct + "%", task.getTaskName()));
+        }
+        return sb.toString();
+    }
+}
+
diff --git a/java-svc/Dockerfile b/java-svc/Dockerfile
new file mode 100644
index 0000000..26d629e
--- /dev/null
+++ b/java-svc/Dockerfile
@@ -0,0 +1,36 @@
+# WordFileParse Java Service — Docker build with pre-built JAR
+# First build JAR locally: mvn package -DskipTests
+# Then: docker build -t wordparse-java -f java-svc/Dockerfile .
+FROM eclipse-temurin:17-jdk
+
+# Install Ruby + Python + build deps
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-venv \
+    ruby ruby-dev build-essential libxml2-dev libxslt-dev pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install pre-built Ruby gems (except nokogiri — compiled for current Ruby)
+COPY scripts/mathtype2mathml/install/gems/one/*.gem \
+     scripts/mathtype2mathml/install/gems/two/bindata-*.gem \
+     scripts/mathtype2mathml/install/gems/two/concurrent-ruby-*.gem \
+     scripts/mathtype2mathml/install/gems/two/mini_portile2-*.gem \
+     scripts/mathtype2mathml/install/gems/two/pry-*.gem \
+     scripts/mathtype2mathml/install/gems/two/ruby-ole-*.gem \
+     scripts/mathtype2mathml/install/gems/third/parallel-*.gem \
+     /tmp/gems/
+RUN gem install /tmp/gems/*.gem --no-doc && rm -rf /tmp/gems
+RUN gem install nokogiri --no-doc
+
+WORKDIR /app
+
+# Copy transform scripts
+COPY scripts/ /opt/transform/
+
+# Python deps for omml_mathml2latex
+RUN pip3 install --break-system-packages -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple lxml
+
+# Copy pre-built JAR
+COPY java-svc/target/word-file-parse-1.0.0.jar /app/app.jar
+
+EXPOSE 8080
+CMD ["java", "-jar", "/app/app.jar"]
diff --git a/java-svc/pom.xml b/java-svc/pom.xml
new file mode 100644
index 0000000..1352501
--- /dev/null
+++ b/java-svc/pom.xml
@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.2.5</version>
+    </parent>
+
+    <groupId>com.wordparse</groupId>
+    <artifactId>word-file-parse</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    <name>WordFileParse</name>
+
+    <properties>
+        <java.version>17</java.version>
+        <docx4j.version>8.3.9</docx4j.version>
+    </properties>
+
+    <dependencies>
+        <!-- Spring Boot Web -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- Docx4J 8.x (Word → HTML) -->
+        <dependency>
+            <groupId>org.docx4j</groupId>
+            <artifactId>docx4j-core</artifactId>
+            <version>${docx4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.docx4j</groupId>
+            <artifactId>docx4j-JAXB-ReferenceImpl</artifactId>
+            <version>${docx4j.version}</version>
+        </dependency>
+
+        <!-- Jsoup (HTML post-processing) -->
+        <dependency>
+            <groupId>org.jsoup</groupId>
+            <artifactId>jsoup</artifactId>
+            <version>1.17.2</version>
+        </dependency>
+
+        <!-- Apache Commons -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.4</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.16.1</version>
+        </dependency>
+
+        <!-- FastJSON -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>2.0.51</version>
+        </dependency>
+
+        <!-- AWS S3 SDK (RustFS) -->
+        <dependency>
+            <groupId>software.amazon.awssdk</groupId>
+            <artifactId>s3</artifactId>
+            <version>2.25.27</version>
+        </dependency>
+
+        
+        <dependency>
+            <groupId>org.glassfish.jaxb</groupId>
+            <artifactId>jaxb-runtime</artifactId>
+            <version>2.3.1</version>
+        </dependency>
+        <dependency>
+            <groupId>net.sf.saxon</groupId>
+            <artifactId>Saxon-HE</artifactId>
+            <version>12.5</version>
+        </dependency>
+
+        <!-- ImageIO for TIFF handling -->
+        <dependency>
+            <groupId>com.twelvemonkeys.imageio</groupId>
+            <artifactId>imageio-tiff</artifactId>
+            <version>3.11.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>1.18.32</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/java-svc/src/main/java/com/wordparse/WordParseApplication.java b/java-svc/src/main/java/com/wordparse/WordParseApplication.java
new file mode 100644
index 0000000..5d54da6
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/WordParseApplication.java
@@ -0,0 +1,13 @@
+package com.wordparse;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+
+@SpringBootApplication
+@EnableConfigurationProperties
+public class WordParseApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(WordParseApplication.class, args);
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/config/WordParseConfig.java b/java-svc/src/main/java/com/wordparse/config/WordParseConfig.java
new file mode 100644
index 0000000..fbc965f
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/config/WordParseConfig.java
@@ -0,0 +1,28 @@
+package com.wordparse.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.Map;
+
+@Configuration
+@ConfigurationProperties(prefix = "wordparse")
+public class WordParseConfig {
+    private String tmpPath = System.getProperty("java.io.tmpdir");
+    private Double imageScalingFactor = 2.0;
+    private Map<String, String[]> cleanStyleMap = Map.of();
+    private String transformScriptsPath = "/opt/transform";
+    private String pythonCommand = "python3";
+
+    public String getTmpPath() { return tmpPath; }
+    public Double getImageScalingFactor() { return imageScalingFactor; }
+    public Map<String, String[]> getCleanStyleMap() { return cleanStyleMap; }
+    public String getTransformScriptsPath() { return transformScriptsPath; }
+    public String getPythonCommand() { return pythonCommand; }
+
+    public void setTmpPath(String v) { this.tmpPath = v; }
+    public void setImageScalingFactor(Double v) { this.imageScalingFactor = v; }
+    public void setCleanStyleMap(Map<String, String[]> v) { this.cleanStyleMap = v; }
+    public void setTransformScriptsPath(String v) { this.transformScriptsPath = v; }
+    public void setPythonCommand(String v) { this.pythonCommand = v; }
+}
diff --git a/java-svc/src/main/java/com/wordparse/controller/WordParseController.java b/java-svc/src/main/java/com/wordparse/controller/WordParseController.java
new file mode 100644
index 0000000..6686574
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/controller/WordParseController.java
@@ -0,0 +1,53 @@
+package com.wordparse.controller;
+
+import com.wordparse.core.WordParseUtil;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.Map;
+import java.util.UUID;
+
+
+@RestController
+@RequestMapping("/api/v3/server_office_file/file")
+public class WordParseController {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(WordParseController.class);
+
+    private final WordParseUtil wordParseUtil;
+
+    public WordParseController(WordParseUtil wordParseUtil) {
+        this.wordParseUtil = wordParseUtil;
+    }
+
+    @PostMapping(value = "/parse", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    public Map<String, Object> parseFile(
+            @RequestParam("file") MultipartFile file,
+            @RequestParam(value = "fileId", required = false) String fileId) {
+
+        if (file.isEmpty()) throw new IllegalArgumentException("File is empty");
+
+        String name = file.getOriginalFilename();
+        if (name == null || !name.toLowerCase().endsWith(".docx")) {
+            throw new IllegalArgumentException("Only .docx files supported");
+        }
+
+        try {
+            String html = wordParseUtil.parseBytes(file.getBytes());
+            String fid = fileId != null ? fileId : UUID.randomUUID().toString();
+            log.info("Parse success: file={}, fileId={}, htmlLen={}", name, fid, html.length());
+            return Map.of("fileId", fid, "content", html);
+        } catch (Exception e) {
+            log.error("Parse failed: {}", name, e);
+            throw new RuntimeException("Parse failed: " + e.getMessage(), e);
+        }
+    }
+
+    @GetMapping("/health")
+    public Map<String, String> health() {
+        return Map.of("status", "ok");
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/CtObjectFinder.java b/java-svc/src/main/java/com/wordparse/core/CtObjectFinder.java
new file mode 100644
index 0000000..5fdb071
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/CtObjectFinder.java
@@ -0,0 +1,46 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import java.util.List;
+import java.util.Objects;
+import org.docx4j.TraversalUtil;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+
+public class CtObjectFinder
+extends TraversalUtil.CallbackImpl {
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+
+    public CtObjectFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof CTOLEObject) {
+            CTOLEObject ctoleObject = (CTOLEObject)o;
+            RelationshipsPart rsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            if (Objects.nonNull(ctoleObject.getId())) {
+                Part part = rsPart.getPart(ctoleObject.getId());
+                String binFilePath = part.getPartName().getURI().getPath();
+                String placeholder = this.parseBO.getMathTypePlaceholder(ctoleObject.getId());
+                this.parseBO.getMathTypeMap().put(placeholder, this.parseBO.getTempDir() + "/temp" + binFilePath);
+            }
+        }
+        return null;
+    }
+}
+
diff --git a/java-svc/src/main/java/com/wordparse/core/CtTextBoxFinder.java b/java-svc/src/main/java/com/wordparse/core/CtTextBoxFinder.java
new file mode 100644
index 0000000..035653c
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/CtTextBoxFinder.java
@@ -0,0 +1,123 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TextUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.mce.AlternateContent
+ *  org.docx4j.mce.AlternateContent$Fallback
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.vml.CTGroup
+ *  org.docx4j.vml.CTRoundRect
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.CTTextbox
+ *  org.docx4j.vml.VmlShapeElements
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import java.util.List;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.mce.AlternateContent;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.vml.CTGroup;
+import org.docx4j.vml.CTRoundRect;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.CTTextbox;
+import org.docx4j.vml.VmlShapeElements;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class CtTextBoxFinder extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtTextBoxFinder.class);
+    private WordprocessingMLPackage wordMlPackage;
+    private ParseBO parseBO;
+
+    public CtTextBoxFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof Pict) {
+            boolean isFirstRun = true;
+            ObjectFactory factory = new ObjectFactory();
+            StringBuilder stringBuilder = new StringBuilder();
+            R sourceR = factory.createR();
+            Pict pict = (Pict)o;
+            List anyAndAny = pict.getAnyAndAny();
+            for (Object object : anyAndAny) {
+                if (!(object instanceof JAXBElement)) continue;
+                JAXBElement jbe = (JAXBElement)object;
+                this.findTextBox(jbe.getValue(), stringBuilder, isFirstRun, sourceR);
+            }
+            if (StringUtils.isNotBlank((CharSequence)stringBuilder.toString())) {
+                AlternateContent.Fallback fallback = (AlternateContent.Fallback)pict.getParent();
+                AlternateContent alternateContent = (AlternateContent)fallback.getParent();
+                R r = (R)alternateContent.getParent();
+                Text text = factory.createText();
+                text.setValue(stringBuilder + "WP_TEXTBOX_WP");
+                r.getContent().set(0, text);
+                r.setRPr(sourceR.getRPr());
+            }
+        }
+        return null;
+    }
+
+    private void findTextBox(Object object, StringBuilder sb, boolean isFirstRun, R sourceR) {
+        block8: {
+            List egShapeElements;
+            if (object instanceof CTShape || object instanceof CTRoundRect) {
+                VmlShapeElements vmlShapeElements = (VmlShapeElements)object;
+                egShapeElements = vmlShapeElements.getEGShapeElements();
+                for (Object o : egShapeElements) {
+                    JAXBElement egShapeElement = (JAXBElement) o;
+                    if (!(egShapeElement.getValue() instanceof CTTextbox)) continue;
+                    CTTextbox ctTextbox = (CTTextbox)egShapeElement.getValue();
+                    CTTxbxContent txbxContent = ctTextbox.getTxbxContent();
+                    for (int i = 0; i < txbxContent.getContent().size(); ++i) {
+                        Object obj = txbxContent.getContent().get(i);
+                        String text = TextUtils.getText(obj);
+                        if (txbxContent.getContent().size() > 1 && i != txbxContent.getContent().size() - 1) {
+                            text = text + "WP_TEXTBOX_BR";
+                        }
+                        sb.append(text);
+                    }
+                }
+            }
+            if (!(object instanceof CTGroup)) break block8;
+            CTGroup ctGroup = (CTGroup)object;
+            egShapeElements = ctGroup.getEGShapeElements();
+            boolean isCtShape = egShapeElements.stream().anyMatch(f -> ((JAXBElement)f).getValue() instanceof CTShape);
+            if (isCtShape) {
+                for (int i = egShapeElements.size() - 1; i >= 0; --i) {
+                    this.findTextBox(((JAXBElement)egShapeElements.get(i)).getValue(), sb, isFirstRun, sourceR);
+                }
+            } else {
+                for (Object o : egShapeElements) {
+                    JAXBElement egShapeElement = (JAXBElement) o;
+                    this.findTextBox(egShapeElement.getValue(), sb, isFirstRun, sourceR);
+                }
+            }
+        }
+    }
+}
+
diff --git a/java-svc/src/main/java/com/wordparse/core/CtoMathFinder.java b/java-svc/src/main/java/com/wordparse/core/CtoMathFinder.java
new file mode 100644
index 0000000..b09cc9d
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/CtoMathFinder.java
@@ -0,0 +1,421 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.XmlUtils
+ *  org.docx4j.math.CTOMath
+ *  org.docx4j.math.CTOMathPara
+ *  org.docx4j.wml.CTTxbxContent
+ *  org.docx4j.wml.CTVerticalAlignRun
+ *  org.docx4j.wml.FldChar
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.P
+ *  org.docx4j.wml.PPr
+ *  org.docx4j.wml.PPrBase$NumPr
+ *  org.docx4j.wml.PPrBase$NumPr$Ilvl
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.RPrAbstract
+ *  org.docx4j.wml.STFldCharType
+ *  org.docx4j.wml.Style
+ *  org.docx4j.wml.Text
+ *  org.docx4j.wml.U
+ *  org.docx4j.wml.UnderlineEnumeration
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import com.wordparse.core.ParseBO;
+import com.wordparse.core.NumPr;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.math.CTOMath;
+import org.docx4j.math.CTOMathPara;
+import org.docx4j.wml.CTTxbxContent;
+import org.docx4j.wml.CTVerticalAlignRun;
+import org.docx4j.wml.FldChar;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.P;
+import org.docx4j.wml.PPr;
+import org.docx4j.wml.PPrBase;
+import org.docx4j.wml.R;
+import org.docx4j.wml.RPrAbstract;
+import org.docx4j.wml.STFldCharType;
+import org.docx4j.wml.Style;
+import org.docx4j.wml.Text;
+import org.docx4j.wml.U;
+import org.docx4j.wml.UnderlineEnumeration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CtoMathFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(CtoMathFinder.class);
+    private ParseBO parseBO;
+    private static final Pattern CIRCLED_NUMBER_PATTERN = Pattern.compile("^\\s*eq\\s*\\\\o\\((?:\u25cb,\\\\s\\\\up\\d+\\((\\d+)\\)|\\\\s\\\\up\\d+\\((\\d+)\\),\u25cb)\\)");
+
+    public CtoMathFinder(ParseBO parseBO) {
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        if (o instanceof P) {
+            Text text;
+            Style style;
+            CTTxbxContent ctTxbxContent;
+            StringBuilder eqCode = new StringBuilder();
+            StringBuilder originEqCode = new StringBuilder();
+            boolean inFiled = false;
+            boolean isEq = false;
+            boolean superScriptFlag = false;
+            boolean subScriptFlag = false;
+            ArrayList<Integer> fieldRunIndexs = new ArrayList<Integer>();
+            P paragraph = (P)o;
+            ObjectFactory factory = new ObjectFactory();
+            boolean isNumPr = true;
+            if (paragraph.getParent() instanceof CTTxbxContent) {
+                isNumPr = false;
+            }
+            PPr pPr = paragraph.getPPr();
+            PPrBase.NumPr numPr = null;
+            if (Objects.nonNull(pPr)) {
+                numPr = pPr.getNumPr();
+            }
+            if (Objects.isNull(numPr) && Objects.nonNull(pPr) && Objects.nonNull(pPr.getPStyle()) && this.parseBO.getStyleDefinitionsPart() != null) {
+                // Style-based numPr lookup — skipped (StyleDefinitionsPart not ported)
+            }
+            if (isNumPr && Objects.nonNull(numPr) && Objects.nonNull(numPr.getNumId()) && Objects.nonNull(numPr.getIlvl())) {
+                String numPrKey = numPr.getNumId().getVal() + "_" + numPr.getIlvl().getVal();
+                Map<String, NumPr> numberingDefinitionsMap = this.parseBO.getNumberingDefinitionsMap();
+                if (numberingDefinitionsMap.containsKey(numPrKey)) {
+                    NumPr currentNumPr = numberingDefinitionsMap.get(numPrKey);
+                    String lvlText = currentNumPr.getLvlText();
+                    for (int i = 0; i <= numPr.getIlvl().getVal().intValue(); ++i) {
+                        NumPr numPrDefine;
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            currentNumPr.setCurrent(currentNumPr.getCurrent().add(BigInteger.ONE));
+                        }
+                        String rep = String.valueOf((numPrDefine = numberingDefinitionsMap.get(numPr.getNumId().getVal() + "_" + i)).getCurrent().compareTo(BigInteger.ZERO) == 0 ? numPrDefine.getStart() : numPrDefine.getCurrent());
+                        if (i == numPr.getIlvl().getVal().intValue()) {
+                            switch (currentNumPr.getNumFmt()) {
+                                case "UPPER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep);
+                                    break;
+                                }
+                                case "DECIMAL_ZERO": {
+                                    rep = CtoMathFinder.strToDecimalZero(rep);
+                                    break;
+                                }
+                                case "LOWER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep);
+                                    break;
+                                }
+                                case "UPPER_LETTER": {
+                                    rep = CtoMathFinder.strToLowerLetter(rep).toUpperCase();
+                                    break;
+                                }
+                                case "LOWER_ROMAN": {
+                                    rep = this.strToUpperRoman(rep).toLowerCase();
+                                    break;
+                                }
+                                case "CHINESE_COUNTING": 
+                                case "CHINESE_COUNTING_THOUSAND": {
+                                    rep = this.strToChineseCounting(rep);
+                                    break;
+                                }
+                            }
+                        }
+                        lvlText = lvlText.replace("%" + (i + 1), rep);
+                    }
+                    if (StringUtils.isNotBlank((CharSequence)lvlText)) {
+                        R run = factory.createR();
+                        text = factory.createText();
+                        text.setValue(lvlText + "  ");
+                        run.getContent().add(text);
+                        paragraph.getContent().add(0, run);
+                    }
+                }
+            }
+            for (int i = 0; i < paragraph.getContent().size(); ++i) {
+                JAXBElement jaxbElement;
+                Object content = paragraph.getContent().get(i);
+                if (content instanceof JAXBElement && ((jaxbElement = (JAXBElement)content).getValue() instanceof CTOMath || jaxbElement.getValue() instanceof CTOMathPara)) {
+                    String placeholder = "";
+                    if (Boolean.TRUE.equals(this.parseBO.getNewParseVersion())) {
+                        String omml = XmlUtils.marshaltoString((Object)jaxbElement);
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, omml);
+                    } else {
+                        String mathMl = WordParseUtil.getMathMl(jaxbElement, this.parseBO.getTransformer());
+                        placeholder = this.parseBO.getOpenOfficeXmlPlaceholder();
+                        this.parseBO.getOpenOfficeXmlMap().put(placeholder, mathMl);
+                    }
+                    R run = factory.createR();
+                    text = factory.createText();
+                    text.setValue(placeholder);
+                    run.getContent().add(text);
+                    paragraph.getContent().set(i, run);
+                }
+                if (!(content instanceof R)) continue;
+                R run = (R)content;
+                for (int j = 0; j < run.getContent().size(); ++j) {
+                    Object runC = run.getContent().get(j);
+                    if (!(runC instanceof JAXBElement)) continue;
+                    JAXBElement runCj = (JAXBElement)runC;
+                    if (runCj.getValue() instanceof FldChar) {
+                        FldChar fldChar = (FldChar)runCj.getValue();
+                        if (fldChar.getFldCharType().equals((Object)STFldCharType.BEGIN)) {
+                            eqCode = new StringBuilder();
+                            originEqCode = new StringBuilder();
+                            inFiled = true;
+                            isEq = false;
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                            fieldRunIndexs = new ArrayList();
+                            fieldRunIndexs.add(i);
+                            continue;
+                        }
+                        if (inFiled && fldChar.getFldCharType().equals((Object)STFldCharType.END)) {
+                            if (isEq) {
+                                String placeholder;
+                                Matcher matcher = CIRCLED_NUMBER_PATTERN.matcher(originEqCode);
+                                if (matcher.matches()) {
+                                    String numStr = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
+                                    placeholder = this.parseBO.getEqLatexPlaceholder() + "WPEQNUM";
+                                    this.parseBO.getEqLatexMap().put(placeholder, CtoMathFinder.getCircledNumber(numStr));
+                                    R runN = factory.createR();
+                                    Text text2 = factory.createText();
+                                    text2.setValue(placeholder);
+                                    runN.getContent().add(text2);
+                                    paragraph.getContent().set(i, runN);
+                                } else if (StringUtils.isNotBlank((CharSequence)eqCode.toString())) {
+                                    String latex = EqToLatexUtil.convert(eqCode.toString());
+                                    latex = latex.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+                                    placeholder = this.parseBO.getEqLatexPlaceholder() + "WPEQNUM";
+                                    this.parseBO.getEqLatexMap().put(placeholder, latex);
+                                    R runN = factory.createR();
+                                    Text text3 = factory.createText();
+                                    text3.setValue(placeholder);
+                                    runN.getContent().add(text3);
+                                    paragraph.getContent().set(i, runN);
+                                }
+                            }
+                            inFiled = false;
+                            isEq = false;
+                            fieldRunIndexs.clear();
+                            continue;
+                        }
+                        if (inFiled && isEq && !fldChar.getFldCharType().value().equals("separate")) continue;
+                    }
+                    if (!inFiled || !(runCj.getValue() instanceof Text)) continue;
+                    CTVerticalAlignRun vertAlign = Optional.ofNullable(run.getRPr()).map(RPrAbstract::getVertAlign).orElse(null);
+                    String value = ((Text)runCj.getValue()).getValue();
+                    originEqCode.append(value);
+                    U u = Optional.ofNullable(run.getRPr()).filter(f -> Objects.nonNull(f.getU()) && !UnderlineEnumeration.NONE.equals((Object)f.getU().getVal()) && Objects.nonNull(f.getU().getVal())).map(RPrAbstract::getU).orElse(null);
+                    if (StringUtils.isBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = value.replace("\u3000", "WPU1WPU").replace(" ", "WPU1WPU");
+                    } else if (StringUtils.isNotBlank((CharSequence)value) && Objects.nonNull(u)) {
+                        value = "WPU2BEGIN" + value + "WPU2END";
+                    } else if (StringUtils.isBlank((CharSequence)value)) {
+                        // empty if block
+                    }
+                    String trimmedOrigin = CtoMathFinder.extractEqPrefix(originEqCode);
+                    if (trimmedOrigin.startsWith("eq")) {
+                        isEq = true;
+                    }
+                    if (isEq) {
+                        if (CollectionUtils.isNotEmpty(fieldRunIndexs)) {
+                            fieldRunIndexs.forEach(m -> paragraph.getContent().set((int)m, factory.createR()));
+                            fieldRunIndexs.clear();
+                        }
+                        if (Objects.nonNull(vertAlign)) {
+                            String newContent;
+                            String tmp;
+                            if ("superscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (superScriptFlag && (start = eqCode.lastIndexOf("\\s\\up4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\up4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\up4(" + value + ")";
+                                }
+                                superScriptFlag = true;
+                                subScriptFlag = false;
+                            } else if ("subscript".equalsIgnoreCase(vertAlign.getVal().toString())) {
+                                int end;
+                                int start;
+                                if (subScriptFlag && (start = eqCode.lastIndexOf("\\s\\do4(")) != -1 && (end = eqCode.toString().indexOf(41, start)) != -1) {
+                                    tmp = eqCode.substring(start + 7, end);
+                                    newContent = tmp + value;
+                                    eqCode = new StringBuilder(eqCode.substring(0, start));
+                                    eqCode.append("\\s\\do4(").append(newContent).append(")");
+                                    value = "";
+                                }
+                                if (StringUtils.isNotBlank((CharSequence)value)) {
+                                    value = "\\s\\do4(" + value + ")";
+                                }
+                                subScriptFlag = true;
+                                superScriptFlag = false;
+                            } else {
+                                superScriptFlag = false;
+                                subScriptFlag = false;
+                            }
+                        } else {
+                            superScriptFlag = false;
+                            subScriptFlag = false;
+                        }
+                        eqCode.append(value);
+                        paragraph.getContent().set(i, factory.createR());
+                        continue;
+                    }
+                    if (trimmedOrigin.length() < 2 || "eq".startsWith(trimmedOrigin)) {
+                        eqCode.append(value);
+                        fieldRunIndexs.add(i);
+                        continue;
+                    }
+                    inFiled = false;
+                    fieldRunIndexs.clear();
+                }
+            }
+        }
+        return null;
+    }
+
+    private String strToUpperRoman(String str) {
+        int num = Integer.parseInt(str);
+        if (num < 1 || num > 3999) {
+            return "I";
+        }
+        int[] values = new int[]{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        String[] symbols = new String[]{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+        StringBuilder roman = new StringBuilder();
+        for (int i = 0; i < values.length; ++i) {
+            while (num >= values[i]) {
+                roman.append(symbols[i]);
+                num -= values[i];
+            }
+        }
+        return roman.toString();
+    }
+
+    private static String strToDecimalZero(String str) {
+        if (str.length() == 1) {
+            return "0" + str;
+        }
+        return str;
+    }
+
+    private static String strToLowerLetter(String str) {
+        int n = Integer.parseInt(str);
+        int length = (n - 1) / 26 + 1;
+        char baseChar = (char)(97 + (n - 1) % 26);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; ++i) {
+            sb.append(baseChar);
+        }
+        return sb.toString();
+    }
+
+    public String strToChineseCounting(String str) {
+        String s;
+        int num = Integer.parseInt(str);
+        if (num < 0 || num >= 1000000000) {
+            throw new IllegalArgumentException("\u4ec5\u652f\u6301 0 \u5230 999,999,999");
+        }
+        if (num == 0) {
+            return "\u3007";
+        }
+        char[] digits = new char[]{'\u3007', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d'};
+        String[] units = new String[]{"", "\u5341", "\u767e", "\u5343"};
+        String[] bigUnits = new String[]{"", "\u4e07", "\u4ebf"};
+        StringBuilder result = new StringBuilder();
+        int yi = num / 100000000;
+        int wan = num / 10000 % 10000;
+        int ge = num % 10000;
+        if (yi > 0) {
+            result.append(CtoMathFinder.convertSegment(yi, digits, units)).append(bigUnits[2]);
+            if (wan == 0 && ge > 0) {
+                result.append('\u3007');
+            }
+        }
+        if (wan > 0) {
+            result.append(CtoMathFinder.convertSegment(wan, digits, units)).append(bigUnits[1]);
+            if (ge > 0 && ge < 1000) {
+                result.append('\u3007');
+            }
+        }
+        if (ge > 0) {
+            result.append(CtoMathFinder.convertSegment(ge, digits, units));
+        }
+        if ((s = result.toString()).startsWith("\u4e00\u5341")) {
+            s = s.substring(1);
+        }
+        return s;
+    }
+
+    private static String convertSegment(int n, char[] digits, String[] units) {
+        if (n == 0) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 4; ++i) {
+            int power = 3 - i;
+            int base = (int)Math.pow(10.0, power);
+            int digit = n / base % 10;
+            if (digit != 0) {
+                sb.append(digits[digit]).append(units[power]);
+                continue;
+            }
+            if (sb.length() <= 0 || n % base == 0 || power <= 0) continue;
+            sb.append('\u3007');
+        }
+        return sb.toString();
+    }
+
+    private static String getCircledNumber(String num) {
+        int n = Integer.parseInt(num);
+        if (n >= 1 && n <= 20) {
+            return String.valueOf((char)(9312 + n - 1));
+        }
+        if (n >= 21 && n <= 35) {
+            return String.valueOf((char)(12881 + n - 21));
+        }
+        if (n >= 36 && n <= 40) {
+            return String.valueOf((char)(12977 + n - 36));
+        }
+        if (n >= 41 && n <= 50) {
+            return String.valueOf((char)(12982 + n - 41));
+        }
+        log.info("\u83b7\u53d6\u5e26\u5708\u5b57\u7b26\u5931\u8d25 {}", (Object)num);
+        return "";
+    }
+
+    private static String extractEqPrefix(StringBuilder originEqCode) {
+        int i;
+        String s = originEqCode.toString().trim();
+        for (i = 0; i < s.length() && s.charAt(i) == '{'; ++i) {
+        }
+        return s.substring(i).trim().toLowerCase();
+    }
+}
+
diff --git a/java-svc/src/main/java/com/wordparse/core/DrawingPictFinder.java b/java-svc/src/main/java/com/wordparse/core/DrawingPictFinder.java
new file mode 100644
index 0000000..17d1ba4
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/DrawingPictFinder.java
@@ -0,0 +1,433 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  com.alibaba.excel.util.StringUtils
+ *  java.util.UUID
+ *  javax.xml.bind.JAXBElement
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.docx4j.TraversalUtil$CallbackImpl
+ *  org.docx4j.dml.GraphicData
+ *  org.docx4j.dml.picture.Pic
+ *  org.docx4j.dml.wordprocessingDrawing.Anchor
+ *  org.docx4j.dml.wordprocessingDrawing.Inline
+ *  org.docx4j.openpackaging.packages.WordprocessingMLPackage
+ *  org.docx4j.openpackaging.parts.Part
+ *  org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage
+ *  org.docx4j.openpackaging.parts.relationships.RelationshipsPart
+ *  org.docx4j.vml.CTImageData
+ *  org.docx4j.vml.CTShape
+ *  org.docx4j.vml.officedrawing.CTOLEObject
+ *  org.docx4j.wml.CTObject
+ *  org.docx4j.wml.Drawing
+ *  org.docx4j.wml.ObjectFactory
+ *  org.docx4j.wml.Pict
+ *  org.docx4j.wml.R
+ *  org.docx4j.wml.Text
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package com.wordparse.core;
+
+import java.util.UUID;
+import com.wordparse.core.ImageBO;
+import com.wordparse.core.ParseBO;
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.imageio.ImageIO;
+import org.apache.commons.lang3.StringUtils;
+import javax.xml.bind.JAXBElement;
+import org.apache.commons.collections4.CollectionUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.dml.GraphicData;
+import org.docx4j.dml.picture.Pic;
+import org.docx4j.dml.wordprocessingDrawing.Anchor;
+import org.docx4j.dml.wordprocessingDrawing.Inline;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.Part;
+import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.vml.CTImageData;
+import org.docx4j.vml.CTShape;
+import org.docx4j.vml.officedrawing.CTOLEObject;
+import org.docx4j.wml.CTObject;
+import org.docx4j.wml.Drawing;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.Pict;
+import org.docx4j.wml.R;
+import org.docx4j.wml.Text;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DrawingPictFinder
+extends TraversalUtil.CallbackImpl {
+    private static final Logger log = LoggerFactory.getLogger(DrawingPictFinder.class);
+    private final WordprocessingMLPackage wordMlPackage;
+    private final ParseBO parseBO;
+    private static final double CROP_SCALE = 1.52587890625;
+
+    public DrawingPictFinder(WordprocessingMLPackage wordMlPackage, ParseBO parseBO) {
+        this.wordMlPackage = wordMlPackage;
+        this.parseBO = parseBO;
+    }
+
+    public List<Object> apply(Object o) {
+        List contentList;
+        List anyAndAny;
+        R r;
+        if (o instanceof Drawing && ((Drawing)o).getParent() instanceof R) {
+            RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+            Drawing drawing = (Drawing)o;
+            List anchorOrInline = drawing.getAnchorOrInline();
+            if (CollectionUtils.isNotEmpty((Collection)anchorOrInline)) {
+                Object anchorOrInlineObj = anchorOrInline.get(0);
+                GraphicData graphicData = null;
+                long cx = 0L;
+                long cy = 0L;
+                if (anchorOrInlineObj instanceof Inline) {
+                    Inline inline = (Inline)anchorOrInlineObj;
+                    graphicData = inline.getGraphic().getGraphicData();
+                    cx = inline.getExtent().getCx();
+                    cy = inline.getExtent().getCy();
+                } else if (anchorOrInlineObj instanceof Anchor) {
+                    Anchor anchor = (Anchor)anchorOrInlineObj;
+                    graphicData = anchor.getGraphic().getGraphicData();
+                    cx = anchor.getExtent().getCx();
+                    cy = anchor.getExtent().getCy();
+                }
+                if (Objects.nonNull(graphicData) && "http://schemas.openxmlformats.org/drawingml/2006/picture".equals(graphicData.getUri())) {
+                    for (Object object : graphicData.getAny()) {
+                        String path;
+                        JAXBElement jaxbElement;
+                        if (!(object instanceof JAXBElement) || !((jaxbElement = (JAXBElement)object).getValue() instanceof Pic)) continue;
+                        Pic pic = (Pic)jaxbElement.getValue();
+                        String imageDataId = null;
+                        int cropLeft = 0;
+                        int cropTop = 0;
+                        int cropRight = 0;
+                        int cropBottom = 0;
+                        int rotation = 0;
+                        if (Objects.nonNull(pic.getBlipFill())) {
+                            if (Objects.nonNull(pic.getBlipFill().getBlip())) {
+                                imageDataId = pic.getBlipFill().getBlip().getEmbed();
+                            }
+                            if (Objects.nonNull(pic.getBlipFill().getSrcRect())) {
+                                cropLeft = pic.getBlipFill().getSrcRect().getL();
+                                cropTop = pic.getBlipFill().getSrcRect().getT();
+                                cropRight = pic.getBlipFill().getSrcRect().getR();
+                                cropBottom = pic.getBlipFill().getSrcRect().getB();
+                            }
+                            if (Objects.nonNull(pic.getSpPr()) && Objects.nonNull(pic.getSpPr().getXfrm())) {
+                                rotation = pic.getSpPr().getXfrm().getRot();
+                            }
+                        }
+                        Map<String, Object> map = this.dealCropRotate(imageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                        Object widthObj = map.get("width");
+                        Object heightObj = map.get("height");
+                        Object pathObj = map.get("imagePath");
+                        double width = Objects.nonNull(widthObj) ? Double.parseDouble(widthObj.toString()) : (double)Math.round((double)cx / 9525.0);
+                        double height = Objects.nonNull(heightObj) ? Double.parseDouble(heightObj.toString()) : (double)Math.round((double)cy / 9525.0);
+                        Part part = relationshipsPart.getPart(imageDataId);
+                        if (Objects.nonNull(pathObj)) {
+                            path = String.valueOf(pathObj);
+                        } else if (Objects.nonNull(part)) {
+                            path = part.getPartName().getURI().getPath();
+                        } else {
+                            log.warn("\u65e0\u6cd5\u83b7\u53d6\u56fe\u7247Part\uff0cimageDataId={}", (Object)imageDataId);
+                            continue;
+                        }
+                        String imagePlaceholder = this.parseBO.getImagePlaceholder(imageDataId);
+                        ImageBO imageBO = new ImageBO().setWidth(width).setHeight(height).setPictureUrl(path);
+                        this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                        R r2 = (R)drawing.getParent();
+                        List contentList2 = r2.getContent();
+                        int drawingIndex = contentList2.indexOf(drawing);
+                        if (drawingIndex != -1) {
+                            Text text = new ObjectFactory().createText();
+                            text.setValue(imagePlaceholder);
+                            contentList2.set(drawingIndex, text);
+                            continue;
+                        }
+                        log.warn("\u672a\u627e\u5230drawing\u5bf9\u8c61\u5728\u7236\u5143\u7d20\u4e2d\u7684\u7d22\u5f15\uff0c\u8df3\u8fc7\u66ff\u6362\u64cd\u4f5c");
+                    }
+                }
+            }
+        }
+        if (o instanceof Pict && ((Pict)o).getParent() instanceof R) {
+            Pict pict = (Pict)o;
+            r = (R)pict.getParent();
+            anyAndAny = pict.getAnyAndAny();
+            contentList = r.getContent();
+            int pictIndex = contentList.indexOf(pict);
+            if (pictIndex != -1) {
+                this.dealCtShape(anyAndAny, r, pictIndex);
+            }
+        }
+        if (o instanceof CTObject && ((CTObject)o).getParent() instanceof R) {
+            CTObject ctObject = (CTObject)o;
+            r = (R)ctObject.getParent();
+            anyAndAny = ctObject.getAnyAndAny();
+            contentList = r.getContent();
+            int ctObjectIndex = contentList.indexOf(ctObject);
+            if (ctObjectIndex != -1) {
+                this.dealCtShape(anyAndAny, r, ctObjectIndex);
+            }
+        }
+        return null;
+    }
+
+    private String extractValue(String style, String property) {
+        if (style == null || property == null) {
+            return null;
+        }
+        String regex = "\\b" + Pattern.quote(property) + "\\s*:\\s*([\\d.]+[a-zA-Z]*)";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+
+    private void dealCtShape(List<Object> anyAndAny, R r, int pictIndex) {
+        String ctOleObjectRid = anyAndAny.stream().filter(f -> f instanceof JAXBElement && ((JAXBElement)f).getValue() instanceof CTOLEObject).map(f -> ((CTOLEObject)((JAXBElement)f).getValue()).getId()).filter(Objects::nonNull).findFirst().orElse(null);
+        if (Objects.nonNull(ctOleObjectRid) && Objects.nonNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            Text text = new ObjectFactory().createText();
+            text.setValue(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            r.getContent().set(pictIndex, text);
+        } else if (Objects.isNull(ctOleObjectRid) || Objects.isNull(this.parseBO.getMathTypeMap().get(this.parseBO.getMathTypePlaceholder(ctOleObjectRid)))) {
+            if (Objects.nonNull(ctOleObjectRid)) {
+                this.parseBO.getMathTypeMap().remove(this.parseBO.getMathTypePlaceholder(ctOleObjectRid));
+            }
+            for (Object object : anyAndAny) {
+                String path;
+                double heightPx;
+                double widthPx;
+                if (!(object instanceof JAXBElement) || !(((JAXBElement)object).getValue() instanceof CTShape)) continue;
+                CTShape ctShape = (CTShape)((JAXBElement)object).getValue();
+                String width = this.extractValue(ctShape.getStyle(), "width");
+                String height = this.extractValue(ctShape.getStyle(), "height");
+                CTImageData ctImageData = ctShape.getEGShapeElements().stream().filter(f -> f.getValue() instanceof CTImageData).map(m -> (CTImageData)m.getValue()).findFirst().orElse(null);
+                if (!Objects.nonNull(ctImageData) || !StringUtils.isNotBlank((CharSequence)width) || !StringUtils.isNotBlank((CharSequence)height)) continue;
+                String ctImageDataId = ctImageData.getId();
+                long cx = 0L;
+                try {
+                    double widthPtIn = Double.parseDouble(width.substring(0, width.length() - 2));
+                    if (width.endsWith("pt")) {
+                        cx = Math.round(widthPtIn * 12700.0);
+                    } else if (width.endsWith("in")) {
+                        cx = Math.round(widthPtIn * 914400.0);
+                    }
+                }
+                catch (NumberFormatException ignored) {
+                    log.error("extractWidth error");
+                }
+                int cropLeft = this.parseVmlCrop(ctImageData.getCropleft());
+                int cropTop = this.parseVmlCrop(ctImageData.getCroptop());
+                int cropRight = this.parseVmlCrop(ctImageData.getCropright());
+                int cropBottom = this.parseVmlCrop(ctImageData.getCropbottom());
+                String rotRaw = this.extractValue(ctShape.getStyle(), "rotation");
+                int rotation = rotRaw == null ? 0 : (int)Math.round((double)Long.parseLong(rotRaw.replaceAll("[^\\d-]", "")) * 0.91552734375);
+                Map<String, Object> map = this.dealCropRotate(ctImageDataId, cx, cropLeft, cropTop, cropRight, cropBottom, rotation);
+                Object widthObj = map.get("width");
+                Object heightObj = map.get("height");
+                Object pathObj = map.get("imagePath");
+                if (Objects.nonNull(widthObj) && Objects.nonNull(heightObj)) {
+                    widthPx = (Double)map.get("width");
+                    heightPx = (Double)map.get("height");
+                } else {
+                    widthPx = Double.parseDouble(width.replaceAll("pt|in", ""));
+                    if (width.endsWith("pt")) {
+                        widthPx = Math.round(widthPx * 96.0 / 72.0);
+                    } else if (width.endsWith("in")) {
+                        widthPx = Math.round(widthPx * 96.0);
+                    }
+                    heightPx = Double.parseDouble(height.replaceAll("pt|in", ""));
+                    if (height.endsWith("pt")) {
+                        heightPx = heightPx * 96.0 / 72.0;
+                    } else if (height.endsWith("in")) {
+                        heightPx *= 96.0;
+                    }
+                }
+                RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                Part part = relationshipsPart.getPart(ctImageDataId);
+                if (Objects.nonNull(pathObj)) {
+                    path = String.valueOf(pathObj);
+                } else if (Objects.nonNull(part)) {
+                    path = part.getPartName().getURI().getPath();
+                } else {
+                    log.warn("\u65e0\u6cd5\u83b7\u53d6\u8001\u7248VML\u56fe\u7247Part\uff0cctImageDataId={}", (Object)ctImageDataId);
+                    continue;
+                }
+                ImageBO imageBO = new ImageBO().setWidth(widthPx).setHeight(heightPx).setPictureUrl(path);
+                String imagePlaceholder = this.parseBO.getImagePlaceholder(ctImageDataId);
+                this.parseBO.getImageMap().put(imagePlaceholder, imageBO);
+                Text text = new ObjectFactory().createText();
+                text.setValue(imagePlaceholder);
+                r.getContent().set(pictIndex, text);
+                break;
+            }
+        }
+    }
+
+    private Map<String, Object> dealCropRotate(String imageDataId, long cx, int cropLeft, int cropTop, int cropRight, int cropBottom, int rotation) {
+        HashMap<String, Object> result = new HashMap<String, Object>();
+        try {
+            if (Objects.nonNull(imageDataId)) {
+                boolean isRotate;
+                boolean isCrop = cropLeft > 0 || cropTop > 0 || cropRight > 0 || cropBottom > 0;
+                boolean bl = isRotate = rotation != 0;
+                if (isCrop || isRotate) {
+                    RelationshipsPart relationshipsPart = this.wordMlPackage.getMainDocumentPart().getRelationshipsPart();
+                    Part part = relationshipsPart.getPart(imageDataId);
+                    BinaryPartAbstractImage imagePart = (BinaryPartAbstractImage)part;
+                    BufferedImage targetImage = ImageIO.read(new ByteArrayInputStream(imagePart.getBytes()));
+                    if (isCrop) {
+                        targetImage = this.cropImage(targetImage, cropLeft, cropTop, cropRight, cropBottom);
+                    }
+                    if (isRotate) {
+                        targetImage = this.rotateImage(targetImage, rotation, cx, result);
+                    }
+                    if (Objects.nonNull(targetImage)) {
+                        String formatName = this.getFormatName(imagePart);
+                        String path = "/word/media/" + UUID.randomUUID().toString() + "." + formatName;
+                        ImageIO.write((RenderedImage)targetImage, formatName, new File(this.parseBO.getTempDir() + "/temp" + path));
+                        result.put("imagePath", path);
+                    }
+                }
+            }
+        }
+        catch (Exception e) {
+            log.error("\u5904\u7406\u56fe\u7247\u88c1\u526a\u4e0e\u65cb\u8f6c\u5f02\u5e38", (Throwable)e);
+        }
+        return result;
+    }
+
+    private String getFormatName(BinaryPartAbstractImage imagePart) {
+        String contentType = imagePart.getContentType();
+        String formatName = contentType.contains("png") ? "png" : (contentType.contains("jpeg") ? "jpeg" : (contentType.contains("gif") ? "gif" : (contentType.contains("bmp") ? "bmp" : "png")));
+        return formatName;
+    }
+
+    public BufferedImage cropImage(BufferedImage originalImage, int srcRectL, int srcRectT, int srcRectR, int srcRectB) {
+        double leftRatio = srcRectL < 0 ? 0.0 : (double)srcRectL / 100000.0;
+        double topRatio = srcRectT < 0 ? 0.0 : (double)srcRectT / 100000.0;
+        double rightRatio = srcRectR < 0 ? 0.0 : (double)srcRectR / 100000.0;
+        double bottomRatio = srcRectB < 0 ? 0.0 : (double)srcRectB / 100000.0;
+        int originalWidth = originalImage.getWidth();
+        int originalHeight = originalImage.getHeight();
+        int left = (int)Math.floor(leftRatio * (double)originalWidth);
+        int top = (int)Math.floor(topRatio * (double)originalHeight);
+        int right = (int)Math.floor(rightRatio * (double)originalWidth);
+        int bottom = (int)Math.floor(bottomRatio * (double)originalHeight);
+        int cropWidth = Math.max(1, originalWidth - left - right);
+        int cropHeight = Math.max(1, originalHeight - top - bottom);
+        if (left < 0 || top < 0 || left + cropWidth > originalWidth || top + cropHeight > originalHeight) {
+            log.error("\u88c1\u526a\u533a\u57df\u65e0\u6548\u6216\u8d85\u51fa\u56fe\u7247\u8fb9\u754c");
+        }
+        return originalImage.getSubimage(left, top, cropWidth, cropHeight);
+    }
+
+    private BufferedImage rotateImage(BufferedImage originalImage, long rotation, long currentCx, Map<String, Object> result) {
+        int origWidth = originalImage.getWidth();
+        int origHeight = originalImage.getHeight();
+        if (origWidth <= 0 || origHeight <= 0) {
+            log.error("\u56fe\u7247\u533a\u57df\u65e0\u6548");
+        }
+        double emuPerPx = (double)currentCx / (double)origWidth;
+        if (currentCx == 0L) {
+            emuPerPx = 9525.0;
+        }
+        double degrees = (double)rotation / 60000.0;
+        double radians = Math.toRadians(degrees);
+        double sin = Math.abs(Math.sin(radians));
+        double cos = Math.abs(Math.cos(radians));
+        double TOLERANCE = 1.0E-10;
+        if (sin < 1.0E-10) {
+            sin = 0.0;
+        }
+        if (cos < 1.0E-10) {
+            cos = 0.0;
+        }
+        int newWidth = (int)Math.ceil((double)origWidth * cos + (double)origHeight * sin);
+        int newHeight = (int)Math.ceil((double)origWidth * sin + (double)origHeight * cos);
+        newWidth = Math.max(1, newWidth);
+        newHeight = Math.max(1, newHeight);
+        int superSampleFactor = 4;
+        int ssWidth = origWidth * superSampleFactor;
+        int ssHeight = origHeight * superSampleFactor;
+        int ssNewW = newWidth * superSampleFactor;
+        int ssNewH = newHeight * superSampleFactor;
+        int imgType1 = originalImage.getType() == 0 ? 2 : originalImage.getType();
+        BufferedImage highResOriginal = new BufferedImage(ssWidth, ssHeight, imgType1);
+        Graphics2D g2dHighRes = highResOriginal.createGraphics();
+        this.configureGraphics2D(g2dHighRes);
+        g2dHighRes.drawImage(originalImage, 0, 0, ssWidth, ssHeight, null);
+        g2dHighRes.dispose();
+        int imgType2 = highResOriginal.getType() == 0 ? 2 : highResOriginal.getType();
+        BufferedImage rotatedSuperSample = new BufferedImage(ssNewW, ssNewH, imgType2);
+        Graphics2D g2dRotated = rotatedSuperSample.createGraphics();
+        if (highResOriginal.getType() == 2) {
+            g2dRotated.setComposite(AlphaComposite.Clear);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+            g2dRotated.setComposite(AlphaComposite.SrcOver);
+        } else {
+            g2dRotated.setColor(Color.WHITE);
+            g2dRotated.fillRect(0, 0, ssNewW, ssNewH);
+        }
+        g2dRotated.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2dRotated.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g2dRotated.translate((double)ssNewW / 2.0, (double)ssNewH / 2.0);
+        g2dRotated.rotate(radians);
+        g2dRotated.drawImage((Image)highResOriginal, -ssWidth / 2, -ssHeight / 2, null);
+        g2dRotated.dispose();
+        BufferedImage rotatedImage = new BufferedImage(newWidth, newHeight, rotatedSuperSample.getType() == 0 ? 2 : rotatedSuperSample.getType());
+        Graphics2D g2dFinal = rotatedImage.createGraphics();
+        this.configureGraphics2D(g2dFinal);
+        g2dFinal.drawImage(rotatedSuperSample, 0, 0, newWidth, newHeight, null);
+        g2dFinal.dispose();
+        long newCx = Math.round((double)newWidth * emuPerPx);
+        long newCy = Math.round((double)newHeight * emuPerPx);
+        double newWidthPx = Math.round((double)newCx / 9525.0);
+        double newHeightPx = Math.round((double)newCy / 9525.0);
+        result.put("width", newWidthPx);
+        result.put("height", newHeightPx);
+        return rotatedImage;
+    }
+
+    private void configureGraphics2D(Graphics2D g2d) {
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+    }
+
+    private int parseVmlCrop(String vmlCrop) {
+        if (vmlCrop == null || StringUtils.isBlank((CharSequence)vmlCrop)) {
+            return 0;
+        }
+        String clean = vmlCrop.trim().replaceAll("[fF]$", "");
+        try {
+            int value = Integer.parseInt(clean);
+            return (int)Math.round((double)value * 1.52587890625);
+        }
+        catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+}
+
diff --git a/java-svc/src/main/java/com/wordparse/core/EqToLatexUtil.java b/java-svc/src/main/java/com/wordparse/core/EqToLatexUtil.java
new file mode 100644
index 0000000..34349f5
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/EqToLatexUtil.java
@@ -0,0 +1,1025 @@
+package com.wordparse.core;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EqToLatexUtil {
+    private static final Logger log = LoggerFactory.getLogger(EqToLatexUtil.class);
+    private static final Pattern LONG_EQUALS_PATTERN = Pattern.compile("^=+$");
+    private static final int LONG_EQUALS_MIN_LENGTH = 3;
+    private static final Map<String, CommandHandler> COMMAND_HANDLERS = new HashMap<String, CommandHandler>();
+
+    public static String sanitizeInput(String input) {
+        if (input == null) {
+            return "";
+        }
+        HashMap<String, String> replacements = new HashMap<String, String>();
+        replacements.put("\uff08", "(");
+        replacements.put("\uff09", ")");
+        replacements.put("\uff5b", "{");
+        replacements.put("\uff5d", "}");
+        replacements.put("\uff0b", "+");
+        replacements.put("\uff0d", "-");
+        replacements.put("\u2212", "-");
+        replacements.put("\u00d7", " \\times ");
+        replacements.put("\u00f7", " \\div ");
+        replacements.put("\uff1d", "=");
+        replacements.put("\u2260", "\\ne ");
+        replacements.put("\u2248", " \\approx ");
+        replacements.put("\u2264", "\\le ");
+        replacements.put("\u2265", "\\ge ");
+        replacements.put("\uff1c", "<");
+        replacements.put("\uff1e", "> ");
+        replacements.put("\u00b7", " \\cdot ");
+        replacements.put("\u2026", "\\dots ");
+        replacements.put("\uff5e", "~");
+        replacements.put("\uff1b", ";");
+        replacements.put("\uff1a", ":");
+        replacements.put("\uf028", "(");
+        replacements.put("\uf029", ")");
+        replacements.put("~", "\\sim");
+        replacements.put("\u221d", "\\propto");
+        String sanitized = input;
+        for (Map.Entry entry : replacements.entrySet()) {
+            sanitized = sanitized.replace((CharSequence)entry.getKey(), (CharSequence)entry.getValue());
+        }
+        sanitized = sanitized.replaceAll("(?i)eq", "EQ ");
+        return sanitized.trim();
+    }
+
+    private static String getCharFromOpt(String opt, int startIdx, String defaultChar) {
+        if (opt.length() <= startIdx) {
+            return defaultChar;
+        }
+        String charPart = opt.substring(startIdx).trim();
+        if (charPart.isEmpty()) {
+            return defaultChar;
+        }
+        if (charPart.startsWith("\\")) {
+            return charPart.substring(1);
+        }
+        return charPart;
+    }
+
+    private static String escapeChar(String ch) {
+        String specialChars = "\\{}$&#%";
+        if ("\\{}$&#%".contains(ch)) {
+            return "\\" + ch;
+        }
+        if ("~".equals(ch)) {
+            return "\\ ";
+        }
+        return ch;
+    }
+
+    public static String convert(String eqField) {
+        if (eqField == null) {
+            throw new IllegalArgumentException("\u8f93\u5165\u5fc5\u987b\u662f\u5b57\u7b26\u4e32\u7c7b\u578b");
+        }
+        if (eqField.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            String sanitizedField = EqToLatexUtil.sanitizeInput(EqToLatexUtil.stripFormattingMarkers(eqField));
+            String content = sanitizedField.replaceAll("^\\s*\\{?\\s*EQ\\s*|\\s*EQ\\s*|\\s*}\\s*$", "").trim();
+            String result = EqToLatexUtil.parseInstructions(content, new HashMap<String, Object>());
+            result = EqToLatexUtil.replaceWpuWithMeasurements(result);
+            result = result.replaceAll("WPU2BEGIN", "\\\\underline{").replaceAll("WPU2END", "}");
+            result = result.replaceAll("\u2192", "\\\\to ");
+            log.info("\u539fEQ\u516c\u5f0f\uff1a{} \u8f6c\u6362\u540e\u7684Latex\u4ee3\u7801\uff1a{}", (Object)eqField, (Object)result);
+            return result;
+        }
+        catch (Exception error) {
+            System.err.println("\u8f6c\u6362\u8fc7\u7a0b\u4e2d\u51fa\u73b0\u9519\u8bef: " + error.getMessage());
+            error.printStackTrace();
+            return "\\text{\u8f6c\u6362\u9519\u8bef: " + error.getMessage() + "}";
+        }
+    }
+
+    private static String stripFormattingMarkers(String input) {
+        return input.replaceAll("\\\\(?:\\s*\\\\?WPU\\s*2(?:BEGIN|END))+\\s*(?!(?:[eE][qQ])\\b)(?=[A-Za-z])", Matcher.quoteReplacement("\\")).replaceAll("\\\\?WPU\\s*2BEGIN", "").replaceAll("\\\\?WPU\\s*2END", "");
+    }
+
+    private static String parseInstructions(String str, Map<String, Object> context) {
+        ArrayList<String> output = new ArrayList<String>();
+        int index = 0;
+        while (index < str.length()) {
+            int textEnd;
+            char ch = str.charAt(index);
+            if (ch == '\\') {
+                String lastOutput;
+                ParseResult result = EqToLatexUtil.parseCommand(str, index, context);
+                String trimmedOutput = result.output.trim();
+                if ((trimmedOutput.startsWith("^") || trimmedOutput.startsWith("_")) && !output.isEmpty()) {
+                    lastOutput = (String)output.get(output.size() - 1);
+                    if (EqToLatexUtil.isConsecutiveScript(lastOutput, trimmedOutput)) {
+                        output.set(output.size() - 1, EqToLatexUtil.mergeConsecutiveScripts(lastOutput, trimmedOutput));
+                    } else {
+                        output.set(output.size() - 1, lastOutput + result.output);
+                    }
+                } else if ((trimmedOutput.startsWith("\\^") || trimmedOutput.startsWith("\\_")) && !output.isEmpty()) {
+                    lastOutput = (String)output.get(output.size() - 1);
+                    if (EqToLatexUtil.isConsecutiveScript(lastOutput, trimmedOutput)) {
+                        output.set(output.size() - 1, EqToLatexUtil.mergeConsecutiveScripts(lastOutput, trimmedOutput));
+                    } else {
+                        output.set(output.size() - 1, lastOutput + result.output);
+                    }
+                } else if (EqToLatexUtil.isSpecialScriptMarker(trimmedOutput) && !output.isEmpty() && EqToLatexUtil.isSpecialScriptMarker((String)output.get(output.size() - 1))) {
+                    String merged = EqToLatexUtil.mergeSpecialScriptMarkers((String)output.get(output.size() - 1), trimmedOutput);
+                    output.set(output.size() - 1, merged);
+                } else {
+                    output.add(result.output);
+                }
+                index = result.newIndex;
+                continue;
+            }
+            if (ch == '{' || ch == '}') {
+                ++index;
+                continue;
+            }
+            for (textEnd = index; textEnd < str.length() && "\\{}".indexOf(str.charAt(textEnd)) == -1; ++textEnd) {
+            }
+            String text = str.substring(index, textEnd);
+            output.add(text.replaceAll("[&%$#_]", "\\\\$0"));
+            index = textEnd;
+        }
+        String result = String.join((CharSequence)" ", output).replaceAll("\\s+", " ").trim();
+        return EqToLatexUtil.postProcessConsecutiveScripts(result);
+    }
+
+    private static ParseResult parseCommand(String str, int startIndex, Map<String, Object> context) {
+        int argParenStartIndex;
+        String cmdName;
+        int currentIndex = startIndex;
+        ArrayList<String> commandChain = new ArrayList<String>();
+        ArrayList<Integer> commandEndIndices = new ArrayList<Integer>();
+        while (currentIndex < str.length()) {
+            int cmdNameEnd;
+            int tempIndex;
+            for (tempIndex = currentIndex; tempIndex < str.length() && Character.isWhitespace(str.charAt(tempIndex)); ++tempIndex) {
+            }
+            if (tempIndex >= str.length() || str.charAt(tempIndex) != '\\') {
+                currentIndex = tempIndex;
+                break;
+            }
+            currentIndex = tempIndex;
+            for (cmdNameEnd = currentIndex + 1; cmdNameEnd < str.length() && Character.isLetter(str.charAt(cmdNameEnd)); ++cmdNameEnd) {
+            }
+            String cmdName2 = str.substring(currentIndex + 1, cmdNameEnd);
+            String token = "\\" + cmdName2;
+            int argStartIndex = cmdNameEnd;
+            List<String> numericArgCmds = Arrays.asList("co", "vs", "hs", "fo", "ba", "up", "do", "ai", "di");
+            if (numericArgCmds.contains(cmdName2.toLowerCase())) {
+                int numEnd;
+                for (numEnd = argStartIndex; numEnd < str.length() && Character.isDigit(str.charAt(numEnd)); ++numEnd) {
+                }
+                if (numEnd > argStartIndex) {
+                    token = token + str.substring(argStartIndex, numEnd);
+                    argStartIndex = numEnd;
+                }
+            } else if (Arrays.asList("lc", "rc", "bc", "fc", "vc").contains(cmdName2.toLowerCase()) && argStartIndex < str.length()) {
+                if (str.charAt(argStartIndex) == '\\' && argStartIndex + 1 < str.length()) {
+                    token = token + str.substring(argStartIndex, argStartIndex + 2);
+                    argStartIndex += 2;
+                } else {
+                    token = token + str.charAt(argStartIndex);
+                    ++argStartIndex;
+                }
+            }
+            commandChain.add(token);
+            commandEndIndices.add(argStartIndex);
+            currentIndex = argStartIndex;
+        }
+        if (commandChain.isEmpty()) {
+            return new ParseResult(EqToLatexUtil.escapeChar(String.valueOf(str.charAt(startIndex))), startIndex + 1);
+        }
+        CommandHandler mainCommandHandler = null;
+        String mainCommandName = "";
+        String firstToken = (String)commandChain.get(0);
+        Matcher matcher = Pattern.compile("^\\\\([a-zA-Z]+)").matcher(firstToken);
+        if (matcher.find() && COMMAND_HANDLERS.containsKey(cmdName = matcher.group(1).toLowerCase())) {
+            mainCommandHandler = COMMAND_HANDLERS.get(cmdName);
+            mainCommandName = cmdName;
+        }
+        if (mainCommandHandler == null) {
+            return new ParseResult((String)commandChain.get(0), (Integer)commandEndIndices.get(0));
+        }
+        ArrayList<String> args = new ArrayList<String>();
+        for (argParenStartIndex = currentIndex; argParenStartIndex < str.length() && Character.isWhitespace(str.charAt(argParenStartIndex)); ++argParenStartIndex) {
+        }
+        if (argParenStartIndex < str.length() && (str.charAt(argParenStartIndex) == '(' || str.charAt(argParenStartIndex) == '[')) {
+            ArgumentResult argsResult = EqToLatexUtil.extractArguments(str, argParenStartIndex);
+            if (argsResult.success) {
+                List<String> rawArgs = EqToLatexUtil.splitArguments(argsResult.content);
+                HashMap<String, Object> childContext = new HashMap<String, Object>();
+                childContext.put("parentCommand", mainCommandName);
+                for (String arg : rawArgs) {
+                    args.add(EqToLatexUtil.parseInstructions(arg, childContext));
+                }
+                currentIndex = argsResult.endIndex;
+            } else {
+                throw new RuntimeException("Mismatched parentheses starting at index " + argParenStartIndex);
+            }
+        }
+        String output = mainCommandHandler.handle(commandChain, args, mainCommandName, context);
+        return new ParseResult(output, currentIndex);
+    }
+
+    private static ArgumentResult extractArguments(String str, int startIndex) {
+        char openParen = str.charAt(startIndex);
+        char closeParen = openParen == '(' ? (char)')' : ']';
+        int depth = 1;
+        StringBuilder content = new StringBuilder();
+        int index = startIndex + 1;
+        while (index < str.length() && depth > 0) {
+            char ch = str.charAt(index);
+            if (ch == '\\' && index + 1 < str.length()) {
+                content.append(ch).append(str.charAt(index + 1));
+                index += 2;
+                continue;
+            }
+            if (ch == openParen) {
+                if (++depth > 1) {
+                    content.append(ch);
+                }
+                ++index;
+                continue;
+            }
+            if (ch == closeParen) {
+                if (--depth > 0) {
+                    content.append(ch);
+                }
+                ++index;
+                continue;
+            }
+            if (depth > 0) {
+                content.append(ch);
+            }
+            ++index;
+        }
+        return new ArgumentResult(depth == 0, content.toString(), index);
+    }
+
+    private static List<String> splitArguments(String str) {
+        ArrayList<String> args = new ArrayList<String>();
+        StringBuilder current = new StringBuilder();
+        int depth = 0;
+        int i = 0;
+        while (i < str.length()) {
+            char ch = str.charAt(i);
+            if (ch == '\\' && i + 1 < str.length()) {
+                current.append(ch).append(str.charAt(i + 1));
+                i += 2;
+                continue;
+            }
+            if (ch == '(') {
+                ++depth;
+            } else if (ch == ')') {
+                --depth;
+            }
+            if (ch == ',' && depth == 0) {
+                args.add(current.toString().trim());
+                current = new StringBuilder();
+            } else {
+                current.append(ch);
+            }
+            ++i;
+        }
+        if (current.length() > 0) {
+            args.add(current.toString().trim());
+        }
+        return args;
+    }
+
+    private static String handleFraction(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.size() != 2) {
+            return "\\text{\u9519\u8bef\u7684\u5206\u6570\u53c2\u6570}";
+        }
+        return String.format("\\dfrac{%s}{%s}", args.get(0), args.get(1));
+    }
+
+    private static String handleRoot(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() == 1) {
+            return String.format("\\sqrt{%s}", args.get(0));
+        }
+        return String.format("\\sqrt[%s]{%s}", args.get(0), args.get(1));
+    }
+
+    private static String handleIntegral(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String symbol = "\\int";
+        if (options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\su"))) {
+            symbol = "\\sum";
+        } else if (options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\pr"))) {
+            symbol = "\\prod";
+        } else {
+            String fc = options.stream().filter(o -> o.toLowerCase().startsWith("\\fc")).findFirst().orElse(null);
+            String vc = options.stream().filter(o -> o.toLowerCase().startsWith("\\vc")).findFirst().orElse(null);
+            if (fc != null) {
+                symbol = EqToLatexUtil.escapeChar(EqToLatexUtil.getCharFromOpt(fc, 3, ""));
+            } else if (vc != null) {
+                symbol = EqToLatexUtil.escapeChar(EqToLatexUtil.getCharFromOpt(vc, 3, ""));
+            }
+        }
+        if (args.isEmpty()) {
+            return symbol;
+        }
+        String lower = args.get(0);
+        String upper = args.size() > 1 ? args.get(1) : "";
+        String integrand = args.size() > 2 ? args.subList(2, args.size()).stream().collect(Collectors.joining(" ")) : "";
+        String limits = !lower.isEmpty() || !upper.isEmpty() ? String.format("^{%s}_{%s}", upper, lower) : "";
+        return String.format("%s%s %s", symbol, limits, integrand);
+    }
+
+    private static String handleScript(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        ArrayList<String> argsCopy = new ArrayList<String>(args);
+        if (argsCopy.size() > 2) {
+            String arrayContent = String.join((CharSequence)"\\\\", argsCopy);
+            return String.format("\\begin{array}{l}%s\\end{array}", arrayContent);
+        }
+        String up = "";
+        String down = "";
+        boolean doOptExists = options.stream().anyMatch(o -> o.toLowerCase().startsWith("\\do"));
+        if (argsCopy.size() == 2) {
+            up = (String)argsCopy.remove(0);
+            down = (String)argsCopy.remove(0);
+        } else if (argsCopy.size() == 1) {
+            if (doOptExists) {
+                down = (String)argsCopy.remove(0);
+            } else {
+                up = (String)argsCopy.remove(0);
+            }
+        }
+        if ("o".equals(context.get("parentCommand"))) {
+            String upTrimmed = up.trim();
+            if ("\u2192".equals(upTrimmed) || "\\rightarrow".equals(upTrimmed)) {
+                return "OVERSET_ARROW";
+            }
+            if ("^".equals(upTrimmed) || "IS_HAT".equals(upTrimmed)) {
+                return "OVERSET_HAT";
+            }
+            if (!up.isEmpty() && !down.isEmpty()) {
+                return "OVER_UNDER_SCRIPT:" + up + "," + down;
+            }
+            if (!up.isEmpty()) {
+                return "OVER_SCRIPT:" + up;
+            }
+            if (!down.isEmpty()) {
+                return "UNDER_SCRIPT:" + down;
+            }
+        }
+        StringBuilder output = new StringBuilder();
+        if (!up.isEmpty()) {
+            output.append(String.format("^{%s}", up));
+        }
+        if (!down.isEmpty()) {
+            output.append(String.format("_{%s}", down));
+        }
+        return output.toString();
+    }
+
+    private static String handleBrackets(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String content = String.join((CharSequence)",", args);
+        HashMap<String, String> delimiterPairMap = new HashMap<String, String>();
+        delimiterPairMap.put("(", ")");
+        delimiterPairMap.put("[", "]");
+        delimiterPairMap.put("{", "}");
+        delimiterPairMap.put("<", ">");
+        String left = null;
+        String right = null;
+        String bcOpt = options.stream().filter(o -> o.startsWith("\\bc")).findFirst().orElse(null);
+        String lcOpt = options.stream().filter(o -> o.startsWith("\\lc")).findFirst().orElse(null);
+        String rcOpt = options.stream().filter(o -> o.startsWith("\\rc")).findFirst().orElse(null);
+        if (bcOpt != null) {
+            String charStr = EqToLatexUtil.getCharFromOpt(bcOpt, 3, "|");
+            left = EqToLatexUtil.getDelimiter(charStr);
+            right = EqToLatexUtil.getDelimiter(delimiterPairMap.getOrDefault(charStr, charStr));
+        } else {
+            if (lcOpt != null) {
+                left = EqToLatexUtil.getDelimiter(EqToLatexUtil.getCharFromOpt(lcOpt, 3, "("));
+            }
+            if (rcOpt != null) {
+                right = EqToLatexUtil.getDelimiter(EqToLatexUtil.getCharFromOpt(rcOpt, 3, ")"));
+            }
+        }
+        if (bcOpt == null && lcOpt == null && rcOpt == null) {
+            left = "(";
+            right = ")";
+        }
+        return String.format("\\left%s %s \\right%s", StringUtils.isNotBlank((CharSequence)left) ? left : ".", content, StringUtils.isNotBlank((CharSequence)right) ? right : ".");
+    }
+
+    private static String getDelimiter(String ch) {
+        return "{".equals(ch) || "}".equals(ch) ? "\\" + ch : ch;
+    }
+
+    private static String handleArray(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() == 1) {
+            return args.get(0);
+        }
+        int cols = 1;
+        String colAlign = "c";
+        for (String opt : options) {
+            Matcher colMatch = Pattern.compile("^\\\\co(\\d+)$").matcher(opt);
+            if (colMatch.matches()) {
+                cols = Integer.parseInt(colMatch.group(1));
+            }
+            if ("\\al".equals(opt)) {
+                colAlign = "l";
+                continue;
+            }
+            if ("\\ac".equals(opt)) {
+                colAlign = "c";
+                continue;
+            }
+            if (!"\\ar".equals(opt)) continue;
+            colAlign = "r";
+        }
+        StringBuilder alignSpec = new StringBuilder();
+        for (int i = 0; i < cols; ++i) {
+            alignSpec.append(colAlign);
+        }
+        ArrayList<String> matrixRows = new ArrayList<String>();
+        int i = 0;
+        while ((double)i < Math.ceil((double)args.size() / (double)cols)) {
+            ArrayList<String> row = new ArrayList<String>(args.subList(i * cols, Math.min((i + 1) * cols, args.size())));
+            while (row.size() < cols) {
+                row.add("");
+            }
+            matrixRows.add(String.join((CharSequence)" & ", row));
+            ++i;
+        }
+        return String.format("\\begin{array}{%s}%s\\end{array}", alignSpec, String.join((CharSequence)"\\\\", matrixRows));
+    }
+
+    private static String handleBox(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (options.stream().anyMatch(o -> o.equalsIgnoreCase("\\to"))) {
+            return args.isEmpty() ? "\\overline{}" : String.format("\\overline{%s}", args.get(0));
+        }
+        String content = String.join((CharSequence)",", args);
+        return args.isEmpty() ? "\\boxed{}" : String.format("\\boxed{%s}", content);
+    }
+
+    private static String handleList(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.join((CharSequence)",\\ ", args);
+    }
+
+    private static String handleOverstrike(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        String limitResult;
+        String firstArg;
+        if (args.isEmpty()) {
+            return "";
+        }
+        if (args.size() >= 1 && ("lim".equals(firstArg = args.get(0).trim().toLowerCase()) || "limit".equals(firstArg)) && (limitResult = EqToLatexUtil.handleLimitExpression(args)) != null) {
+            return limitResult;
+        }
+        String chemResult = EqToLatexUtil.handleChemicalSymbols(args, context);
+        if (chemResult != null) {
+            return chemResult;
+        }
+        boolean allArgsAreScriptMarkers = true;
+        for (String arg : args) {
+            if (EqToLatexUtil.isScriptMarker(arg)) continue;
+            allArgsAreScriptMarkers = false;
+            break;
+        }
+        if (allArgsAreScriptMarkers) {
+            boolean hasAlignCenter = options.stream().anyMatch(o -> "\\ac".equalsIgnoreCase((String)o));
+            if (hasAlignCenter) {
+                ArrayList<String> scriptContents = new ArrayList<String>();
+                for (String script2 : args) {
+                    if (!script2.startsWith("OVER_SCRIPT:")) continue;
+                    scriptContents.add(script2.substring("OVER_SCRIPT:".length()).trim());
+                }
+                if (!scriptContents.isEmpty()) {
+                    String result = (String)scriptContents.get(scriptContents.size() - 1);
+                    for (int i = scriptContents.size() - 2; i >= 0; --i) {
+                        result = String.format("\\rlap{%s}{%s}", scriptContents.get(i), result);
+                    }
+                    return String.format("^{%s}", result);
+                }
+            }
+            StringBuilder up = new StringBuilder();
+            StringBuilder down = new StringBuilder();
+            args.forEach(script -> {
+                if (script.startsWith("OVER_UNDER_SCRIPT:")) {
+                    String[] parts = script.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                    up.append(up.length() > 0 ? " " : "").append(parts[0]);
+                    down.append(down.length() > 0 ? " " : "").append(parts[1]);
+                } else if (script.startsWith("OVER_SCRIPT:")) {
+                    up.append(up.length() > 0 ? " " : "").append(script.substring("OVER_SCRIPT:".length()));
+                } else if (script.startsWith("UNDER_SCRIPT:")) {
+                    down.append(down.length() > 0 ? " " : "").append(script.substring("UNDER_SCRIPT:".length()));
+                } else if ("OVERSET_ARROW".equals(script)) {
+                    up.append(up.length() > 0 ? " " : "").append("\\rightarrow");
+                } else if ("OVERSET_HAT".equals(script)) {
+                    up.append(up.length() > 0 ? " " : "").append("^");
+                } else {
+                    MathJaxScripts extracted = EqToLatexUtil.extractMathJaxScripts(script);
+                    if (!extracted.up.isEmpty()) {
+                        up.append(up.length() > 0 ? " " : "").append(extracted.up);
+                    }
+                    if (!extracted.down.isEmpty()) {
+                        down.append(down.length() > 0 ? " " : "").append(extracted.down);
+                    }
+                }
+            });
+            String newUp = up.toString().replaceAll("\\s?OVER_SCRIPT:|\\s?UNDER_SCRIPT:", "");
+            String newDown = down.toString().replaceAll("\\s?OVER_SCRIPT:|\\s?UNDER_SCRIPT:", "");
+            StringBuilder output = new StringBuilder();
+            if (up.length() > 0) {
+                output.append(String.format("^{%s}", newUp));
+            }
+            if (down.length() > 0) {
+                output.append(String.format("_{%s}", newDown));
+            }
+            return output.toString();
+        }
+        int baseIndex = -1;
+        for (int i = 0; i < args.size(); ++i) {
+            if (EqToLatexUtil.isScriptMarker(args.get(i))) continue;
+            baseIndex = i;
+            break;
+        }
+        if (baseIndex == -1) {
+            String result = args.get(0);
+            for (int i = 1; i < args.size(); ++i) {
+                result = String.format("\\rlap{%s}{%s}", args.get(i), result);
+            }
+            return result;
+        }
+        String base = args.get(baseIndex);
+        base = EqToLatexUtil.resolveNestedScripts(base);
+        ArrayList<String> otherArgs = new ArrayList<String>();
+        for (int i = 0; i < args.size(); ++i) {
+            if (i == baseIndex) continue;
+            otherArgs.add(args.get(i));
+        }
+        boolean otherArgsAreScriptMarkers = true;
+        for (String arg : otherArgs) {
+            if (EqToLatexUtil.isScriptMarker(arg)) continue;
+            otherArgsAreScriptMarkers = false;
+            break;
+        }
+        if (!otherArgs.isEmpty() && otherArgsAreScriptMarkers) {
+            StringBuilder over = new StringBuilder();
+            StringBuilder under = new StringBuilder();
+            otherArgs.forEach(script -> {
+                if ("OVERSET_ARROW".equals(script)) {
+                    over.append("\\rightarrow");
+                } else if ("OVERSET_HAT".equals(script)) {
+                    over.append("^");
+                } else if (script.startsWith("OVER_UNDER_SCRIPT:")) {
+                    String[] parts = script.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                    over.append(over.length() > 0 ? " " : "").append(parts[0]);
+                    under.append(under.length() > 0 ? " " : "").append(parts[1]);
+                } else if (script.startsWith("OVER_SCRIPT:")) {
+                    over.append(over.length() > 0 ? " " : "").append(script.substring("OVER_SCRIPT:".length()));
+                } else if (script.startsWith("UNDER_SCRIPT:")) {
+                    under.append(under.length() > 0 ? " " : "").append(script.substring("UNDER_SCRIPT:".length()));
+                }
+            });
+            if ("^".equals(over.toString())) {
+                return String.format("\\hat{%s}", base);
+            }
+            String cleanOver = over.toString().replace(" ", "").replace("\\to", "\\rightarrow").replace("\u2192", "\\rightarrow");
+            if ("\\rightarrow".equals(cleanOver) || cleanOver.contains("\\rightarrow") && (cleanOver.matches(".*[\u2014\u2013\u2212\u2015\u2012\u2010\\-].*") || cleanOver.contains("OVERSET_ARROW"))) {
+                return String.format("\\overrightarrow{%s}", base);
+            }
+            if ("\\rightarrow".equals(over.toString())) {
+                return String.format("\\overrightarrow{%s}", base);
+            }
+            String result = base;
+            if (over.length() > 0) {
+                result = String.format("\\overset{%s}{%s}", over.toString(), result);
+            }
+            if (under.length() > 0) {
+                result = String.format("\\underset{%s}{%s}", under.toString(), result);
+            }
+            return result;
+        }
+        String result = base;
+        for (int i = otherArgs.size() - 1; i >= 0; --i) {
+            result = String.format("\\rlap{%s}{%s}", otherArgs.get(i), result);
+        }
+        return result;
+    }
+
+    private static String handleChemicalSymbols(List<String> args, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return null;
+        }
+        String firstArg = args.get(0).trim();
+        if (LONG_EQUALS_PATTERN.matcher(firstArg).matches() && firstArg.length() >= 3) {
+            return EqToLatexUtil.handleLongEqual(args);
+        }
+        if ((firstArg.contains("\u2192") || firstArg.contains("\\rightarrow")) && !firstArg.contains("\u2190") && !firstArg.contains("\\leftarrow")) {
+            return EqToLatexUtil.handleRightArrow(args);
+        }
+        if (firstArg.matches("^\u2190[\u2015\uff0d\u2014\\-]+$") || firstArg.contains("\u2190") || firstArg.contains("\\leftarrow")) {
+            return EqToLatexUtil.handleLeftArrow(args);
+        }
+        return null;
+    }
+
+    private static String handleLongEqual(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xlongequal[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xlongequal{%s}", upper);
+        }
+        return "\\xlongequal{}";
+    }
+
+    private static String handleRightArrow(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xrightarrow[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xrightarrow{%s}", upper);
+        }
+        if (!lower.isEmpty()) {
+            return String.format("\\xrightarrow[%s]{}", lower);
+        }
+        return "\\xrightarrow{}";
+    }
+
+    private static String handleLeftArrow(List<String> args) {
+        String upper = "";
+        String lower = "";
+        for (int i = 1; i < args.size(); ++i) {
+            String content;
+            String arg = args.get(i);
+            if (arg.startsWith("OVER_SCRIPT:")) {
+                upper = (upper + " " + arg.substring("OVER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("UNDER_SCRIPT:")) {
+                lower = (lower + " " + arg.substring("UNDER_SCRIPT:".length())).trim();
+                continue;
+            }
+            if (arg.startsWith("OVER_UNDER_SCRIPT:")) {
+                String[] parts = arg.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+                upper = (upper + " " + parts[0]).trim();
+                lower = (lower + " " + (parts.length > 1 ? parts[1] : "")).trim();
+                continue;
+            }
+            if (arg.startsWith("^{") && arg.endsWith("}")) {
+                content = arg.substring(2, arg.length() - 1);
+                upper = (upper + " " + content).trim();
+                continue;
+            }
+            if (!arg.startsWith("_{") || !arg.endsWith("}")) continue;
+            content = arg.substring(2, arg.length() - 1);
+            lower = (lower + " " + content).trim();
+        }
+        if (!upper.isEmpty() && !lower.isEmpty()) {
+            return String.format("\\xleftarrow[%s]{%s}", lower, upper);
+        }
+        if (!upper.isEmpty()) {
+            return String.format("\\xleftarrow{%s}", upper);
+        }
+        if (!lower.isEmpty()) {
+            return String.format("\\xleftarrow[%s]{}", lower);
+        }
+        return "\\xleftarrow{}";
+    }
+
+    private static String handleDisplacement(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        if (args.isEmpty()) {
+            return "";
+        }
+        return String.join((CharSequence)" ", args);
+    }
+
+    private static String handleUp(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.format("^{%s}", String.join((CharSequence)",", args));
+    }
+
+    private static String handleDo(List<String> options, List<String> args, String mainCommandName, Map<String, Object> context) {
+        return String.format("_{%s}", String.join((CharSequence)",", args));
+    }
+
+    public static String replaceWpuWithMeasurements(String input) {
+        String pattern = "(WPU1WPU)+";
+        Matcher matcher = Pattern.compile(pattern).matcher(input);
+        StringBuffer result = new StringBuffer();
+        while (matcher.find()) {
+            String match = matcher.group();
+            int count = match.length() / 4;
+            int groups = (count + 4) / 5;
+            StringBuilder replacement = new StringBuilder();
+            for (int i = 0; i < groups; ++i) {
+                replacement.append("\\\\underline{\\\\qquad}");
+            }
+            matcher.appendReplacement(result, replacement.toString());
+        }
+        matcher.appendTail(result);
+        return result.toString();
+    }
+
+    private static String handleLimitExpression(List<String> args) {
+        Matcher m;
+        if (args.size() < 2) {
+            return null;
+        }
+        String limitArg = args.get(1).trim();
+        Pattern nestedDoPattern = Pattern.compile("\\\\s\\\\do4\\(\\\\s\\\\do4\\(([^)]+)\\)\\)");
+        Matcher match = nestedDoPattern.matcher(limitArg);
+        if (match.find()) {
+            return String.format("\\lim_{%s}", match.group(1));
+        }
+        Pattern singleDoPattern = Pattern.compile("\\\\s\\\\do4\\(([^)]+)\\)");
+        Matcher singleMatch = singleDoPattern.matcher(limitArg);
+        if (singleMatch.find()) {
+            return String.format("\\lim_{%s}", singleMatch.group(1));
+        }
+        if (limitArg.startsWith("_{") && limitArg.endsWith("}")) {
+            return String.format("\\lim_{%s}", limitArg.substring(2, limitArg.length() - 1));
+        }
+        if (limitArg.matches("^_\\{_\\{([^}]+)}}$") && (m = Pattern.compile("^_\\{_\\{([^}]+)}}$").matcher(limitArg)).find()) {
+            return String.format("\\lim_{%s}", m.group(1));
+        }
+        Pattern anySubPattern = Pattern.compile("_\\{([^}]+)}");
+        Matcher anySubMatch = anySubPattern.matcher(limitArg);
+        if (anySubMatch.find()) {
+            Matcher inner;
+            String limitContent = anySubMatch.group(1);
+            if (limitContent.contains("_{") && limitContent.contains("}") && (inner = Pattern.compile("_\\{([^}]+)}").matcher(limitContent)).find()) {
+                limitContent = inner.group(1);
+            }
+            return String.format("\\lim_{%s}", limitContent);
+        }
+        if (!limitArg.isEmpty() && !limitArg.contains("\\")) {
+            return String.format("\\lim_{%s}", limitArg);
+        }
+        return null;
+    }
+
+    private static boolean isConsecutiveScript(String first, String second) {
+        if (first == null || second == null) {
+            return false;
+        }
+        String firstTrimmed = first.trim();
+        String secondTrimmed = second.trim();
+        boolean firstIsSuper = firstTrimmed.matches(".*\\\\?\\^\\{\\s*[^}]*\\s*}$");
+        boolean secondIsSuper = secondTrimmed.matches("^\\s*\\\\?\\^\\{.*");
+        boolean firstIsSub = firstTrimmed.matches(".*\\\\?_\\{\\s*[^}]*\\s*}$");
+        boolean secondIsSub = secondTrimmed.matches("^\\s*\\\\?_\\{.*");
+        return firstIsSuper && secondIsSuper || firstIsSub && secondIsSub;
+    }
+
+    private static String mergeConsecutiveScripts(String first, String second) {
+        if (EqToLatexUtil.isConsecutiveScript(first, second)) {
+            Matcher firstMatch = Pattern.compile("(\\\\?)(\\^|_)\\{([^}]*)}$").matcher(first.trim());
+            if (!firstMatch.find()) {
+                return first + second;
+            }
+            String firstBackslash = firstMatch.group(1);
+            String scriptType = firstMatch.group(2);
+            String firstContent = firstMatch.group(3);
+            Matcher secondMatch = Pattern.compile("^\\s*(\\\\?)(\\^|_)\\{([^}]*)}").matcher(second.trim());
+            if (!secondMatch.find() || !secondMatch.group(2).equals(scriptType)) {
+                return first + second;
+            }
+            String secondContent = secondMatch.group(3);
+            String mergedContent = firstContent + secondContent;
+            String beforeScript = first.replaceAll("(\\\\?)(\\^|_)\\{[^}]*}$", "");
+            return beforeScript + firstBackslash + scriptType + "{" + mergedContent + "}";
+        }
+        return first + second;
+    }
+
+    private static String postProcessConsecutiveScripts(String text) {
+        String previousText;
+        String result = text;
+        do {
+            previousText = result;
+            result = result.replaceAll("(\\\\?)\\^\\{([^}]*?)}\\s+(\\\\?)\\^\\{([^}]*?)}", "$1^{$2$4}");
+        } while (!(result = result.replaceAll("(\\\\?)_\\{([^}]*?)}\\s+(\\\\?)_\\{([^}]*?)}", "$1_{$2$4}")).equals(previousText));
+        return result;
+    }
+
+    private static boolean isScriptMarker(String str) {
+        if (str == null) {
+            return false;
+        }
+        return str.equals("OVERSET_ARROW") || str.equals("OVERSET_HAT") || str.startsWith("OVER_UNDER_SCRIPT:") || str.startsWith("OVER_SCRIPT:") || str.startsWith("UNDER_SCRIPT:") || str.matches("^\\^\\{.*}$") || str.matches("^_\\{.*}$") || str.matches("^(\\^\\{[^}]*})+$") || str.matches("^(_\\{[^}]*})+$") || str.matches("^(\\^\\{[^}]*}|_\\{[^}]*})+$");
+    }
+
+    private static MathJaxScripts extractMathJaxScripts(String mathjaxScript) {
+        MathJaxScripts result = new MathJaxScripts();
+        Matcher upMatcher = Pattern.compile("\\^\\{([^}]*)}").matcher(mathjaxScript);
+        while (upMatcher.find()) {
+            result.up = result.up + upMatcher.group(1);
+        }
+        Matcher downMatcher = Pattern.compile("_\\{([^}]*)}").matcher(mathjaxScript);
+        while (downMatcher.find()) {
+            result.down = result.down + downMatcher.group(1);
+        }
+        return result;
+    }
+
+    private static String resolveNestedScripts(String text) {
+        if (text == null) {
+            return null;
+        }
+        String result = text;
+        result = result.replaceAll("OVERSET_ARROW", "\\\\rightarrow");
+        result = result.replaceAll("OVERSET_HAT", "^");
+        Pattern p = Pattern.compile("OVER_UNDER_SCRIPT:([^ ]+)");
+        Matcher m = p.matcher(result);
+        StringBuffer sb = new StringBuffer();
+        while (m.find()) {
+            String content = m.group(1);
+            String[] parts = content.split(",", 2);
+            String up = parts[0].trim();
+            String down = (parts.length > 1 ? parts[1] : "").trim();
+            m.appendReplacement(sb, "^{" + up + "}_{" + down + "}");
+        }
+        m.appendTail(sb);
+        result = sb.toString();
+        result = result.replaceAll("OVER_SCRIPT:([^ ]+)", "^{$1}");
+        result = result.replaceAll("UNDER_SCRIPT:([^ ]+)", "_{$1}");
+        return result;
+    }
+
+    private static boolean isSpecialScriptMarker(String str) {
+        return EqToLatexUtil.isScriptMarker(str);
+    }
+
+    private static String mergeSpecialScriptMarkers(String first, String second) {
+        String upFirst = "";
+        String downFirst = "";
+        if (first.startsWith("OVER_SCRIPT:")) {
+            upFirst = first.substring("OVER_SCRIPT:".length());
+        } else if (first.startsWith("UNDER_SCRIPT:")) {
+            downFirst = first.substring("UNDER_SCRIPT:".length());
+        } else if (first.startsWith("OVER_UNDER_SCRIPT:")) {
+            String[] parts = first.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+            upFirst = parts[0];
+            downFirst = parts.length > 1 ? parts[1] : "";
+        }
+        String upSecond = "";
+        String downSecond = "";
+        if (second.startsWith("OVER_SCRIPT:")) {
+            upSecond = second.substring("OVER_SCRIPT:".length());
+        } else if (second.startsWith("UNDER_SCRIPT:")) {
+            downSecond = second.substring("UNDER_SCRIPT:".length());
+        } else if (second.startsWith("OVER_UNDER_SCRIPT:")) {
+            String[] parts = second.substring("OVER_UNDER_SCRIPT:".length()).split(",", 2);
+            upSecond = parts[0];
+            downSecond = parts.length > 1 ? parts[1] : "";
+        }
+        String upMerged = (upFirst + upSecond).trim();
+        String downMerged = (downFirst + downSecond).trim();
+        if (!upMerged.isEmpty() && !downMerged.isEmpty()) {
+            return "OVER_UNDER_SCRIPT:" + upMerged + "," + downMerged;
+        }
+        if (!upMerged.isEmpty()) {
+            return "OVER_SCRIPT:" + upMerged;
+        }
+        if (!downMerged.isEmpty()) {
+            return "UNDER_SCRIPT:" + downMerged;
+        }
+        return first;
+    }
+
+    public static void main(String[] args) {
+        EqToLatexUtil.expect("P1-1", "eq \\o\\al(\\s\\up4(\u00b7),\\s\\do4(\u00b7))", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P1-2", "eq \\o(Cl,\\s\\up6(\\s\\up4(\u00b7\u00b7)),\\s\\do4(\\s\\do4(\u00b7\u00b7)))", "\\underset{_{\\cdot \\cdot}}{\\overset{^{\\cdot \\cdot}}{Cl}}");
+        EqToLatexUtil.expect("P1-3", "eq \\o\\al(\\s\\up4(\u00b7),\\s\\do4(\u00b7))", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P3-1", "\\WPU2BEGINeq \\\\WPU2END\\WPU2BEGINo\\al(\\WPU2END\\WPU2BEGIN\\s\\up4(\u00b7)\\WPU2END,\\WPU2BEGIN\\s\\do4(\u00b7)\\WPU2END)\\WPU2END", "^{\\cdot}_{\\cdot}");
+        EqToLatexUtil.expect("P3-2", "\\WPU2BEGINeq \\\\WPU2END\\WPU2BEGINo(Cl,\\s\\up6(\\WPU2BEGIN\\s\\up4(\u00b7\u00b7)\\WPU2END),\\s\\do4(\\WPU2BEGIN\\s\\do4(\u00b7\u00b7)\\WPU2END))\\WPU2END", "\\underset{_{\\cdot \\cdot}}{\\overset{^{\\cdot \\cdot}}{Cl}}");
+        EqToLatexUtil.expect("P3-3", "\\WPU2BEGINeq \\\\WPU2END\\WPU2BEGINo\\al(\\WPU2END\\WPU2BEGIN\\s\\up4(\u00b7)\\WPU2END,\\WPU2BEGIN\\s\\do4(\u00b7)\\WPU2END)\\WPU2END", "^{\\cdot}_{\\cdot}");
+        System.out.println("OK");
+    }
+
+    private static void expect(String label, String input, String expected) {
+        String actual = EqToLatexUtil.convert(input);
+        if (!expected.equals(actual)) {
+            throw new AssertionError((Object)(label + " expected " + expected + " but got " + actual));
+        }
+    }
+
+    static {
+        COMMAND_HANDLERS.put("f", EqToLatexUtil::handleFraction);
+        COMMAND_HANDLERS.put("r", EqToLatexUtil::handleRoot);
+        COMMAND_HANDLERS.put("i", EqToLatexUtil::handleIntegral);
+        COMMAND_HANDLERS.put("s", EqToLatexUtil::handleScript);
+        COMMAND_HANDLERS.put("b", EqToLatexUtil::handleBrackets);
+        COMMAND_HANDLERS.put("a", EqToLatexUtil::handleArray);
+        COMMAND_HANDLERS.put("x", EqToLatexUtil::handleBox);
+        COMMAND_HANDLERS.put("l", EqToLatexUtil::handleList);
+        COMMAND_HANDLERS.put("o", EqToLatexUtil::handleOverstrike);
+        COMMAND_HANDLERS.put("d", EqToLatexUtil::handleDisplacement);
+        COMMAND_HANDLERS.put("up", EqToLatexUtil::handleUp);
+        COMMAND_HANDLERS.put("do", EqToLatexUtil::handleDo);
+    }
+
+    private static class MathJaxScripts {
+        String up = "";
+        String down = "";
+
+        private MathJaxScripts() {
+        }
+    }
+
+    private static class ArgumentResult {
+        boolean success;
+        String content;
+        int endIndex;
+
+        ArgumentResult(boolean success, String content, int endIndex) {
+            this.success = success;
+            this.content = content;
+            this.endIndex = endIndex;
+        }
+    }
+
+    private static class ParseResult {
+        String output;
+        int newIndex;
+
+        ParseResult(String output, int newIndex) {
+            this.output = output;
+            this.newIndex = newIndex;
+        }
+    }
+
+    @FunctionalInterface
+    static interface CommandHandler {
+        public String handle(List<String> var1, List<String> var2, String var3, Map<String, Object> var4);
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/HtmlAttr.java b/java-svc/src/main/java/com/wordparse/core/HtmlAttr.java
new file mode 100644
index 0000000..34600de
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/HtmlAttr.java
@@ -0,0 +1,77 @@
+package com.wordparse.core;
+
+/**
+ * Brand-neutral HTML attribute names (CSS properties and HTML attributes).
+ *
+ * Derived from jby AttrEnum — all tinymce / brand-specific entries removed.
+ */
+public enum HtmlAttr {
+
+    STYLE("style"),
+    COLOR("color"),
+    BACKGROUND_COLOR("background-color"),
+    BACKGROUND("background"),
+    FONT_WEIGHT("font-weight"),
+    FONT_SIZE("font-size"),
+    MIN_HEIGHT("min-height"),
+    LINE_HEIGHT("line-height"),
+    TEXT_ALIGN("text-align"),
+    PADDING("padding"),
+    PADDING_TOP("padding-top"),
+    PADDING_RIGHT("padding-right"),
+    PADDING_BOTTOM("padding-bottom"),
+    PADDING_LEFT("padding-left"),
+    TEXT_INDENT("text-indent"),
+    MARGIN("margin"),
+    MARGIN_TOP("margin-top"),
+    MARGIN_RIGHT("margin-right"),
+    MARGIN_BOTTOM("margin-bottom"),
+    MARGIN_LEFT("margin-left"),
+    VERTICAL_ALIGN("vertical-align"),
+    FONT_FAMILY("font-family"),
+    FONT_STYLE("font-style"),
+    FACE("face"),
+    SIZE("size"),
+    HREF("href"),
+    SRC("src"),
+    WIDTH("width"),
+    HEIGHT("height"),
+    CLASS("class"),
+    BORDER_STYLE("border-style"),
+    COLSPAN("colspan"),
+    ROWSPAN("rowspan"),
+    TEXT_DECORATION("text-decoration"),
+    BACKGROUND_IMAGE("background-image"),
+    TEXT_EMPHASIS_POSITION("text-emphasis-position"),
+    DATA_TYPE("data-type"),
+    SEGMENT("segment"),
+    LIST_STYLE_TYPE("list-style-type"),
+    ALT("alt"),
+    NAME("name"),
+    DATA_HREF("data-href"),
+    DATA_FILE_SUFFIX("data-file-suffix"),
+    BORDER("border"),
+    BORDER_LEFT("border-left"),
+    BORDER_BOTTOM("border-bottom"),
+    BORDER_RIGHT("border-right"),
+    BORDER_TOP("border-top"),
+    BORDER_LEFT_COLOR("border-left-color"),
+    BORDER_BOTTOM_COLOR("border-bottom-color"),
+    BORDER_RIGHT_COLOR("border-right-color"),
+    BORDER_TOP_COLOR("border-top-color");
+
+    private final String value;
+
+    HtmlAttr(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/HtmlTag.java b/java-svc/src/main/java/com/wordparse/core/HtmlTag.java
new file mode 100644
index 0000000..f259edb
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/HtmlTag.java
@@ -0,0 +1,27 @@
+package com.wordparse.core;
+
+/**
+ * Brand-neutral HTML tag names.
+ *
+ * Minimal subset from jby TagEnum — only what the post-processing pipeline needs.
+ */
+public enum HtmlTag {
+
+    SUB("sub"),
+    SUP("sup");
+
+    private final String value;
+
+    HtmlTag(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/ImageBO.java b/java-svc/src/main/java/com/wordparse/core/ImageBO.java
new file mode 100644
index 0000000..2da391a
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/ImageBO.java
@@ -0,0 +1,14 @@
+package com.wordparse.core;
+
+public class ImageBO {
+    private String pictureUrl;
+    private Double width;
+    private Double height;
+
+    public String getPictureUrl() { return pictureUrl; }
+    public Double getWidth() { return width; }
+    public Double getHeight() { return height; }
+    public ImageBO setPictureUrl(String v) { this.pictureUrl = v; return this; }
+    public ImageBO setWidth(Double v) { this.width = v; return this; }
+    public ImageBO setHeight(Double v) { this.height = v; return this; }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/NumPr.java b/java-svc/src/main/java/com/wordparse/core/NumPr.java
new file mode 100644
index 0000000..97421f6
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/NumPr.java
@@ -0,0 +1,19 @@
+package com.wordparse.core;
+
+import java.math.BigInteger;
+
+public class NumPr {
+    private BigInteger start;
+    private BigInteger current;
+    private String numFmt;
+    private String lvlText;
+
+    public BigInteger getStart() { return start; }
+    public BigInteger getCurrent() { return current; }
+    public String getNumFmt() { return numFmt; }
+    public String getLvlText() { return lvlText; }
+    public void setStart(BigInteger v) { this.start = v; }
+    public void setCurrent(BigInteger v) { this.current = v; }
+    public void setNumFmt(String v) { this.numFmt = v; }
+    public void setLvlText(String v) { this.lvlText = v; }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/ParseBO.java b/java-svc/src/main/java/com/wordparse/core/ParseBO.java
new file mode 100644
index 0000000..9142000
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/ParseBO.java
@@ -0,0 +1,68 @@
+package com.wordparse.core;
+
+import com.alibaba.fastjson2.JSONObject;
+
+import javax.xml.transform.Transformer;
+import java.nio.file.Path;
+import java.util.*;
+
+public class ParseBO {
+    private Path tempDir;
+    private String sourceFilePath;
+    private String htmlPath;
+    private String imagesDir;
+    private String ossFolder;
+    private Transformer transformer;
+    private final Map<String, String> openOfficeXmlMap = new HashMap<>();
+    private final Map<String, String> mathTypeMap = new HashMap<>();
+    private final Map<String, String> eqLatexMap = new HashMap<>();
+    private final Map<String, ImageBO> imageMap = new HashMap<>();
+    private final Map<String, String> imgMap = new HashMap<>();
+    private final Map<String, NumPr> numberingDefinitionsMap = new HashMap<>();
+    private List<JSONObject> latexReplaceList = new ArrayList<>();
+    private int count = 0;
+    private Boolean newParseVersion = false;
+
+    // Placeholder generators
+    public String nextOmmPlchld()   { return "WP_OM_" + (++count) + "_END"; }
+    public String nextMtPlchld()    { return "WP_MT_" + (++count) + "_END"; }
+    public String nextEqPlchld()    { return "WP_EQ_" + (++count) + "_END"; }
+    public String nextImgName()     { return "image_" + (++count); }
+
+    // Original named placeholder methods (called by finders)
+    public String getOpenOfficeXmlPlaceholder()   { return nextOmmPlchld(); }
+    public String getMathTypePlaceholder(String rid) { return "WP_MT_" + rid + "_END"; }
+    public String getMathTypePlaceholder()         { return nextMtPlchld(); }
+    public String getImagePlaceholder(String rid)  { return "WP_IMG_" + rid + "_END"; }
+    public String getEqLatexPlaceholder()          { return nextEqPlchld(); }
+    public String getShapeImgPlaceholder()         { return "WP_IMG_" + (++count) + "_END"; }
+
+    // Getters
+    public Path getTempDir() { return tempDir; }
+    public String getSourceFilePath() { return sourceFilePath; }
+    public String getHtmlPath() { return htmlPath; }
+    public String getImagesDir() { return imagesDir; }
+    public String getOssFolder() { return ossFolder; }
+    public Transformer getTransformer() { return transformer; }
+    public Map<String, String> getOpenOfficeXmlMap() { return openOfficeXmlMap; }
+    public Map<String, String> getMathTypeMap() { return mathTypeMap; }
+    public Map<String, String> getEqLatexMap() { return eqLatexMap; }
+    public Map<String, ImageBO> getImageMap() { return imageMap; }
+    public Map<String, String> getImgMap() { return imgMap; }
+    public Map<String, NumPr> getNumberingDefinitionsMap() { return numberingDefinitionsMap; }
+    public int getCount() { return count; }
+    public Boolean getNewParseVersion() { return newParseVersion; }
+    public List<JSONObject> getLatexReplaceList() { return latexReplaceList; }
+    public Object getStyleDefinitionsPart() { return null; }
+
+    // Setters
+    public ParseBO setTempDir(Path v) { this.tempDir = v; return this; }
+    public ParseBO setSourceFilePath(String v) { this.sourceFilePath = v; return this; }
+    public ParseBO setHtmlPath(String v) { this.htmlPath = v; return this; }
+    public ParseBO setImagesDir(String v) { this.imagesDir = v; return this; }
+    public ParseBO setOssFolder(String v) { this.ossFolder = v; return this; }
+    public ParseBO setTransformer(Transformer v) { this.transformer = v; return this; }
+    public ParseBO setCount(int v) { this.count = v; return this; }
+    public ParseBO setNewParseVersion(Boolean v) { this.newParseVersion = v; return this; }
+    public ParseBO setLatexReplaceList(List<JSONObject> v) { this.latexReplaceList = v; return this; }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/TagStyleBO.java b/java-svc/src/main/java/com/wordparse/core/TagStyleBO.java
new file mode 100644
index 0000000..c825d94
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/TagStyleBO.java
@@ -0,0 +1,58 @@
+package com.wordparse.core;
+
+import java.io.Serializable;
+
+/**
+ * Brand-neutral replacement for jby TagStyleBO.
+ *
+ * Represents a single CSS property (attr, value) parsed from an element's style attribute.
+ */
+public class TagStyleBO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String tagName;
+    private String attr;
+    private String value;
+
+    public TagStyleBO() {
+    }
+
+    public TagStyleBO(String tagName, String attr, String value) {
+        this.tagName = tagName;
+        this.attr = attr;
+        this.value = value;
+    }
+
+    public String getTagName() {
+        return tagName;
+    }
+
+    public TagStyleBO setTagName(String tagName) {
+        this.tagName = tagName;
+        return this;
+    }
+
+    public String getAttr() {
+        return attr;
+    }
+
+    public TagStyleBO setAttr(String attr) {
+        this.attr = attr;
+        return this;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public TagStyleBO setValue(String value) {
+        this.value = value;
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return "TagStyleBO{tagName='" + tagName + "', attr='" + attr + "', value='" + value + "'}";
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/core/WordParseUtil.java b/java-svc/src/main/java/com/wordparse/core/WordParseUtil.java
new file mode 100644
index 0000000..425992b
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/core/WordParseUtil.java
@@ -0,0 +1,1496 @@
+package com.wordparse.core;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.wordparse.config.WordParseConfig;
+import com.wordparse.oss.OssService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.docx4j.Docx4J;
+import org.docx4j.TextUtils;
+import org.docx4j.TraversalUtil;
+import org.docx4j.XmlUtils;
+import org.docx4j.convert.out.HTMLSettings;
+import org.docx4j.openpackaging.packages.OpcPackage;
+import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
+import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
+import org.docx4j.openpackaging.parts.WordprocessingML.NumberingDefinitionsPart;
+import org.docx4j.wml.*;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.nodes.Node;
+import org.jsoup.nodes.TextNode;
+import org.jsoup.select.Elements;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StopWatch;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Word -> HTML parsing engine.
+ *
+ * Standalone version - only new parse path (omml_mathml2latex).
+ * All internal dependencies replaced with open-source equivalents.
+ * OSS uses RustFS (S3-compatible).
+ */
+@Component
+public class WordParseUtil {
+
+    private static final Logger log = LoggerFactory.getLogger(WordParseUtil.class);
+
+    private final WordParseConfig config;
+    private final OssService ossService;
+
+    public WordParseUtil(WordParseConfig config, OssService ossService) {
+        this.config = config;
+        this.ossService = ossService;
+    }
+
+    private static final String MATH_PLACEHOLDER = "<w:rPr><w:rFonts w:hint=\"eastAsia\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\"/></w:rPr><w:t>%s</w:t>";
+    private static final String[] SYMBOL = {"\\ue0fc", "\\ue100", "\\ue101"};
+
+    // ---------- Class-level constants (brand-neutral replacements for jby Constants) ----------
+    private static final Set<String> RETAIN_CLASS_VALUE_SET = Set.of(
+            "custom-text-decoration-dot-dashed",
+            "custom-text-decoration-double-dot-dashed"
+    );
+    private static final Set<String> DOT_DASHED_STYLE_SET = Set.of(
+            "background-image", "background-size", "background-position", "background-repeat"
+    );
+
+    // ===================== public entry =====================
+
+    public String parse(File sourceFile) throws Exception {
+        ParseBO bo = new ParseBO();
+        createTempDir(bo);
+        bo.setSourceFilePath(sourceFile.getAbsolutePath());
+        bo.setOssFolder(bo.getTempDir().getFileName().toString());
+
+        // 1) Pre-process: fix document.xml (handleFormat)
+        handleFormat(bo.getSourceFilePath());
+
+        // 2) Load
+        WordprocessingMLPackage wordML = WordprocessingMLPackage.load(sourceFile);
+        bo.setTransformer(createTransformer());
+
+        // 3) Custom parse: extract formulas, images, textboxes
+        customParse(wordML, bo);
+
+        // 4) Docx4J -> HTML
+        FileOutputStream os = new FileOutputStream(new File(bo.getHtmlPath()));
+        HTMLSettings htmlSettings = Docx4J.createHTMLSettings();
+        htmlSettings.setImageDirPath(bo.getImagesDir());
+        htmlSettings.setImageTargetUri("images");
+        htmlSettings.setFontFamilyStack(true);
+        htmlSettings.setOpcPackage((OpcPackage) wordML);
+        Docx4J.toHTML(htmlSettings, os, 1);
+        os.close();
+
+        // 5) Upload images to OSS (from package parts, docx4j 8.x doesn't extract to disk)
+        uploadImgToOss(bo, wordML);
+        log.info("After upload: imgMap size={}, imageMap size={}", bo.getImgMap().size(), bo.getImageMap().size());
+
+        // 6) Post-process HTML
+        String html = Files.readString(Paths.get(bo.getHtmlPath()), StandardCharsets.UTF_8);
+        // Debug: check raw img tags
+        log.info("Raw HTML img count: {}", html.split("<img").length - 1);
+        html = customParseOfficeHtml(html, bo);
+        // Replace image src with OSS URLs (after post-processing creates img tags)
+        html = replaceImgUrls(bo, html);
+
+        return html;
+    }
+
+    public String parseBytes(byte[] data) throws Exception {
+        Path tmp = Files.createTempFile("wordparse_", ".docx");
+        Files.write(tmp, data);
+        try {
+            return parse(tmp.toFile());
+        } finally {
+            Files.deleteIfExists(tmp);
+        }
+    }
+
+    // ===================== temp / format =====================
+
+    private void createTempDir(ParseBO bo) throws IOException {
+        Path tempDir = Files.createTempDirectory(Paths.get(config.getTmpPath()), "parse-");
+        bo.setTempDir(tempDir);
+        bo.setImagesDir(tempDir.resolve("images").toString());
+        bo.setHtmlPath(tempDir.resolve("output.html").toString());
+    }
+
+    void handleFormat(String docxPath) throws IOException {
+        Path tmpDir = Files.createTempDirectory("fmt_");
+        try {
+            unzipDocx(docxPath, tmpDir.toString());
+            Path docXml = tmpDir.resolve("word/document.xml");
+            String content = Files.readString(docXml, StandardCharsets.UTF_8);
+
+            content = content.replace("<w:b w:val=\"off\"", "<w:b w:val=\"0\"");
+            content = content.replace("<w:i w:val=\"off\"", "<w:i w:val=\"0\"");
+            // 无 w:val 的 <w:u> 视为无下划线（Word/textutil 行为；docx4j 按 spec 默认 single 会误判）
+            content = content.replaceAll("<w:u(?![^>]*?w:val)[^>]*?/>", "");
+            content = content.replaceAll("[\\u200B\\u200C\\u200D]", "");
+            content = content.replace("\u00A0", " ");
+            content = content.replace("\uf028", "(");
+            content = content.replace("\uf029", ")");
+            for (String sl : SYMBOL) {
+                content = content.replace(sl, "@@@" + sl.substring(2).toUpperCase() + "@@@");
+            }
+            content = content.replace("<w:shd w:val=\"pct15\" w:color=\"auto\" w:fill=\"FFFFFF\"/>",
+                    "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"D9D9D9\"/>");
+            content = content.replace("<w:shd w:val=\"pct10\" w:color=\"auto\" w:fill=\"FFFFFF\"/>",
+                    "<w:shd w:val=\"clear\" w:color=\"FFFFFF\" w:fill=\"E5E5E5\"/>");
+
+            Files.writeString(docXml, content);
+            zipToDocx(tmpDir.toString(), docxPath);
+        } finally {
+            deleteDir(tmpDir.toFile());
+        }
+    }
+
+    // ─────────────────────── customParse ───────────────────────
+
+    private void customParse(WordprocessingMLPackage wordML, ParseBO bo) throws Exception {
+        MainDocumentPart main = wordML.getMainDocumentPart();
+
+        // Numbering definitions
+        NumberingDefinitionsPart numPart = main.getNumberingDefinitionsPart();
+        if (numPart != null) {
+            Map<String, NumPr> numMap = new HashMap<>();
+            numPart.getInstanceListDefinitions().forEach((key, def) -> {
+                def.getAbstractListDefinition().getAbstractNumNode().getLvl().stream()
+                        .filter(l -> l.getStart() != null)
+                        .forEach(l -> {
+                            NumPr np = new NumPr();
+                            np.setStart(l.getStart().getVal());
+                            np.setCurrent(np.getStart().subtract(BigInteger.ONE));
+                            np.setNumFmt(Optional.ofNullable(l.getNumFmt())
+                                    .map(f -> f.getVal().toString()).orElse(""));
+                            np.setLvlText(Optional.ofNullable(l.getLvlText())
+                                    .map(Lvl.LvlText::getVal).orElse(""));
+                            numMap.put(key + "_" + l.getIlvl(), np);
+                        });
+            });
+        }
+
+        Body body = ((org.docx4j.wml.Document) main.getJaxbElement()).getBody();
+
+        // 1) MathType OLE → MathML → LaTeX
+        CtObjectFinder mtFinder = new CtObjectFinder(wordML, bo);
+        new TraversalUtil(body.getContent(), mtFinder);
+        mathTypeToLatexNew(bo, wordML);
+
+        // 2) Word OMML formulas
+        CtoMathFinder ommlFinder = new CtoMathFinder(bo);
+        new TraversalUtil(body.getContent(), ommlFinder);
+        log.info("OMML map size: {}, MathType map: {}",
+                bo.getOpenOfficeXmlMap().size(), bo.getMathTypeMap().size());
+        ommlToLatexNew(bo.getOpenOfficeXmlMap(), bo.getTempDir());
+
+        // 3) Drawing / pictures
+        DrawingPictFinder picFinder = new DrawingPictFinder(wordML, bo);
+        new TraversalUtil(body.getContent(), picFinder);
+
+        // 4) Textboxes
+        CtTextBoxFinder tbFinder = new CtTextBoxFinder(wordML, bo);
+        new TraversalUtil(body.getContent(), tbFinder);
+
+        // Textbox reorder
+        for (Object obj : body.getContent()) {
+            if (!(obj instanceof P p)) continue;
+            String text = TextUtils.getText(p);
+            if (text == null || !text.contains("WP_TEXTBOX_WP")) continue;
+            if (CollectionUtils.isEmpty(p.getContent())) continue;
+            List<Object> matched = new ArrayList<>(), unmatched = new ArrayList<>();
+            for (Object c : p.getContent()) {
+                (TextUtils.getText(c).contains("WP_TEXTBOX_WP") ? matched : unmatched).add(c);
+            }
+            p.getContent().clear();
+            p.getContent().addAll(unmatched);
+            p.getContent().addAll(matched);
+        }
+    }
+
+    // ===================== OMML -> LaTeX (new path) =====================
+
+    // ─────────────────────── MathType OLE → LaTeX ───────────────────────
+
+    private void mathTypeToLatexNew(ParseBO bo, WordprocessingMLPackage wordML) {
+        if (MapUtils.isEmpty(bo.getMathTypeMap())) return;
+        try {
+            // 1) Build mapping: placeholder -> bin file name
+            Map<String, String> placeholderToBin = new LinkedHashMap<>();
+            // Debug: log all part names with "embedding"
+            wordML.getParts().getParts().keySet().stream()
+                .filter(k -> k.getName().contains("embedding"))
+                .limit(5).forEach(k -> log.info("Embedding part: {}", k.getName()));
+            for (var entry : bo.getMathTypeMap().entrySet()) {
+                String placeholder = entry.getKey();
+                String binPath = entry.getValue(); // e.g. WP_MT_rId8 -> /tmp/.../temp/word/embeddings/oleObject1.bin
+                String fileName = binPath.substring(binPath.lastIndexOf('/') + 1);
+                // Extract OLE binary from the part relation (CtObjectFinder stored the temp path)
+                // The part name in the package is /word/embeddings/oleObject1.bin
+                String partNameInPackage = "/" + binPath.substring(binPath.indexOf("word/"));
+                Path dest = bo.getTempDir().resolve("mathtype").resolve(fileName);
+                try {
+                    // Find part by name in the Parts map (PartName objects, not strings)
+                    org.docx4j.openpackaging.parts.Part found = null;
+                    for (var pe : wordML.getParts().getParts().entrySet()) {
+                        if (pe.getKey().getName().equals(partNameInPackage)) {
+                            found = pe.getValue(); break;
+                        }
+                    }
+                    if (found instanceof org.docx4j.openpackaging.parts.WordprocessingML.BinaryPart bp) {
+                        Files.createDirectories(dest.getParent());
+                        Files.write(dest, bp.getBytes());
+                        placeholderToBin.put(placeholder, dest.toString());
+                    } else {
+                        log.warn("Part not found for MathType: {}", partNameInPackage);
+                    }
+                } catch (Exception e) {
+                    log.warn("Failed to extract {}: {}", partNameInPackage, e.getMessage());
+                }
+            }
+            if (placeholderToBin.isEmpty()) return;
+
+            // 2) Call Ruby batch_converter.rb with file paths
+            Path inputJson = bo.getTempDir().resolve("mathtype_input.json");
+            Files.writeString(inputJson, JSON.toJSONString(placeholderToBin));
+
+            String scriptPath = config.getTransformScriptsPath() + "/mathtype2mathml/batch_converter.rb";
+            ProcessBuilder pb = new ProcessBuilder("ruby", scriptPath, inputJson.toString());
+            pb.directory(new File(config.getTransformScriptsPath() + "/mathtype2mathml"));
+            pb.environment().put("GEM_HOME", "/var/lib/gems/3.3.0");
+            pb.environment().put("GEM_PATH", "/var/lib/gems/3.3.0");
+            Process proc = pb.start();
+            String stdout = new String(proc.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+            int code = proc.waitFor(120, TimeUnit.SECONDS) ? proc.exitValue() : -1;
+
+            if (code != 0 || StringUtils.isBlank(stdout)) {
+                log.warn("MathType conversion failed: exit={}, stderr={}", code,
+                        new String(proc.getErrorStream().readAllBytes()));
+                return;
+            }
+
+            // 3) Parse JSON output: find WP_RUBY_ prefix
+            String marker = "WP_RUBY_";
+            int markerIdx = stdout.indexOf(marker);
+            if (markerIdx < 0) { log.warn("No MathType output marker found"); return; }
+            JSONObject wrapper = JSON.parseObject(stdout.substring(markerIdx + marker.length()));
+            if (wrapper == null) return;
+            JSONObject result = wrapper.getJSONObject("results");
+            if (result == null) return;
+
+            // 4) Use MathML directly
+            Map<String, String> mathmlMap = new LinkedHashMap<>();
+            result.forEach((k, v) -> {
+                if (v instanceof JSONObject jo) {
+                    String mathml = jo.getString("mathml");
+                    if (StringUtils.isNotBlank(mathml)) {
+                        mathmlMap.put(k, mathml);
+                    }
+                }
+            });
+            log.info("Ruby returned {} MathML entries", mathmlMap.size());
+
+            // 4b) Convert MathML → LaTeX via Python
+            mathmlToLatexViaPython(mathmlMap, bo.getTempDir());
+
+            // 5) Update mathTypeMap: placeholder → LaTeX
+            bo.getMathTypeMap().clear();
+            for (var pe : placeholderToBin.entrySet()) {
+                String placeholder = pe.getKey();
+                String latex = mathmlMap.get(placeholder);
+                if (StringUtils.isNotBlank(latex)) {
+                    bo.getMathTypeMap().put(placeholder, latex);
+                }
+            }
+            log.info("MathType: {} formulas converted", bo.getMathTypeMap().size());
+        } catch (Exception e) {
+            log.error("MathType→LaTeX error", e);
+        }
+    }
+
+    // ──────────────── MathML → LaTeX via Python (batch) ────────────────
+
+    private void mathmlToLatexViaPython(Map<String, String> mathmlMap, Path tempDir) {
+        if (MapUtils.isEmpty(mathmlMap)) return;
+        try {
+            // Write all MathML as JSON, batch convert
+            Path inputJson = tempDir.resolve("mathml_batch.json");
+            Files.writeString(inputJson, JSON.toJSONString(mathmlMap));
+
+            String scriptPath = config.getTransformScriptsPath() + "/omml_mathml2latex/omml_mathml2latex.py";
+            ProcessBuilder pb = new ProcessBuilder(
+                    config.getPythonCommand(), scriptPath,
+                    "--json", inputJson.toString(), "--output-format", "json", "--quiet");
+            pb.directory(new File(config.getTransformScriptsPath() + "/omml_mathml2latex"));
+            Process proc = pb.start();
+            String stdout = new String(proc.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+            int code = proc.waitFor(60, TimeUnit.SECONDS) ? proc.exitValue() : -1;
+
+            if (code == 0 && StringUtils.isNotBlank(stdout)) {
+                JSONObject result = JSON.parseObject(stdout);
+                if (result != null) {
+                    result.forEach((k, v) -> {
+                        if (v != null) {
+                            String latex = v.toString().replace("$", "").trim();
+                            mathmlMap.put(k, latex);
+                        }
+                    });
+                }
+            }
+            log.info("MathML→LaTeX: {} formulas converted, sample: {}",
+                    mathmlMap.size(), mathmlMap.values().stream().findFirst().orElse("N/A"));
+        } catch (Exception e) {
+            log.error("MathML→LaTeX error", e);
+        }
+    }
+
+    private void ommlToLatexNew(Map<String, String> ommlMap, Path tempDir) {
+        if (MapUtils.isEmpty(ommlMap)) return;
+        try {
+            Path input = tempDir.resolve("omml_input.json");
+            Files.writeString(input, JSON.toJSONString(ommlMap));
+
+            String scriptPath = config.getTransformScriptsPath() + "/omml_mathml2latex/omml_mathml2latex.py";
+            ProcessBuilder pb = new ProcessBuilder(
+                    config.getPythonCommand(), scriptPath,
+                    "--json", input.toString(),
+                    "--output-format", "json", "--parallel", "--quiet"
+            );
+            pb.directory(new File(config.getTransformScriptsPath() + "/omml_mathml2latex"));
+            Process proc = pb.start();
+            String stdout = new String(proc.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+            int code = proc.waitFor(180, TimeUnit.SECONDS) ? proc.exitValue() : -1;
+
+            if (code == 0 && StringUtils.isNotBlank(stdout)) {
+                JSONObject result = JSON.parseObject(stdout);
+                if (result != null) {
+                    result.forEach((k, v) -> {
+                        if (!"code".equals(k) && !"fileId".equals(k)) {
+                            ommlMap.put(k, v.toString());
+                        }
+                    });
+                }
+            } else {
+                log.warn("omml->latex failed: exit={}, stderr={}",
+                        code, new String(proc.getErrorStream().readAllBytes()));
+            }
+        } catch (Exception e) {
+            log.error("omml->latex error", e);
+        }
+    }
+
+    // ===================== XSLT transformer =====================
+
+    private Transformer createTransformer() throws Exception {
+        InputStream xsl = getClass().getClassLoader().getResourceAsStream("OMML2MML.xsl");
+        if (xsl == null) {
+            // Read from transform scripts
+            Path xslPath = Paths.get(config.getTransformScriptsPath(),
+                    "omml_mathml2latex", "core", "OMML2MML.xsl");
+            xsl = Files.newInputStream(xslPath);
+        }
+        return TransformerFactory.newInstance().newTransformer(new StreamSource(xsl));
+    }
+
+    // JAXBElement overload called from CtoMathFinder (decompiled code compatibility)
+    public static String getMathMl(javax.xml.bind.JAXBElement<?> jaxbEl, Transformer transformer) {
+        return ommlToMathMlStatic(jaxbEl, transformer);
+    }
+
+    public static String ommlToMathMlStatic(Object ommlNode, Transformer transformer) {
+        try {
+            String omml = XmlUtils.marshaltoString(ommlNode, true, false);
+            StringWriter sw = new StringWriter();
+            transformer.transform(new StreamSource(new StringReader(omml)), new StreamResult(sw));
+            String ml = sw.toString();
+            int idx = ml.indexOf("=\"http://www.w3.org/1998/Math/MathML\"");
+            if (idx >= 0) {
+                ml = "<math display=\"inline\" xmlns" + ml.substring(idx);
+            }
+            ml = ml.replaceAll("mml:", "").replace("\u00a0", "~");
+            return ml;
+        } catch (Exception e) {
+            log.error("omml->mathml error", e);
+            return "";
+        }
+    }
+
+    public String ommlToMathMl(Object ommlNode, Transformer transformer) {
+        return ommlToMathMlStatic(ommlNode, transformer);
+    }
+
+    // =====================================================================
+    //  HTML POST-PROCESSING PIPELINE
+    //  Ported EXACTLY from original jby WordParseUtil (brand-neutralized)
+    // =====================================================================
+
+    String customParseOfficeHtml(String html, ParseBO bo) {
+        // Convert our custom underline markers to real underlines
+        html = html.replaceAll("text-decoration: wp-underline;", "text-decoration: underline;");
+
+        Document doc = Jsoup.parse(html);
+        doc.outputSettings().prettyPrint(false);
+
+        dealUderlineSubSup(doc);
+        dealTitle(doc);
+        dealUnderlineAndLineThrough(doc);
+        dealUnderline(doc);
+        dealCustomTextDecoration(doc);
+        dealLi(doc);
+        dealSubSup(doc);
+        cleanDocument(doc);
+        dealNoSPanWhiteSpace((Element) doc);
+        dealLineHeight((Element) doc);
+
+        return dealPlaceholder(bo, doc);
+    }
+
+    // ── image URL replacement (post-placeholder, on HTML string) ──
+
+    private String replaceImgUrls(ParseBO bo, String html) {
+        if (MapUtils.isEmpty(bo.getImgMap())) return html;
+        for (var entry : bo.getImgMap().entrySet()) {
+            String key = entry.getKey();
+            if (!key.startsWith("/")) continue; // only use normalized paths
+            html = html.replace("\"" + key + "\"", "\"" + entry.getValue() + "\"");
+        }
+        return html;
+    }
+
+    // ---------- dealUderlineSubSup ----------
+
+    private void dealUderlineSubSup(Document doc) {
+        try {
+            Elements spansWithSupSub = doc.select("span:has(sup), span:has(sub)");
+            for (Element span : spansWithSupSub) {
+                String style = span.attr("style");
+                if (style == null || !style.contains("text-decoration: underline;")) continue;
+                Elements supSubElements = span.select("sup, sub");
+                Element previousSpan = span.previousElementSibling();
+                if (previousSpan == null || !"span".equals(previousSpan.tagName())) continue;
+                for (Element supSub : supSubElements) {
+                    previousSpan.appendChild((Node) supSub);
+                }
+                span.remove();
+            }
+        } catch (Exception e) {
+            log.error("处理带下划线的上标下标异常", e);
+        }
+    }
+
+    // ---------- dealLineHeight ----------
+
+    private void dealLineHeight(Element doc) {
+        String[] patterns = new String[]{
+                "line-height:\\s*([0-9]*\\.?[0-9]+)%",
+                "line-height:\\s*([0-9]*\\.?[0-9]+)",
+                "line-height:\\s*([0-9]+(?:\\.[0-9]+)?em)"
+        };
+        Elements elements = doc.select("[style*=\"line-height\"]");
+        for (Element element : elements) {
+            String style = element.attr("style");
+            String newStyle = style;
+            for (String pStr : patterns) {
+                Pattern pattern = Pattern.compile(pStr);
+                Matcher matcher = pattern.matcher(newStyle);
+                StringBuffer sb = new StringBuffer();
+                while (matcher.find()) {
+                    double lineHeightValue;
+                    String originalValue = matcher.group(1);
+                    try {
+                        String numericValue = originalValue.replaceAll("[^0-9.]", "");
+                        lineHeightValue = Double.parseDouble(numericValue);
+                        if (pStr.contains("%")) {
+                            lineHeightValue /= 100.0;
+                        }
+                    } catch (NumberFormatException e) {
+                        lineHeightValue = 0.0;
+                    }
+                    if (lineHeightValue < 2.0) {
+                        String replacement = pStr.contains("%")
+                                ? "line-height: 200%"
+                                : (pStr.contains("em") ? "line-height: 2.0em" : "line-height: 2.0");
+                        matcher.appendReplacement(sb, replacement);
+                        continue;
+                    }
+                    matcher.appendReplacement(sb, matcher.group(0));
+                }
+                matcher.appendTail(sb);
+                newStyle = sb.toString();
+            }
+            if (!newStyle.equals(style)) continue;
+            element.attr("style", newStyle);
+        }
+    }
+
+    // ---------- dealNoSPanWhiteSpace ----------
+
+    private void dealNoSPanWhiteSpace(Element doc) {
+        for (Node node : doc.childNodes()) {
+            if (node instanceof TextNode) {
+                TextNode textNode = (TextNode) node;
+                String text = textNode.getWholeText();
+                if (!text.contains("\u00a0")) continue;
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < text.length(); ++i) {
+                    char c = text.charAt(i);
+                    sb.append(c);
+                    if (c != '\u00a0' || i == text.length() - 1 || text.charAt(i + 1) != '\u00a0') continue;
+                    sb.append(" ");
+                }
+                text = sb.toString();
+                if (!textNode.parent().nodeName().equals("span")) {
+                    Element span = new Element("span");
+                    span.text(text);
+                    textNode.replaceWith((Node) span);
+                    continue;
+                }
+                textNode.text(text);
+                continue;
+            }
+            if (!(node instanceof Element)) continue;
+            dealNoSPanWhiteSpace((Element) node);
+        }
+    }
+
+    // ---------- dealWhiteSpace ----------
+    // (called from dealUnderline / other places in original; keep for completeness)
+
+    private void dealWhiteSpace(Document doc) {
+        try {
+            Elements elements = doc.select("span");
+            for (Element span : elements) {
+                processSpanContent((Node) span);
+            }
+        } catch (Exception e) {
+            log.error("处理空格异常", e);
+        }
+    }
+
+    // ---------- processSpanContent ----------
+
+    private void processSpanContent(Node node) {
+        if (node.childNodeSize() > 0) {
+            for (Node childNode : node.childNodes()) {
+                processSpanContent(childNode);
+            }
+        } else if (node instanceof TextNode) {
+            TextNode textNode = (TextNode) node;
+            textNode.text(textNode.getWholeText().replaceAll(" ", "WP_nbsp;"));
+        }
+    }
+
+    // ---------- dealTitle ----------
+
+    private void dealTitle(Document doc) {
+        try {
+            Map<String, List<Map<String, String>>> pStyleMap = parseCssRulesToMap(doc);
+            Elements elements = doc.select("p, li");
+            for (Element p : elements) {
+                String classAttr = p.attr("class");
+                if (!StringUtils.isNotBlank(classAttr)) continue;
+                HashMap<String, String> finalStyles = new HashMap<>();
+                String existingStyle = p.attr("style");
+                HashSet<String> existingStyleKeys = new HashSet<>();
+                if (StringUtils.isNotBlank(existingStyle)) {
+                    String[] stylePairs = existingStyle.split(";");
+                    for (String pair : stylePairs) {
+                        String[] parts = pair.split(":", 2);
+                        if (parts.length != 2) continue;
+                        String key = parts[0].trim();
+                        String value = parts[1].trim();
+                        finalStyles.put(key, value);
+                        existingStyleKeys.add(key);
+                    }
+                }
+                String[] classNames = classAttr.split("\\s+");
+                ArrayList<String> orderedClassNames = new ArrayList<>();
+                block4:
+                for (String selector : pStyleMap.keySet()) {
+                    String className = selector.substring(1);
+                    for (String currentClass : classNames) {
+                        if (!className.equals(currentClass)) continue;
+                        orderedClassNames.add(currentClass);
+                        continue block4;
+                    }
+                }
+                for (String className : orderedClassNames) {
+                    if (!pStyleMap.containsKey("." + className)) continue;
+                    List<Map<String, String>> classStyles = pStyleMap.get("." + className);
+                    for (Map<String, String> map : classStyles) {
+                        for (Map.Entry<String, String> entry : map.entrySet()) {
+                            if (existingStyleKeys.contains(entry.getKey())) continue;
+                            finalStyles.put(entry.getKey(), entry.getValue());
+                        }
+                    }
+                }
+                if (finalStyles.isEmpty()) continue;
+                StringBuilder styleBuilder = new StringBuilder();
+                for (Map.Entry<String, String> entry : finalStyles.entrySet()) {
+                    styleBuilder.append(entry.getKey()).append(": ").append(entry.getValue()).append("; ");
+                }
+                p.attr("style", styleBuilder.toString().trim());
+            }
+        } catch (NumberFormatException e) {
+            log.error("处理标题异常", e);
+        }
+    }
+
+    // ---------- parseCssRulesToMap ----------
+
+    private Map<String, List<Map<String, String>>> parseCssRulesToMap(Document doc) {
+        Element styleElement = doc.selectFirst("style");
+        String cssContent = styleElement.html();
+        LinkedHashMap<String, List<Map<String, String>>> cssMap = new LinkedHashMap<>();
+        if (StringUtils.isBlank(cssContent)) {
+            return cssMap;
+        }
+        Pattern sectionPattern = Pattern.compile("/\\* PARAGRAPH STYLES \\*/(.*?)/\\* CHARACTER STYLES \\*/", Pattern.DOTALL);
+        Matcher sectionMatcher = sectionPattern.matcher(cssContent);
+        String targetContent;
+        targetContent = sectionMatcher.find() ? sectionMatcher.group(1) : cssContent;
+        Pattern cssRulePattern = Pattern.compile("([^\\{]+)\\{([^\\}]+)\\}");
+        Matcher matcher = cssRulePattern.matcher(targetContent);
+        ArrayList<String> selectorOrder = new ArrayList<>();
+        while (matcher.find()) {
+            String selector = matcher.group(1).trim();
+            String properties = matcher.group(2).trim();
+            ArrayList<Map<String, String>> propertyList = new ArrayList<>();
+            String[] propertyPairs = properties.split(";");
+            for (String propertyPair : propertyPairs) {
+                if (!StringUtils.isNotBlank(propertyPair)) continue;
+                String[] parts = propertyPair.split(":", 2);
+                if (parts.length != 2) continue;
+                HashMap<String, String> propertyMap = new HashMap<>();
+                String key = parts[0].trim();
+                String value = parts[1].trim();
+                propertyMap.put(key, value);
+                propertyList.add(propertyMap);
+            }
+            cssMap.put(selector, propertyList);
+            selectorOrder.add(selector);
+        }
+        return selectorOrder.stream()
+                .filter(selector -> selector.startsWith(".") && cssMap.containsKey(selector))
+                .collect(Collectors.toMap(Function.identity(), cssMap::get,
+                        (existing, replacement) -> existing, LinkedHashMap::new));
+    }
+
+    // ---------- cleanDocument ----------
+
+    private void cleanDocument(Document doc) {
+        try {
+            Element docElement = doc.selectFirst(".document");
+            if (Objects.isNull(docElement)) {
+                return;
+            }
+            log.info("去除非必要样式配置信息:{}", JSON.toJSONString(config.getCleanStyleMap()));
+            Elements allElements = docElement.select("*");
+            for (Element el : allElements) {
+                cleanClass(el, docElement);
+                cleanStyle(el);
+            }
+        } catch (Exception e) {
+            log.error("清洁文档异常", e);
+        }
+    }
+
+    // ---------- cleanClass ----------
+
+    private void cleanClass(Element el, Element docElement) {
+        if (el == docElement) {
+            return;
+        }
+        String className = Optional.ofNullable(el.className()).orElse("");
+        for (String retainClass : RETAIN_CLASS_VALUE_SET) {
+            if (!className.contains(retainClass)) continue;
+            return;
+        }
+        el.attributes().remove(HtmlAttr.CLASS.getValue());
+    }
+
+    // ---------- cleanStyle ----------
+
+    private void cleanStyle(Element el) {
+        // Ensure font-family is present on styled spans
+        if (el.tagName().equals("span")) {
+            String style = el.attr(HtmlAttr.STYLE.getValue());
+            if (!style.contains("font-family")) {
+                if (StringUtils.isNotBlank(style)) {
+                    el.attr(HtmlAttr.STYLE.getValue(), style + "font-family: simsun, serif;");
+                } else {
+                    el.attr(HtmlAttr.STYLE.getValue(), "font-family: simsun, serif;");
+                }
+            }
+        }
+        if (MapUtils.isEmpty(config.getCleanStyleMap())) {
+            return;
+        }
+        String oldStyle = el.attr(HtmlAttr.STYLE.getValue());
+        if (StringUtils.isBlank(oldStyle)) {
+            return;
+        }
+        String[] originalStyle = new String[]{oldStyle};
+        config.getCleanStyleMap().forEach((tagName, styles) -> {
+            if (StringUtils.isBlank(tagName) || styles == null) {
+                return;
+            }
+            for (String style : styles) {
+                if (StringUtils.isBlank(style)) {
+                    return;
+                }
+                if (tagName.equals(el.tagName())) {
+                    originalStyle[0] = originalStyle[0].replaceAll(style, "");
+                }
+            }
+            if (StringUtils.isBlank(originalStyle[0])) {
+                el.removeAttr(HtmlAttr.STYLE.getValue());
+                return;
+            }
+            String newStyle = Arrays.stream(originalStyle[0].split(";"))
+                    .filter(StringUtils::isNotBlank)
+                    .map(e -> e.trim() + "; ")
+                    .collect(Collectors.joining())
+                    .trim();
+            el.attr(HtmlAttr.STYLE.getValue(), newStyle);
+        });
+    }
+
+    // ---------- dealSubSup ----------
+
+    private void dealSubSup(Document doc) {
+        try {
+            Elements elements = doc.select("span[style~=(?:vertical-align: (sub|super);font-size: smaller;)]");
+            for (Element span : elements) {
+                List<TagStyleBO> styles = getStyleList(span);
+                boolean isSub = styles.stream().anyMatch(
+                        e -> HtmlAttr.VERTICAL_ALIGN.getValue().equals(e.getAttr())
+                                && HtmlTag.SUB.getValue().equals(e.getValue()));
+                Element suElement = new Element(isSub ? HtmlTag.SUB.getValue() : HtmlTag.SUP.getValue())
+                        .html(span.html());
+                if (suElement.childNodeSize() == 0) {
+                    span.remove();
+                    continue;
+                }
+                span.html(suElement.outerHtml());
+                String styleValue = styles.stream()
+                        .filter(e -> !HtmlAttr.VERTICAL_ALIGN.getValue().equals(e.getAttr())
+                                && !HtmlAttr.FONT_SIZE.getValue().equals(e.getAttr()))
+                        .map(e -> e.getAttr() + ": " + e.getValue())
+                        .collect(Collectors.joining(";"));
+                if (StringUtils.isBlank(styleValue)) {
+                    span.removeAttr(HtmlAttr.STYLE.getValue());
+                    continue;
+                }
+                span.attr(HtmlAttr.STYLE.getValue(), styleValue);
+            }
+        } catch (Exception e) {
+            log.error("处理上标、下标异常", e);
+        }
+    }
+
+    // ---------- getStyleList (inline replacement for TagEnum.getStyleList) ----------
+
+    private static List<TagStyleBO> getStyleList(Element element) {
+        List<TagStyleBO> styleList = new ArrayList<>();
+        // Parse inline style attribute
+        String styleAttr = element.attr(HtmlAttr.STYLE.getValue());
+        if (StringUtils.isNotBlank(styleAttr)) {
+            for (String style : styleAttr.split(";")) {
+                if (StringUtils.isBlank(style)) continue;
+                String[] split = style.split(":");
+                if (split.length < 2) continue;
+                String attr = split[0].trim();
+                String value = split[1].trim();
+                if (StringUtils.isBlank(value) || "null".equals(value)
+                        || StringUtils.isBlank(attr) || "null".equals(attr)) continue;
+                styleList.add(new TagStyleBO().setTagName(element.tagName()).setAttr(attr).setValue(value));
+            }
+        }
+        return styleList;
+    }
+
+    // ---------- dealImg (HTML post-processing) ----------
+
+    private void dealImg(ParseBO bo, Document doc) {
+        try {
+            Elements elements = doc.select("img[src]");
+            log.info("dealImg: found {} img[src] elements", elements.size());
+            if (MapUtils.isNotEmpty(bo.getImgMap())) {
+                log.info("imgMap size: {}, keys: {}", bo.getImgMap().size(), bo.getImgMap().keySet());
+                for (Element img : elements) {
+                    String src = img.attr(HtmlAttr.SRC.getValue());
+                    // Try exact match first, then with "images/" prefix
+                    String srcUrl = bo.getImgMap().get(src);
+                    if (StringUtils.isBlank(srcUrl) && src.startsWith("/")) {
+                        srcUrl = bo.getImgMap().get("images" + src);
+                    }
+                    if (StringUtils.isBlank(srcUrl)) {
+                        srcUrl = bo.getImgMap().get(src.startsWith("/") ? src.substring(1) : src);
+                    }
+                    if (StringUtils.isNotBlank(srcUrl)) {
+                        img.attr(HtmlAttr.SRC.getValue(), srcUrl);
+                        log.info("Replaced img src: {} -> {}", src, srcUrl);
+                    } else {
+                        log.info("No imgMap match for src: {}", src);
+                    }
+                    adjustWidthHeight(img);
+                    addImgAttr(img);
+                }
+            }
+            Elements elementImgNot = doc.select("img:not([src])");
+            elementImgNot.remove();
+        } catch (Exception e) {
+            log.error("处理图片异常", e);
+        }
+    }
+
+    // ---------- adjustWidthHeight ----------
+
+    private void adjustWidthHeight(Element img) {
+        try {
+            String style = img.attr("style");
+            if (style != null && !style.isEmpty()) {
+                String widthValue = extractDimensionFromStyle(style, "width");
+                String heightValue = extractDimensionFromStyle(style, "height");
+                String newStyle = "";
+                if (widthValue != null) {
+                    String widthPx = convertToPx(widthValue);
+                    if (widthPx != null) {
+                        img.attr("width", widthPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = removeDimensionFromStyle(style, "width");
+                }
+                if (heightValue != null) {
+                    String heightPx = convertToPx(heightValue);
+                    if (heightPx != null) {
+                        img.attr("height", heightPx.replaceAll("[^0-9.]", ""));
+                    }
+                    newStyle = removeDimensionFromStyle(newStyle, "height");
+                }
+                if (StringUtils.isBlank(newStyle)) {
+                    img.removeAttr("style");
+                } else {
+                    img.attr("style", newStyle);
+                }
+            }
+            String widthStr = img.attr(HtmlAttr.WIDTH.getValue());
+            if (StringUtils.isNotBlank(widthStr)) {
+                double width = Double.parseDouble(Objects.requireNonNull(convertToPx(widthStr)));
+                width /= config.getImageScalingFactor().doubleValue();
+                img.attr(HtmlAttr.WIDTH.getValue(), Double.toString(Math.round(width * 100.0) / 100.0));
+            }
+            String heightStr = img.attr(HtmlAttr.HEIGHT.getValue());
+            if (StringUtils.isNotBlank(heightStr)) {
+                double height = Double.parseDouble(Objects.requireNonNull(convertToPx(heightStr)));
+                height /= config.getImageScalingFactor().doubleValue();
+                img.attr(HtmlAttr.HEIGHT.getValue(), Double.toString(Math.round(height * 100.0) / 100.0));
+            }
+        } catch (Exception e) {
+            log.error("调整宽高异常", e);
+        }
+    }
+
+    // ---------- convertToPx ----------
+
+    private String convertToPx(String value) {
+        if (StringUtils.isBlank(value)) {
+            return null;
+        }
+        value = value.trim().toLowerCase();
+        Pattern pattern = Pattern.compile("([0-9.]+)\\s*([a-z%]*)");
+        Matcher matcher = pattern.matcher(value);
+        if (matcher.matches()) {
+            double numericValue = Double.parseDouble(matcher.group(1));
+            String unit = matcher.group(2);
+            switch (unit) {
+                case "pt":
+                    return String.valueOf(Math.round(numericValue * 4.0 / 3.0));
+                case "in":
+                    return String.valueOf(Math.round(numericValue * 96.0));
+                case "cm":
+                    return String.valueOf(Math.round(numericValue * 96.0 / 2.54));
+                case "mm":
+                    return String.valueOf(Math.round(numericValue * 96.0 / 25.4));
+                case "":
+                    return String.valueOf(Math.round(numericValue));
+                default:
+                    return String.valueOf(Math.round(numericValue));
+            }
+        }
+        return null;
+    }
+
+    // ---------- extractDimensionFromStyle ----------
+
+    private String extractDimensionFromStyle(String style, String dimension) {
+        if (StringUtils.isBlank(style) || StringUtils.isBlank(dimension)) {
+            return null;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*([^;]+)(?:;|$)");
+        Matcher matcher = pattern.matcher(style);
+        if (matcher.find()) {
+            String value = matcher.group(1).trim();
+            if (isValidDimensionValue(value)) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    // ---------- isValidDimensionValue ----------
+
+    private boolean isValidDimensionValue(String value) {
+        if (StringUtils.isBlank(value)) {
+            return false;
+        }
+        Pattern pattern = Pattern.compile("^[0-9]+(\\.[0-9]+)?\\s*(px|pt|in|cm|mm|%|em|rem|ex|ch|vw|vh|vmin|vmax)?$");
+        return pattern.matcher(value).matches();
+    }
+
+    // ---------- removeDimensionFromStyle ----------
+
+    private String removeDimensionFromStyle(String style, String dimension) {
+        if (StringUtils.isBlank(style) || StringUtils.isBlank(dimension)) {
+            return style;
+        }
+        Pattern pattern = Pattern.compile(dimension + "\\s*:\\s*[^;]+;?");
+        Matcher matcher = pattern.matcher(style);
+        String result = matcher.replaceAll("");
+        result = result.replaceAll(";;", ";").replaceAll("^;|;$", "");
+        return result;
+    }
+
+    // ---------- dealLi ----------
+
+    private void dealLi(Document doc) {
+        try {
+            Elements elements = doc.getElementsByTag("li");
+            for (Element li : elements) {
+                String style = li.attr(HtmlAttr.STYLE.getValue()) + "line-height: 2;";
+                li.tagName("p").attr(HtmlAttr.STYLE.getValue(), style);
+            }
+        } catch (Exception e) {
+            log.error("处理列表异常", e);
+        }
+    }
+
+    // ---------- dealBookTitle ----------
+
+    private void dealBookTitle(Document doc) {
+        try {
+            Elements elements = doc.select(":matchesOwn(\u300a|\u300b)");
+            for (int i = 0; i < elements.size(); ++i) {
+                Element start = (Element) elements.get(i);
+                if (!start.text().contains("\u300a") || i + 1 >= elements.size()) continue;
+                Element end = (Element) elements.get(i + 1);
+                if (!end.text().contains("\u300b")) continue;
+                if (Objects.nonNull(start.parent()) && start.parent().equals(end.parent())) {
+                    List<Node> siblings = start.parent().childNodes();
+                    int startIndex = siblings.indexOf(start);
+                    int endIndex = siblings.indexOf(end);
+                    if (startIndex == -1 || endIndex == -1 || startIndex > endIndex) continue;
+                    StringBuilder content = new StringBuilder();
+                    ArrayList<Node> deleteList = new ArrayList<>();
+                    for (int j = startIndex; j <= endIndex; ++j) {
+                        Node node = siblings.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode) node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element) node).text());
+                        }
+                        if (j <= startIndex) continue;
+                        deleteList.add(node);
+                    }
+                    start.text(content.toString());
+                    deleteList.forEach(Node::remove);
+                    continue;
+                }
+                if (!Objects.nonNull(start.parent()) || !Objects.nonNull(start.parent().parent())
+                        || !start.parent().parent().equals(end.parent())
+                        || start.parent().siblingIndex() >= end.siblingIndex()) continue;
+                StringBuilder content = new StringBuilder();
+                ArrayList<Node> deleteList = new ArrayList<>();
+                Element startParent = start.parent();
+                List<Node> parentChild = startParent.childNodes();
+                int startIndex = parentChild.indexOf(start);
+                if (startIndex != -1) {
+                    for (int j = startIndex + 1; j < parentChild.size(); ++j) {
+                        Node node = parentChild.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode) node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element) node).text());
+                        }
+                        deleteList.add(node);
+                    }
+                }
+                Element grandParent = start.parent().parent();
+                List<Node> grandSiblings = grandParent.childNodes();
+                int parentIdx = grandSiblings.indexOf(startParent);
+                int endIdx = grandSiblings.indexOf(end);
+                if (parentIdx != -1 && endIdx != -1 && parentIdx < endIdx) {
+                    for (int j = parentIdx + 1; j <= endIdx; ++j) {
+                        Node node = grandSiblings.get(j);
+                        if (node instanceof TextNode) {
+                            content.append(((TextNode) node).getWholeText());
+                        } else if (node instanceof Element) {
+                            content.append(((Element) node).text());
+                        }
+                        deleteList.add(node);
+                    }
+                }
+                start.text(content.toString());
+                deleteList.forEach(Node::remove);
+            }
+        } catch (Exception e) {
+            log.error("处理书名号异常", e);
+        }
+    }
+
+    // ---------- dealUnderline ----------
+
+    private void dealUnderline(Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='text-decoration: underline']");
+            for (Element u : elements) {
+                String style = u.attr("style");
+                if (!style.matches(".*text-decoration:\\s*underline\\s*(;|$).*")) continue;
+                u.tagName("u");
+                processSpanContent((Node) u);
+            }
+        } catch (Exception e) {
+            log.error("处理下划线异常", e);
+        }
+    }
+
+    // ---------- dealCustomTextDecoration ----------
+
+    private void dealCustomTextDecoration(Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='background-image: repeating-linear-gradient']");
+            for (Element span : elements) {
+                LinkedHashMap<String, TagStyleBO> styleMap = new LinkedHashMap<>();
+                List<String> styles = Arrays.asList(span.attr("style").split(";"));
+                styles.forEach(style -> {
+                    if (StringUtils.isBlank(style)) {
+                        return;
+                    }
+                    String[] split = style.split(":");
+                    if (split.length < 2) {
+                        return;
+                    }
+                    TagStyleBO tagStyleBO = new TagStyleBO()
+                            .setTagName(span.tagName())
+                            .setAttr(split[0].trim())
+                            .setValue(split[1].trim());
+                    styleMap.put(tagStyleBO.getAttr(), tagStyleBO);
+                });
+                if (!styleMap.containsKey("background-size")) {
+                    continue;
+                }
+                span.addClass(styleMap.get("background-size").getValue().contains("11px")
+                        ? "custom-text-decoration-double-dot-dashed"
+                        : "custom-text-decoration-dot-dashed");
+                ArrayList<String> newStyleList = new ArrayList<>();
+                styleMap.forEach((key, value) -> {
+                    if (!DOT_DASHED_STYLE_SET.contains(key)) {
+                        newStyleList.add(value.getAttr() + ": " + value.getValue() + ";");
+                    }
+                });
+                if (newStyleList.isEmpty()) {
+                    span.removeAttr(HtmlAttr.STYLE.getValue());
+                    continue;
+                }
+                span.attr(HtmlAttr.STYLE.getValue(), String.join(" ", newStyleList));
+            }
+        } catch (Exception e) {
+            log.error("处理自定义文本装饰（点划线）异常", e);
+        }
+    }
+
+    // ---------- dealUnderlineAndLineThrough ----------
+
+    private void dealUnderlineAndLineThrough(Document doc) {
+        try {
+            Elements elements = doc.select("span[style*='wp-line-through: true']");
+            for (int i = elements.size() - 1; i >= 0; --i) {
+                Element span = (Element) elements.get(i);
+                Element wrapper = new Element("span");
+                wrapper.attr("style", "text-decoration: line-through");
+                span.replaceWith((Node) wrapper);
+                wrapper.appendChild((Node) span);
+            }
+        } catch (Exception e) {
+            log.error("处理下划线和删除并存异常", e);
+        }
+    }
+
+    // ---------- dealPlaceholder ----------
+
+    private String dealPlaceholder(ParseBO bo, Document doc) {
+        String result = doc.html();
+        // Fix Jsoup XML prolog serialization
+        result = result.replace("<!--?xml", "<?xml").replace("?-->", "?>");
+        if (MapUtils.isNotEmpty(bo.getImageMap())) {
+            for (Map.Entry<String, ImageBO> entry : bo.getImageMap().entrySet()) {
+                String imgUrl = entry.getValue().getPictureUrl();
+                Element element = new Element("img");
+                element.attr(HtmlAttr.SRC.getValue(), imgUrl);
+                element.attr(HtmlAttr.WIDTH.getValue(), String.valueOf(entry.getValue().getWidth().intValue()));
+                element.attr(HtmlAttr.HEIGHT.getValue(), String.valueOf(entry.getValue().getHeight().intValue()));
+                addImgAttr(element);
+                result = result.replace(entry.getKey(), element.outerHtml());
+            }
+        }
+        if (MapUtils.isNotEmpty(bo.getOpenOfficeXmlMap())) {
+            for (Map.Entry<String, String> entry : bo.getOpenOfficeXmlMap().entrySet()) {
+                result = dealPlaceholder(bo, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(bo.getMathTypeMap())) {
+            for (Map.Entry<String, String> entry : bo.getMathTypeMap().entrySet()) {
+                result = dealPlaceholder(bo, entry, result, false);
+            }
+        }
+        if (MapUtils.isNotEmpty(bo.getEqLatexMap())) {
+            for (Map.Entry<String, String> entry : bo.getEqLatexMap().entrySet()) {
+                result = dealPlaceholder(bo, entry, result, true);
+            }
+        }
+        result = result.replaceAll("WP_nbsp;", "&nbsp;");
+        result = result.replaceAll("font-style: italic;", "font-style: italic; z-index: 1;");
+        result = result.replaceAll("border-color: #auto;", "border-color: transparent;");
+        result = result.replaceAll("WP_TEXTBOX_WPBR", "<br/>");
+        result = result.replaceAll("WP_TEXTBOX_WP", "");
+        // MathML formulas should be inline by default
+        result = result.replace("display=\"block\"", "display=\"inline\"");
+        result = result.replace("<?xml version=\"1.0\"?>", "");
+        result = result.replaceAll(">\\\\s+(?=<(?!/span))", ">");
+        result = result.replaceAll(
+                "(background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;)\\s*background-color:\\s*#[0-9A-Fa-f]{3,6}[^;]*;",
+                "$1");
+        for (String sym : SYMBOL) {
+            Element imgElement = new Element("img");
+            imgElement.attr(HtmlAttr.SRC.getValue(),
+                    "https://resource.xinjiaoyu.com/prod/office/unicode-symbol/"
+                            + sym.substring(2).toUpperCase() + ".svg");
+            imgElement.attr(HtmlAttr.WIDTH.getValue(), "14");
+            imgElement.attr(HtmlAttr.HEIGHT.getValue(), "14");
+            result = result.replace("@@@" + sym.substring(2).toUpperCase() + "@@@", imgElement.outerHtml());
+            result = result.replace("\ue225\ue226", "\\(\\rightleftharpoons\\)");
+        }
+        writeHtml(result);
+        return result;
+    }
+
+    // ---------- dealPlaceholder (overloaded, per-entry) ----------
+
+    private String dealPlaceholder(ParseBO bo, Map.Entry<String, String> entry, String html, Boolean isEq) {
+        String value = entry.getValue();
+        if (isEq || !Boolean.TRUE.equals(bo.getNewParseVersion())) {
+            value = latexReplace(bo.getLatexReplaceList(), value);
+        }
+        // EQ 域产出的 LaTeX 同样需要 \( \) 包裹，否则前端/MathJax 不渲染
+        if (!value.startsWith("<img") && !value.startsWith("<?xml") && !value.startsWith("<math")) {
+            value = "\\(" + value + "\\)";
+        }
+        html = html.replace(entry.getKey(), value);
+        log.info("latexReplace,替换前{},替换后{}", entry.getValue(), value);
+        return html;
+    }
+
+    // ---------- latexReplace ----------
+
+    private String latexReplace(List<JSONObject> latexReplaceList, String latex) {
+        try {
+            if (StringUtils.isBlank(latex)) {
+                return latex;
+            }
+            if (CollectionUtils.isEmpty(latexReplaceList)) {
+                return latex;
+            }
+            if (latex.startsWith("<img")) {
+                return latex;
+            }
+            for (JSONObject latexReplace : latexReplaceList) {
+                String key = latexReplace.getString("key");
+                String value = latexReplace.getString("value");
+                if (StringUtils.isBlank(key) || StringUtils.isBlank(value)) continue;
+                latex = latex.replaceAll(key, value);
+            }
+            return wrapTextColorWithBraces(latex);
+        } catch (Exception e) {
+            log.error("latex公式规范正则替换处理异常:{}", latex, e);
+            return latex;
+        }
+    }
+
+    // ---------- wrapTextColorWithBraces ----------
+
+    public static String wrapTextColorWithBraces(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        Pattern pattern = Pattern.compile("\\\\textcolor\\[rgb\\]\\{[^}]*\\}\\{");
+        ArrayList<int[]> matches = new ArrayList<>();
+        Matcher matcher = pattern.matcher(input);
+        int start = 0;
+        while (matcher.find(start)) {
+            int contentStart = matcher.end() - 1;
+            int depth = 0;
+            for (int pos = contentStart; pos < input.length(); ++pos) {
+                char c = input.charAt(pos);
+                if (c == '{') {
+                    ++depth;
+                    continue;
+                }
+                if (c != '}' || --depth != 0) continue;
+                matches.add(new int[]{matcher.start(), pos});
+                break;
+            }
+            start = matcher.start() + 1;
+        }
+        matches.sort(Comparator.comparingInt(a -> -a[0]));
+        StringBuilder sb = new StringBuilder(input);
+        for (int[] match : matches) {
+            sb.insert(match[1] + 1, '}');
+            sb.insert(match[0], '{');
+        }
+        return sb.toString();
+    }
+
+    // ---------- getMatchParent ----------
+
+    public static Element getMatchParent(Element element, String cssQuery) {
+        if (element == null) {
+            return null;
+        }
+        if (element.is(cssQuery)) {
+            return element;
+        }
+        return getMatchParent(element.parent(), cssQuery);
+    }
+
+    // ---------- addImgAttr ----------
+
+    void addImgAttr(Element img) {
+        img.attr("data-default-src", img.attr(HtmlAttr.SRC.getValue()));
+        img.attr(HtmlAttr.CLASS.getValue(), "img-t");
+        img.attr("data-mce-resize", "false");
+    }
+
+    // ---------- writeHtml (local debug, simplified from original) ----------
+
+    private void writeHtml(String html) {
+        // Original checked SpringContextHolder.getActiveProfile() == "local"
+        // Simplified: just skip in production
+        try {
+            String savePath = config.getTmpPath() + "/upload/" + UUID.randomUUID() + ".html";
+            File file = new File(savePath);
+            file.getParentFile().mkdirs();
+            Files.writeString(file.toPath(), html);
+            log.info("本地html文件路径：{}", file.getPath());
+        } catch (Exception e) {
+            log.debug("writeHtml skipped: {}", e.getMessage());
+        }
+    }
+
+    // ===================== image upload =====================
+
+
+    private void collectFiles(File dir, List<File> result) {
+        File[] files = dir.listFiles();
+        if (files == null) return;
+        for (File f : files) {
+            if (f.isDirectory()) collectFiles(f, result);
+            else result.add(f);
+        }
+    }
+
+    private void uploadImgToOss(ParseBO bo, WordprocessingMLPackage wordML) {
+        try {
+            // Extract images from package parts (docx4j 8.x doesn't extract to disk)
+            for (org.docx4j.openpackaging.parts.Part part : wordML.getParts().getParts().values()) {
+                String partName = part.getPartName().getName();
+                if (!(part instanceof org.docx4j.openpackaging.parts.WordprocessingML.BinaryPart)) continue;
+                if (!partName.contains("media")) continue;
+
+                // Upload the binary part
+                org.docx4j.openpackaging.parts.WordprocessingML.BinaryPart bp =
+                        (org.docx4j.openpackaging.parts.WordprocessingML.BinaryPart) part;
+                String fileName = partName.substring(partName.lastIndexOf('/') + 1);
+                String url = ossService.uploadStream(
+                        new ByteArrayInputStream(bp.getBytes()), bp.getBytes().length,
+                        bo.getOssFolder(), fileName);
+                if (url != null) {
+                    // Map both relative paths to the URL
+                    bo.getImgMap().put(partName, url);
+                    bo.getImgMap().put("/" + partName, url);
+                }
+            }
+            log.info("Uploaded {} images to OSS", bo.getImgMap().size());
+        } catch (Exception e) {
+            log.warn("Image upload from package failed: {}", e.getMessage());
+        }
+    }
+
+    // ── legacy disk-based upload (kept for reference) ──
+
+    private void uploadImgToOss_legacy(ParseBO bo) {
+        // Try disk images first (legacy path)
+        File folder = new File(bo.getImagesDir());
+        if (!folder.exists() || !folder.isDirectory()) {
+            // Fallback: no disk images (docx4j 8.x doesn't extract them)
+            log.info("No disk images found, skipping OSS upload");
+            return;
+        }
+        // Recursively find all image files (docx4j creates word/media/ subdirs)
+        List<File> allFiles = new ArrayList<>();
+        collectFiles(folder, allFiles);
+        if (allFiles.isEmpty()) return;
+
+        Map<String, String> tifNameMap = new HashMap<>();
+        for (File f : allFiles) {
+            String ext = FilenameUtils.getExtension(f.getName()).toLowerCase();
+            if ("tif".equals(ext) || "tiff".equals(ext)) {
+                tifToPng(f);
+                tifNameMap.put(FilenameUtils.getBaseName(f.getName()) + ".png", f.getName());
+            }
+        }
+
+        for (File f : allFiles) {
+            String ext = FilenameUtils.getExtension(f.getName()).toLowerCase();
+            if ("tif".equals(ext) || "tiff".equals(ext)) continue;
+            String url;
+            if ("wmf".equals(ext) || "emf".equals(ext)) {
+                try {
+                    url = mf2svg(f, bo.getOssFolder());
+                } catch (Exception e) {
+                    log.warn("wmf->svg failed: {}", f.getName());
+                    url = ossService.uploadFile(f, bo.getOssFolder(), f.getName());
+                }
+            } else {
+                url = ossService.uploadFile(f, bo.getOssFolder(), f.getName());
+            }
+            String key = "images/" + tifNameMap.getOrDefault(f.getName(), f.getName());
+            bo.getImgMap().put(key, url);
+        }
+    }
+
+    private void tifToPng(File tif) {
+        try {
+            var readers = javax.imageio.ImageIO.getImageReaders(
+                    javax.imageio.ImageIO.createImageInputStream(new FileInputStream(tif)));
+            if (!readers.hasNext()) return;
+            var reader = readers.next();
+            reader.setInput(javax.imageio.ImageIO.createImageInputStream(new FileInputStream(tif)));
+            var img = reader.read(0);
+            String pngPath = tif.getParent() + "/" + FilenameUtils.getBaseName(tif.getName()) + ".png";
+            javax.imageio.ImageIO.write(img, "png", new File(pngPath));
+        } catch (Exception e) {
+            log.warn("tif->png failed: {}", tif.getName());
+        }
+    }
+
+    private String mf2svg(File mfFile, String folder) throws Exception {
+        // For now, upload as-is; in production use a WMF->SVG converter
+        log.info("WMF/EMF detected: {}, uploading as-is", mfFile.getName());
+        return ossService.uploadFile(mfFile, folder, mfFile.getName());
+    }
+
+    private void dealImg(ParseBO bo) {
+        // Iterate imageMap, upload in parallel
+        if (MapUtils.isEmpty(bo.getImageMap())) return;
+        ExecutorService executor = Executors.newFixedThreadPool(4);
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (var entry : bo.getImageMap().entrySet()) {
+            futures.add(CompletableFuture.runAsync(() -> {
+                try {
+                    String fullPath = bo.getTempDir() + "/temp" + entry.getValue().getPictureUrl();
+                    File f = new File(fullPath);
+                    if (!f.exists()) return;
+                    String url = ossService.uploadFile(f, bo.getOssFolder(), f.getName());
+                    entry.getValue().setPictureUrl(url);
+                } catch (Exception e) {
+                    log.warn("image upload failed: {}", entry.getKey());
+                }
+            }, executor));
+        }
+        try {
+            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(5, TimeUnit.MINUTES);
+        } catch (Exception e) {
+            log.error("image upload timeout", e);
+        }
+        executor.shutdown();
+    }
+
+    // ===================== zip utils =====================
+
+    private void unzipDocx(String docxPath, String outputDir) throws IOException {
+        new File(outputDir).mkdirs();
+        try (ZipFile zf = new ZipFile(docxPath)) {
+            Enumeration<? extends ZipEntry> entries = zf.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                File f = new File(outputDir, entry.getName());
+                if (entry.isDirectory()) { f.mkdirs(); continue; }
+                f.getParentFile().mkdirs();
+                try (InputStream is = zf.getInputStream(entry);
+                     FileOutputStream fos = new FileOutputStream(f)) {
+                    is.transferTo(fos);
+                }
+            }
+        }
+    }
+
+    private void zipToDocx(String sourceDir, String outputDocx) throws IOException {
+        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(outputDocx))) {
+            File root = new File(sourceDir);
+            addFolderToZip(root, root, zos);
+        }
+    }
+
+    private void addFolderToZip(File root, File folder, ZipOutputStream zos) throws IOException {
+        for (File f : Objects.requireNonNull(folder.listFiles())) {
+            if (f.isDirectory()) { addFolderToZip(root, f, zos); continue; }
+            String name = root.toPath().relativize(f.toPath()).toString().replace(File.separator, "/");
+            zos.putNextEntry(new ZipEntry(name));
+            try (FileInputStream fis = new FileInputStream(f)) { fis.transferTo(zos); }
+            zos.closeEntry();
+        }
+    }
+
+    private void deleteDir(File dir) {
+        if (dir.isDirectory()) for (File f : Objects.requireNonNull(dir.listFiles())) deleteDir(f);
+        dir.delete();
+    }
+}
diff --git a/java-svc/src/main/java/com/wordparse/oss/OssService.java b/java-svc/src/main/java/com/wordparse/oss/OssService.java
new file mode 100644
index 0000000..92ea1d3
--- /dev/null
+++ b/java-svc/src/main/java/com/wordparse/oss/OssService.java
@@ -0,0 +1,104 @@
+package com.wordparse.oss;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import software.amazon.awssdk.core.sync.RequestBody;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+
+import jakarta.annotation.PostConstruct;
+import java.io.File;
+import java.io.InputStream;
+import java.net.URI;
+
+@Service
+public class OssService {
+
+    private static final Logger log = LoggerFactory.getLogger(OssService.class);
+
+    @Value("${wordparse.oss.endpoint:https://fs.code-lab.cn}")
+    private String endpoint;
+
+    @Value("${wordparse.oss.access-key:}")
+    private String accessKey;
+
+    @Value("${wordparse.oss.secret-key:}")
+    private String secretKey;
+
+    @Value("${wordparse.oss.bucket:word-parse}")
+    private String bucket;
+
+    @Value("${wordparse.oss.prefix:office/file/parse/}")
+    private String prefix;
+
+    private S3Client client;
+    private boolean enabled = true;
+
+    @PostConstruct
+    public void init() {
+        try {
+            this.client = S3Client.builder()
+                    .endpointOverride(URI.create(endpoint))
+                    .credentialsProvider(StaticCredentialsProvider.create(
+                            AwsBasicCredentials.create(accessKey, secretKey)))
+                    .region(Region.US_EAST_1)
+                    .forcePathStyle(true)
+                    .build();
+            // Quick connectivity test
+            client.headBucket(b -> b.bucket(bucket));
+            log.info("OSS client initialized: {} (bucket: {})", endpoint, bucket);
+        } catch (Exception e) {
+            enabled = false;
+            log.warn("OSS unavailable ({}: {}) — images will not be uploaded", e.getClass().getSimpleName(), e.getMessage());
+        }
+    }
+
+    public String uploadFile(File file, String folder, String fileName) {
+        if (!enabled) return null;
+        try {
+            String key = prefix + folder + "/" + fileName;
+            String contentType = guessContentType(fileName);
+            client.putObject(
+                    PutObjectRequest.builder().bucket(bucket).key(key).contentType(contentType).build(),
+                    RequestBody.fromFile(file));
+            return endpoint + "/" + bucket + "/" + key;
+        } catch (Exception e) {
+            log.warn("Upload failed: {}", fileName, e);
+            return null;
+        }
+    }
+
+    public String uploadStream(InputStream is, long size, String folder, String fileName) {
+        if (!enabled) return null;
+        try {
+            String key = prefix + folder + "/" + fileName;
+            String contentType = guessContentType(fileName);
+            client.putObject(
+                    PutObjectRequest.builder().bucket(bucket).key(key).contentType(contentType).build(),
+                    RequestBody.fromInputStream(is, size));
+            return endpoint + "/" + bucket + "/" + key;
+        } catch (Exception e) {
+            log.warn("Upload failed: {}", fileName, e);
+            return null;
+        }
+    }
+
+    private String guessContentType(String name) {
+        String ext = name.substring(name.lastIndexOf('.') + 1).toLowerCase();
+        return switch (ext) {
+            case "png" -> "image/png";
+            case "jpg", "jpeg" -> "image/jpeg";
+            case "gif" -> "image/gif";
+            case "svg" -> "image/svg+xml";
+            case "wmf" -> "image/wmf";
+            case "emf" -> "image/emf";
+            case "webp" -> "image/webp";
+            default -> "application/octet-stream";
+        };
+    }
+}
diff --git a/java-svc/src/main/resources/OMML2MML.xsl b/java-svc/src/main/resources/OMML2MML.xsl
new file mode 100644
index 0000000..9db269b
--- /dev/null
+++ b/java-svc/src/main/resources/OMML2MML.xsl
@@ -0,0 +1,851 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
+    xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+    xmlns:mml="http://www.w3.org/1998/Math/MathML"
+    xmlns="http://www.w3.org/1998/Math/MathML"
+    exclude-result-prefixes="m w">
+
+    <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
+
+    <!-- Root template -->
+    <xsl:template match="/">
+        <xsl:apply-templates select="//m:oMath"/>
+    </xsl:template>
+
+    <!-- Main math element -->
+    <xsl:template match="m:oMath">
+        <math>
+            <xsl:apply-templates select="*"/>
+        </math>
+    </xsl:template>
+
+    <!-- Text run -->
+    <xsl:template match="m:r">
+        <xsl:apply-templates select="m:t"/>
+    </xsl:template>
+
+    <!-- Text content -->
+    <xsl:template match="m:t">
+        <!-- Get style from parent <m:r><m:rPr><m:sty> -->
+        <xsl:variable name="sty" select="../m:rPr/m:sty/@m:val"/>
+
+        <!-- Get Word run properties (w:rPr) - check for italic (w:i) -->
+        <!-- w:rPr is a sibling of m:t (both are children of m:r) -->
+        <!-- CRITICAL: w:i with @w:val="0" or "false" means NOT italic! -->
+        <!-- Only treat as italic if w:i exists AND val is not "0" or "false" -->
+        <xsl:variable name="has_word_italic" select="boolean(../w:rPr/w:i[not(@w:val = '0') and not(@w:val = 'false')])"/>
+
+        <!-- Get math "normal" style (m:nor) - text mode button -->
+        <xsl:variable name="has_math_normal" select="boolean(../m:rPr/m:nor)"/>
+
+        <xsl:choose>
+            <xsl:when test="normalize-space(.) = ''">
+                <!-- Skip empty text -->
+            </xsl:when>
+            <xsl:when test="number(.) = number(.)">
+                <mn><xsl:value-of select="normalize-space(.)"/></mn>
+            </xsl:when>
+            <!-- Fence delimiters: parentheses, brackets, pipes (with fence="true") -->
+            <xsl:when test=". = '(' or . = ')' or . = '[' or . = ']' or . = '|'">
+                <mo fence="true"><xsl:value-of select="normalize-space(.)"/></mo>
+            </xsl:when>
+            <!-- Plain operators (no fence attribute) -->
+            <!-- NOTE: { and } are converted to markers to distinguish source braces from generated LaTeX braces -->
+            <xsl:when test=". = '{' or . = '}' or . = '+' or . = '-' or . = '=' or . = '&lt;' or . = '&gt;' or . = '±' or . = '≠' or . = '≤' or . = '≥' or . = '×' or . = '÷' or . = '∞'">
+                <mo>
+                    <xsl:choose>
+                        <xsl:when test=". = '{'">__LBRACE__</xsl:when>
+                        <xsl:when test=". = '}'">__RBRACE__</xsl:when>
+                        <xsl:otherwise><xsl:value-of select="normalize-space(.)"/></xsl:otherwise>
+                    </xsl:choose>
+                </mo>
+            </xsl:when>
+            <!-- Mixed operators/delimiters (like ")+" or ")=" or "(A" or "={" or ",}") -->
+            <!-- Check if string contains multiple operator/delimiter characters -->
+            <xsl:when test="string-length(normalize-space(.)) &gt; 1 and (contains(., '(') or contains(., ')') or contains(., '[') or contains(., ']') or contains(., '{') or contains(., '}') or contains(., '+') or contains(., '-') or contains(., '=') or contains(., '&lt;') or contains(., '&gt;'))">
+                <!-- Split into individual characters and classify each one -->
+                <!-- Pass style info so letters get proper mathvariant (e.g., mathvariant="normal" for m:nor text mode) -->
+                <xsl:call-template name="split-operators">
+                    <xsl:with-param name="text" select="normalize-space(.)"/>
+                    <xsl:with-param name="math_variant">
+                        <xsl:choose>
+                            <xsl:when test="$has_word_italic">italic</xsl:when>
+                            <xsl:when test="$sty = 'b' or $sty = 'bi'">bold</xsl:when>
+                            <xsl:when test="$sty = 'p'">normal</xsl:when>
+                            <xsl:when test="$has_math_normal">normal</xsl:when>
+                            <xsl:otherwise></xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:when test="contains(., '|')">
+                <!-- Special handling for text containing | (like "x|x", "A|B", or "||") -->
+                <!-- Split by | and create separate elements with fence="true" for absolute values -->
+                <xsl:variable name="before" select="substring-before(., '|')"/>
+                <xsl:variable name="after" select="substring-after(., '|')"/>
+                <!-- Process before part (plain text) -->
+                <xsl:if test="$before != ''">
+                    <xsl:choose>
+                        <!-- If before part contains operators or is multi-char, use split-operators -->
+                        <xsl:when test="string-length($before) &gt; 1">
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$before"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- Single character - output as mi -->
+                        <xsl:otherwise>
+                            <mi><xsl:value-of select="$before"/></mi>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+                <!-- Output the | as fence for potential absolute value -->
+                <mo fence="true">|</mo>
+                <!-- Process after part recursively if it contains more | or operators -->
+                <xsl:if test="$after != ''">
+                    <xsl:choose>
+                        <!-- If after part is just |, output as fence -->
+                        <xsl:when test="$after = '|'">
+                            <mo fence="true">|</mo>
+                        </xsl:when>
+                        <!-- If after part contains more |, recursively process this m:t content -->
+                        <xsl:when test="contains($after, '|')">
+                            <xsl:call-template name="process-text-with-pipe">
+                                <xsl:with-param name="text" select="$after"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- If after part contains operators, use split-operators -->
+                        <xsl:when test="string-length($after) &gt; 1 and (contains($after, '+') or contains($after, '-') or contains($after, '='))">
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$after"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- Single character or simple text - output as mi -->
+                        <xsl:otherwise>
+                            <mi><xsl:value-of select="$after"/></mi>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+            </xsl:when>
+            <xsl:when test="string-length(normalize-space(.)) = 1 and not(contains('0123456789', .))">
+                <mi>
+                    <!-- Apply mathvariant based on style -->
+                    <!-- Note: m:sty='i' (italic) is NOT handled here as italic is the default for variables -->
+                    <!-- Priority: italic (w:i explicit) > bold > plain (m:sty='p') > normal (m:nor) -->
+                    <xsl:choose>
+                        <xsl:when test="$has_word_italic">
+                            <xsl:attribute name="mathvariant">italic</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'b' or $sty = 'bi'">
+                            <xsl:attribute name="mathvariant">bold</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'p'">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$has_math_normal">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                    </xsl:choose>
+                    <xsl:value-of select="normalize-space(.)"/>
+                </mi>
+            </xsl:when>
+            <xsl:otherwise>
+                <mi>
+                    <!-- Apply mathvariant for multi-character identifiers too -->
+                    <!-- Note: m:sty='i' (italic) is NOT handled here as italic is the default for variables -->
+                    <!-- Priority: italic (w:i explicit) > bold > plain (m:sty='p') > normal (m:nor) -->
+                    <xsl:choose>
+                        <xsl:when test="$has_word_italic">
+                            <xsl:attribute name="mathvariant">italic</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'b' or $sty = 'bi'">
+                            <xsl:attribute name="mathvariant">bold</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'p'">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$has_math_normal">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                    </xsl:choose>
+                    <xsl:value-of select="normalize-space(.)"/>
+                </mi>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Superscript -->
+    <xsl:template match="m:sSup">
+        <msup>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sup"/>
+        </msup>
+    </xsl:template>
+
+    <!-- Subscript -->
+    <xsl:template match="m:sSub">
+        <msub>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sub"/>
+        </msub>
+    </xsl:template>
+
+    <!-- Sub-superscript -->
+    <xsl:template match="m:sSubSup">
+        <msubsup>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sub"/>
+            <xsl:apply-templates select="m:sup"/>
+        </msubsup>
+    </xsl:template>
+
+    <!-- Pre-script (left-side subscript/superscript) -->
+    <!-- Used for nuclear notation like _{2}^{3}He -->
+    <xsl:template match="m:sPre">
+        <mmultiscripts>
+            <xsl:apply-templates select="m:e"/>
+            <mprescripts/>
+            <xsl:apply-templates select="m:sub"/>
+            <xsl:apply-templates select="m:sup"/>
+        </mmultiscripts>
+    </xsl:template>
+
+    <!-- Fraction -->
+    <!-- m:type values: bar (default), noBar, lin (linear), skw (skewed) -->
+    <xsl:template match="m:f">
+        <xsl:variable name="type" select="m:fPr/m:type/@m:val"/>
+        <mfrac>
+            <!-- Add linethickness="0" for noBar fractions (stacked without bar) -->
+            <xsl:if test="$type = 'noBar'">
+                <xsl:attribute name="linethickness">0</xsl:attribute>
+            </xsl:if>
+            <!-- Add bevelled="true" for linear fractions -->
+            <xsl:if test="$type = 'lin'">
+                <xsl:attribute name="bevelled">true</xsl:attribute>
+            </xsl:if>
+            <xsl:apply-templates select="m:num"/>
+            <xsl:apply-templates select="m:den"/>
+        </mfrac>
+    </xsl:template>
+
+    <!-- Radical -->
+    <xsl:template match="m:rad">
+        <xsl:choose>
+            <xsl:when test="m:deg">
+                <mroot>
+                    <xsl:apply-templates select="m:e"/>
+                    <xsl:apply-templates select="m:deg"/>
+                </mroot>
+            </xsl:when>
+            <xsl:otherwise>
+                <msqrt>
+                    <xsl:apply-templates select="m:e"/>
+                </msqrt>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Parentheses/delimiters -->
+    <xsl:template match="m:d">
+        <mrow>
+            <!-- Opening delimiter: skip if begChr has empty or whitespace-only val -->
+            <xsl:choose>
+                <xsl:when test="not(m:dPr/m:begChr)">
+                    <mo fence="true">(</mo>
+                </xsl:when>
+                <xsl:when test="normalize-space(m:dPr/m:begChr/@m:val) != ''">
+                    <mo fence="true">
+                        <xsl:value-of select="m:dPr/m:begChr/@m:val"/>
+                    </mo>
+                </xsl:when>
+                <!-- begChr with empty/whitespace val → no opening delimiter -->
+            </xsl:choose>
+            <!-- Handle multiple m:e elements with separators -->
+            <xsl:for-each select="m:e">
+                <xsl:apply-templates select="."/>
+                <!-- Insert separator | between elements (except after the last one) -->
+                <xsl:if test="position() != last()">
+                    <mo>|</mo>
+                </xsl:if>
+            </xsl:for-each>
+            <!-- Closing delimiter: skip if endChr has empty or whitespace-only val -->
+            <xsl:choose>
+                <xsl:when test="not(m:dPr/m:endChr)">
+                    <mo fence="true">)</mo>
+                </xsl:when>
+                <xsl:when test="normalize-space(m:dPr/m:endChr/@m:val) != ''">
+                    <mo fence="true">
+                        <xsl:value-of select="m:dPr/m:endChr/@m:val"/>
+                    </mo>
+                </xsl:when>
+                <!-- endChr with empty/whitespace val → no closing delimiter -->
+            </xsl:choose>
+        </mrow>
+    </xsl:template>
+
+    <!-- Function -->
+    <xsl:template match="m:func">
+        <mrow>
+            <xsl:apply-templates select="m:fName"/>
+            <xsl:apply-templates select="m:e"/>
+        </mrow>
+    </xsl:template>
+
+    <!-- Matrix -->
+    <xsl:template match="m:m">
+        <mtable>
+            <xsl:apply-templates select="m:mr"/>
+        </mtable>
+    </xsl:template>
+
+    <!-- Matrix row -->
+    <xsl:template match="m:mr">
+        <mtr>
+            <xsl:apply-templates select="m:e"/>
+        </mtr>
+    </xsl:template>
+
+    <!-- Equation array (for piecewise functions) -->
+    <xsl:template match="m:eqArr">
+        <mtable>
+            <!-- Each <m:e> child represents one row in the piecewise function -->
+            <xsl:for-each select="m:e">
+                <mtr>
+                    <mtd>
+                        <xsl:apply-templates select="node()"/>
+                    </mtd>
+                </mtr>
+            </xsl:for-each>
+        </mtable>
+    </xsl:template>
+
+    <!-- Bar (overbar/underbar) -->
+    <!-- OMML spec: no pos attribute = underline (default), pos="top" = overline, pos="bot" = underline -->
+    <xsl:template match="m:bar">
+        <xsl:choose>
+            <xsl:when test="m:barPr/m:pos/@m:val = 'top'">
+                <mover>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>‾</mo>
+                </mover>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- Default: no pos attribute or pos="bot" both mean underline -->
+                <munder>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>‾</mo>
+                </munder>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Limits -->
+    <!-- limLow: Lower limit position (content BELOW the base, like underscript) -->
+    <xsl:template match="m:limLow">
+        <munder>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim"/>
+        </munder>
+    </xsl:template>
+
+    <!-- limUpp: Upper limit position (content ABOVE the base, like overscript) -->
+    <xsl:template match="m:limUpp">
+        <mover>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="m:limUppLow">
+        <munderover>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim[1]"/>
+            <xsl:apply-templates select="m:lim[2]"/>
+        </munderover>
+    </xsl:template>
+
+    <!-- N-ary operators (integrals, sums, products) -->
+    <xsl:template match="m:nary">
+        <xsl:variable name="chr" select="m:naryPr/m:chr/@m:val"/>
+        <xsl:variable name="limLoc" select="m:naryPr/m:limLoc/@m:val"/>
+        <xsl:variable name="subHide" select="m:naryPr/m:subHide/@m:val"/>
+        <xsl:variable name="supHide" select="m:naryPr/m:supHide/@m:val"/>
+
+        <xsl:choose>
+            <!-- Both limits hidden: just operator and integrand -->
+            <xsl:when test="$subHide = '1' and $supHide = '1'">
+                <mrow>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>∫</xsl:otherwise>
+                        </xsl:choose>
+                    </mo>
+                    <xsl:apply-templates select="m:e"/>
+                </mrow>
+            </xsl:when>
+
+            <!-- Limits as subscript/superscript (default for integrals) -->
+            <xsl:when test="not($limLoc) or $limLoc = 'subSup'">
+                <xsl:choose>
+                    <!-- Both sub and sup present -->
+                    <xsl:when test="m:sub and m:sup">
+                        <msubsup>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sub"/>
+                            <xsl:apply-templates select="m:sup"/>
+                        </msubsup>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- Only subscript -->
+                    <xsl:when test="m:sub">
+                        <msub>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sub"/>
+                        </msub>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- Only superscript -->
+                    <xsl:when test="m:sup">
+                        <msup>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sup"/>
+                        </msup>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- No limits -->
+                    <xsl:otherwise>
+                        <mrow>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:e"/>
+                        </mrow>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+
+            <!-- Limits as under/over (for sums, products) -->
+            <xsl:when test="$limLoc = 'undOvr'">
+                <mrow>
+                    <xsl:choose>
+                        <!-- Both under and over -->
+                        <xsl:when test="m:sub and m:sup and not($subHide = '1') and not($supHide = '1')">
+                            <munderover>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sub"/>
+                                <xsl:apply-templates select="m:sup"/>
+                            </munderover>
+                        </xsl:when>
+                        <!-- Only under -->
+                        <xsl:when test="m:sub and not($subHide = '1')">
+                            <munder>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sub"/>
+                            </munder>
+                        </xsl:when>
+                        <!-- Only over -->
+                        <xsl:when test="m:sup and not($supHide = '1')">
+                            <mover>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sup"/>
+                            </mover>
+                        </xsl:when>
+                        <!-- No visible limits -->
+                        <xsl:otherwise>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                    <xsl:apply-templates select="m:e"/>
+                </mrow>
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Accent (vector arrows, dots, etc.) -->
+    <xsl:template match="m:acc">
+        <xsl:variable name="chr" select="m:accPr/m:chr/@m:val"/>
+        <mover>
+            <!-- Add data attribute to distinguish default accents from explicit ones -->
+            <xsl:if test="not($chr)">
+                <xsl:attribute name="data-default-accent">true</xsl:attribute>
+            </xsl:if>
+            <xsl:apply-templates select="m:e"/>
+            <mo>
+                <xsl:choose>
+                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                    <xsl:otherwise>⃗</xsl:otherwise><!-- Default accent (should be hat in most cases) -->
+                </xsl:choose>
+            </mo>
+        </mover>
+    </xsl:template>
+
+    <!-- Group character (for over/under arrows with text) -->
+    <xsl:template match="m:groupChr">
+        <xsl:variable name="chr" select="m:groupChrPr/m:chr/@m:val"/>
+        <xsl:variable name="pos" select="m:groupChrPr/m:pos/@m:val"/>
+        <xsl:variable name="vertJc" select="m:groupChrPr/m:vertJc/@m:val"/>
+
+        <xsl:choose>
+            <!-- vertJc='bot': Character at bottom (base), content above → mover(char, content) -->
+            <!-- This is used for extensible arrows like \xrightarrow[]{text} or \overset{text}{arrow} -->
+            <xsl:when test="$vertJc = 'bot'">
+                <mover accent="false">
+                    <mo stretchy="true">
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>→</xsl:otherwise>
+                        </xsl:choose>
+                    </mo>
+                    <xsl:apply-templates select="m:e"/>
+                </mover>
+            </xsl:when>
+            <!-- pos='bot': Character position at bottom, content above → munder -->
+            <xsl:when test="$pos = 'bot'">
+                <munder>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>⏟</xsl:otherwise><!-- Default underbrace -->
+                        </xsl:choose>
+                    </mo>
+                </munder>
+            </xsl:when>
+            <!-- pos='top' (or default): Character above content → mover(content, char) -->
+            <xsl:otherwise>
+                <mover>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>⏞</xsl:otherwise><!-- Default overbrace -->
+                        </xsl:choose>
+                    </mo>
+                </mover>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Box (but detect if it contains groupChr for reaction arrows) -->
+    <xsl:template match="m:box">
+        <xsl:choose>
+            <!-- Skip boxes with opEmu="1" (operator emulation - should be transparent) -->
+            <!-- This means process all children in m:e transparently -->
+            <xsl:when test="m:boxPr/m:opEmu/@m:val='1'">
+                <xsl:apply-templates select="m:e/*"/>
+            </xsl:when>
+
+            <!-- If box contains ONLY a single direct groupChr, handle specially -->
+            <!-- This is for cases like reaction arrows: text above/below extensible arrow -->
+            <xsl:when test="count(m:e/*) = 1 and m:e/m:groupChr">
+                <xsl:variable name="groupChr" select="m:e/m:groupChr"/>
+                <xsl:variable name="arrow" select="$groupChr/m:groupChrPr/m:chr/@m:val"/>
+                <xsl:variable name="vertJc" select="$groupChr/m:groupChrPr/m:vertJc/@m:val"/>
+                <xsl:variable name="pos" select="$groupChr/m:groupChrPr/m:pos/@m:val"/>
+
+                <xsl:choose>
+                    <xsl:when test="$vertJc = 'bot'">
+                        <!-- Arrow at bottom with text above (like \xrightarrow[]{text}) -->
+                        <!-- For extensible arrows: mover with arrow base, text above -->
+                        <mover accent="false">
+                            <mo stretchy="true">
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                        </mover>
+                    </xsl:when>
+                    <xsl:when test="$pos = 'top'">
+                        <!-- Arrow at top: \overrightarrow pattern -->
+                        <!-- mover with content base, arrow above -->
+                        <mover>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </mover>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <!-- Default: Vector arrow over content -->
+                        <mover>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </mover>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+
+            <!-- Skip phantom/layout boxes (argSz with negative value) -->
+            <!-- These are used for sizing/spacing control, not actual visible boxes -->
+            <xsl:when test="m:e/m:argPr/m:argSz/@m:val &lt; 0">
+                <xsl:apply-templates select="m:e"/>
+            </xsl:when>
+
+            <!-- Regular box -->
+            <xsl:otherwise>
+                <menclose notation="box">
+                    <xsl:apply-templates select="m:e"/>
+                </menclose>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Border box with strikethrough and border notation support -->
+    <xsl:template match="m:borderBox">
+        <xsl:variable name="props" select="m:borderBoxPr"/>
+
+        <!-- Check for strikethrough properties -->
+        <xsl:variable name="strikeBLTR" select="boolean($props/m:strikeBLTR)"/>
+        <xsl:variable name="strikeTLBR" select="boolean($props/m:strikeTLBR)"/>
+        <xsl:variable name="strikeH" select="boolean($props/m:strikeH)"/>
+        <xsl:variable name="strikeV" select="boolean($props/m:strikeV)"/>
+
+        <!-- Check for border hiding properties -->
+        <xsl:variable name="hideTop" select="boolean($props/m:hideTop)"/>
+        <xsl:variable name="hideBot" select="boolean($props/m:hideBot)"/>
+        <xsl:variable name="hideLeft" select="boolean($props/m:hideLeft)"/>
+        <xsl:variable name="hideRight" select="boolean($props/m:hideRight)"/>
+
+        <!-- Determine notation attribute -->
+        <xsl:variable name="notation">
+            <xsl:choose>
+                <!-- Combined diagonal strikes → xcancel -->
+                <xsl:when test="$strikeBLTR and $strikeTLBR">updiagonalstrike downdiagonalstrike</xsl:when>
+
+                <!-- Single diagonal strike BLTR → cancel (updiagonal) -->
+                <xsl:when test="$strikeBLTR">updiagonalstrike</xsl:when>
+
+                <!-- Single diagonal strike TLBR → bcancel (downdiagonal) -->
+                <xsl:when test="$strikeTLBR">downdiagonalstrike</xsl:when>
+
+                <!-- Combined horizontal and vertical → cancel -->
+                <xsl:when test="$strikeH and $strikeV">horizontalstrike verticalstrike</xsl:when>
+
+                <!-- Single horizontal strike → cancel -->
+                <xsl:when test="$strikeH">horizontalstrike</xsl:when>
+
+                <!-- Single vertical strike → bcancel -->
+                <xsl:when test="$strikeV">verticalstrike</xsl:when>
+
+                <!-- Single side visible -->
+                <xsl:when test="not($hideTop) and $hideBot and $hideLeft and $hideRight">top</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and $hideLeft and $hideRight">bottom</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and not($hideLeft) and $hideRight">left</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and $hideLeft and not($hideRight)">right</xsl:when>
+
+                <!-- Two sides visible -->
+                <xsl:when test="not($hideTop) and not($hideBot) and $hideLeft and $hideRight">top bottom</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and not($hideLeft) and $hideRight">top left</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and $hideLeft and not($hideRight)">top right</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and not($hideLeft) and $hideRight">bottom left</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and $hideLeft and not($hideRight)">bottom right</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and not($hideLeft) and not($hideRight)">left right</xsl:when>
+
+                <!-- Three sides visible -->
+                <xsl:when test="not($hideTop) and not($hideBot) and not($hideLeft) and $hideRight">top bottom left</xsl:when>
+                <xsl:when test="not($hideTop) and not($hideBot) and $hideLeft and not($hideRight)">top bottom right</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and not($hideLeft) and not($hideRight)">top left right</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and not($hideLeft) and not($hideRight)">bottom left right</xsl:when>
+
+                <!-- All four sides visible (or none hidden) -->
+                <xsl:when test="not($hideTop or $hideBot or $hideLeft or $hideRight)">box</xsl:when>
+
+                <!-- Default: roundedbox -->
+                <xsl:otherwise>roundedbox</xsl:otherwise>
+            </xsl:choose>
+        </xsl:variable>
+
+        <menclose notation="{$notation}">
+            <xsl:apply-templates select="m:e"/>
+        </menclose>
+    </xsl:template>
+
+    <!-- Math element base -->
+    <xsl:template match="m:e | m:num | m:den | m:sup | m:sub | m:deg | m:fName | m:lim">
+        <mrow>
+            <xsl:apply-templates select="*"/>
+        </mrow>
+    </xsl:template>
+
+    <!-- Template to split mixed operator/delimiter strings character by character -->
+    <!-- Recursive template to process text containing | characters -->
+    <xsl:template name="process-text-with-pipe">
+        <xsl:param name="text"/>
+        <xsl:if test="string-length($text) &gt; 0">
+            <xsl:choose>
+                <!-- If text contains |, split and recurse -->
+                <xsl:when test="contains($text, '|')">
+                    <xsl:variable name="before" select="substring-before($text, '|')"/>
+                    <xsl:variable name="after" select="substring-after($text, '|')"/>
+                    <!-- Output before part if not empty -->
+                    <xsl:if test="$before != ''">
+                        <xsl:choose>
+                            <!-- If before is single char, output as mi or mn -->
+                            <xsl:when test="string-length($before) = 1">
+                                <xsl:choose>
+                                    <xsl:when test="contains('0123456789', $before)">
+                                        <mn><xsl:value-of select="$before"/></mn>
+                                    </xsl:when>
+                                    <xsl:otherwise>
+                                        <mi><xsl:value-of select="$before"/></mi>
+                                    </xsl:otherwise>
+                                </xsl:choose>
+                            </xsl:when>
+                            <!-- Multi-char - use split-operators -->
+                            <xsl:otherwise>
+                                <xsl:call-template name="split-operators">
+                                    <xsl:with-param name="text" select="$before"/>
+                                </xsl:call-template>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:if>
+                    <!-- Output | as fence -->
+                    <mo fence="true">|</mo>
+                    <!-- Recurse on after part -->
+                    <xsl:if test="$after != ''">
+                        <xsl:call-template name="process-text-with-pipe">
+                            <xsl:with-param name="text" select="$after"/>
+                        </xsl:call-template>
+                    </xsl:if>
+                </xsl:when>
+                <!-- No more | in text - output as-is -->
+                <xsl:otherwise>
+                    <xsl:choose>
+                        <!-- Single char -->
+                        <xsl:when test="string-length($text) = 1">
+                            <xsl:choose>
+                                <xsl:when test="contains('0123456789', $text)">
+                                    <mn><xsl:value-of select="$text"/></mn>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <mi><xsl:value-of select="$text"/></mi>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:when>
+                        <!-- Multi-char - use split-operators for proper handling -->
+                        <xsl:otherwise>
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$text"/>
+                            </xsl:call-template>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="split-operators">
+        <xsl:param name="text"/>
+        <!-- Style variant to apply to identifier (letter) elements: 'normal', 'bold', 'italic', or empty -->
+        <xsl:param name="math_variant" select="''"/>
+        <xsl:if test="string-length($text) &gt; 0">
+            <!-- Process first character -->
+            <xsl:variable name="char" select="substring($text, 1, 1)"/>
+            <xsl:choose>
+                <!-- Fence delimiters with fence="true" -->
+                <xsl:when test="$char = '(' or $char = ')' or $char = '[' or $char = ']' or $char = '|'">
+                    <mo fence="true"><xsl:value-of select="$char"/></mo>
+                </xsl:when>
+                <!-- Plain operators (no fence attribute) -->
+                <!-- NOTE: { and } are converted to markers to distinguish source braces from generated LaTeX braces -->
+                <xsl:when test="$char = '+' or $char = '-' or $char = '=' or $char = '&lt;' or $char = '&gt;' or $char = '*' or $char = '/' or $char = '±' or $char = '≠' or $char = '≤' or $char = '≥' or $char = '×' or $char = '÷'">
+                    <mo><xsl:value-of select="$char"/></mo>
+                </xsl:when>
+                <!-- Source braces - use markers -->
+                <xsl:when test="$char = '{'">
+                    <mo>__LBRACE__</mo>
+                </xsl:when>
+                <xsl:when test="$char = '}'">
+                    <mo>__RBRACE__</mo>
+                </xsl:when>
+                <!-- Numbers -->
+                <xsl:when test="contains('0123456789', $char)">
+                    <mn><xsl:value-of select="$char"/></mn>
+                </xsl:when>
+                <!-- Identifiers (letters) -->
+                <xsl:otherwise>
+                    <mi>
+                        <!-- Apply mathvariant from parent run style if available -->
+                        <xsl:if test="$math_variant != ''">
+                            <xsl:attribute name="mathvariant"><xsl:value-of select="$math_variant"/></xsl:attribute>
+                        </xsl:if>
+                        <xsl:value-of select="$char"/>
+                    </mi>
+                </xsl:otherwise>
+            </xsl:choose>
+            <!-- Recursively process remaining characters -->
+            <xsl:if test="string-length($text) &gt; 1">
+                <xsl:call-template name="split-operators">
+                    <xsl:with-param name="text" select="substring($text, 2)"/>
+                    <xsl:with-param name="math_variant" select="$math_variant"/>
+                </xsl:call-template>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Properties elements - ignore -->
+    <xsl:template match="m:rPr | m:ctrlPr | m:dPr | m:fPr | m:funcPr | m:limLowPr | m:limUppPr | m:naryPr | m:phantPr | m:radPr | m:sPrePr | m:sSubPr | m:sSubSupPr | m:sSupPr | m:accPr | m:barPr | m:boxPr | m:borderBoxPr | m:dPr | m:eqArrPr | m:groupChrPr | m:mPr | w:rPr">
+        <!-- Ignore formatting properties -->
+    </xsl:template>
+
+    <!-- Control properties - ignore -->
+    <xsl:template match="m:ctrlPr">
+        <!-- Ignore control properties -->
+    </xsl:template>
+
+    <!-- Default template -->
+    <xsl:template match="*">
+        <xsl:apply-templates select="*"/>
+    </xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/java-svc/src/main/resources/application.yml.example b/java-svc/src/main/resources/application.yml.example
new file mode 100644
index 0000000..e51fcdf
--- /dev/null
+++ b/java-svc/src/main/resources/application.yml.example
@@ -0,0 +1,22 @@
+spring:
+  application:
+    name: word-file-parse
+  servlet:
+    multipart:
+      max-file-size: 100MB
+      max-request-size: 100MB
+
+server:
+  port: 8080
+
+wordparse:
+  tmp-path: ${java.io.tmpdir}
+  image-scaling-factor: 2.0
+  transform-scripts-path: /opt/transform
+  python-command: python3
+  oss:
+    endpoint: https://fs.code-lab.cn
+    access-key: ${WORDPARSE_OSS_AK:}
+    secret-key: ${WORDPARSE_OSS_SK:}
+    bucket: word-parse
+    prefix: office/file/parse/
diff --git a/java-svc/src/main/resources/static/symbols/E0FC.svg b/java-svc/src/main/resources/static/symbols/E0FC.svg
new file mode 100644
index 0000000..97b8252
--- /dev/null
+++ b/java-svc/src/main/resources/static/symbols/E0FC.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<svg xmlns="http://www.w3.org/2000/svg" width="1.385ex" height="2.262ex" viewBox="0 -750 612 1000" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" style=""><defs><path id="MJX-39-TEX-N-2212" d="M84 237T84 250T98 270H679Q694 262 694 250T679 230H98Q84 237 84 250Z"></path><path id="MJX-39-TEX-N-5B" d="M118 -250V750H255V710H158V-210H255V-250H118Z"></path></defs><g stroke="currentColor" fill="currentColor" stroke-width="0" transform="matrix(1 0 0 -1 0 0)"><g data-mml-node="math"><g data-mml-node="mo"><use xlink:href="#MJX-39-TEX-N-2212"></use></g><g data-mml-node="mspace" transform="translate(778, 0)"></g><g data-mml-node="mo" transform="translate(334, 0)"><use xlink:href="#MJX-39-TEX-N-5B"></use></g></g></g></svg>
\ No newline at end of file
diff --git a/java-svc/src/main/resources/static/symbols/E100.svg b/java-svc/src/main/resources/static/symbols/E100.svg
new file mode 100644
index 0000000..56b2b3e
--- /dev/null
+++ b/java-svc/src/main/resources/static/symbols/E100.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<svg xmlns="http://www.w3.org/2000/svg" width="2.204ex" height="2.262ex" viewBox="0 -750 974.3 1000" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" style=""><defs><path id="MJX-94-TEX-N-2212" d="M84 237T84 250T98 270H679Q694 262 694 250T679 230H98Q84 237 84 250Z"></path><path id="MJX-94-TEX-N-5D" d="M22 710V750H159V-250H22V-210H119V710H22Z"></path><path id="MJX-94-TEX-I-1D45B" d="M21 287Q22 293 24 303T36 341T56 388T89 425T135 442Q171 442 195 424T225 390T231 369Q231 367 232 367L243 378Q304 442 382 442Q436 442 469 415T503 336T465 179T427 52Q427 26 444 26Q450 26 453 27Q482 32 505 65T540 145Q542 153 560 153Q580 153 580 145Q580 144 576 130Q568 101 554 73T508 17T439 -10Q392 -10 371 17T350 73Q350 92 386 193T423 345Q423 404 379 404H374Q288 404 229 303L222 291L189 157Q156 26 151 16Q138 -11 108 -11Q95 -11 87 -5T76 7T74 17Q74 30 112 180T152 343Q153 348 153 366Q153 405 129 405Q91 405 66 305Q60 285 60 284Q58 278 41 278H27Q21 284 21 287Z"></path></defs><g stroke="currentColor" fill="currentColor" stroke-width="0" transform="matrix(1 0 0 -1 0 0)"><g data-mml-node="math"><g data-mml-node="mo"><use xlink:href="#MJX-94-TEX-N-2212"></use></g><g data-mml-node="mspace" transform="translate(778, 0)"></g><g data-mml-node="msub" transform="translate(222, 0)"><g data-mml-node="mo"><use xlink:href="#MJX-94-TEX-N-5D"></use></g><g data-mml-node="mi" transform="translate(278, -150) scale(0.707)"><use xlink:href="#MJX-94-TEX-I-1D45B"></use></g></g></g></g></svg>
\ No newline at end of file
diff --git a/java-svc/src/main/resources/static/symbols/E101.svg b/java-svc/src/main/resources/static/symbols/E101.svg
new file mode 100644
index 0000000..41169b1
--- /dev/null
+++ b/java-svc/src/main/resources/static/symbols/E101.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<svg xmlns="http://www.w3.org/2000/svg" width="2.649ex" height="2.262ex" viewBox="0 -750 1170.8 1000" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" style=""><defs><path id="MJX-92-TEX-N-2212" d="M84 237T84 250T98 270H679Q694 262 694 250T679 230H98Q84 237 84 250Z"></path><path id="MJX-92-TEX-N-5D" d="M22 710V750H159V-250H22V-210H119V710H22Z"></path><path id="MJX-92-TEX-I-1D45A" d="M21 287Q22 293 24 303T36 341T56 388T88 425T132 442T175 435T205 417T221 395T229 376L231 369Q231 367 232 367L243 378Q303 442 384 442Q401 442 415 440T441 433T460 423T475 411T485 398T493 385T497 373T500 364T502 357L510 367Q573 442 659 442Q713 442 746 415T780 336Q780 285 742 178T704 50Q705 36 709 31T724 26Q752 26 776 56T815 138Q818 149 821 151T837 153Q857 153 857 145Q857 144 853 130Q845 101 831 73T785 17T716 -10Q669 -10 648 17T627 73Q627 92 663 193T700 345Q700 404 656 404H651Q565 404 506 303L499 291L466 157Q433 26 428 16Q415 -11 385 -11Q372 -11 364 -4T353 8T350 18Q350 29 384 161L420 307Q423 322 423 345Q423 404 379 404H374Q288 404 229 303L222 291L189 157Q156 26 151 16Q138 -11 108 -11Q95 -11 87 -5T76 7T74 17Q74 30 112 181Q151 335 151 342Q154 357 154 369Q154 405 129 405Q107 405 92 377T69 316T57 280Q55 278 41 278H27Q21 284 21 287Z"></path></defs><g stroke="currentColor" fill="currentColor" stroke-width="0" transform="matrix(1 0 0 -1 0 0)"><g data-mml-node="math"><g data-mml-node="mo"><use xlink:href="#MJX-92-TEX-N-2212"></use></g><g data-mml-node="mspace" transform="translate(778, 0)"></g><g data-mml-node="msub" transform="translate(222, 0)"><g data-mml-node="mo"><use xlink:href="#MJX-92-TEX-N-5D"></use></g><g data-mml-node="mi" transform="translate(278, -150) scale(0.707)"><use xlink:href="#MJX-92-TEX-I-1D45A"></use></g></g></g></g></svg>
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/.dockerignore b/scripts/mathtype2mathml/.dockerignore
new file mode 100644
index 0000000..3bdaf8b
--- /dev/null
+++ b/scripts/mathtype2mathml/.dockerignore
@@ -0,0 +1,60 @@
+# Node.js
+node_modules
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Ruby
+.bundle
+vendor/bundle
+
+# 开发工具
+.git
+.gitignore
+*.md
+!README.md
+!SETUP_GUIDE.md
+
+# 临时文件和缓存
+uploads/*
+!uploads/.gitkeep
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+
+# 日志文件
+*.log
+logs
+
+# 编辑器文件
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# 测试文件
+test_*
+spec/
+.rspec
+
+# 环境文件
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# 构建文件
+dist/
+build/
+
+# 操作系统文件
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/DOCKER_SUMMARY.md b/scripts/mathtype2mathml/DOCKER_SUMMARY.md
new file mode 100644
index 0000000..363970c
--- /dev/null
+++ b/scripts/mathtype2mathml/DOCKER_SUMMARY.md
@@ -0,0 +1,116 @@
+# 🐳 MathType to MathML Docker 化完成
+
+## 📁 新增的 Docker 文件
+
+| 文件名 | 用途 | 描述 |
+|--------|------|------|
+| `Dockerfile` | 容器构建配置 | 定义如何构建包含 Ruby + Node.js 的容器镜像 |
+| `docker-compose.yml` | 服务编排 | 简化容器启动、端口映射和卷挂载 |
+| `.dockerignore` | 构建排除 | 指定哪些文件不需要复制到容器中 |
+| `entrypoint.sh` | 启动脚本 | 容器启动时的环境检查和初始化 |
+| `docker-build.sh` | 构建脚本 | 自动化构建和启动流程 |
+| `README.Docker.md` | 详细文档 | 完整的 Docker 部署和使用指南 |
+| `uploads/.gitkeep` | 目录占位 | 确保上传目录存在 |
+
+## 🚀 快速启动（3种方式）
+
+### 方式1：一键脚本（最简单）
+```bash
+./docker-build.sh
+```
+
+### 方式2：Docker Compose（推荐）
+```bash
+docker-compose up -d
+```
+
+### 方式3：原生 Docker
+```bash
+docker build -t mathtype-converter .
+docker run -d --name mathtype-to-mathml -p 3000:3000 -v $(pwd)/uploads:/app/uploads mathtype-converter
+```
+
+## 🌐 访问服务
+
+启动后通过以下地址访问：
+
+- **Web 界面**: http://localhost:3000/mathtype_converter_demo.html
+- **健康检查**: http://localhost:3000/health  
+- **API 转换**: `POST http://localhost:3000/convert-mathtype`
+
+## 📋 常用管理命令
+
+```bash
+# 查看运行状态
+docker-compose ps
+
+# 查看日志
+docker-compose logs -f
+
+# 停止服务
+docker-compose down
+
+# 重启服务
+docker-compose restart
+
+# 重建镜像
+docker-compose build --no-cache
+```
+
+## 🔧 技术栈
+
+- **基础镜像**: Ruby 3.1 (Debian Bullseye)
+- **运行时**: Ruby + Node.js LTS
+- **端口**: 3000
+- **依赖**: mathtype_to_mathml gem + Express.js
+- **持久化**: uploads 目录挂载
+
+## 📊 资源使用
+
+- **镜像大小**: ~500-800MB
+- **运行内存**: ~100-200MB
+- **文件上传限制**: 10MB
+- **并发处理**: 支持多文件并发转换
+
+## 🚀 部署到生产环境
+
+1. **修改端口映射**：编辑 `docker-compose.yml` 中的端口配置
+2. **添加反向代理**：使用 Nginx/Apache 代理到容器端口
+3. **配置域名**：更新 Traefik 标签或反向代理配置
+4. **监控日志**：设置日志轮转和监控告警
+5. **备份数据**：定期备份 uploads 目录
+
+## 🐛 故障排除
+
+### 常见问题
+
+1. **端口冲突**: 修改 `docker-compose.yml` 中的端口映射
+2. **Ruby Gem 错误**: 重建镜像 `docker-compose build --no-cache`
+3. **文件权限**: 检查 uploads 目录权限
+4. **内存不足**: 增加 Docker 内存限制
+
+### 调试命令
+```bash
+# 进入容器调试
+docker-compose exec mathtype-converter bash
+
+# 查看详细日志
+docker-compose logs --tail=100 mathtype-converter
+
+# 检查容器内文件
+docker exec mathtype-to-mathml ls -la /app
+```
+
+## ✅ 验证部署
+
+部署完成后，验证以下功能：
+
+1. ✅ 健康检查响应正常
+2. ✅ Web 界面可访问
+3. ✅ 文件上传功能正常
+4. ✅ MathML 转换功能正常
+5. ✅ 容器重启后服务恢复
+
+---
+
+🎉 **Docker 化完成！** 现在您可以轻松地将此服务部署到任何支持 Docker 的平台上。 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/Dockerfile b/scripts/mathtype2mathml/Dockerfile
new file mode 100644
index 0000000..2d6ab6f
--- /dev/null
+++ b/scripts/mathtype2mathml/Dockerfile
@@ -0,0 +1,71 @@
+# 使用官方 Ruby 镜像作为基础镜像
+FROM ruby:3.1-bullseye
+
+# 设置镜像源（提高国内网络访问速度）
+RUN sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list \
+    && sed -i 's/security.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list
+
+# 安装系统依赖
+RUN apt-get update && apt-get install -y \
+    curl \
+    gnupg \
+    build-essential \
+    libxml2-dev \
+    libxslt1-dev \
+    pkg-config \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# 安装 Node.js 16 (LTS) - 使用官方二进制包，增加重试机制
+RUN for i in 1 2 3; do \
+        curl -fsSL --connect-timeout 10 --max-time 300 \
+        https://nodejs.org/dist/v16.20.2/node-v16.20.2-linux-x64.tar.xz -o node.tar.xz \
+        && break || sleep 5; \
+    done \
+    && tar -xJf node.tar.xz -C /usr/local --strip-components=1 \
+    && rm node.tar.xz \
+    && ln -s /usr/local/bin/node /usr/local/bin/nodejs
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 vendor 目录（包含本地gems）
+COPY vendor ./vendor
+
+# 复制 Gemfile 和 package.json 先安装依赖（利用 Docker 缓存）
+COPY Gemfile Gemfile.lock ./
+COPY package.json package-lock.json ./
+
+# 配置npm使用国内镜像源（提高网络访问速度）
+RUN npm config set registry https://registry.npmmirror.com/ \
+    && npm config set timeout 60000 \
+    && npm config set network-timeout 300000
+
+# 配置bundle使用国内gem源
+RUN bundle config mirror.https://rubygems.org https://gems.ruby-china.com
+
+# 安装 Ruby 依赖（不使用 deployment 模式避免版本冲突）
+RUN bundle config set --local without 'development test' \
+    && bundle install --retry=3
+
+# 安装 Node.js 依赖（使用重试机制）
+RUN npm install --production --retry=3 || \
+    (npm config set registry https://registry.npmjs.org/ && npm install --production --retry=3)
+
+# 复制项目文件
+COPY . .
+
+# 创建必要的目录
+RUN mkdir -p uploads public
+
+# 设置文件权限
+RUN chmod +x entrypoint.sh
+
+# 暴露端口
+EXPOSE 3000
+
+# 设置启动脚本
+ENTRYPOINT ["./entrypoint.sh"]
+
+# 默认命令
+CMD ["npm", "start"] 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/Gemfile b/scripts/mathtype2mathml/Gemfile
new file mode 100644
index 0000000..f590048
--- /dev/null
+++ b/scripts/mathtype2mathml/Gemfile
@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+# Use local, vendored gems
+gem 'mathtype_to_mathml', path: 'vendor/gems/mathtype_to_mathml'
+gem 'mathtype', path: 'vendor/gems/mathtype'
+
+# Required dependency for XML processing
+gem 'nokogiri', '~> 1.13'
+
+# Required dependency for mathtype_to_mathml gem
+gem 'pry'
+
+# Concurrency support for batch processing
+gem 'concurrent-ruby', '~> 1.1'
+
+# Multi-process parallel processing
+gem 'parallel'
+
+# Optional: Add these for better development experience
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.0' if ENV['RAILS_ENV'] == 'test' 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/Gemfile.lock b/scripts/mathtype2mathml/Gemfile.lock
new file mode 100644
index 0000000..80dfc7d
--- /dev/null
+++ b/scripts/mathtype2mathml/Gemfile.lock
@@ -0,0 +1,67 @@
+PATH
+  remote: vendor/gems/mathtype_to_mathml
+  specs:
+    mathtype_to_mathml (0.0.7)
+      mathtype (~> 0.1.0)
+      nokogiri (~> 1.6)
+
+PATH
+  remote: vendor/gems/mathtype
+  specs:
+    mathtype (0.1.0)
+      bindata (~> 2.1)
+      nokogiri (~> 1.6)
+      ruby-ole (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bindata (2.5.1)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.7)
+    io-console (0.8.2)
+    method_source (1.1.0)
+    nokogiri (1.19.4-x64-mingw-ucrt)
+      racc (~> 1.4)
+    parallel (2.1.0)
+    pry (0.16.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+      reline (>= 0.6.0)
+    racc (1.8.1)
+    rake (13.4.2)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    ruby-ole (1.2.13.1)
+
+PLATFORMS
+  x64-mingw-ucrt
+
+DEPENDENCIES
+  concurrent-ruby (~> 1.1)
+  mathtype!
+  mathtype_to_mathml!
+  nokogiri (~> 1.13)
+  parallel
+  pry
+  rake (~> 13.0)
+
+CHECKSUMS
+  bindata (2.5.1) sha256=53186a1ec2da943d4cb413583d680644eb810aacbf8902497aac8f191fad9e58
+  bundler (4.0.15) sha256=a4ceb882fe94a0e0ac63cd0813932bbfd631a14e5ac0b7975189b19a4d28d9e7
+  coderay (1.1.3) sha256=dc530018a4684512f8f38143cd2a096c9f02a1fc2459edcfe534787a7fc77d4b
+  concurrent-ruby (1.3.7) sha256=4412caec3a5ea2e5fdc52076724c071a81f2c0593d83b2ac8cbb8ca63b3151b0
+  io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
+  mathtype (0.1.0)
+  mathtype_to_mathml (0.0.7)
+  method_source (1.1.0) sha256=181301c9c45b731b4769bc81e8860e72f9161ad7d66dd99103c9ab84f560f5c5
+  nokogiri (1.19.4-x64-mingw-ucrt) sha256=051da97b8eccfdb5444fed40246a35e10d7298b9efe759b4cd25455ea04c587e
+  parallel (2.1.0) sha256=b35258865c2e31134c5ecb708beaaf6772adf9d5efae28e93e99260877b09356
+  pry (0.16.0) sha256=d76c69065698ed1f85e717bd33d7942c38a50868f6b0673c636192b3d1b6054e
+  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835
+  ruby-ole (1.2.13.1) sha256=578d10dd2a797a2b35a1286c6fb2c9525f67c24791346fc8015d39f0ffa3cb72
+
+BUNDLED WITH
+  4.0.15
diff --git a/scripts/mathtype2mathml/README.Docker.md b/scripts/mathtype2mathml/README.Docker.md
new file mode 100644
index 0000000..9fd64f9
--- /dev/null
+++ b/scripts/mathtype2mathml/README.Docker.md
@@ -0,0 +1,182 @@
+# MathType to MathML Docker 部署指南
+
+这个 Docker 化版本让您可以轻松在任何支持 Docker 的平台上运行 MathType 到 MathML 转换服务。
+
+## 🚀 快速开始
+
+### 方法一：使用 Docker Compose（推荐）
+
+```bash
+# 构建并启动服务
+docker-compose up -d
+
+# 查看日志
+docker-compose logs -f
+
+# 停止服务
+docker-compose down
+```
+
+### 方法二：直接使用 Docker
+
+```bash
+# 构建镜像
+docker build -t mathtype-converter .
+
+# 运行容器
+docker run -d \
+  --name mathtype-to-mathml \
+  -p 3000:3000 \
+  -v $(pwd)/uploads:/app/uploads \
+  mathtype-converter
+
+# 查看日志
+docker logs -f mathtype-to-mathml
+
+# 停止容器
+docker stop mathtype-to-mathml
+docker rm mathtype-to-mathml
+```
+
+## 📱 使用服务
+
+服务启动后，可以通过以下方式使用：
+
+### Web 界面
+打开浏览器访问：`http://localhost:3000/mathtype_converter_demo.html`
+
+### API 接口
+
+#### 健康检查
+```bash
+curl http://localhost:3000/health
+```
+
+#### 转换 MathType 文件
+```bash
+curl -X POST \
+  -F "file=@your_mathtype_file.bin" \
+  http://localhost:3000/convert-mathtype
+```
+
+## 🔧 配置说明
+
+### 环境变量
+- `NODE_ENV`: 运行环境（默认：production）
+- `PORT`: 服务端口（默认：3000）
+
+### 数据卷
+- `/app/uploads`: 上传文件存储目录
+- `/app/config`: 配置文件目录（可选）
+
+### 端口映射
+- `3000`: Web 服务端口
+
+## 📁 目录结构
+
+```
+/app/
+├── server_converter.js     # Node.js 主服务器
+├── server/
+│   ├── converter.rb        # Ruby 转换脚本
+│   └── setup.js           # 设置脚本
+├── public/                 # 静态文件
+├── uploads/               # 上传文件目录
+├── vendor/                # Ruby gems
+└── Gemfile                # Ruby 依赖
+```
+
+## 🐛 故障排除
+
+### 查看容器日志
+```bash
+# Docker Compose
+docker-compose logs mathtype-converter
+
+# 直接 Docker
+docker logs mathtype-to-mathml
+```
+
+### 进入容器调试
+```bash
+# Docker Compose
+docker-compose exec mathtype-converter bash
+
+# 直接 Docker
+docker exec -it mathtype-to-mathml bash
+```
+
+### 重建镜像
+```bash
+# 清理并重建
+docker-compose down
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+## 🚀 部署到生产环境
+
+### 修改 docker-compose.yml
+```yaml
+services:
+  mathtype-converter:
+    # ... 其他配置
+    environment:
+      - NODE_ENV=production
+    restart: always
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+        reservations:
+          memory: 256M
+```
+
+### 使用反向代理（Nginx 示例）
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;
+    
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+    
+    # 文件上传大小限制
+    client_max_body_size 10M;
+}
+```
+
+## 📊 监控和维护
+
+### 健康检查
+服务内置健康检查端点：`/health`
+
+### 日志管理
+```bash
+# 设置日志轮转
+docker-compose up -d --log-opt max-size=10m --log-opt max-file=3
+```
+
+### 备份上传文件
+```bash
+# 备份上传目录
+docker run --rm -v mathtype_uploads:/data -v $(pwd):/backup alpine tar czf /backup/uploads-backup.tar.gz -C /data .
+```
+
+## 🔄 更新服务
+
+```bash
+# 停止服务
+docker-compose down
+
+# 拉取最新代码（如果有）
+git pull
+
+# 重建并启动
+docker-compose up -d --build
+``` 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/README.md b/scripts/mathtype2mathml/README.md
new file mode 100644
index 0000000..0c51dc6
--- /dev/null
+++ b/scripts/mathtype2mathml/README.md
@@ -0,0 +1,115 @@
+# MathType to MathML Converter
+
+一个基于 Ruby gem 的 MathType 二进制文件转 MathML 的 Node.js 服务器。
+
+## 功能特点
+
+- 支持上传 MathType 二进制文件 (.bin)
+- 转换为标准 MathML 格式
+- RESTful API 接口
+- Web 界面演示
+- Docker 容器化部署
+- 网络优化和重试机制
+- 支持开发和生产环境配置
+
+## 快速开始
+
+### 方式一：Docker 部署（推荐）
+
+#### Windows 环境
+```powershell
+# 开发环境构建并启动
+.\docker-build.ps1
+
+# 生产环境构建并启动
+.\docker-build.ps1 -Production
+
+# 查看帮助
+.\docker-build.ps1 -Help
+```
+
+#### Linux/macOS 环境
+```bash
+# 增强构建脚本（推荐）
+./docker-build-enhanced.sh
+
+# 标准构建脚本
+./docker-build.sh
+
+# 或使用 docker-compose
+docker-compose up -d
+
+# 生产环境
+docker-compose -f docker-compose.production.yml up -d
+```
+
+### 方式二：本地部署
+
+1. 确保安装了 Ruby 和 Node.js
+2. 安装依赖：
+
+```bash
+# 安装 Ruby 依赖
+bundle install
+
+# 安装 Node.js 依赖  
+npm install
+```
+
+3. 启动服务：
+
+```bash
+npm start
+```
+
+## 配置说明
+
+### 环境配置
+
+- **开发环境**: 使用 `docker-compose.yml`，包含代码热重载
+- **生产环境**: 使用 `docker-compose.production.yml`，优化性能和安全性
+
+### 配置文件
+
+- `config/app.json`: 应用基础配置
+- `uploads/`: 文件上传目录
+- `vendor/gems/`: 本地 Ruby gems
+
+## API 使用
+
+### 转换 MathType 文件
+
+```bash
+curl -X POST http://localhost:3000/convert-mathtype \
+  -F "file=@path/to/mathtype.bin"
+```
+
+### 健康检查
+
+```bash
+curl http://localhost:3000/health
+```
+
+## Web 界面
+
+启动服务后访问：http://localhost:3000/mathtype_converter_demo.html
+
+## 故障排除
+
+### 网络问题
+如果遇到 Docker Hub 连接问题：
+1. 使用增强构建脚本：`./docker-build-enhanced.sh` 或 `.\docker-build.ps1`
+2. 脚本会自动检测网络状况并使用国内镜像源
+
+### 常见问题
+- **端口冲突**: 修改 docker-compose.yml 中的端口映射
+- **构建失败**: 清理 Docker 缓存 `docker system prune`
+- **权限问题**: 确保 uploads 目录权限正确
+
+## 技术栈
+
+- **后端**: Node.js + Express
+- **Ruby Gem**: mathtype_to_mathml  
+- **容器化**: Docker + Docker Compose
+- **前端**: 原生 HTML/JavaScript
+- **网络优化**: 国内镜像源支持
diff --git a/scripts/mathtype2mathml/SETUP_GUIDE.md b/scripts/mathtype2mathml/SETUP_GUIDE.md
new file mode 100644
index 0000000..99467d2
--- /dev/null
+++ b/scripts/mathtype2mathml/SETUP_GUIDE.md
@@ -0,0 +1,217 @@
+# 🔧 Setup Guide: Converting Real MathType .bin Files
+
+## Why You Need This Setup
+
+The JavaScript client-side converter only shows a sample equation (x²) because **parsing MathType's proprietary binary format requires the Ruby gem**. To convert real `.bin` files, you need the server setup.
+
+## 📋 Prerequisites
+
+### 1. Install Ruby and Gems
+```bash
+# On Windows (using RubyInstaller)
+# Download from: https://rubyinstaller.org/
+
+# On macOS (using Homebrew)
+brew install ruby
+
+# On Ubuntu/Debian
+sudo apt-get install ruby-full
+
+# Install bundler and the required gems from the project root
+gem install bundler
+bundle install
+```
+
+### 2. Install Node.js
+```bash
+# Download from: https://nodejs.org/
+# Or using package managers:
+
+# macOS
+brew install node
+
+# Ubuntu/Debian  
+sudo apt-get install nodejs npm
+
+# Windows
+# Download installer from nodejs.org
+```
+
+## 🚀 Quick Setup
+
+### Step 1: Install Server Dependencies
+```bash
+# In your project's server directory
+cd server
+npm install
+cd ..
+```
+
+### Step 2: Start the Server
+```bash
+# From the project root
+npm start
+```
+
+You should see:
+```
+MathType converter server running at http://localhost:3000
+Make sure you have the mathtype_to_mathml Ruby gem installed.
+```
+
+### Step 3: Open the Demo
+1. Open `http://localhost:3000/index.html`
+2. Upload a real MathType `.bin` file
+3. Click "Convert Real File (Server Required)"
+
+## 📁 Finding MathType .bin Files
+
+MathType equations in Word documents are typically stored as:
+- `oleObject1.bin`, `oleObject2.bin`, etc.
+- In the `word/embeddings/` folder when you unzip a `.docx` file
+
+### Extract from Word Document:
+```bash
+# Rename .docx to .zip and extract
+cp document.docx document.zip
+unzip document.zip
+ls word/embeddings/  # Look for .bin files
+```
+
+## 🧪 Testing the Setup
+
+### Test 1: Server Health Check
+```bash
+curl http://localhost:3000/health
+# Should return: {"status":"ok","message":"MathType converter server is running"}
+```
+
+### Test 2: Convert a File via API
+```bash
+# Make sure to be in the directory with oleObject1.bin
+curl -X POST -F "file=@oleObject1.bin" http://localhost:3000/convert-mathtype
+# Should return JSON with MathML
+```
+
+### Test 3: Web Interface
+1. Open browser to `http://localhost:3000/index.html`
+2. Upload a `.bin` file
+3. Click "Convert Real File"
+4. Should see actual MathML output (not just x²)
+
+## 🐛 Troubleshooting
+
+### Error: "Ruby conversion failed"
+```bash
+# Check if Ruby gems are installed via bundle from the project root
+bundle check
+
+# Reinstall if missing
+bundle install
+```
+
+### Error: "Failed to spawn Ruby process"
+```bash
+# Check if Ruby is in PATH
+ruby --version
+
+# The script now runs from the project root, so bundle should find the correct ruby executable.
+# If you still have issues, ensure 'bundle' command is in your system's PATH.
+```
+
+### Error: "Cannot find module 'express'"
+```bash
+cd server
+npm install express multer cors
+cd ..
+```
+
+### Error: "File upload failed"
+- Check file size (limit is 10MB)
+- Ensure file has `.bin` extension
+- Verify file is actually a MathType binary
+
+## 📊 Expected Behavior
+
+### ✅ Success Case:
+1. Upload `oleObject1.bin` containing equation `E = mc²`
+2. Server processes file with Ruby gem
+3. Returns: `<math xmlns="http://www.w3.org/1998/Math/MathML"><mi>E</mi><mo>=</mo><mi>m</mi><msup><mi>c</mi><mn>2</mn></msup></math>`
+4. Browser displays rendered equation
+
+### ❌ Fallback Case:
+1. Server unavailable or fails
+2. Client falls back to demo mode
+3. Always shows `x²` sample regardless of uploaded file
+4. Warning message: "Client-side demo completed (shows sample x² only)"
+
+## 🔄 Development Workflow
+
+### For Development:
+```bash
+# Use nodemon for auto-restart (run from project root)
+npm run dev
+```
+
+### For Production:
+```bash
+# Use PM2 or similar process manager (run from project root)
+npm install -g pm2
+pm2 start server/server.js --name mathtype-converter
+```
+
+## 📈 Performance Notes
+
+- **Ruby Process**: Each conversion spawns a Ruby process (~100-500ms overhead)
+- **File Size**: Typical `.bin` files are 1-50KB
+- **Concurrent Requests**: Server handles multiple files simultaneously
+- **Memory**: Each Ruby process uses ~10-50MB temporarily
+
+## 🔒 Security Considerations
+
+For production deployment:
+- Add file type validation
+- Implement rate limiting
+- Add authentication if needed
+- Sanitize file names
+- Use temporary directories with cleanup
+
+## 📦 Alternative Deployment
+
+### Docker Option:
+```dockerfile
+FROM node:18
+RUN apt-get update && apt-get install -y ruby-full
+RUN gem install bundler
+
+# Set work directory
+WORKDIR /app
+
+# Copy gem files and install gems
+COPY Gemfile Gemfile.lock ./
+COPY vendor ./vendor
+RUN bundle install
+
+# Copy server files and install node modules
+COPY server ./server
+WORKDIR /app/server
+RUN npm install
+
+# Go back to root to run the server
+WORKDIR /app
+EXPOSE 3000
+CMD ["npm", "start"]
+```
+
+### Cloud Function Option:
+Deploy to AWS Lambda, Google Cloud Functions, or Vercel with Ruby runtime support.
+
+## 📞 Support
+
+If you encounter issues:
+1. Check Ruby gem installation from root: `bundle check`
+2. Verify Node.js setup in server folder: `cd server && npm install && cd ..`
+3. Test with sample `.bin` files first
+4. Check server logs for detailed error messages
+
+The key is having both Ruby (for binary parsing) and Node.js (for web interface) working together! 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/batch_converter.rb b/scripts/mathtype2mathml/batch_converter.rb
new file mode 100644
index 0000000..36a9659
--- /dev/null
+++ b/scripts/mathtype2mathml/batch_converter.rb
@@ -0,0 +1,211 @@
+require_relative 'vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml'
+require 'json'
+require 'concurrent-ruby'
+require 'pathname'
+require 'parallel'
+
+class BatchConverter
+  def initialize(max_threads: 4)
+    @max_threads = max_threads
+    @thread_pool = Concurrent::ThreadPoolExecutor.new(
+      min_threads: 1,
+      max_threads: @max_threads,
+      max_queue: 100,
+      fallback_policy: :caller_runs
+    )
+  end
+
+  # 新增多进程处理方法
+  def process_files_multi_process(file_paths)
+    # 确保传入的是可枚举的哈希结构
+    file_paths_hash = file_paths.is_a?(Hash) ? file_paths : {}
+    # 根据平台自动选择并行模式：
+    # Linux/macOS 支持 Process.fork，使用多进程实现真正的 CPU 并行
+    # Windows 不支持 Process.fork，降级为多线程
+    parallel_opts = Process.respond_to?(:fork) ? { in_processes: @max_threads } : { in_threads: @max_threads }
+    result_array = Parallel.map(file_paths_hash.to_a, parallel_opts) do |key, value|
+      begin
+        result = process_single_file(value)
+        [key, result]
+      rescue => e
+        [key, {
+          success: false,
+          error: e.message,
+          mathml: nil
+        }]
+      end
+    end
+    # 将数组结果转换为哈希
+    result_array.to_h
+  end
+
+  def process_files(file_paths)
+    results = {}
+    futures = []
+    
+    # 遍历json入参开始转换
+    file_paths.each do |key, value|
+      future = Concurrent::Future.execute(executor: @thread_pool) do
+        process_single_file(value)
+      end
+      futures << [key, future]
+    end
+
+    # Wait for all conversions to complete
+    futures.each do |file_path, future|
+      begin
+        result = future.value(30) # 30 second timeout per file
+        results[file_path] = result
+      rescue Concurrent::TimeoutError
+        results[file_path] = {
+          success: false,
+          error: 'Conversion timeout (30 seconds)',
+          mathml: nil
+        }
+      rescue => e
+        results[file_path] = {
+          success: false,
+          error: e.message,
+          mathml: nil
+        }
+      end
+    end
+
+    @thread_pool.shutdown
+    @thread_pool.wait_for_termination(60)
+
+    results
+  end
+
+  private
+
+  def process_single_file(file_path)
+    begin
+      # Validate file
+      unless File.exist?(file_path)
+        return {
+          success: false,
+          error: "File does not exist: #{file_path}",
+          mathml: nil
+        }
+      end
+      
+      unless File.readable?(file_path)
+        return {
+          success: false,
+          error: "File is not readable: #{file_path}",
+          mathml: nil
+        }
+      end
+      
+      file_size = File.size(file_path)
+      if file_size == 0
+        return {
+          success: false,
+          error: "File is empty: #{file_path}",
+          mathml: nil
+        }
+      end
+
+      # Convert the file
+      converter = MathTypeToMathML::Converter.new(file_path)
+      mathml = converter.convert
+      
+      # Validate output
+      if mathml.nil? || mathml.strip.empty?
+        return {
+          success: false,
+          error: "Conversion resulted in empty MathML",
+          mathml: nil
+        }
+      end
+
+      {
+        success: true,
+        error: nil,
+        mathml: mathml.strip,
+        file_size: file_size
+      }
+
+    rescue NoMethodError => e
+      {
+        success: false,
+        error: "Ruby parsing error - #{e.message}. This usually indicates an incompatible or corrupted MathType file",
+        mathml: nil
+      }
+    rescue ArgumentError => e
+      {
+        success: false,
+        error: "Invalid file format - #{e.message}",
+        mathml: nil
+      }
+    rescue StandardError => e
+      {
+        success: false,
+        error: "Unexpected error - #{e.class}: #{e.message}",
+        mathml: nil
+      }
+    end
+  end
+end
+
+# Command line interface
+if __FILE__ == $0
+  begin
+    if ARGV.empty?
+      STDERR.puts "Usage: #{$0} file1.bin [file2.bin ...]"
+      exit 1
+    end
+
+    # Validate all files exist before processing
+    # missing_files = ARGV.reject { |file| File.exist?(file) }
+    # unless missing_files.empty?
+    #   STDERR.puts "Error: Files not found: #{missing_files.join(', ')}"
+    #   exit 1
+    # end
+
+    # 入参可以是文件路径或JSON字符串
+    arg = ARGV[0] || '{}'
+    if File.exist?(arg) && File.file?(arg)
+      json_data = File.read(arg, mode: 'rb:utf-8').gsub(/\A\xEF\xBB\xBF/, '')
+    else
+      json_data = arg.gsub(/\A'|'\z/, '')
+    end
+    begin      
+      data = JSON.parse(json_data)
+    rescue JSON::ParserError => e
+      STDERR.puts "ERROR: Invalid JSON input: #{e.message}"
+      exit 1
+    end
+
+    # Process files
+    # batch_converter = BatchConverter.new(max_threads: [ARGV.size, 8].min)
+    # results = batch_converter.process_files(data)
+
+    batch_converter = BatchConverter.new(max_threads: [data.size, Parallel.processor_count].min)
+    results = batch_converter.process_files_multi_process(data)
+
+    # Output results as JSON
+    output = {
+      total_files: data.size,
+      successful: results.count { |_, result| result[:success] },
+      failed: results.count { |_, result| !result[:success] },
+      results: results
+    }
+
+    puts "WP_RUBY_".concat(output.to_json)
+    # puts JSON.pretty_generate(output)
+
+    # Exit with error code if any conversions failed
+    exit_code = results.any? { |_, result| !result[:success] } ? 1 : 0
+    # exit exit_code
+    exit 0
+
+  rescue Interrupt
+    STDERR.puts "\nBatch conversion interrupted by user"
+    exit 130
+  rescue => e
+    STDERR.puts "Fatal error: #{e.message}"
+    exit 1
+  end
+end
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/config/.gitkeep b/scripts/mathtype2mathml/config/.gitkeep
new file mode 100644
index 0000000..fc321cc
--- /dev/null
+++ b/scripts/mathtype2mathml/config/.gitkeep
@@ -0,0 +1 @@
+# Keep this directory in git 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/config/app.json b/scripts/mathtype2mathml/config/app.json
new file mode 100644
index 0000000..12ba5bf
--- /dev/null
+++ b/scripts/mathtype2mathml/config/app.json
@@ -0,0 +1,19 @@
+{
+  "name": "MathType to MathML Converter",
+  "version": "1.0.0",
+  "description": "Server for converting MathType binary files to MathML",
+  "port": 3000,
+  "environment": "production",
+  "limits": {
+    "maxFileSize": "10MB",
+    "maxFiles": 10
+  },
+  "logging": {
+    "level": "info",
+    "format": "combined"
+  },
+  "cors": {
+    "enabled": true,
+    "origin": "*"
+  }
+} 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/converter.rb b/scripts/mathtype2mathml/converter.rb
new file mode 100644
index 0000000..1cc7792
--- /dev/null
+++ b/scripts/mathtype2mathml/converter.rb
@@ -0,0 +1,65 @@
+require 'mathtype_to_mathml'
+
+def safe_convert(file_path)
+  begin
+    # Check if file exists and is readable
+    unless File.exist?(file_path)
+      STDERR.puts "Error: File does not exist: #{file_path}"
+      exit 1
+    end
+    
+    unless File.readable?(file_path)
+      STDERR.puts "Error: File is not readable: #{file_path}"
+      exit 1
+    end
+    
+    # Check file size
+    file_size = File.size(file_path)
+    if file_size == 0
+      STDERR.puts "Error: File is empty: #{file_path}"
+      exit 1
+    end
+    
+    STDERR.puts "Processing file: #{file_path} (#{file_size} bytes)"
+    
+    # Try to convert the file
+    converter = MathTypeToMathML::Converter.new(file_path)
+    mathml = converter.convert
+    
+    # Check if we got valid output
+    if mathml.nil? || mathml.strip.empty?
+      STDERR.puts "Error: Conversion resulted in empty MathML"
+      exit 1
+    end
+    
+    puts mathml
+    
+  rescue NoMethodError => e
+    STDERR.puts "Error: Ruby parsing error - #{e.message}"
+    STDERR.puts "This usually indicates an incompatible or corrupted MathType file"
+    STDERR.puts "Backtrace: #{e.backtrace.first(3).join(', ')}"
+    exit 1
+  rescue ArgumentError => e
+    STDERR.puts "Error: Invalid file format - #{e.message}"
+    exit 1
+  rescue StandardError => e
+    STDERR.puts "Error: Unexpected error - #{e.class}: #{e.message}"
+    STDERR.puts "Backtrace: #{e.backtrace.first(5).join(', ')}"
+    exit 1
+  end
+end
+
+begin
+  file_path = ARGV[0]
+  
+  if file_path.nil? || file_path.empty?
+    STDERR.puts "Error: No file path provided"
+    exit 1
+  end
+  
+  safe_convert(file_path)
+  
+rescue => e
+  STDERR.puts "Error: #{e.message}"
+  exit 1
+end 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/docker-build-enhanced.sh b/scripts/mathtype2mathml/docker-build-enhanced.sh
new file mode 100644
index 0000000..31e5ad1
--- /dev/null
+++ b/scripts/mathtype2mathml/docker-build-enhanced.sh
@@ -0,0 +1,182 @@
+#!/bin/bash
+
+# Enhanced Docker 构建脚本 - 网络优化版本
+set -e
+
+echo "🐳 Enhanced MathType to MathML Docker 构建脚本"
+echo "================================================="
+
+# 检查 Docker 是否安装
+if ! command -v docker &> /dev/null; then
+    echo "❌ Docker 未安装，请先安装 Docker"
+    exit 1
+fi
+
+# 检查 docker-compose 是否安装
+if ! command -v docker-compose &> /dev/null; then
+    echo "⚠️  docker-compose 未安装，将使用 docker build"
+    USE_COMPOSE=false
+else
+    USE_COMPOSE=true
+fi
+
+# 设置镜像名称
+IMAGE_NAME="mathtype-converter"
+CONTAINER_NAME="mathtype-to-mathml"
+
+# 检查网络连接并选择最佳构建策略
+echo "🌐 检查网络连接..."
+
+# 测试Docker Hub连接
+if curl -s --connect-timeout 5 https://registry.hub.docker.com/ > /dev/null; then
+    echo "✅ Docker Hub 连接正常"
+    NETWORK_MODE="standard"
+else
+    echo "⚠️  Docker Hub 连接异常，使用网络优化模式"
+    NETWORK_MODE="optimized"
+fi
+
+# 根据网络状况选择构建参数
+if [ "$NETWORK_MODE" = "optimized" ]; then
+    echo "📦 使用网络优化构建..."
+    BUILD_ARGS="--build-arg USE_MIRROR=true --network=host"
+else
+    echo "📦 使用标准构建..."
+    BUILD_ARGS=""
+fi
+
+echo "🔨 开始构建 Docker 镜像..."
+
+# 构建函数
+build_image() {
+    local attempt=$1
+    echo "📝 构建尝试 $attempt/3..."
+    
+    if [ "$USE_COMPOSE" = true ]; then
+        if docker-compose build $BUILD_ARGS; then
+            return 0
+        else
+            return 1
+        fi
+    else
+        if docker build -t $IMAGE_NAME $BUILD_ARGS .; then
+            return 0
+        else
+            return 1
+        fi
+    fi
+}
+
+# 重试构建
+for attempt in 1 2 3; do
+    if build_image $attempt; then
+        echo "✅ Docker 镜像构建成功！"
+        BUILD_SUCCESS=true
+        break
+    else
+        echo "❌ 构建尝试 $attempt 失败"
+        if [ $attempt -lt 3 ]; then
+            echo "⏳ 等待 10 秒后重试..."
+            sleep 10
+        fi
+        BUILD_SUCCESS=false
+    fi
+done
+
+if [ "$BUILD_SUCCESS" != true ]; then
+    echo "❌ 所有构建尝试都失败了"
+    echo "💡 建议："
+    echo "   1. 检查网络连接"
+    echo "   2. 确认 Docker 服务运行正常"
+    echo "   3. 尝试手动清理 Docker 缓存: docker system prune"
+    exit 1
+fi
+
+# 验证镜像构建
+echo "🔍 验证镜像..."
+if docker images | grep -q $IMAGE_NAME; then
+    echo "✅ 镜像验证成功！"
+else
+    echo "❌ 镜像验证失败"
+    exit 1
+fi
+
+# 提供启动选项
+echo ""
+echo "🚀 启动选项："
+echo "1. 使用 docker-compose（推荐）："
+echo "   docker-compose up -d"
+echo ""
+echo "2. 直接使用 Docker："
+echo "   docker run -d --name $CONTAINER_NAME -p 3000:3000 -v \$(pwd)/uploads:/app/uploads $IMAGE_NAME"
+echo ""
+echo "📱 启动后访问："
+echo "   Web界面: http://localhost:3000/mathtype_converter_demo.html"
+echo "   健康检查: http://localhost:3000/health"
+echo ""
+echo "📋 管理命令："
+echo "   查看日志: docker logs -f $CONTAINER_NAME"
+echo "   停止容器: docker stop $CONTAINER_NAME"
+echo "   删除容器: docker rm $CONTAINER_NAME"
+
+# 询问是否立即启动
+read -p "是否立即启动容器？ (y/N): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo "🚀 启动容器..."
+    if [ "$USE_COMPOSE" = true ]; then
+        if docker-compose up -d; then
+            echo "✅ 容器已启动！"
+            echo "📊 查看状态: docker-compose ps"
+            echo "📋 查看日志: docker-compose logs -f"
+        else
+            echo "❌ 容器启动失败"
+            exit 1
+        fi
+    else
+        # 停止并删除已存在的容器
+        docker stop $CONTAINER_NAME 2>/dev/null || true
+        docker rm $CONTAINER_NAME 2>/dev/null || true
+        
+        # 启动新容器
+        if docker run -d \
+            --name $CONTAINER_NAME \
+            -p 3000:3000 \
+            -v "$(pwd)/uploads:/app/uploads" \
+            -v "$(pwd)/config:/app/config:ro" \
+            $IMAGE_NAME; then
+            
+            echo "✅ 容器已启动！"
+            echo "📊 查看状态: docker ps"
+            echo "📋 查看日志: docker logs -f $CONTAINER_NAME"
+        else
+            echo "❌ 容器启动失败"
+            exit 1
+        fi
+    fi
+    
+    echo ""
+    echo "⏳ 等待服务启动..."
+    sleep 10
+    
+    # 健康检查
+    echo "🏥 执行健康检查..."
+    for i in {1..6}; do
+        if curl -s http://localhost:3000/health > /dev/null; then
+            echo "✅ 服务启动成功！"
+            echo "🌐 请访问: http://localhost:3000/mathtype_converter_demo.html"
+            break
+        else
+            if [ $i -eq 6 ]; then
+                echo "⚠️  健康检查超时，但服务可能仍在启动中"
+                echo "💡 请手动检查: curl http://localhost:3000/health"
+            else
+                echo "⏳ 等待服务启动... ($i/6)"
+                sleep 5
+            fi
+        fi
+    done
+fi
+
+echo ""
+echo "🎉 构建完成！" 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/docker-build.ps1 b/scripts/mathtype2mathml/docker-build.ps1
new file mode 100644
index 0000000..e07885c
--- /dev/null
+++ b/scripts/mathtype2mathml/docker-build.ps1
@@ -0,0 +1,216 @@
+# Enhanced Docker 构建脚本 - Windows PowerShell 版本
+param(
+    [switch]$Production,
+    [switch]$NoBuild,
+    [switch]$Help
+)
+
+if ($Help) {
+    Write-Host "🐳 MathType to MathML Docker 构建脚本 - Windows版本" -ForegroundColor Cyan
+    Write-Host "用法: .\docker-build.ps1 [参数]" -ForegroundColor Yellow
+    Write-Host ""
+    Write-Host "参数:" -ForegroundColor Yellow
+    Write-Host "  -Production    使用生产环境配置 (docker-compose.production.yml)"
+    Write-Host "  -NoBuild       跳过构建，直接启动已有镜像"
+    Write-Host "  -Help          显示此帮助信息"
+    Write-Host ""
+    Write-Host "示例:" -ForegroundColor Yellow
+    Write-Host "  .\docker-build.ps1                # 开发环境构建和启动"
+    Write-Host "  .\docker-build.ps1 -Production   # 生产环境构建和启动"
+    Write-Host "  .\docker-build.ps1 -NoBuild      # 跳过构建，直接启动"
+    exit 0
+}
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "🐳 Enhanced MathType to MathML Docker 构建脚本" -ForegroundColor Cyan
+Write-Host "=================================================" -ForegroundColor Cyan
+
+# 检查 Docker 是否安装
+if (!(Get-Command docker -ErrorAction SilentlyContinue)) {
+    Write-Host "❌ Docker 未安装，请先安装 Docker Desktop" -ForegroundColor Red
+    exit 1
+}
+
+# 检查 docker-compose 是否安装
+if (!(Get-Command docker-compose -ErrorAction SilentlyContinue)) {
+    Write-Host "⚠️  docker-compose 未安装，将使用 docker build" -ForegroundColor Yellow
+    $UseCompose = $false
+} else {
+    $UseCompose = $true
+}
+
+# 设置镜像名称和配置文件
+$ImageName = "mathtype-converter"
+$ContainerName = "mathtype-to-mathml"
+
+if ($Production) {
+    $ComposeFile = "docker-compose.production.yml"
+    $ContainerName += "-prod"
+    Write-Host "📦 使用生产环境配置" -ForegroundColor Green
+} else {
+    $ComposeFile = "docker-compose.yml"
+    Write-Host "📦 使用开发环境配置" -ForegroundColor Green
+}
+
+# 检查网络连接
+Write-Host "🌐 检查网络连接..." -ForegroundColor Yellow
+
+try {
+    $response = Invoke-WebRequest -Uri "https://registry.hub.docker.com/" -TimeoutSec 5 -UseBasicParsing
+    Write-Host "✅ Docker Hub 连接正常" -ForegroundColor Green
+    $NetworkMode = "standard"
+} catch {
+    Write-Host "⚠️  Docker Hub 连接异常，使用网络优化模式" -ForegroundColor Yellow
+    $NetworkMode = "optimized"
+}
+
+if (!$NoBuild) {
+    Write-Host "🔨 开始构建 Docker 镜像..." -ForegroundColor Yellow
+
+    # 构建函数
+    function Build-DockerImage {
+        param([int]$Attempt)
+        
+        Write-Host "📝 构建尝试 $Attempt/3..." -ForegroundColor Cyan
+        
+        try {
+            if ($UseCompose) {
+                if ($NetworkMode -eq "optimized") {
+                    docker-compose -f $ComposeFile build --build-arg USE_MIRROR=true
+                } else {
+                    docker-compose -f $ComposeFile build
+                }
+            } else {
+                if ($NetworkMode -eq "optimized") {
+                    docker build -t $ImageName --build-arg USE_MIRROR=true .
+                } else {
+                    docker build -t $ImageName .
+                }
+            }
+            return $true
+        } catch {
+            Write-Host "❌ 构建失败: $($_.Exception.Message)" -ForegroundColor Red
+            return $false
+        }
+    }
+
+    # 重试构建
+    $BuildSuccess = $false
+    for ($attempt = 1; $attempt -le 3; $attempt++) {
+        if (Build-DockerImage -Attempt $attempt) {
+            Write-Host "✅ Docker 镜像构建成功！" -ForegroundColor Green
+            $BuildSuccess = $true
+            break
+        } else {
+            if ($attempt -lt 3) {
+                Write-Host "⏳ 等待 10 秒后重试..." -ForegroundColor Yellow
+                Start-Sleep -Seconds 10
+            }
+        }
+    }
+
+    if (!$BuildSuccess) {
+        Write-Host "❌ 所有构建尝试都失败了" -ForegroundColor Red
+        Write-Host "💡 建议：" -ForegroundColor Yellow
+        Write-Host "   1. 检查网络连接"
+        Write-Host "   2. 确认 Docker Desktop 运行正常"
+        Write-Host "   3. 尝试手动清理 Docker 缓存: docker system prune"
+        exit 1
+    }
+
+    # 验证镜像构建
+    Write-Host "🔍 验证镜像..." -ForegroundColor Yellow
+    $images = docker images --format "{{.Repository}}" | Where-Object { $_ -eq $ImageName }
+    if ($images) {
+        Write-Host "✅ 镜像验证成功！" -ForegroundColor Green
+    } else {
+        Write-Host "❌ 镜像验证失败" -ForegroundColor Red
+        exit 1
+    }
+} else {
+    Write-Host "⏭️  跳过构建步骤" -ForegroundColor Yellow
+}
+
+# 提供启动选项
+Write-Host ""
+Write-Host "🚀 启动选项：" -ForegroundColor Cyan
+if ($UseCompose) {
+    Write-Host "1. 使用 docker-compose（推荐）：" -ForegroundColor White
+    Write-Host "   docker-compose -f $ComposeFile up -d" -ForegroundColor Gray
+} else {
+    Write-Host "1. 直接使用 Docker：" -ForegroundColor White
+    Write-Host "   docker run -d --name $ContainerName -p 3000:3000 -v `$(pwd)/uploads:/app/uploads -v `$(pwd)/config:/app/config:ro $ImageName" -ForegroundColor Gray
+}
+Write-Host ""
+Write-Host "📱 启动后访问：" -ForegroundColor Cyan
+Write-Host "   Web界面: http://localhost:3000/mathtype_converter_demo.html" -ForegroundColor White
+Write-Host "   健康检查: http://localhost:3000/health" -ForegroundColor White
+Write-Host ""
+Write-Host "📋 管理命令：" -ForegroundColor Cyan
+Write-Host "   查看日志: docker logs -f $ContainerName" -ForegroundColor Gray
+Write-Host "   停止容器: docker stop $ContainerName" -ForegroundColor Gray
+Write-Host "   删除容器: docker rm $ContainerName" -ForegroundColor Gray
+
+# 询问是否立即启动
+$reply = Read-Host "`n是否立即启动容器？ (y/N)"
+if ($reply -match "^[Yy]$") {
+    Write-Host "🚀 启动容器..." -ForegroundColor Yellow
+    
+    try {
+        if ($UseCompose) {
+            docker-compose -f $ComposeFile up -d
+            Write-Host "✅ 容器已启动！" -ForegroundColor Green
+            Write-Host "📊 查看状态: docker-compose -f $ComposeFile ps" -ForegroundColor Gray
+            Write-Host "📋 查看日志: docker-compose -f $ComposeFile logs -f" -ForegroundColor Gray
+        } else {
+            # 停止并删除已存在的容器
+            try { docker stop $ContainerName 2>$null } catch {}
+            try { docker rm $ContainerName 2>$null } catch {}
+            
+            # 启动新容器
+            $currentDir = Get-Location
+            docker run -d `
+                --name $ContainerName `
+                -p 3000:3000 `
+                -v "${currentDir}/uploads:/app/uploads" `
+                -v "${currentDir}/config:/app/config:ro" `
+                $ImageName
+            
+            Write-Host "✅ 容器已启动！" -ForegroundColor Green
+            Write-Host "📊 查看状态: docker ps" -ForegroundColor Gray
+            Write-Host "📋 查看日志: docker logs -f $ContainerName" -ForegroundColor Gray
+        }
+        
+        Write-Host ""
+        Write-Host "⏳ 等待服务启动..." -ForegroundColor Yellow
+        Start-Sleep -Seconds 10
+        
+        # 健康检查
+        Write-Host "🏥 执行健康检查..." -ForegroundColor Yellow
+        $healthCheckSuccess = $false
+        for ($i = 1; $i -le 6; $i++) {
+            try {
+                $response = Invoke-WebRequest -Uri "http://localhost:3000/health" -TimeoutSec 5 -UseBasicParsing
+                Write-Host "✅ 服务启动成功！" -ForegroundColor Green
+                Write-Host "🌐 请访问: http://localhost:3000/mathtype_converter_demo.html" -ForegroundColor Cyan
+                $healthCheckSuccess = $true
+                break
+            } catch {
+                if ($i -eq 6) {
+                    Write-Host "⚠️  健康检查超时，但服务可能仍在启动中" -ForegroundColor Yellow
+                    Write-Host "💡 请手动检查: Invoke-WebRequest http://localhost:3000/health" -ForegroundColor Gray
+                } else {
+                    Write-Host "⏳ 等待服务启动... ($i/6)" -ForegroundColor Yellow
+                    Start-Sleep -Seconds 5
+                }
+            }
+        }
+    } catch {
+        Write-Host "❌ 容器启动失败: $($_.Exception.Message)" -ForegroundColor Red
+        exit 1
+    }
+}
+
+Write-Host ""
+Write-Host "🎉 构建完成！" -ForegroundColor Green 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/docker-build.sh b/scripts/mathtype2mathml/docker-build.sh
new file mode 100644
index 0000000..40a321f
--- /dev/null
+++ b/scripts/mathtype2mathml/docker-build.sh
@@ -0,0 +1,96 @@
+#!/bin/bash
+
+# Docker 构建和测试脚本
+set -e
+
+echo "🐳 MathType to MathML Docker 构建脚本"
+echo "=================================="
+
+# 检查 Docker 是否安装
+if ! command -v docker &> /dev/null; then
+    echo "❌ Docker 未安装，请先安装 Docker"
+    exit 1
+fi
+
+# 检查 docker-compose 是否安装
+if ! command -v docker-compose &> /dev/null; then
+    echo "⚠️  docker-compose 未安装，将使用 docker build"
+    USE_COMPOSE=false
+else
+    USE_COMPOSE=true
+fi
+
+# 设置镜像名称
+IMAGE_NAME="mathtype-converter"
+CONTAINER_NAME="mathtype-to-mathml"
+
+echo "📦 开始构建 Docker 镜像..."
+
+if [ "$USE_COMPOSE" = true ]; then
+    echo "使用 docker-compose 构建..."
+    docker-compose build
+else
+    echo "使用 docker build 构建..."
+    docker build -t $IMAGE_NAME .
+fi
+
+echo "✅ Docker 镜像构建完成！"
+
+# 提供启动选项
+echo ""
+echo "🚀 启动选项："
+echo "1. 使用 docker-compose（推荐）："
+echo "   docker-compose up -d"
+echo ""
+echo "2. 直接使用 Docker："
+echo "   docker run -d --name $CONTAINER_NAME -p 3000:3000 -v \$(pwd)/uploads:/app/uploads $IMAGE_NAME"
+echo ""
+echo "📱 启动后访问："
+echo "   Web界面: http://localhost:3000/mathtype_converter_demo.html"
+echo "   健康检查: http://localhost:3000/health"
+echo ""
+echo "📋 管理命令："
+echo "   查看日志: docker logs -f $CONTAINER_NAME"
+echo "   停止容器: docker stop $CONTAINER_NAME"
+echo "   删除容器: docker rm $CONTAINER_NAME"
+
+# 询问是否立即启动
+read -p "是否立即启动容器？ (y/N): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo "🚀 启动容器..."
+    if [ "$USE_COMPOSE" = true ]; then
+        docker-compose up -d
+        echo "✅ 容器已启动！"
+        echo "📊 查看状态: docker-compose ps"
+        echo "📋 查看日志: docker-compose logs -f"
+    else
+        # 停止并删除已存在的容器
+        docker stop $CONTAINER_NAME 2>/dev/null || true
+        docker rm $CONTAINER_NAME 2>/dev/null || true
+        
+        # 启动新容器
+        docker run -d \
+            --name $CONTAINER_NAME \
+            -p 3000:3000 \
+            -v "$(pwd)/uploads:/app/uploads" \
+            $IMAGE_NAME
+        
+        echo "✅ 容器已启动！"
+        echo "📊 查看状态: docker ps"
+        echo "📋 查看日志: docker logs -f $CONTAINER_NAME"
+    fi
+    
+    echo ""
+    echo "⏳ 等待服务启动..."
+    sleep 5
+    
+    # 健康检查
+    echo "🏥 执行健康检查..."
+    if curl -s http://localhost:3000/health > /dev/null; then
+        echo "✅ 服务启动成功！"
+        echo "🌐 请访问: http://localhost:3000/mathtype_converter_demo.html"
+    else
+        echo "⚠️  服务可能还在启动中，请稍等片刻后再次访问"
+    fi
+fi 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/docker-compose.production.yml b/scripts/mathtype2mathml/docker-compose.production.yml
new file mode 100644
index 0000000..0c855da
--- /dev/null
+++ b/scripts/mathtype2mathml/docker-compose.production.yml
@@ -0,0 +1,29 @@
+services:
+  mathtype-converter:
+    build: .
+    container_name: mathtype-to-mathml-prod
+    ports:
+      - "3000:3000"
+    volumes:
+      # 持久化上传文件目录
+      - ./uploads:/app/uploads
+      # 挂载配置文件
+      - ./config:/app/config:ro
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.mathtype-prod.rule=Host(`mathtype.local`)"
+      - "traefik.http.services.mathtype-prod.loadbalancer.server.port=3000"
+
+networks:
+  default:
+    name: mathtype-network-prod 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/docker-compose.yml b/scripts/mathtype2mathml/docker-compose.yml
new file mode 100644
index 0000000..b68a124
--- /dev/null
+++ b/scripts/mathtype2mathml/docker-compose.yml
@@ -0,0 +1,37 @@
+services:
+  mathtype-converter:
+    build: .
+    container_name: mathtype-to-mathml
+    ports:
+      - "3000:3000"
+    volumes:
+      # 持久化上传文件目录
+      - ./uploads:/app/uploads
+      # 挂载配置文件
+      - ./config:/app/config:ro
+      # 开发模式：实时同步源代码
+      - ./server_converter.js:/app/server_converter.js
+      - ./server:/app/server
+      - ./public:/app/public
+      - ./vendor:/app/vendor
+      - ./package.json:/app/package.json
+      - ./package-lock.json:/app/package-lock.json
+      - ./entrypoint.sh:/app/entrypoint.sh
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.mathtype.rule=Host(`mathtype.local`)"
+      - "traefik.http.services.mathtype.loadbalancer.server.port=3000"
+
+networks:
+  default:
+    name: mathtype-network 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/entrypoint.sh b/scripts/mathtype2mathml/entrypoint.sh
new file mode 100644
index 0000000..25f83fb
--- /dev/null
+++ b/scripts/mathtype2mathml/entrypoint.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Starting MathType to MathML Converter..."
+
+# 检查必要的目录
+echo "📁 Checking directories..."
+mkdir -p uploads
+mkdir -p public
+mkdir -p vendor
+
+# 确保上传目录权限正确
+chmod 755 uploads
+
+# 检查 Ruby 和 gem 是否可用
+echo "💎 Checking Ruby environment..."
+ruby --version
+bundle --version
+
+# 检查关键 gem 是否安装
+echo "🔍 Verifying gem installation..."
+if ! bundle exec ruby -e "require 'mathtype_to_mathml'; puts 'mathtype_to_mathml gem loaded successfully'"; then
+    echo "❌ mathtype_to_mathml gem not found!"
+    exit 1
+fi
+
+# 检查 Node.js 环境
+echo "📦 Checking Node.js environment..."
+node --version
+npm --version
+
+# 检查关键文件是否存在
+echo "📄 Checking critical files..."
+for file in "server_converter.js" "server/converter.rb" "public/mathtype_converter_demo.html"; do
+    if [ ! -f "$file" ]; then
+        echo "❌ Critical file missing: $file"
+        exit 1
+    fi
+done
+
+echo "✅ Environment check completed successfully!"
+
+# 创建健康检查端点（如果 server_converter.js 没有的话）
+echo "🏥 Setting up health check..."
+
+# 启动应用
+echo "🎯 Starting application..."
+exec "$@" 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/install/JBY-README.md b/scripts/mathtype2mathml/install/JBY-README.md
new file mode 100644
index 0000000..926131a
--- /dev/null
+++ b/scripts/mathtype2mathml/install/JBY-README.md
@@ -0,0 +1,43 @@
+# 本地开发环境配置
+1. 安装ruby
+2. 安装依赖包
+```
+进入到jby-office-formula目录下
+bundle install
+```
+3. 测试
+```
+ruby batch_converter.rb '{"testkey":"C:\\embeddings\\oleObject1.bin"}'
+ruby batch_converter.rb '{"testkey":"/opt/embeddings/oleObject1.bin"}'
+ruby batch_converter.rb '{"testkey":"install/example.bin"}'
+```
+
+# 线上环境配置
+1. ruby环境基础镜像(bjjby-registry-vpc.cn-zhangjiakou.cr.aliyuncs.com/base/image:ruby-v1)核心命令
+安装包: install/ruby-2.6.0.tar.gz、install/gems/*
+```
+cd /opt 
+&& tar -zxf ruby-2.6.0.tar.gz 
+&& cd /opt/ruby-2.6.0 
+&& ./configure --prefix=/usr/local/ruby
+&& make -j$(nproc) 
+&& make install 
+&& export PATH=/usr/local/ruby/bin:$PATH 
+&& gem --version 
+&& unzip /opt/gems.zip -d /opt/ 
+&& gem install --local /opt/gems/one/* 
+&& gem install --local /opt/gems/two/* 
+&& make clean 
+&& rm -rf /opt/ruby/ruby-2.6.0 
+&& rm -rf /opt/gems 
+&& rm -rf /var/cache/*
+```
+2. 业务容器镜像Dockerfile
+```
+FROM bjjby-registry-vpc.cn-zhangjiakou.cr.aliyuncs.com/base/image:ruby-v1
+LABEL maintainer="chen 15662138562@163.com"
+RUN mkdir /opt/servers
+COPY jby-office-formula  /opt/servers/jby-office-formula
+ADD jby-office-file-server/target/jby-office-file-server-3.0.jar  /opt/servers/office-file.jar
+CMD ["java","-jar", "/opt/servers/office-file.jar"]
+```
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/install/example.bin b/scripts/mathtype2mathml/install/example.bin
new file mode 100644
index 0000000..c38617e
Binary files /dev/null and b/scripts/mathtype2mathml/install/example.bin differ
diff --git a/scripts/mathtype2mathml/install/gems/one/coderay-1.1.3.gem b/scripts/mathtype2mathml/install/gems/one/coderay-1.1.3.gem
new file mode 100644
index 0000000..3475820
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/one/coderay-1.1.3.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/one/method_source-1.1.0.gem b/scripts/mathtype2mathml/install/gems/one/method_source-1.1.0.gem
new file mode 100644
index 0000000..61e0210
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/one/method_source-1.1.0.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/one/racc-1.8.1.gem b/scripts/mathtype2mathml/install/gems/one/racc-1.8.1.gem
new file mode 100644
index 0000000..ad9e6bb
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/one/racc-1.8.1.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/third/parallel-1.19.2.gem b/scripts/mathtype2mathml/install/gems/third/parallel-1.19.2.gem
new file mode 100644
index 0000000..c7d5b92
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/third/parallel-1.19.2.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/bindata-2.5.1.gem b/scripts/mathtype2mathml/install/gems/two/bindata-2.5.1.gem
new file mode 100644
index 0000000..16aa27e
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/bindata-2.5.1.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/concurrent-ruby-1.3.5.gem b/scripts/mathtype2mathml/install/gems/two/concurrent-ruby-1.3.5.gem
new file mode 100644
index 0000000..1cd9f52
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/concurrent-ruby-1.3.5.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/mini_portile2-2.8.9.gem b/scripts/mathtype2mathml/install/gems/two/mini_portile2-2.8.9.gem
new file mode 100644
index 0000000..f90f71b
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/mini_portile2-2.8.9.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/nokogiri-1.13.10-x86_64-linux.gem b/scripts/mathtype2mathml/install/gems/two/nokogiri-1.13.10-x86_64-linux.gem
new file mode 100644
index 0000000..8a7f2b6
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/nokogiri-1.13.10-x86_64-linux.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/pry-0.15.2.gem b/scripts/mathtype2mathml/install/gems/two/pry-0.15.2.gem
new file mode 100644
index 0000000..24d92d9
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/pry-0.15.2.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/rake-13.3.0.gem b/scripts/mathtype2mathml/install/gems/two/rake-13.3.0.gem
new file mode 100644
index 0000000..fe11cec
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/rake-13.3.0.gem differ
diff --git a/scripts/mathtype2mathml/install/gems/two/ruby-ole-1.2.13.1.gem b/scripts/mathtype2mathml/install/gems/two/ruby-ole-1.2.13.1.gem
new file mode 100644
index 0000000..021f8d3
Binary files /dev/null and b/scripts/mathtype2mathml/install/gems/two/ruby-ole-1.2.13.1.gem differ
diff --git a/scripts/mathtype2mathml/install/ruby-2.6.0.tar.gz b/scripts/mathtype2mathml/install/ruby-2.6.0.tar.gz
new file mode 100644
index 0000000..2e373e1
Binary files /dev/null and b/scripts/mathtype2mathml/install/ruby-2.6.0.tar.gz differ
diff --git a/scripts/mathtype2mathml/package-lock.json b/scripts/mathtype2mathml/package-lock.json
new file mode 100644
index 0000000..13a93fb
--- /dev/null
+++ b/scripts/mathtype2mathml/package-lock.json
@@ -0,0 +1,1397 @@
+{
+  "name": "mathtype-to-mathml-server",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "mathtype-to-mathml-server",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "cors": "^2.8.5",
+        "express": "^4.18.2",
+        "multer": "^1.4.5-lts.1"
+      },
+      "devDependencies": {
+        "nodemon": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmmirror.com/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmmirror.com/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/append-field": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/append-field/-/append-field-1.0.0.tgz",
+      "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
+      "license": "MIT"
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmmirror.com/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmmirror.com/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmmirror.com/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "license": "MIT"
+    },
+    "node_modules/busboy": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmmirror.com/busboy/-/busboy-1.6.0.tgz",
+      "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
+      "dependencies": {
+        "streamsearch": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=10.16.0"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmmirror.com/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmmirror.com/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-stream": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmmirror.com/concat-stream/-/concat-stream-1.6.2.tgz",
+      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
+      "engines": [
+        "node >= 0.8"
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^2.2.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmmirror.com/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmmirror.com/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmmirror.com/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmmirror.com/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmmirror.com/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmmirror.com/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmmirror.com/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmmirror.com/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmmirror.com/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmmirror.com/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmmirror.com/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmmirror.com/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmmirror.com/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmmirror.com/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmmirror.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmmirror.com/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmmirror.com/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmmirror.com/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmmirror.com/mkdirp/-/mkdirp-0.5.6.tgz",
+      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/multer": {
+      "version": "1.4.5-lts.2",
+      "resolved": "https://registry.npmmirror.com/multer/-/multer-1.4.5-lts.2.tgz",
+      "integrity": "sha512-VzGiVigcG9zUAoCNU+xShztrlr1auZOlurXynNvO9GiWD1/mTBbUljOKY+qMeazBqXgRnjzeEgJI/wyjJUHg9A==",
+      "deprecated": "Multer 1.x is impacted by a number of vulnerabilities, which have been patched in 2.x. You should upgrade to the latest 2.x version.",
+      "license": "MIT",
+      "dependencies": {
+        "append-field": "^1.0.0",
+        "busboy": "^1.0.0",
+        "concat-stream": "^1.5.2",
+        "mkdirp": "^0.5.4",
+        "object-assign": "^4.1.1",
+        "type-is": "^1.6.4",
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmmirror.com/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmmirror.com/nodemon/-/nodemon-3.1.10.tgz",
+      "integrity": "sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmmirror.com/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmmirror.com/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmmirror.com/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmmirror.com/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmmirror.com/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+      "license": "MIT"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmmirror.com/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmmirror.com/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmmirror.com/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmmirror.com/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmmirror.com/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmmirror.com/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/readable-stream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmmirror.com/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmmirror.com/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmmirror.com/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmmirror.com/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/streamsearch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/streamsearch/-/streamsearch-1.1.0.tgz",
+      "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/string_decoder/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmmirror.com/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmmirror.com/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmmirror.com/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
+      "license": "MIT"
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmmirror.com/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmmirror.com/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    }
+  }
+}
diff --git a/scripts/mathtype2mathml/package.json b/scripts/mathtype2mathml/package.json
new file mode 100644
index 0000000..cd73ff1
--- /dev/null
+++ b/scripts/mathtype2mathml/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "mathtype-to-mathml-server",
+  "version": "1.0.0",
+  "description": "Server for converting MathType binary files to MathML using Ruby gem",
+  "main": "server_converter.js",
+  "scripts": {
+    "setup": "node server/setup.js",
+    "start": "node server_converter.js",
+    "dev": "nodemon server_converter.js"
+  },
+  "keywords": [
+    "mathtype",
+    "mathml",
+    "equation",
+    "converter",
+    "ruby",
+    "gem"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2",
+    "multer": "^1.4.5-lts.1",
+    "cors": "^2.8.5"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}
diff --git a/scripts/mathtype2mathml/public/mathtype_converter_demo.html b/scripts/mathtype2mathml/public/mathtype_converter_demo.html
new file mode 100644
index 0000000..20e38b3
--- /dev/null
+++ b/scripts/mathtype2mathml/public/mathtype_converter_demo.html
@@ -0,0 +1,891 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MathType to MathML Converter Demo</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        
+        .container {
+            background: white;
+            padding: 30px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        
+        h1 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 10px;
+        }
+        
+        .subtitle {
+            text-align: center;
+            color: #666;
+            margin-bottom: 30px;
+        }
+        
+        .upload-section {
+            border: 2px dashed #ddd;
+            border-radius: 8px;
+            padding: 30px;
+            text-align: center;
+            margin-bottom: 30px;
+            background-color: #fafafa;
+        }
+        
+        .upload-section:hover {
+            border-color: #007bff;
+            background-color: #f0f8ff;
+        }
+        
+        input[type="file"] {
+            margin: 10px 0;
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            background: white;
+        }
+        
+        button {
+            background-color: #007bff;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 16px;
+            margin: 10px;
+        }
+        
+        button:hover {
+            background-color: #0056b3;
+        }
+        
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+        
+        .demo-section {
+            margin: 20px 0;
+        }
+        
+        .output-section {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-top: 20px;
+        }
+        
+        .output-panel {
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            padding: 15px;
+            background-color: #f9f9f9;
+        }
+        
+        .output-panel h3 {
+            margin-top: 0;
+            color: #333;
+            border-bottom: 1px solid #ddd;
+            padding-bottom: 10px;
+        }
+        
+        .mathml-output {
+            background-color: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 4px;
+            padding: 15px;
+            font-family: 'Courier New', monospace;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            max-height: 300px;
+            overflow-y: auto;
+            font-size: 12px;
+        }
+        
+        .mathml-preview {
+            background-color: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 4px;
+            padding: 20px;
+            text-align: center;
+            min-height: 100px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 18px;
+        }
+        
+        .status {
+            padding: 10px;
+            border-radius: 4px;
+            margin: 10px 0;
+            font-weight: bold;
+        }
+        
+        .status.success {
+            background-color: #d4edda;
+            color: #155724;
+            border: 1px solid #c3e6cb;
+        }
+        
+        .status.error {
+            background-color: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+        }
+        
+        .status.info {
+            background-color: #d1ecf1;
+            color: #0c5460;
+            border: 1px solid #bee5eb;
+        }
+        
+        .debug-info {
+            background-color: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 4px;
+            padding: 15px;
+            margin-top: 15px;
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        
+        .architecture-diagram {
+            text-align: center;
+            margin: 20px 0;
+            padding: 20px;
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            font-family: monospace;
+            line-height: 1.8;
+        }
+        
+        .feature-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin: 20px 0;
+        }
+        
+        .feature-card {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 6px;
+            border-left: 4px solid #007bff;
+        }
+        
+        .feature-card h4 {
+            margin-top: 0;
+            color: #007bff;
+        }
+        
+        .batch-upload-zone {
+            border: 2px dashed #007bff;
+            border-radius: 8px;
+            padding: 30px;
+            text-align: center;
+            background-color: #f8f9fa;
+            margin: 20px 0;
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+        
+        .batch-upload-zone:hover {
+            border-color: #0056b3;
+            background-color: #e3f2fd;
+        }
+        
+        .batch-upload-zone.dragover {
+            border-color: #28a745;
+            background-color: #d4edda;
+        }
+        
+        .file-list {
+            margin-top: 15px;
+            text-align: left;
+        }
+        
+        .file-item {
+            background: white;
+            padding: 8px 12px;
+            margin: 5px 0;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            font-size: 14px;
+        }
+        
+        .file-item .remove-file {
+            color: #dc3545;
+            cursor: pointer;
+            font-weight: bold;
+        }
+        
+        .progress-container {
+            margin: 20px 0;
+            display: none;
+        }
+        
+        .progress-bar {
+            width: 100%;
+            height: 20px;
+            background-color: #e9ecef;
+            border-radius: 10px;
+            overflow: hidden;
+        }
+        
+        .progress-bar-fill {
+            height: 100%;
+            background-color: #007bff;
+            transition: width 0.3s ease;
+            width: 0%;
+        }
+        
+        .batch-results {
+            margin-top: 20px;
+            display: none;
+        }
+        
+        .result-item {
+            background: white;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            margin: 10px 0;
+            padding: 15px;
+        }
+        
+        .result-item.success {
+            border-left: 4px solid #28a745;
+        }
+        
+        .result-item.error {
+            border-left: 4px solid #dc3545;
+        }
+        
+        .result-header {
+            font-weight: bold;
+            margin-bottom: 10px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .result-mathml {
+            background-color: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 4px;
+            padding: 10px;
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+            max-height: 150px;
+            overflow-y: auto;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+        
+        @media (max-width: 768px) {
+            .output-section {
+                grid-template-columns: 1fr;
+            }
+            
+            .container {
+                padding: 15px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🧮 MathType to MathML Converter</h1>
+        <p class="subtitle">JavaScript implementation for converting MathType binary files to MathML format</p>
+        
+        <div class="architecture-diagram">
+            <strong>Conversion Pipeline:</strong><br>
+            Binary MTEF → XML Structure → Preprocessing → MathML Transform → Final Output
+        </div>
+        
+        <div class="upload-section">
+            <h3>📁 Upload Single MathType File</h3>
+            <p>Select a MathType binary file (.bin) to convert to MathML</p>
+            <div class="status info" style="margin: 10px 0; font-size: 14px;">
+                <strong>💡 For Real Conversion:</strong> Start the server with <code>npm start</code> to convert actual .bin files.<br>
+                <strong>🎮 Demo Mode:</strong> Works without server but only shows sample equation (x²).
+            </div>
+            <input type="file" id="fileInput" accept=".bin" />
+            <br>
+            <button id="convertBtn" onclick="convertFile()">Convert Real File (Server Required)</button>
+            <button id="demoBtn" onclick="runDemo()">Run Client Demo (x² Sample)</button>
+        </div>
+
+        <div class="upload-section">
+            <h3>📁 Batch Upload MathType Files</h3>
+            <p>Upload multiple MathType binary files (.bin) for batch conversion</p>
+            <div class="status info" style="margin: 10px 0; font-size: 14px;">
+                <strong>🚀 High Performance:</strong> Process multiple files in parallel using optimized batch processing.<br>
+                <strong>📊 Progress Tracking:</strong> Real-time progress updates for each file in the batch.
+            </div>
+            
+            <div class="batch-upload-zone" id="batchUploadZone" onclick="document.getElementById('batchFileInput').click()">
+                <div>
+                    <h4>🎯 Drop files here or click to select</h4>
+                    <p>Drag and drop multiple .bin files, or click to browse</p>
+                    <p style="font-size: 14px; color: #6c757d;">Supports up to 50 files per batch</p>
+                </div>
+            </div>
+            
+            <input type="file" id="batchFileInput" accept=".bin" multiple style="display: none;" />
+            
+            <div class="file-list" id="fileList" style="display: none;">
+                <h4>Selected Files:</h4>
+                <div id="fileItems"></div>
+            </div>
+            
+            <div style="margin-top: 15px;">
+                <button id="batchConvertBtn" onclick="convertBatchFiles()" style="display: none;">
+                    🚀 Convert Batch (Server Required)
+                </button>
+                <button id="clearBatchBtn" onclick="clearBatchFiles()" style="display: none; margin-left: 10px;">
+                    🗑️ Clear All
+                </button>
+            </div>
+            
+            <div class="progress-container" id="progressContainer">
+                <h4>Conversion Progress:</h4>
+                <div class="progress-bar">
+                    <div class="progress-bar-fill" id="progressBarFill"></div>
+                </div>
+                <p id="progressText">0 / 0 files processed</p>
+            </div>
+            
+            <div class="batch-results" id="batchResults">
+                <h4>Conversion Results:</h4>
+                <div id="resultItems"></div>
+            </div>
+        </div>
+        
+        <div id="status"></div>
+        
+        <div class="output-section">
+            <div class="output-panel">
+                <h3>📄 Generated MathML</h3>
+                <div id="mathmlOutput" class="mathml-output">
+                    <!-- Generated MathML will appear here -->
+                </div>
+            </div>
+            
+            <div class="output-panel">
+                <h3>🔍 MathML Preview</h3>
+                <div id="mathmlPreview" class="mathml-preview">
+                    <!-- Rendered math will appear here -->
+                </div>
+            </div>
+        </div>
+        
+        <div id="debugInfo" class="debug-info" style="display: none;">
+            <!-- Debug information will appear here -->
+        </div>
+    </div>
+    
+    <div class="container">
+        <h2>🚀 Features</h2>
+        <div class="feature-grid">
+            <div class="feature-card">
+                <h4>Multi-Stage Pipeline</h4>
+                <p>Follows the same architecture as the Ruby mathtype_to_mathml gem with binary parsing, preprocessing, and transformation stages.</p>
+            </div>
+            
+            <div class="feature-card">
+                <h4>Character Mapping</h4>
+                <p>Comprehensive Unicode character support including Greek letters, mathematical operators, and special symbols.</p>
+            </div>
+            
+            <div class="feature-card">
+                <h4>Mathematical Structures</h4>
+                <p>Supports fractions, subscripts, superscripts, roots, matrices, integrals, summations, and more.</p>
+            </div>
+            
+            <div class="feature-card">
+                <h4>Web Compatible</h4>
+                <p>Pure JavaScript implementation that works in browsers without external dependencies.</p>
+            </div>
+        </div>
+    </div>
+    
+    <div class="container">
+        <h2>⚠️ Important Notes</h2>
+        <div class="status info">
+            <strong>Binary Parsing Limitation:</strong> This demo uses a simplified MTEF parser. For production use, you would need:
+            <ul style="margin: 10px 0; padding-left: 20px;">
+                <li>A complete MTEF binary format parser</li>
+                <li>WebAssembly port of the Ruby mathtype gem</li>
+                <li>Server-side conversion with the Ruby gem</li>
+            </ul>
+        </div>
+    </div>
+
+    <!-- Include the converter script -->
+    <script src="mathtype_to_mathml_converter.js"></script>
+    
+    <script>
+        // Global converter instance
+        let converter;
+        
+        // Initialize converter when page loads
+        document.addEventListener('DOMContentLoaded', function() {
+            try {
+                converter = new MathTypeToMathMLConverter();
+                showStatus('Converter initialized successfully', 'success');
+            } catch (error) {
+                showStatus('Failed to initialize converter: ' + error.message, 'error');
+            }
+        });
+        
+        // File conversion function - uses server for real binary parsing
+        async function convertFile() {
+            const fileInput = document.getElementById('fileInput');
+            const file = fileInput.files[0];
+            
+            if (!file) {
+                showStatus('Please select a file first', 'error');
+                return;
+            }
+            
+            try {
+                showStatus('Converting file using server...', 'info');
+                setButtonsEnabled(false);
+                
+                // Show debug info about the binary data
+                showDebugInfo(`Uploading file: ${file.name} (${file.size} bytes)`);
+                
+                // Send file to server for conversion
+                const mathml = await convertFileOnServer(file);
+                
+                // Display results
+                displayResults(mathml);
+                showStatus('Server conversion completed successfully!', 'success');
+                
+            } catch (error) {
+                showStatus('Server conversion failed: ' + error.message, 'error');
+                console.error('Conversion error:', error);
+                
+                // Fallback to client-side demo
+                showStatus('Falling back to client-side demo...', 'info');
+                try {
+                    const binaryData = await loadBinaryFile(fileInput);
+                    const mathml = await converter.convert(binaryData);
+                    displayResults(mathml);
+                    showStatus('Client-side demo completed (shows sample x² only)', 'success');
+                } catch (fallbackError) {
+                    showStatus('Both server and client conversion failed', 'error');
+                }
+            } finally {
+                setButtonsEnabled(true);
+            }
+        }
+        
+        // Server-side conversion function
+        async function convertFileOnServer(file) {
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            const response = await fetch('/convert-mathtype', {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || `Server error: ${response.status}`);
+            }
+            
+            const result = await response.json();
+            
+            if (!result.success) {
+                throw new Error(result.error || 'Conversion failed');
+            }
+            
+            return result.mathml;
+        }
+        
+        // Demo function with sample data
+        async function runDemo() {
+            if (!converter) {
+                showStatus('Converter not initialized', 'error');
+                return;
+            }
+            
+            try {
+                showStatus('Running demo with sample equation (x²)...', 'info');
+                setButtonsEnabled(false);
+                
+                // Create sample binary data (this would normally be read from a .bin file)
+                const sampleData = new Uint8Array([0x01, 0x02, 0x03, 0x04]); // Placeholder binary data
+                
+                showDebugInfo('Demo using simulated binary data for equation: x²');
+                
+                // Convert using the sample data
+                const mathml = await converter.convert(sampleData);
+                
+                // Display results
+                displayResults(mathml);
+                showStatus('Demo completed successfully!', 'success');
+                
+            } catch (error) {
+                showStatus('Demo failed: ' + error.message, 'error');
+                console.error('Demo error:', error);
+            } finally {
+                setButtonsEnabled(true);
+            }
+        }
+        
+        // Display conversion results
+        function displayResults(mathml) {
+            // Show raw MathML
+            document.getElementById('mathmlOutput').textContent = mathml;
+            
+            // Try to render MathML preview
+            const previewDiv = document.getElementById('mathmlPreview');
+            try {
+                previewDiv.innerHTML = mathml;
+                
+                // If MathJax is available, re-render
+                if (window.MathJax && window.MathJax.typesetPromise) {
+                    MathJax.typesetPromise([previewDiv]).catch((err) => {
+                        console.warn('MathJax rendering failed:', err);
+                    });
+                }
+            } catch (error) {
+                previewDiv.innerHTML = '<em>Preview not available (MathML not supported in this browser)</em>';
+            }
+        }
+        
+        // Show status message
+        function showStatus(message, type = 'info') {
+            const statusDiv = document.getElementById('status');
+            statusDiv.innerHTML = `<div class="status ${type}">${message}</div>`;
+            
+            // Auto-hide success/info messages after 5 seconds
+            if (type === 'success' || type === 'info') {
+                setTimeout(() => {
+                    statusDiv.innerHTML = '';
+                }, 5000);
+            }
+        }
+        
+        // Show debug information
+        function showDebugInfo(info) {
+            const debugDiv = document.getElementById('debugInfo');
+            debugDiv.style.display = 'block';
+            debugDiv.textContent = info;
+        }
+        
+        // Enable/disable buttons
+        function setButtonsEnabled(enabled) {
+            document.getElementById('convertBtn').disabled = !enabled;
+            document.getElementById('demoBtn').disabled = !enabled;
+        }
+
+        // Batch processing variables
+        let batchFiles = [];
+
+        // Initialize batch upload functionality
+        document.addEventListener('DOMContentLoaded', function() {
+            const batchUploadZone = document.getElementById('batchUploadZone');
+            const batchFileInput = document.getElementById('batchFileInput');
+
+            // File input change handler
+            batchFileInput.addEventListener('change', function(e) {
+                handleBatchFiles(Array.from(e.target.files));
+            });
+
+            // Drag and drop handlers for batch upload
+            batchUploadZone.addEventListener('dragover', function(e) {
+                e.preventDefault();
+                batchUploadZone.classList.add('dragover');
+            });
+
+            batchUploadZone.addEventListener('dragleave', function(e) {
+                e.preventDefault();
+                batchUploadZone.classList.remove('dragover');
+            });
+
+            batchUploadZone.addEventListener('drop', function(e) {
+                e.preventDefault();
+                batchUploadZone.classList.remove('dragover');
+                
+                const files = Array.from(e.dataTransfer.files).filter(file => 
+                    file.name.toLowerCase().endsWith('.bin')
+                );
+                
+                if (files.length > 0) {
+                    handleBatchFiles(files);
+                } else {
+                    showStatus('No valid .bin files found in the dropped files', 'error');
+                }
+            });
+        });
+
+        // Handle batch file selection
+        function handleBatchFiles(files) {
+            // Filter for .bin files and check for duplicates
+            const validFiles = files.filter(file => {
+                if (!file.name.toLowerCase().endsWith('.bin')) {
+                    return false;
+                }
+                // Check for duplicates
+                return !batchFiles.some(existing => 
+                    existing.name === file.name && existing.size === file.size
+                );
+            });
+
+            if (validFiles.length === 0) {
+                showStatus('No new valid .bin files to add', 'error');
+                return;
+            }
+
+            // Check total file limit
+            if (batchFiles.length + validFiles.length > 50) {
+                showStatus('Maximum 50 files allowed per batch', 'error');
+                return;
+            }
+
+            // Add files to batch
+            batchFiles.push(...validFiles);
+            updateFileList();
+            showStatus(`Added ${validFiles.length} file(s) to batch (${batchFiles.length} total)`, 'success');
+        }
+
+        // Update file list display
+        function updateFileList() {
+            const fileList = document.getElementById('fileList');
+            const fileItems = document.getElementById('fileItems');
+            const batchConvertBtn = document.getElementById('batchConvertBtn');
+            const clearBatchBtn = document.getElementById('clearBatchBtn');
+
+            if (batchFiles.length === 0) {
+                fileList.style.display = 'none';
+                batchConvertBtn.style.display = 'none';
+                clearBatchBtn.style.display = 'none';
+                return;
+            }
+
+            fileList.style.display = 'block';
+            batchConvertBtn.style.display = 'inline-block';
+            clearBatchBtn.style.display = 'inline-block';
+
+            fileItems.innerHTML = batchFiles.map((file, index) => `
+                <div class="file-item">
+                    <span>${file.name} (${formatFileSize(file.size)})</span>
+                    <span class="remove-file" onclick="removeFile(${index})">✕</span>
+                </div>
+            `).join('');
+        }
+
+        // Remove file from batch
+        function removeFile(index) {
+            batchFiles.splice(index, 1);
+            updateFileList();
+            showStatus('File removed from batch', 'info');
+        }
+
+        // Clear all batch files
+        function clearBatchFiles() {
+            batchFiles = [];
+            updateFileList();
+            document.getElementById('progressContainer').style.display = 'none';
+            document.getElementById('batchResults').style.display = 'none';
+            showStatus('Batch cleared', 'info');
+        }
+
+        // Convert batch files
+        async function convertBatchFiles() {
+            if (batchFiles.length === 0) {
+                showStatus('No files selected for batch conversion', 'error');
+                return;
+            }
+
+            try {
+                showStatus(`Starting batch conversion of ${batchFiles.length} files...`, 'info');
+                
+                // Show progress container
+                const progressContainer = document.getElementById('progressContainer');
+                const progressBarFill = document.getElementById('progressBarFill');
+                const progressText = document.getElementById('progressText');
+                const batchResults = document.getElementById('batchResults');
+                const resultItems = document.getElementById('resultItems');
+                
+                progressContainer.style.display = 'block';
+                batchResults.style.display = 'block';
+                resultItems.innerHTML = '';
+                
+                // Update progress
+                progressBarFill.style.width = '0%';
+                progressText.textContent = `0 / ${batchFiles.length} files processed`;
+                
+                // Disable buttons
+                document.getElementById('batchConvertBtn').disabled = true;
+                document.getElementById('clearBatchBtn').disabled = true;
+
+                // Send files to server for batch conversion
+                const results = await convertBatchOnServer(batchFiles);
+                
+                // Update progress to 100%
+                progressBarFill.style.width = '100%';
+                progressText.textContent = `${batchFiles.length} / ${batchFiles.length} files processed`;
+                
+                // Display results
+                displayBatchResults(results);
+                
+                const successCount = results.results.filter(r => r.success).length;
+                const failCount = results.results.length - successCount;
+                
+                showStatus(
+                    `Batch conversion completed! ${successCount} successful, ${failCount} failed`, 
+                    failCount === 0 ? 'success' : 'info'
+                );
+                
+            } catch (error) {
+                showStatus('Batch conversion failed: ' + error.message, 'error');
+                console.error('Batch conversion error:', error);
+            } finally {
+                // Re-enable buttons
+                document.getElementById('batchConvertBtn').disabled = false;
+                document.getElementById('clearBatchBtn').disabled = false;
+            }
+        }
+
+        // Server-side batch conversion function
+        async function convertBatchOnServer(files) {
+            const formData = new FormData();
+            
+            // Append all files
+            files.forEach(file => {
+                formData.append('files', file);
+            });
+            
+            const response = await fetch('/convert-mathtype-batch', {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || `Server error: ${response.status}`);
+            }
+            
+            const result = await response.json();
+            
+            if (!result.success) {
+                throw new Error(result.error || 'Batch conversion failed');
+            }
+            
+            return result;
+        }
+
+        // Display batch conversion results
+        function displayBatchResults(results) {
+            const resultItems = document.getElementById('resultItems');
+            
+            resultItems.innerHTML = results.results.map((result, index) => {
+                const statusClass = result.success ? 'success' : 'error';
+                const statusIcon = result.success ? '✅' : '❌';
+                
+                return `
+                    <div class="result-item ${statusClass}">
+                        <div class="result-header">
+                            <span>${statusIcon} ${result.originalName}</span>
+                            <span>${result.success ? 'Success' : 'Failed'}</span>
+                        </div>
+                        ${result.error ? `<div style="color: #dc3545; margin-bottom: 10px;">Error: ${result.error}</div>` : ''}
+                        ${result.success && result.mathml ? `
+                            <div class="result-mathml">${result.mathml}</div>
+                            <button onclick="copyToClipboard('${escapeHtml(result.mathml)}')" style="margin-top: 10px;">
+                                📋 Copy MathML
+                            </button>
+                        ` : ''}
+                    </div>
+                `;
+            }).join('');
+        }
+
+        // Helper functions
+        function formatFileSize(bytes) {
+            if (bytes === 0) return '0 Bytes';
+            const k = 1024;
+            const sizes = ['Bytes', 'KB', 'MB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+        }
+
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML.replace(/'/g, '&apos;');
+        }
+
+        function copyToClipboard(text) {
+            navigator.clipboard.writeText(text.replace(/&apos;/g, "'")).then(() => {
+                showStatus('MathML copied to clipboard', 'success');
+            }).catch(err => {
+                console.error('Failed to copy: ', err);
+                showStatus('Failed to copy to clipboard', 'error');
+            });
+        }
+        
+        // File drop functionality
+        const uploadSection = document.querySelector('.upload-section');
+        
+        uploadSection.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadSection.style.borderColor = '#007bff';
+            uploadSection.style.backgroundColor = '#f0f8ff';
+        });
+        
+        uploadSection.addEventListener('dragleave', (e) => {
+            e.preventDefault();
+            uploadSection.style.borderColor = '#ddd';
+            uploadSection.style.backgroundColor = '#fafafa';
+        });
+        
+        uploadSection.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadSection.style.borderColor = '#ddd';
+            uploadSection.style.backgroundColor = '#fafafa';
+            
+            const files = e.dataTransfer.files;
+            if (files.length > 0) {
+                document.getElementById('fileInput').files = files;
+                showStatus('File dropped successfully: ' + files[0].name, 'success');
+            }
+        });
+    </script>
+    
+    <!-- Optional: Include MathJax for better MathML rendering -->
+    <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/mml-chtml.js"></script>
+    <script>
+        window.MathJax = {
+            startup: {
+                ready: () => {
+                    console.log('MathJax is loaded and ready');
+                    MathJax.startup.defaultReady();
+                }
+            }
+        };
+    </script>
+</body>
+</html> 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/public/mathtype_to_mathml_converter.js b/scripts/mathtype2mathml/public/mathtype_to_mathml_converter.js
new file mode 100644
index 0000000..3730c53
--- /dev/null
+++ b/scripts/mathtype2mathml/public/mathtype_to_mathml_converter.js
@@ -0,0 +1,766 @@
+/**
+ * MathType to MathML Converter (JavaScript Implementation)
+ * 
+ * This JavaScript implementation follows the same architectural principles
+ * as the Ruby mathtype_to_mathml gem, providing a multi-stage conversion
+ * pipeline from MathType binary format to MathML.
+ * 
+ * Architecture:
+ * Binary MTEF → XML Structure → Preprocessing → XSLT-like Transform → MathML
+ */
+
+class MathTypeToMathMLConverter {
+    constructor() {
+        this.characterReplacer = new CharacterReplacer();
+        this.mover = new ElementMover();
+        this.transformer = new MathMLTransformer();
+    }
+
+    /**
+     * Convert MathType binary data to MathML
+     * @param {ArrayBuffer|Uint8Array} binaryData - MathType binary data
+     * @returns {Promise<string>} MathML string
+     */
+    async convert(binaryData) {
+        try {
+            // Stage 1: Parse binary MTEF to XML structure
+            const xmlStructure = await this.parseBinaryMTEF(binaryData);
+            
+            // Stage 2: Preprocessing
+            this.mover.restructureElements(xmlStructure);
+            this.characterReplacer.replaceCharacters(xmlStructure);
+            
+            // Stage 3: Transform to MathML
+            const mathml = this.transformer.transformToMathML(xmlStructure);
+            
+            // Stage 4: Cleanup and namespace handling
+            return this.finalizeMathML(mathml);
+        } catch (error) {
+            throw new Error(`MathType conversion failed: ${error.message}`);
+        }
+    }
+
+    /**
+     * Parse binary MTEF data to XML-like structure
+     * Note: This is a simplified implementation. In practice, you would need
+     * a full MTEF parser or use a WebAssembly port of the mathtype gem.
+     */
+    async parseBinaryMTEF(binaryData) {
+        // For demo purposes, we'll simulate the XML structure
+        // In a real implementation, this would parse the actual MTEF binary format
+        
+        if (binaryData instanceof ArrayBuffer) {
+            binaryData = new Uint8Array(binaryData);
+        }
+
+        // Placeholder: In reality, this would parse the binary MTEF format
+        // You could use a WebAssembly port of the Ruby mathtype gem
+        // or implement a native JavaScript MTEF parser
+        
+        return this.createSampleXMLStructure();
+    }
+
+    /**
+     * Create a sample XML structure for demonstration
+     * This would be replaced by actual MTEF parsing
+     */
+    createSampleXMLStructure() {
+        return {
+            type: 'mtef',
+            equation_options: 'inline',
+            children: [
+                {
+                    type: 'slot',
+                    children: [
+                        {
+                            type: 'char',
+                            mt_code_value: '0x0078', // 'x'
+                            typeface: '1'
+                        },
+                        {
+                            type: 'tmpl',
+                            selector: 'tmSUP',
+                            children: [
+                                {
+                                    type: 'slot',
+                                    children: [
+                                        {
+                                            type: 'char',
+                                            mt_code_value: '0x0032', // '2'
+                                            typeface: '2'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+
+    /**
+     * Finalize MathML output with proper namespace
+     */
+    finalizeMathML(mathmlContent) {
+        return `<math xmlns="http://www.w3.org/1998/Math/MathML">${mathmlContent}</math>`;
+    }
+}
+
+/**
+ * Character Replacement Module
+ * Handles Unicode character conversion and mathematical symbol mapping
+ */
+class CharacterReplacer {
+    constructor() {
+        this.replacements = this.initializeReplacements();
+    }
+
+    /**
+     * Initialize character replacement mappings
+     * Based on the Ruby CharReplacer class
+     */
+    initializeReplacements() {
+        return {
+            // Basic Latin digits
+            '0x0030': { mathmode: '<mn>0</mn>', textmode: '0' },
+            '0x0031': { mathmode: '<mn>1</mn>', textmode: '1' },
+            '0x0032': { mathmode: '<mn>2</mn>', textmode: '2' },
+            '0x0033': { mathmode: '<mn>3</mn>', textmode: '3' },
+            '0x0034': { mathmode: '<mn>4</mn>', textmode: '4' },
+            '0x0035': { mathmode: '<mn>5</mn>', textmode: '5' },
+            '0x0036': { mathmode: '<mn>6</mn>', textmode: '6' },
+            '0x0037': { mathmode: '<mn>7</mn>', textmode: '7' },
+            '0x0038': { mathmode: '<mn>8</mn>', textmode: '8' },
+            '0x0039': { mathmode: '<mn>9</mn>', textmode: '9' },
+            
+            // Basic Latin letters (uppercase)
+            '0x0041': { mathmode: '<mi>A</mi>', textmode: 'A' },
+            '0x0042': { mathmode: '<mi>B</mi>', textmode: 'B' },
+            '0x0043': { mathmode: '<mi>C</mi>', textmode: 'C' },
+            '0x0044': { mathmode: '<mi>D</mi>', textmode: 'D' },
+            '0x0045': { mathmode: '<mi>E</mi>', textmode: 'E' },
+            '0x0046': { mathmode: '<mi>F</mi>', textmode: 'F' },
+            
+            // Basic Latin letters (lowercase)
+            '0x0061': { mathmode: '<mi>a</mi>', textmode: 'a' },
+            '0x0062': { mathmode: '<mi>b</mi>', textmode: 'b' },
+            '0x0063': { mathmode: '<mi>c</mi>', textmode: 'c' },
+            '0x0064': { mathmode: '<mi>d</mi>', textmode: 'd' },
+            '0x0065': { mathmode: '<mi>e</mi>', textmode: 'e' },
+            '0x0066': { mathmode: '<mi>f</mi>', textmode: 'f' },
+            '0x0067': { mathmode: '<mi>g</mi>', textmode: 'g' },
+            '0x0068': { mathmode: '<mi>h</mi>', textmode: 'h' },
+            '0x0069': { mathmode: '<mi>i</mi>', textmode: 'i' },
+            '0x006A': { mathmode: '<mi>j</mi>', textmode: 'j' },
+            '0x006B': { mathmode: '<mi>k</mi>', textmode: 'k' },
+            '0x006C': { mathmode: '<mi>l</mi>', textmode: 'l' },
+            '0x006D': { mathmode: '<mi>m</mi>', textmode: 'm' },
+            '0x006E': { mathmode: '<mi>n</mi>', textmode: 'n' },
+            '0x006F': { mathmode: '<mi>o</mi>', textmode: 'o' },
+            '0x0070': { mathmode: '<mi>p</mi>', textmode: 'p' },
+            '0x0071': { mathmode: '<mi>q</mi>', textmode: 'q' },
+            '0x0072': { mathmode: '<mi>r</mi>', textmode: 'r' },
+            '0x0073': { mathmode: '<mi>s</mi>', textmode: 's' },
+            '0x0074': { mathmode: '<mi>t</mi>', textmode: 't' },
+            '0x0075': { mathmode: '<mi>u</mi>', textmode: 'u' },
+            '0x0076': { mathmode: '<mi>v</mi>', textmode: 'v' },
+            '0x0077': { mathmode: '<mi>w</mi>', textmode: 'w' },
+            '0x0078': { mathmode: '<mi>x</mi>', textmode: 'x' },
+            '0x0079': { mathmode: '<mi>y</mi>', textmode: 'y' },
+            '0x007A': { mathmode: '<mi>z</mi>', textmode: 'z' },
+            
+            // Mathematical operators
+            '0x002B': { mathmode: '<mo>+</mo>', textmode: '+' },
+            '0x002D': { mathmode: '<mo>-</mo>', textmode: '-' },
+            '0x002A': { mathmode: '<mo>*</mo>', textmode: '*' },
+            '0x002F': { mathmode: '<mo>/</mo>', textmode: '/' },
+            '0x003D': { mathmode: '<mo>=</mo>', textmode: '=' },
+            '0x003C': { mathmode: '<mo>&lt;</mo>', textmode: '<' },
+            '0x003E': { mathmode: '<mo>&gt;</mo>', textmode: '>' },
+            
+            // Parentheses and brackets
+            '0x0028': { mathmode: '<mo stretchy="false">(</mo>', textmode: '(' },
+            '0x0029': { mathmode: '<mo stretchy="false">)</mo>', textmode: ')' },
+            '0x005B': { mathmode: '<mo stretchy="false">[</mo>', textmode: '[' },
+            '0x005D': { mathmode: '<mo stretchy="false">]</mo>', textmode: ']' },
+            '0x007B': { mathmode: '<mo>{</mo>', textmode: '{' },
+            '0x007D': { mathmode: '<mo>}</mo>', textmode: '}' },
+            
+            // Greek letters (common mathematical symbols)
+            '0x03B1': { mathmode: '<mi>α</mi>', textmode: 'α' }, // alpha
+            '0x03B2': { mathmode: '<mi>β</mi>', textmode: 'β' }, // beta
+            '0x03B3': { mathmode: '<mi>γ</mi>', textmode: 'γ' }, // gamma
+            '0x03B4': { mathmode: '<mi>δ</mi>', textmode: 'δ' }, // delta
+            '0x03B5': { mathmode: '<mi>ε</mi>', textmode: 'ε' }, // epsilon
+            '0x03B8': { mathmode: '<mi>θ</mi>', textmode: 'θ' }, // theta
+            '0x03BB': { mathmode: '<mi>λ</mi>', textmode: 'λ' }, // lambda
+            '0x03BC': { mathmode: '<mi>μ</mi>', textmode: 'μ' }, // mu
+            '0x03C0': { mathmode: '<mi>π</mi>', textmode: 'π' }, // pi
+            '0x03C3': { mathmode: '<mi>σ</mi>', textmode: 'σ' }, // sigma
+            '0x03C4': { mathmode: '<mi>τ</mi>', textmode: 'τ' }, // tau
+            '0x03C6': { mathmode: '<mi>φ</mi>', textmode: 'φ' }, // phi
+            '0x03C7': { mathmode: '<mi>χ</mi>', textmode: 'χ' }, // chi
+            '0x03C8': { mathmode: '<mi>ψ</mi>', textmode: 'ψ' }, // psi
+            '0x03C9': { mathmode: '<mi>ω</mi>', textmode: 'ω' }, // omega
+            
+            // Mathematical symbols
+            '0x221E': { mathmode: '<mo>∞</mo>', textmode: '∞' }, // infinity
+            '0x2211': { mathmode: '<mo>∑</mo>', textmode: '∑' }, // summation
+            '0x222B': { mathmode: '<mo>∫</mo>', textmode: '∫' }, // integral
+            '0x2206': { mathmode: '<mo>∆</mo>', textmode: '∆' }, // delta
+            '0x2207': { mathmode: '<mo>∇</mo>', textmode: '∇' }, // nabla
+            '0x2208': { mathmode: '<mo>∈</mo>', textmode: '∈' }, // element of
+            '0x2209': { mathmode: '<mo>∉</mo>', textmode: '∉' }, // not element of
+            '0x220B': { mathmode: '<mo>∋</mo>', textmode: '∋' }, // contains
+            '0x2260': { mathmode: '<mo>≠</mo>', textmode: '≠' }, // not equal
+            '0x2264': { mathmode: '<mo>≤</mo>', textmode: '≤' }, // less than or equal
+            '0x2265': { mathmode: '<mo>≥</mo>', textmode: '≥' }, // greater than or equal
+            '0x00B1': { mathmode: '<mo>±</mo>', textmode: '±' }, // plus-minus
+            '0x00D7': { mathmode: '<mo>×</mo>', textmode: '×' }, // multiplication
+            '0x00F7': { mathmode: '<mo>÷</mo>', textmode: '÷' }, // division
+        };
+    }
+
+    /**
+     * Replace characters in the XML structure
+     */
+    replaceCharacters(xmlStructure) {
+        this.traverseAndReplace(xmlStructure);
+    }
+
+    /**
+     * Recursively traverse and replace characters
+     */
+    traverseAndReplace(node) {
+        if (node.type === 'char') {
+            const replacement = this.getCharacterReplacement(node);
+            if (replacement) {
+                node.mathml = replacement;
+            }
+        }
+        
+        if (node.children) {
+            node.children.forEach(child => this.traverseAndReplace(child));
+        }
+    }
+
+    /**
+     * Get character replacement based on mt_code_value
+     */
+    getCharacterReplacement(charNode) {
+        const codeValue = charNode.mt_code_value;
+        const isTextMode = charNode.variation === 'textmode';
+        const replacement = this.replacements[codeValue];
+        
+        if (!replacement) {
+            // Handle character ranges
+            return this.handleCharacterRange(codeValue, isTextMode);
+        }
+        
+        return isTextMode ? replacement.textmode : replacement.mathmode;
+    }
+
+    /**
+     * Handle character ranges for undefined individual characters
+     */
+    handleCharacterRange(codeValue, isTextMode) {
+        const codeNum = parseInt(codeValue, 16);
+        
+        // Numbers (0-9)
+        if (codeNum >= 0x0030 && codeNum <= 0x0039) {
+            const char = String.fromCharCode(codeNum);
+            return isTextMode ? char : `<mn>${char}</mn>`;
+        }
+        
+        // Uppercase letters (A-Z)
+        if (codeNum >= 0x0041 && codeNum <= 0x005A) {
+            const char = String.fromCharCode(codeNum);
+            return isTextMode ? char : `<mi>${char}</mi>`;
+        }
+        
+        // Lowercase letters (a-z)
+        if (codeNum >= 0x0061 && codeNum <= 0x007A) {
+            const char = String.fromCharCode(codeNum);
+            return isTextMode ? char : `<mi>${char}</mi>`;
+        }
+        
+        // Mathematical operators range
+        if (codeNum >= 0x2200 && codeNum <= 0x22FF) {
+            const char = String.fromCharCode(codeNum);
+            return isTextMode ? char : `<mo>${char}</mo>`;
+        }
+        
+        // Default fallback
+        try {
+            const char = String.fromCharCode(codeNum);
+            return isTextMode ? char : `<mi>${char}</mi>`;
+        } catch (e) {
+            return 'Unsupported character';
+        }
+    }
+}
+
+/**
+ * Element Mover Module
+ * Handles structural reorganization for subscripts/superscripts
+ */
+class ElementMover {
+    constructor() {
+        this.subscriptSelectors = ['tmSUP', 'tmSUB', 'tmSUBSUP'];
+        this.parenthesesPairs = {
+            '0x0028': '0x0029', // ( )
+            '0x005B': '0x005D', // [ ]
+            '0x007B': '0x007D', // { }
+        };
+    }
+
+    /**
+     * Restructure elements to handle MathType vs MathML differences
+     */
+    restructureElements(xmlStructure) {
+        this.moveSubscriptsAndSuperscripts(xmlStructure);
+        this.invertEmbellishments(xmlStructure);
+    }
+
+    /**
+     * Move base elements into subscript/superscript containers
+     */
+    moveSubscriptsAndSuperscripts(node) {
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                const child = node.children[i];
+                
+                if (child.type === 'tmpl' && this.subscriptSelectors.includes(child.selector)) {
+                    // Find preceding element(s) to use as base
+                    const baseElements = this.findBaseElements(node.children, i);
+                    if (baseElements.length > 0) {
+                        // Create new slot for base elements
+                        const baseSlot = {
+                            type: 'slot',
+                            children: baseElements
+                        };
+                        
+                        // Insert base slot as first child of template
+                        child.children = child.children || [];
+                        child.children.unshift(baseSlot);
+                        
+                        // Remove base elements from original position
+                        baseElements.forEach(elem => {
+                            const index = node.children.indexOf(elem);
+                            if (index > -1) {
+                                node.children.splice(index, 1);
+                                if (index < i) i--; // Adjust loop index
+                            }
+                        });
+                    }
+                }
+                
+                // Recursively process children
+                this.moveSubscriptsAndSuperscripts(child);
+            }
+        }
+    }
+
+    /**
+     * Find base elements for subscript/superscript
+     */
+    findBaseElements(siblings, templateIndex) {
+        const baseElements = [];
+        
+        // Look for preceding elements
+        for (let i = templateIndex - 1; i >= 0; i--) {
+            const sibling = siblings[i];
+            
+            // For simple cases, take the immediately preceding element
+            if (sibling.type === 'char' || 
+                (sibling.type === 'tmpl' && !this.subscriptSelectors.includes(sibling.selector))) {
+                baseElements.unshift(sibling);
+                break;
+            }
+        }
+        
+        return baseElements;
+    }
+
+    /**
+     * Invert embellishment structures: char[embell] -> embell[char]
+     */
+    invertEmbellishments(node) {
+        if (node.type === 'char' && node.embellishment) {
+            // Move char content into embellishment
+            const embellishment = node.embellishment;
+            embellishment.children = embellishment.children || [];
+            embellishment.children.push({
+                type: 'char',
+                mt_code_value: node.mt_code_value,
+                typeface: node.typeface
+            });
+            
+            // Replace char node with embellishment
+            Object.keys(node).forEach(key => delete node[key]);
+            Object.assign(node, embellishment);
+        }
+        
+        if (node.children) {
+            node.children.forEach(child => this.invertEmbellishments(child));
+        }
+    }
+}
+
+/**
+ * MathML Transformer Module
+ * Converts preprocessed XML structure to MathML
+ */
+class MathMLTransformer {
+    constructor() {
+        this.templateHandlers = this.initializeTemplateHandlers();
+    }
+
+    /**
+     * Initialize template transformation handlers
+     */
+    initializeTemplateHandlers() {
+        return {
+            // Fractions
+            'tmFRACT': (node) => this.handleFraction(node),
+            
+            // Subscripts and superscripts
+            'tmSUP': (node) => this.handleSuperscript(node),
+            'tmSUB': (node) => this.handleSubscript(node),
+            'tmSUBSUP': (node) => this.handleSubSuperscript(node),
+            
+            // Roots
+            'tmROOT': (node) => this.handleRoot(node),
+            'tmSQRT': (node) => this.handleSquareRoot(node),
+            
+            // Large operators
+            'tmSUM': (node) => this.handleSummation(node),
+            'tmINT': (node) => this.handleIntegral(node),
+            
+            // Matrices
+            'tmMATRIX': (node) => this.handleMatrix(node),
+            
+            // Fences (parentheses, brackets)
+            'tmPARENS': (node) => this.handleParentheses(node),
+            'tmBRACK': (node) => this.handleBrackets(node),
+            'tmBRACE': (node) => this.handleBraces(node),
+        };
+    }
+
+    /**
+     * Transform XML structure to MathML
+     */
+    transformToMathML(xmlStructure) {
+        return this.processNode(xmlStructure);
+    }
+
+    /**
+     * Process a single node
+     */
+    processNode(node) {
+        switch (node.type) {
+            case 'mtef':
+                return this.processMTEF(node);
+            case 'slot':
+                return this.processSlot(node);
+            case 'char':
+                return this.processCharacter(node);
+            case 'tmpl':
+                return this.processTemplate(node);
+            default:
+                return this.processChildren(node);
+        }
+    }
+
+    /**
+     * Process MTEF root node
+     */
+    processMTEF(node) {
+        const content = this.processChildren(node);
+        const displayMode = node.equation_options === 'block' ? ' display="block"' : '';
+        return content; // Math wrapper added in finalizeMathML
+    }
+
+    /**
+     * Process slot (grouping) node
+     */
+    processSlot(node) {
+        const content = this.processChildren(node);
+        return content ? `<mrow>${content}</mrow>` : '';
+    }
+
+    /**
+     * Process character node
+     */
+    processCharacter(node) {
+        return node.mathml || `<mi>${String.fromCharCode(parseInt(node.mt_code_value, 16))}</mi>`;
+    }
+
+    /**
+     * Process template node
+     */
+    processTemplate(node) {
+        const handler = this.templateHandlers[node.selector];
+        if (handler) {
+            return handler(node);
+        }
+        
+        // Default processing for unknown templates
+        return this.processChildren(node);
+    }
+
+    /**
+     * Process children nodes
+     */
+    processChildren(node) {
+        if (!node.children || node.children.length === 0) {
+            return '';
+        }
+        
+        return node.children
+            .map(child => this.processNode(child))
+            .filter(result => result !== '')
+            .join('');
+    }
+
+    // Template handlers
+
+    /**
+     * Handle fraction templates
+     */
+    handleFraction(node) {
+        const children = node.children || [];
+        const numerator = children[0] ? this.processNode(children[0]) : '';
+        const denominator = children[1] ? this.processNode(children[1]) : '';
+        
+        if (node.variation === 'tvFR_SLASH') {
+            return `<mfrac bevelled="true">${numerator}${denominator}</mfrac>`;
+        } else if (node.variation === 'tvFR_SMALL') {
+            return `<mstyle scriptlevel="+1"><mfrac>${numerator}${denominator}</mfrac></mstyle>`;
+        } else {
+            return `<mfrac>${numerator}${denominator}</mfrac>`;
+        }
+    }
+
+    /**
+     * Handle superscript templates
+     */
+    handleSuperscript(node) {
+        const children = node.children || [];
+        const base = children[0] ? this.processNode(children[0]) : '';
+        const superscript = children[1] ? this.processNode(children[1]) : '';
+        
+        if (node.variation === 'tvSU_PRECEDES') {
+            return `<mmultiscripts>${base}<mprescripts/><none/>${superscript}</mmultiscripts>`;
+        } else {
+            return `<msup>${base}${superscript}</msup>`;
+        }
+    }
+
+    /**
+     * Handle subscript templates
+     */
+    handleSubscript(node) {
+        const children = node.children || [];
+        const base = children[0] ? this.processNode(children[0]) : '';
+        const subscript = children[1] ? this.processNode(children[1]) : '';
+        
+        if (node.variation === 'tvSU_PRECEDES') {
+            return `<mmultiscripts>${base}<mprescripts/>${subscript}<none/></mmultiscripts>`;
+        } else {
+            return `<msub>${base}${subscript}</msub>`;
+        }
+    }
+
+    /**
+     * Handle combined subscript-superscript templates
+     */
+    handleSubSuperscript(node) {
+        const children = node.children || [];
+        const base = children[0] ? this.processNode(children[0]) : '';
+        const subscript = children[1] ? this.processNode(children[1]) : '';
+        const superscript = children[2] ? this.processNode(children[2]) : '';
+        
+        if (node.variation === 'tvSU_PRECEDES') {
+            return `<mmultiscripts>${base}<mprescripts/>${subscript}${superscript}</mmultiscripts>`;
+        } else {
+            return `<msubsup>${base}${subscript}${superscript}</msubsup>`;
+        }
+    }
+
+    /**
+     * Handle square root templates
+     */
+    handleSquareRoot(node) {
+        const children = node.children || [];
+        const content = children[0] ? this.processNode(children[0]) : '';
+        return `<msqrt>${content}</msqrt>`;
+    }
+
+    /**
+     * Handle nth root templates
+     */
+    handleRoot(node) {
+        const children = node.children || [];
+        const radicand = children[0] ? this.processNode(children[0]) : '';
+        const index = children[1] ? this.processNode(children[1]) : '';
+        return `<mroot>${radicand}${index}</mroot>`;
+    }
+
+    /**
+     * Handle summation templates
+     */
+    handleSummation(node) {
+        const children = node.children || [];
+        const base = '<mo>∑</mo>';
+        
+        if (children.length === 1) {
+            return `<mrow>${base}${this.processNode(children[0])}</mrow>`;
+        } else if (children.length === 2) {
+            return `<munder>${base}${this.processNode(children[0])}</munder>`;
+        } else if (children.length === 3) {
+            return `<munderover>${base}${this.processNode(children[1])}${this.processNode(children[2])}</munderover>`;
+        }
+        
+        return base;
+    }
+
+    /**
+     * Handle integral templates
+     */
+    handleIntegral(node) {
+        const children = node.children || [];
+        const base = '<mo>∫</mo>';
+        
+        if (children.length === 1) {
+            return `<mrow>${base}${this.processNode(children[0])}</mrow>`;
+        } else if (children.length === 2) {
+            return `<munder>${base}${this.processNode(children[0])}</munder>`;
+        } else if (children.length === 3) {
+            return `<munderover>${base}${this.processNode(children[1])}${this.processNode(children[2])}</munderover>`;
+        }
+        
+        return base;
+    }
+
+    /**
+     * Handle matrix templates
+     */
+    handleMatrix(node) {
+        const children = node.children || [];
+        let tableContent = '';
+        
+        children.forEach(row => {
+            if (row.type === 'mtr') {
+                tableContent += '<mtr>';
+                if (row.children) {
+                    row.children.forEach(cell => {
+                        if (cell.type === 'mtd') {
+                            tableContent += `<mtd>${this.processNode(cell)}</mtd>`;
+                        }
+                    });
+                }
+                tableContent += '</mtr>';
+            }
+        });
+        
+        return `<mtable>${tableContent}</mtable>`;
+    }
+
+    /**
+     * Handle parentheses templates
+     */
+    handleParentheses(node) {
+        const content = this.processChildren(node);
+        return `<mrow><mo>(</mo>${content}<mo>)</mo></mrow>`;
+    }
+
+    /**
+     * Handle bracket templates
+     */
+    handleBrackets(node) {
+        const content = this.processChildren(node);
+        return `<mrow><mo>[</mo>${content}<mo>]</mo></mrow>`;
+    }
+
+    /**
+     * Handle brace templates
+     */
+    handleBraces(node) {
+        const content = this.processChildren(node);
+        return `<mrow><mo>{</mo>${content}<mo>}</mo></mrow>`;
+    }
+}
+
+// Utility functions for working with binary data
+
+/**
+ * Load binary file from input element
+ */
+function loadBinaryFile(fileInput) {
+    return new Promise((resolve, reject) => {
+        const file = fileInput.files[0];
+        if (!file) {
+            reject(new Error('No file selected'));
+            return;
+        }
+        
+        const reader = new FileReader();
+        reader.onload = (e) => resolve(e.target.result);
+        reader.onerror = (e) => reject(new Error('Failed to read file'));
+        reader.readAsArrayBuffer(file);
+    });
+}
+
+/**
+ * Convert ArrayBuffer to hex string for debugging
+ */
+function arrayBufferToHex(buffer) {
+    const uint8Array = new Uint8Array(buffer);
+    return Array.from(uint8Array)
+        .map(byte => byte.toString(16).padStart(2, '0'))
+        .join(' ');
+}
+
+// Export for Node.js or browser usage
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        MathTypeToMathMLConverter,
+        CharacterReplacer,
+        ElementMover,
+        MathMLTransformer,
+        loadBinaryFile,
+        arrayBufferToHex
+    };
+} else if (typeof window !== 'undefined') {
+    window.MathTypeToMathMLConverter = MathTypeToMathMLConverter;
+    window.CharacterReplacer = CharacterReplacer;
+    window.ElementMover = ElementMover;
+    window.MathMLTransformer = MathMLTransformer;
+    window.loadBinaryFile = loadBinaryFile;
+    window.arrayBufferToHex = arrayBufferToHex;
+}
+
+// Example usage:
+/*
+// In a web page:
+const converter = new MathTypeToMathMLConverter();
+
+// From file input
+document.getElementById('fileInput').addEventListener('change', async (e) => {
+    try {
+        const binaryData = await loadBinaryFile(e.target);
+        const mathml = await converter.convert(binaryData);
+        document.getElementById('output').innerHTML = mathml;
+    } catch (error) {
+        console.error('Conversion failed:', error);
+    }
+});
+
+// From existing binary data
+const binaryData = new Uint8Array([...]); // Your binary MTEF data
+converter.convert(binaryData).then(mathml => {
+    console.log('Generated MathML:', mathml);
+});
+*/ 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/server_converter.js b/scripts/mathtype2mathml/server_converter.js
new file mode 100644
index 0000000..a4f3712
--- /dev/null
+++ b/scripts/mathtype2mathml/server_converter.js
@@ -0,0 +1,387 @@
+// Node.js server for MathType to MathML conversion
+// This uses the actual Ruby gem to parse binary files
+
+const express = require('express');
+const multer = require('multer');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const cors = require('cors');
+const crypto = require('crypto'); // Added for filename generation
+
+const app = express();
+const port = 3000;
+
+// Define the correct paths relative to this file location
+const MATHTYPE_DIR = __dirname; // Current directory is the mathtype_to_mathml folder
+const CONVERTER_SCRIPT = path.join(MATHTYPE_DIR, 'server', 'converter.rb');
+const BATCH_CONVERTER_SCRIPT = path.join(MATHTYPE_DIR, 'server', 'batch_converter.rb');
+const PUBLIC_DIR = path.join(MATHTYPE_DIR, 'public');
+
+// Enable CORS for cross-origin requests
+app.use(cors());
+
+// Configure multer for file uploads with proper extension preservation
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, 'uploads/');
+    },
+    filename: function (req, file, cb) {
+        // Preserve the original file extension for proper format detection
+        const ext = path.extname(file.originalname);
+        const name = crypto.randomBytes(16).toString('hex');
+        cb(null, name + ext);
+    }
+});
+
+const upload = multer({ 
+    storage: storage,
+    limits: { fileSize: 10 * 1024 * 1024 } // 10MB limit
+});
+
+// Serve static files from the correct public directory
+app.use(express.static(PUBLIC_DIR));
+
+// Convert MathType binary to MathML using Ruby gem
+app.post('/convert-mathtype', upload.single('file'), async (req, res) => {
+    if (!req.file) {
+        return res.status(400).json({ error: 'No file uploaded' });
+    }
+
+    const filePath = req.file.path;
+    console.log(`File uploaded: ${req.file.originalname}`);
+    console.log(`Temp file path: ${filePath}`);
+    console.log(`File exists: ${fs.existsSync(filePath)}`);
+    
+    try {
+        // Call Ruby script to convert the file
+        const mathml = await convertWithRubyGem(filePath);
+        
+        // Clean up uploaded file
+        fs.unlinkSync(filePath);
+        
+        res.json({ 
+            success: true, 
+            mathml: mathml,
+            originalName: req.file.originalname
+        });
+        
+    } catch (error) {
+        // Clean up uploaded file
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+        
+        console.error('Conversion error:', error);
+        res.status(500).json({ 
+            error: 'Conversion failed', 
+            message: error.message 
+        });
+    }
+});
+
+// Function to call Ruby gem for conversion
+function convertWithRubyGem(filePath) {
+    return new Promise((resolve, reject) => {
+        // Check if converter script exists
+        if (!fs.existsSync(CONVERTER_SCRIPT)) {
+            reject(new Error(`Converter script not found at: ${CONVERTER_SCRIPT}`));
+            return;
+        }
+        
+        // Convert relative path to absolute path since Ruby script runs from different directory
+        const absoluteFilePath = path.resolve(filePath);
+        console.log(`Converting relative path: ${filePath}`);
+        console.log(`To absolute path: ${absoluteFilePath}`);
+        console.log(`Absolute file exists: ${fs.existsSync(absoluteFilePath)}`);
+        
+        // Add debugging for working directory
+        console.log(`Working directory (MATHTYPE_DIR): ${MATHTYPE_DIR}`);
+        console.log(`Working directory exists: ${fs.existsSync(MATHTYPE_DIR)}`);
+        console.log(`Converter script path: ${CONVERTER_SCRIPT}`);
+        console.log(`Converter script exists: ${fs.existsSync(CONVERTER_SCRIPT)}`);
+        
+        // Check if the file actually exists
+        if (!fs.existsSync(absoluteFilePath)) {
+            reject(new Error(`Upload file not found at: ${absoluteFilePath}`));
+            return;
+        }
+        
+        // Validate working directory exists
+        if (!fs.existsSync(MATHTYPE_DIR)) {
+            reject(new Error(`Working directory not found at: ${MATHTYPE_DIR}`));
+            return;
+        }
+        
+        // Execute Ruby script with bundle exec from the correct directory
+        // Removed shell: true to fix path issues with spaces
+        const ruby = spawn('bundle', ['exec', 'ruby', CONVERTER_SCRIPT, absoluteFilePath], {
+            cwd: MATHTYPE_DIR,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        
+        let output = '';
+        let errorOutput = '';
+
+        ruby.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+
+        ruby.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+
+        ruby.on('close', (code) => {
+            console.log(`Ruby process exited with code: ${code}`);
+            if (errorOutput) {
+                console.log(`Ruby stderr output: ${errorOutput}`);
+            }
+            
+            if (code !== 0) {
+                console.error(`Ruby script exited with code ${code}: ${errorOutput}`);
+                
+                // Provide more specific error messages based on the error content
+                let errorMessage = 'Ruby conversion failed';
+                
+                if (errorOutput.includes('undefined method')) {
+                    errorMessage = 'MathType file parsing error - this may be due to an incompatible or corrupted MathType file format';
+                } else if (errorOutput.includes('No such file')) {
+                    errorMessage = 'File not found during conversion';
+                } else if (errorOutput.includes('File is empty')) {
+                    errorMessage = 'The uploaded file appears to be empty';
+                } else if (errorOutput.includes('Invalid file format')) {
+                    errorMessage = 'The file does not appear to be a valid MathType binary file';
+                } else if (errorOutput.includes('Permission denied')) {
+                    errorMessage = 'Permission error accessing the file';
+                } else if (errorOutput.includes('command not found') || errorOutput.includes('bundle: not found')) {
+                    errorMessage = 'Bundle command not found - please ensure Ruby bundler is installed';
+                } else if (errorOutput.includes('Could not locate Gemfile')) {
+                    errorMessage = 'Gemfile not found - please run bundle install from the project directory';
+                }
+                
+                reject(new Error(`${errorMessage}: ${errorOutput || 'Unknown error'}`));
+            } else {
+                const mathML = output.trim();
+                if (!mathML) {
+                    reject(new Error('Conversion resulted in empty MathML.'));
+                } else {
+                    console.log('Ruby conversion successful, MathML length:', mathML.length);
+                    resolve(mathML);
+                }
+            }
+        });
+
+        ruby.on('error', (err) => {
+            console.error('Failed to start Ruby process:', err);
+            console.error('Error details:', {
+                code: err.code,
+                errno: err.errno,
+                syscall: err.syscall,
+                path: err.path
+            });
+            
+            let errorMessage = `Failed to start Ruby process: ${err.message}`;
+            if (err.code === 'ENOENT') {
+                errorMessage = 'Bundle command not found - please ensure Ruby bundler is installed and in your PATH';
+            }
+            
+            reject(new Error(errorMessage));
+        });
+    });
+}
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+    res.json({ 
+        status: 'ok', 
+        message: 'MathType converter server is running',
+        paths: {
+            mathtypeDir: MATHTYPE_DIR,
+            converterScript: CONVERTER_SCRIPT,
+            publicDir: PUBLIC_DIR
+        }
+    });
+});
+
+// Batch convert multiple MathType files to MathML
+app.post('/convert-mathtype-batch', upload.array('files', 50), async (req, res) => {
+    if (!req.files || req.files.length === 0) {
+        return res.status(400).json({ error: 'No files uploaded' });
+    }
+
+    console.log(`Batch conversion requested for ${req.files.length} files`);
+    
+    try {
+        // Prepare file paths for batch processing
+        const filePaths = req.files.map(file => path.resolve(file.path));
+        const fileInfo = req.files.map(file => ({
+            originalName: file.originalname,
+            tempPath: file.path,
+            size: file.size
+        }));
+
+        console.log('Files to process:', fileInfo.map(f => f.originalName));
+
+        // Call Ruby batch converter
+        const results = await convertBatchWithRubyGem(filePaths);
+        
+        // Clean up uploaded files
+        req.files.forEach(file => {
+            if (fs.existsSync(file.path)) {
+                fs.unlinkSync(file.path);
+            }
+        });
+
+        // Combine results with file info
+        const response = {
+            success: true,
+            totalFiles: req.files.length,
+            successful: results.successful,
+            failed: results.failed,
+            results: Object.entries(results.results).map(([filePath, result], index) => ({
+                originalName: fileInfo[index].originalName,
+                success: result.success,
+                mathml: result.mathml,
+                error: result.error,
+                fileSize: result.file_size || fileInfo[index].size
+            }))
+        };
+
+        res.json(response);
+        
+    } catch (error) {
+        // Clean up uploaded files in case of error
+        req.files.forEach(file => {
+            if (fs.existsSync(file.path)) {
+                fs.unlinkSync(file.path);
+            }
+        });
+        
+        console.error('Batch conversion error:', error);
+        res.status(500).json({ 
+            error: 'Batch conversion failed', 
+            message: error.message 
+        });
+    }
+});
+
+// Function to call Ruby batch converter
+function convertBatchWithRubyGem(filePaths) {
+    return new Promise((resolve, reject) => {
+        // Check if batch converter script exists
+        if (!fs.existsSync(BATCH_CONVERTER_SCRIPT)) {
+            reject(new Error(`Batch converter script not found at: ${BATCH_CONVERTER_SCRIPT}`));
+            return;
+        }
+
+        // Validate working directory exists
+        if (!fs.existsSync(MATHTYPE_DIR)) {
+            reject(new Error(`Working directory not found at: ${MATHTYPE_DIR}`));
+            return;
+        }
+
+        console.log(`Starting batch conversion of ${filePaths.length} files`);
+        console.log(`Using batch converter: ${BATCH_CONVERTER_SCRIPT}`);
+
+        // Execute Ruby batch script
+        const args = ['exec', 'ruby', BATCH_CONVERTER_SCRIPT, ...filePaths];
+        const ruby = spawn('bundle', args, {
+            cwd: MATHTYPE_DIR,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        
+        let output = '';
+        let errorOutput = '';
+
+        ruby.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+
+        ruby.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+
+        ruby.on('close', (code) => {
+            console.log(`Ruby batch process exited with code: ${code}`);
+            if (errorOutput) {
+                console.log(`Ruby stderr output: ${errorOutput}`);
+            }
+            
+            if (code !== 0) {
+                console.error(`Ruby batch script exited with code ${code}: ${errorOutput}`);
+                reject(new Error(`Batch conversion failed: ${errorOutput || 'Unknown error'}`));
+            } else {
+                try {
+                    const results = JSON.parse(output.trim());
+                    console.log(`Batch conversion completed: ${results.successful}/${results.total_files} successful`);
+                    resolve(results);
+                } catch (parseError) {
+                    console.error('Failed to parse batch conversion results:', parseError);
+                    reject(new Error(`Failed to parse batch conversion results: ${parseError.message}`));
+                }
+            }
+        });
+
+        ruby.on('error', (err) => {
+            console.error('Failed to start Ruby batch process:', err);
+            let errorMessage = `Failed to start Ruby batch process: ${err.message}`;
+            if (err.code === 'ENOENT') {
+                errorMessage = 'Bundle command not found - please ensure Ruby bundler is installed and in your PATH';
+            }
+            reject(new Error(errorMessage));
+        });
+
+        // Set timeout for the entire batch (5 minutes)
+        const timeout = setTimeout(() => {
+            ruby.kill('SIGTERM');
+            reject(new Error('Batch conversion timeout (5 minutes)'));
+        }, 5 * 60 * 1000);
+
+        ruby.on('close', () => {
+            clearTimeout(timeout);
+        });
+    });
+}
+
+// Diagnostic endpoint for testing file uploads
+app.post('/test-upload', upload.single('file'), (req, res) => {
+    if (!req.file) {
+        return res.status(400).json({ error: 'No file uploaded' });
+    }
+
+    const filePath = req.file.path;
+    const absoluteFilePath = path.resolve(filePath);
+    
+    // Get file info
+    const stats = fs.statSync(absoluteFilePath);
+    
+    // Clean up uploaded file immediately after getting info
+    fs.unlinkSync(filePath);
+    
+    res.json({
+        success: true,
+        fileInfo: {
+            originalName: req.file.originalname,
+            size: stats.size,
+            mimetype: req.file.mimetype,
+            encoding: req.file.encoding,
+            tempPath: filePath,
+            absolutePath: absoluteFilePath,
+            existed: true
+        },
+        message: 'File upload test successful - file was received and cleaned up'
+    });
+});
+
+// Start server
+app.listen(port, () => {
+    console.log(`MathType converter server running at http://localhost:${port}`);
+    console.log(`Using MathType directory: ${MATHTYPE_DIR}`);
+    console.log(`Converter script: ${CONVERTER_SCRIPT}`);
+    console.log(`Public directory: ${PUBLIC_DIR}`);
+    console.log('Make sure you have the mathtype_to_mathml Ruby gem installed:');
+    console.log(`  cd "${MATHTYPE_DIR}" && bundle install`);
+    console.log(`Demo page available at: http://localhost:${port}/mathtype_converter_demo.html`);
+});
+
+module.exports = app; 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/test/input/25.bin b/scripts/mathtype2mathml/test/input/25.bin
new file mode 100644
index 0000000..5037cbd
Binary files /dev/null and b/scripts/mathtype2mathml/test/input/25.bin differ
diff --git a/scripts/mathtype2mathml/test/input/26.bin b/scripts/mathtype2mathml/test/input/26.bin
new file mode 100644
index 0000000..58b25e2
Binary files /dev/null and b/scripts/mathtype2mathml/test/input/26.bin differ
diff --git a/scripts/mathtype2mathml/test/input/40.bin b/scripts/mathtype2mathml/test/input/40.bin
new file mode 100644
index 0000000..22d06df
Binary files /dev/null and b/scripts/mathtype2mathml/test/input/40.bin differ
diff --git a/scripts/mathtype2mathml/test/input/61.bin b/scripts/mathtype2mathml/test/input/61.bin
new file mode 100644
index 0000000..e88bba3
Binary files /dev/null and b/scripts/mathtype2mathml/test/input/61.bin differ
diff --git a/scripts/mathtype2mathml/test/output/25.wmf b/scripts/mathtype2mathml/test/output/25.wmf
new file mode 100644
index 0000000..5648ead
Binary files /dev/null and b/scripts/mathtype2mathml/test/output/25.wmf differ
diff --git a/scripts/mathtype2mathml/test/output/26.wmf b/scripts/mathtype2mathml/test/output/26.wmf
new file mode 100644
index 0000000..1842cab
Binary files /dev/null and b/scripts/mathtype2mathml/test/output/26.wmf differ
diff --git a/scripts/mathtype2mathml/test/output/40.wmf b/scripts/mathtype2mathml/test/output/40.wmf
new file mode 100644
index 0000000..e6fc3c9
Binary files /dev/null and b/scripts/mathtype2mathml/test/output/40.wmf differ
diff --git a/scripts/mathtype2mathml/test/output/61.wmf b/scripts/mathtype2mathml/test/output/61.wmf
new file mode 100644
index 0000000..1c35939
Binary files /dev/null and b/scripts/mathtype2mathml/test/output/61.wmf differ
diff --git a/scripts/mathtype2mathml/uploads/.gitkeep b/scripts/mathtype2mathml/uploads/.gitkeep
new file mode 100644
index 0000000..fc321cc
--- /dev/null
+++ b/scripts/mathtype2mathml/uploads/.gitkeep
@@ -0,0 +1 @@
+# Keep this directory in git 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/vendor/gems/.rspec b/scripts/mathtype2mathml/vendor/gems/.rspec
new file mode 100644
index 0000000..8c18f1a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/.rspec
@@ -0,0 +1,2 @@
+--format documentation
+--color
diff --git a/scripts/mathtype2mathml/vendor/gems/.ruby-version b/scripts/mathtype2mathml/vendor/gems/.ruby-version
new file mode 100644
index 0000000..b1b25a5
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/.ruby-version
@@ -0,0 +1 @@
+2.2.2
diff --git a/scripts/mathtype2mathml/vendor/gems/.travis.yml b/scripts/mathtype2mathml/vendor/gems/.travis.yml
new file mode 100644
index 0000000..23a0abe
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/.travis.yml
@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/.rspec b/scripts/mathtype2mathml/vendor/gems/mathtype/.rspec
new file mode 100644
index 0000000..83e16f8
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/.rspec
@@ -0,0 +1,2 @@
+--color
+--require spec_helper
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/.travis.yml b/scripts/mathtype2mathml/vendor/gems/mathtype/.travis.yml
new file mode 100644
index 0000000..43cc7f4
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/.travis.yml
@@ -0,0 +1,28 @@
+language: ruby
+
+matrix:
+  include:
+  - rvm: 2.1
+    before_script: mv gemspecs/mathtype.ruby-2-2.gemspec mathtype.gemspec
+  - rvm: 2.2
+    before_script: mv gemspecs/mathtype.ruby-2-2.gemspec mathtype.gemspec
+  - rvm: 2.3
+    before_install:
+    - gem update --system
+    - gem install bundler
+    before_script: mv gemspecs/mathtype.ruby-2-6.gemspec mathtype.gemspec
+  - rvm: 2.4
+    before_install:
+    - gem update --system
+    - gem install bundler
+    before_script: mv gemspecs/mathtype.ruby-2-6.gemspec mathtype.gemspec
+  - rvm: 2.5
+    before_install:
+    - gem update --system
+    - gem install bundler
+    before_script: mv gemspecs/mathtype.ruby-2-6.gemspec mathtype.gemspec
+  - rvm: 2.6
+    before_install:
+    - gem update --system
+    - gem install bundler
+    before_script: mv gemspecs/mathtype.ruby-2-6.gemspec mathtype.gemspec
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/Gemfile b/scripts/mathtype2mathml/vendor/gems/mathtype/Gemfile
new file mode 100644
index 0000000..5c232e2
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/Gemfile
@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mathtype.gemspec
+gemspec
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/LICENSE.txt b/scripts/mathtype2mathml/vendor/gems/mathtype/LICENSE.txt
new file mode 100644
index 0000000..370c190
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jure Triglav
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/README.md b/scripts/mathtype2mathml/vendor/gems/mathtype/README.md
new file mode 100644
index 0000000..99114af
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/README.md
@@ -0,0 +1,43 @@
+# What does the `mathtype` gem do?
+
+This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mathtype'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathtype
+
+## Usage
+
+To convert a MathType binary equation (e.g. extracted from a Word document) to an XML form:
+
+```
+xml = Mathtype::Converter.new("equation1.bin") # to get the Nokogiri XML object
+puts xml.to_xml # to get the string XML representation
+```
+
+# Testing
+
+Run `bundle exec rspec` to run specs.
+
+# Maintainers
+- Sebastian Bulka ([sbulka](https://github.com/sbulka))
+- Jure Triglav ([jure](https://github.com/jure))
+
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/Rakefile b/scripts/mathtype2mathml/vendor/gems/mathtype/Rakefile
new file mode 100644
index 0000000..fe27fdc
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/Rakefile
@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-2.gemspec b/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-2.gemspec
new file mode 100644
index 0000000..07c8384
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-2.gemspec
@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mathtype/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathtype"
+  spec.version       = Mathtype::VERSION
+  spec.authors       = ["Jure Triglav", "Sebastian Bulka"]
+  spec.email         = ["juretriglav@gmail.com", "sebastian.bulka@le-tex.de"]
+  spec.summary       = %q{ A Ruby gem for reading MathType binaries and converting them to an XML form. }
+  spec.description   = %q{ This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = Dir.glob("{lib,spec}/**/*")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_dependency "bindata", "~> 2.1"
+  spec.add_dependency "nokogiri", "~> 1.6"
+  spec.add_dependency "ruby-ole", "~> 1.2"
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-6.gemspec b/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-6.gemspec
new file mode 100644
index 0000000..c83b713
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/gemspecs/mathtype.ruby-2-6.gemspec
@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mathtype/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathtype"
+  spec.version       = Mathtype::VERSION
+  spec.authors       = ["Jure Triglav", "Sebastian Bulka"]
+  spec.email         = ["juretriglav@gmail.com", "sebastian.bulka@le-tex.de"]
+  spec.summary       = %q{ A Ruby gem for reading MathType binaries and converting them to an XML form. }
+  spec.description   = %q{ This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = Dir.glob("{lib,spec}/**/*")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_dependency "bindata", "~> 2.1"
+  spec.add_dependency "nokogiri", "~> 1.6"
+  spec.add_dependency "ruby-ole", "~> 1.2"
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/eps.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/eps.rb
new file mode 100644
index 0000000..180854a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/eps.rb
@@ -0,0 +1,30 @@
+module Mathtype
+  class EpsFileParser < FileParser
+    def initialize(path)
+      super(path)
+      extract_mtef_from_epscomment(@raw)
+    end
+
+    def extract_mtef_from_epscomment(comment)
+      string64 = @raw.gsub /\r/, ""
+      # d for delimiter
+      d = string64[(/MathType(.)MTEF\1/ =~ string64) + 8]
+      matches = string64.match /.*MathType#{d}MTEF#{d}(.)#{d}(.)#{d}(.)(.)(.*)#{d}([0-9A-F]{4})#{d}.*/m
+      leading_chrs = matches[1].to_i
+      trailing_chrs = matches[2].to_i - 1
+      a64_chr1 = matches[3]
+      a64_chr2 = matches[4]
+      A64[a64_chr1] = 62
+      A64[a64_chr2] = 63
+      A64[62] = a64_chr1
+      A64[63] = a64_chr2
+      string64   = matches[5]
+      mtchecksum = matches[6]
+      string64.gsub! /.{#{trailing_chrs}}(\n).{#{leading_chrs}}/m, ""
+      @equation = decode string64
+      unless checksum == mtchecksum
+        raise ArgumentError, "Checksums do not match, expected #{mtchecksum} but got #{checksum}"
+      end
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/ole.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/ole.rb
new file mode 100644
index 0000000..1812fbf
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/ole.rb
@@ -0,0 +1,15 @@
+require "bindata"
+require "ole/storage"
+
+module Mathtype
+  class OleFileParser < FileParser
+    def initialize(path)
+      read_from_file(path)
+    end
+    def read_from_file(path)
+      ole = Ole::Storage.open(path, "rb+")
+      @equation = ole.file.read("Equation Native")[28..-1]
+      ole.close
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/parser.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/parser.rb
new file mode 100644
index 0000000..733396e
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/parser.rb
@@ -0,0 +1,102 @@
+module Mathtype
+  class FileParser
+    attr_reader :raw
+    attr_reader :equation
+    def initialize(path)
+      read_from_file(path)
+    end
+
+    def checksum
+      (@equation.bytes.reduce(:+) & 0xFFFF).to_s(16).upcase
+    end
+
+    def read_from_file(path)
+      f = File.open(path, "rb")
+      @raw = f.read
+      f.close
+    end
+
+    A64 =
+      {
+        "a" => 0, "b" => 1, "c" => 2, "d" => 3, "e" => 4,
+        "f" => 5, "g" => 6, "h" => 7, "i" => 8, "j" => 9,
+        "k" => 10, "l" => 11, "m" => 12, "n" => 13, "o" => 14, "p" => 15,
+        "q" => 16, "r" => 17, "s" => 18, "t" => 19, "u" => 20, "v" => 21,
+        "w" => 22, "x" => 23, "y" => 24, "z" => 25, "A" => 26, "B" => 27,
+        "C" => 28, "D" => 29, "E" => 30, "F" => 31, "G" => 32, "H" => 33,
+        "I" => 34, "J" => 35, "K" => 36, "L" => 37, "M" => 38, "N" => 39,
+        "O" => 40, "P" => 41, "Q" => 42, "R" => 43, "S" => 44, "T" => 45,
+        "U" => 46, "V" => 47, "W" => 48, "X" => 49, "Y" => 50, "Z" => 51,
+        "0" => 52, "1" => 53, "2" => 54, "3" => 55, "4" => 56, "5" => 57,
+        "6" => 58, "7" => 59, "8" => 60, "9" => 61, "+" => 62, "-" => 63,
+        0 => "a", 1 => "b", 2 => "c", 3 => "d", 4 => "e",
+        5 => "f", 6 => "g", 7 => "h", 8 => "i", 9 => "j",
+        10 => "k", 11 => "l", 12 => "m", 13 => "n", 14 => "o", 15 => "p",
+        16 => "q", 17 => "r", 18 => "s", 19 => "t", 20 => "u", 21 => "v",
+        22 => "w", 23 => "x", 24 => "y", 25 => "z", 26 => "A", 27 => "B",
+        28 => "C", 29 => "D", 30 => "E", 31 => "F", 32 => "G", 33 => "H",
+        34 => "I", 35 => "J", 36 => "K", 37 => "L", 38 => "M", 39 => "N",
+        40 => "O", 41 => "P", 42 => "Q", 43 => "R", 44 => "S", 45 => "T",
+        46 => "U", 47 => "V", 48 => "W", 49 => "X", 50 => "Y", 51 => "Z",
+        52 => "0", 53 => "1", 54 => "2", 55 => "3", 56 => "4", 57 => "5",
+        58 => "6", 59 => "7", 60 => "8", 61 => "9", 62 => "+", 63 => "-"
+      }
+
+    def decode(string64)
+      #decode from base64 mtef to binary mtef
+      l = string64.length
+      i = b0 = b1 = carry = 0
+      out = []
+      while i < l
+        chr  = A64[string64[i]]
+        case i % 4
+        when 0
+          b0  = chr
+          b1 = 0
+        when 1
+          b0 += ((chr & 3) << 6)
+          b1    = ((chr & 0xfc) >> 2)
+          out   << b0
+        when 2
+          b0  = ((chr & 0x30) >> 4)
+          b1   += ((chr & 0xf) << 4)
+        when 3
+          b0 += chr << 2
+          out << b1 << b0
+          b0=b1=0
+        end
+        i += 1
+      end
+      out << b0 if i % 2 == 1
+      return out.pack("C*")
+    end
+
+    def encode(mtef)
+      #encode from binary mtef to base64 mtef
+      out = ""
+      bytes = mtef.bytes
+      i = shft = 0
+      l = bytes.length
+      carry = 0
+      while i < l
+        chr = bytes[i] << shft
+        chr = chr | carry
+        out << A64[chr & 0x3f]
+        carry = chr >> 6
+        i += 1
+        shft = (i % 3) * 2
+        if shft == 0
+          out << A64[carry]
+          carry = 0
+        end
+      end
+      return out
+    end
+  end
+end
+
+
+require_relative "ole.rb"
+require_relative "wmf.rb"
+require_relative "eps.rb"
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/wmf.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/wmf.rb
new file mode 100644
index 0000000..52734cf
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/file_parser/wmf.rb
@@ -0,0 +1,28 @@
+module Mathtype
+  class WmfFileParser < FileParser
+    def initialize(path)
+      super(path)
+      extract_mtef_from_mfcomment(@raw)
+    end
+
+    def extract_mtef_from_mfcomment(comment)
+      match = comment.match("MathTypeUU")
+      if match
+        lenpos = match.end(0)
+        len = comment[lenpos..lenpos+1].unpack("H*")[0].to_i 16
+        start = lenpos + 2
+      else
+        match = comment.match("AppsMFCC\x01")
+        raise ::NotImplementedError, "No MathType Equation found in wmf" unless match
+        len_start = match.end(0)
+        totallen = comment[len_start..len_start + 3].reverse.chars.rotate(-1).join.unpack("H*")[0].to_i 16
+        datalen = comment[len_start + 4 .. len_start + 7].reverse.chars.rotate(-1).join.unpack("H*")[0].to_i 16
+        signature = comment[len_start + 8.. -1].match(/.+?\x00/)
+        raise ::NotImplementedError, "Equation split over multiple comments" unless totallen == datalen
+        start = len_start + 8 + signature.end(0)
+        len = datalen
+      end
+      @equation = comment[start..(start + len)]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype.rb
new file mode 100644
index 0000000..c0cd1bc
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype.rb
@@ -0,0 +1,86 @@
+require_relative "mathtype/version"
+require "nokogiri"
+require_relative "file_parser/parser.rb"
+require_relative "records/mtef.rb"
+require_relative "records3/mtef.rb"
+require_relative "records5/mtef.rb"
+
+
+module Mathtype
+  class Converter
+    attr_reader :parser
+    attr_reader :xml
+    attr_reader :builder
+    attr_reader :version
+    def initialize(equation)
+      set_parser(equation)
+      raise ::NotImplementedError, "Equation format not supported. Only .eps, .wmf and .bin (OLE-Object) currently supported, supplied was: #{equation}" unless @parser.equation
+      @version = @parser.equation[0].unpack('C')[0].to_i
+      raise ::NotImplementedError, "Only MTEF Version 3 and 5 currently supported, version is #{version}" unless (version==3 or version==5)
+      case @version
+      when 3
+        data = Mathtype3::Equation.read(@parser.equation).snapshot
+      when 5
+        data = Mathtype5::Equation.read(@parser.equation).snapshot
+      end
+      @builder = Nokogiri::XML::Builder.new do |xml|
+        @xml = xml
+        xml.root do
+          process(object: data)
+        end
+      end
+    end
+
+    def set_parser(equation)
+      if equation.end_with?(".bin")
+        @parser = Mathtype::OleFileParser.new equation
+      elsif equation.end_with?(".wmf")
+        @parser = Mathtype::WmfFileParser.new equation
+      else
+        @parser = Mathtype::EpsFileParser.new equation
+      end
+    end
+
+    def to_xml
+      @builder.to_xml
+    end
+
+    def process(element: "mtef", object:)
+      if object.is_a? Hash
+        case @version
+        when 3
+          name = Mathtype3::RECORD_NAMES[object[:record_type]]
+        else
+          name = Mathtype5::RECORD_NAMES[object[:record_type]]
+        end
+        if name
+          xml.send(name) do
+            (object[:payload] || {}).each do |k, v|
+              process(element: k, object: v)
+            end
+          end
+        else
+          xml.send(element) do
+            object.each do |k, v|
+              process(element: k, object: v)
+            end
+          end
+        end
+      elsif object.is_a? Array
+        object.each do |a|
+          process(element: element, object: a)
+        end
+      else
+        process_final_element(element, object)
+      end
+    end
+
+    def process_final_element(element, object)
+      if object.is_a? Hash
+        xml.send(element, object)
+      else
+        xml.send(element) { xml.text object }
+      end
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype/version.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype/version.rb
new file mode 100644
index 0000000..f12d0dc
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/mathtype/version.rb
@@ -0,0 +1,3 @@
+module Mathtype
+  VERSION = "0.1.0"
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/bintypes.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/bintypes.rb
new file mode 100644
index 0000000..798dbc4
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/bintypes.rb
@@ -0,0 +1,37 @@
+module Mathtype
+  class Mtef16 < BinData::Primitive
+    uint8 :low, :initial_value => 0
+    uint8 :high, :initial_value => 0
+
+    def get; (high << 8) + low end
+    def getlow
+      self.low
+    end
+    def gethigh
+      self.high
+    end
+    def set(v)
+      self.low = v & 0xFF
+      self.high = (v & 0xFF00) >> 8
+    end
+  end
+
+  class MatrixLineByte < BinData::Primitive
+    # row/columlines are represented as 2-bit values in a full byte, in reverse
+    # see MATRIX RECORD (5)
+    # a 3x3 matrix with rows "solid none dashed solid" would be represented as
+    # 01 10 00 01 = reverse      01   00     10    01
+    # a 4x4 matrix with "solid none dashed solid solid         " accordingly does
+    # 01100001 00000001 =   01   00     10    01    01 00 00 00
+    uint8 :_byte
+
+    def get
+      [
+        (self._byte & 0x03),
+        (self._byte & 0x0C) >> 2,
+        (self._byte & 0x30) >> 4,
+        (self._byte & 0xC0) >> 6
+      ]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/end.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/end.rb
new file mode 100644
index 0000000..54dcd07
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/end.rb
@@ -0,0 +1,8 @@
+module Mathtype
+  class RecordEnd < BinData::Primitive
+    def get; ""; end
+    def set(v); end
+
+    def to_formatted_s(indent = 0); to_s; end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/mtef.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/mtef.rb
new file mode 100644
index 0000000..366e3b3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/mtef.rb
@@ -0,0 +1,36 @@
+require_relative 'snapshot'
+require_relative 'bintypes'
+require_relative 'end'
+require_relative 'nudge'
+require_relative 'ruler'
+require_relative 'typesizes'
+
+module Mathtype
+
+  HALIGN = {
+    1 => "left",
+    2 => "center",
+    3 => "right",
+    4 => "al", # relational
+    5 => "dec" # decimal
+  }
+
+  VALIGN = {
+    0 => "top_baseline",
+    1 => "center_baseline",
+    2 => "bottom_baseline",
+    3 => "center", # vertical centering
+    4 => "axis" # math axis (center of +,-, brace points, etc.)
+  }
+
+  class Equation < BinData::Record
+    endian :little
+    uint8 :mtef_version
+    uint8 :platform
+    uint8 :product
+    uint8 :product_version
+    uint8 :product_subversion
+    include Snapshot
+  end
+
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/nudge.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/nudge.rb
new file mode 100644
index 0000000..5b1d73a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/nudge.rb
@@ -0,0 +1,38 @@
+# Nudge values:
+# LINE, CHAR, TMPL, PILE, MATRIX, and EMBELL records may store the result of
+# nudging (small offsets applied by the user). A nudged record has the
+# mtefOPT_NUDGE option (0x8) and the option byte is followed immediately by
+# the nudge offset. The nudge offset consists of either two bytes or six,
+# depending on the amount of offset. If -128 <= dx < +128 and
+# -128 <= dy < +128, then the offsets are stored as two bytes, dx followed
+# by dy, where each value has 128 added to it before it is written. Otherwise,
+# two bytes of 128 are stored, followed by the offsets, dx and dy, stored as
+# 16-bit values, low byte followed by high byte.
+
+require_relative "snapshot"
+
+module Mathtype
+  class RecordNudge < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(dx dy)
+
+    endian :little
+
+    int8 :_small_dx
+    int8 :_small_dy
+    mtef16 :_large_dx, :onlyif => lambda { has_large_offset }
+    mtef16 :_large_dy, :onlyif => lambda { has_large_offset }
+
+    def dx
+      has_large_offset ? _large_dx : (_small_dx - 128)
+    end
+
+    def dy
+      has_large_offset ? _large_dy : (_small_dy - 128)
+    end
+
+    def has_large_offset
+      _small_dx == -128 and _small_dy == -128
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/ruler.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/ruler.rb
new file mode 100644
index 0000000..47c56da
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/ruler.rb
@@ -0,0 +1,22 @@
+# RULER record (7):
+# Consists of:
+# record type (7)
+# [n_stops] number of tab-stops
+# [tab-stop list] tab-stops in order from left-to-right
+# Each tab stop is described by a tab-stop type
+# (0 for left, 1 for center, 2 for right, 3 for equal, 4 for decimal),
+# followed by a 16-bit integer offset from the left end of the slot or pile
+# with which it is associated.
+
+module Mathtype
+  class RecordRuler < BinData::Record
+    endian :little
+
+    int8 :n_stops
+
+    array :tab_stops, initial_length: :n_stops do
+      int8 :tab_stop_type
+      mtef16 :tab_stop
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/snapshot.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/snapshot.rb
new file mode 100644
index 0000000..0069d79
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/snapshot.rb
@@ -0,0 +1,19 @@
+require "bindata"
+
+module Mathtype
+  module Snapshot
+    def snapshot
+      snapshot = BinData::Record::Snapshot.new
+      exposed = self.class.const_get(:EXPOSED_IN_SNAPSHOT)
+      exposed.each do |name|
+        obj = find_obj_for_name(name)
+        if obj
+          snapshot[name] = obj.snapshot if include_obj?(obj)
+        else
+          snapshot[name] = self.send(name)
+        end
+      end
+      snapshot
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/typesizes.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/typesizes.rb
new file mode 100644
index 0000000..70a3d02
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records/typesizes.rb
@@ -0,0 +1,19 @@
+# Typesize records (10-14):
+# Consists of:
+# record type (10-14)
+# These records are just short ways of specifying a simple typesize where dsize
+# is zero. The tag value represents an lsize + 10. So if the tag value is 10,
+# it means equation content following it will be Full size (szFULL), tag value
+# 11 means szSUB, and so on. See typesize.
+
+module Mathtype
+  class RecordFull < BinData::Record; end
+
+  class RecordSub < BinData::Record; end
+
+  class RecordSub2 < BinData::Record; end
+
+  class RecordSym < BinData::Record; end
+
+  class RecordSubsym < BinData::Record; end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/char.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/char.rb
new file mode 100644
index 0000000..8badae0
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/char.rb
@@ -0,0 +1,53 @@
+# CHAR record (2):
+# Consists of:
+# record type (2)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [typeface] typeface value (signed integer; see FONT_STYLE_DEF record below)
+# [character] character value (see below)
+# [embellishment list] if mtefOPT_CHAR_EMBELL is set (embellishments)
+# The character value itself is represented by one or more values. The presence or absence of these value is indicated by options and appear in this order:
+# 16-bit integer MTCode value present unless the mtefOPT_CHAR_ENC_NO_MTCODE option is set
+# 8-bit font position present if the mtefOPT_CHAR_ENC_CHAR_8 option is set
+# 16-bit integer font position  present if the mtefOPT_CHAR_ENC_CHAR_16 option is set
+# The MTCode value defines the character independent of its font. MTCode is a superset of Unicode and is described in MTCode Encoding Tables. The 8-bit and 16-bit font positions are mutually exclusive but may both be absent. This is the position of the character within its font. Some of the common font encodings are given in Font Encoding Tables.
+
+require_relative "snapshot"
+
+module Mathtype3
+  class RecordEmbell < BinData::Record; end
+  class RecordChar < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge typeface mt_code_value embellishment_list)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_typeface
+
+    mtef16 :_mt_code_value
+
+    array :embellishment_list,
+        onlyif: lambda { _options & OPTIONS["xfEMBELL"] > 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def mt_code_value
+      sprintf("0x%04X", _mt_code_value)
+    end
+
+    def typeface
+      _typeface + 128
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/embell.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/embell.rb
new file mode 100644
index 0000000..86cbb65
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/embell.rb
@@ -0,0 +1,109 @@
+require_relative "snapshot"
+
+# EMBELL record (6):
+# Consists of:
+# record type (6)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [embell] embellishment type
+# The embellishment types are:
+
+# value symbol  description
+# 2 emb1DOT over single dot
+# 3 emb2DOT over double dot
+# 4 emb3DOT over triple dot
+# 5 emb1PRIME single prime
+# 6 emb2PRIME double prime
+# 7 embBPRIME backwards prime (left of character)
+# 8 embTILDE  tilde
+# 9 embHAT  hat (circumflex)
+# 10  embNOT  diagonal slash through character
+# 11  embRARROW over right arrow
+# 12  embLARROW over left arrow
+# 13  embBARROW over both arrow (left and right)
+# 14  embR1ARROW  over right single-barbed arrow
+# 15  embL1ARROW  over left single-barbed arrow
+# 16  embMBAR mid-height horizontal bar
+# 17  embOBAR over-bar
+# 18  emb3PRIME triple prime
+# 19  embFROWN  over-arc, concave downward
+# 20  embSMILE  over-arc, concave upward
+# 21  embX_BARS double diagonal bars
+# 22  embUP_BAR bottom-left to top-right diagonal bar
+# 23  embDOWN_BAR top-left to bottom-right diagonal bar
+# 24  emb4DOT over quad dot
+# 25  embU_1DOT under single dot
+# 26  embU_2DOT under double dot
+# 27  embU_3DOT under triple dot
+# 28  embU_4DOT under quad dot
+# 29  embU_BAR  under bar
+# 30  embU_TILDE  under tilde (~)
+# 31  embU_FROWN  under arc (ends point down)
+# 32  embU_SMILE  under arc (ends point up)
+# 33  embU_RARROW under right arrow
+# 34  embU_LARROW under left arrow
+# 35  embU_BARROW under both arrow (left and right)
+# 36  embU_R1ARROW  under right arrow (1 barb)
+# 37  embU_L1ARROW  under left arrow (1 barb)
+
+module Mathtype3
+  class RecordEmbell < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge embell)
+
+    EMBELL = {
+      2 => "emb1DOT", # over single dot
+      3 => "emb2DOT", # over double dot
+      4 => "emb3DOT", # over triple dot
+      5 => "emb1PRIME", # single prime
+      6 => "emb2PRIME", # double prime
+      7 => "embBPRIME", # backwards prime (left of character)
+      8 => "embTILDE", #  tilde
+      9 => "embHAT", #  hat (circumflex)
+      10 => "embNOT", #  diagonal slash through character
+      11 => "embRARROW", # over right arrow
+      12 => "embLARROW", # over left arrow
+      13 => "embBARROW", # over both arrow (left and right)
+      14 => "embR1ARROW", #  over right single-barbed arrow
+      15 => "embL1ARROW", #  over left single-barbed arrow
+      16 => "embMBAR", # mid-height horizontal bar
+      17 => "embOBAR", # over-bar
+      18 => "emb3PRIME", # triple prime
+      19 => "embFROWN", #  over-arc, concave downward
+      20 => "embSMILE", #  over-arc, concave upward
+      21 => "embX_BARS", # double diagonal bars
+      22 => "embUP_BAR", # bottom-left to top-right diagonal bar
+      23 => "embDOWN_BAR", # top-left to bottom-right diagonal bar
+      24 => "emb4DOT", # over quad dot
+      25 => "embU_1DOT", # under single dot
+      26 => "embU_2DOT", # under double dot
+      27 => "embU_3DOT", # under triple dot
+      28 => "embU_4DOT", # under quad dot
+      29 => "embU_BAR", #  under bar
+      30 => "embU_TILDE", #  under tilde (~)
+      31 => "embU_FROWN", #  under arc (ends point down)
+      32 => "embU_SMILE", #  under arc (ends point up)
+      33 => "embU_RARROW", # under right arrow
+      34 => "embU_LARROW", # under left arrow
+      35 => "embU_BARROW", # under both arrow (left and right)
+      36 => "embU_R1ARROW", #  under right arrow (1 barb)
+      37 => "embU_L1ARROW", #  under left arrow (1 barb)
+    }
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_embell
+    int8 :_none
+
+    def embell
+      EMBELL[_embell]
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/font.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/font.rb
new file mode 100644
index 0000000..7384410
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/font.rb
@@ -0,0 +1,27 @@
+require_relative "snapshot"
+
+module Mathtype3
+  class RecordFont < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options name typeface style)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    int8 :_typeface
+
+    int8 :style
+
+    stringz :name
+    def typeface
+      _typeface + 128
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/line.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/line.rb
new file mode 100644
index 0000000..f3a89a3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/line.rb
@@ -0,0 +1,47 @@
+# LINE record (1):
+# Consists of:
+# record type (1)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [line spacing] if mtefOPT_LINE_LSPACE is set (16-bit integer)
+# [RULER record] if mtefOPT_LP_RULER is set
+# object list of line (single pile, characters and templates, or nothing)
+# The line spacing value, if present, is the distance between the baseline of
+# this line and the line above it.
+
+require_relative "snapshot"
+
+module Mathtype3
+  class NamedRecord < BinData::Record; end
+  class RecordLine < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge line_spacing ruler object_list)
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    mtef16 :line_spacing, onlyif: (lambda do
+      _options & OPTIONS["xfLSPACE"] > 0
+    end)
+
+    record_ruler :ruler, onlyif: (lambda do
+      _options & OPTIONS["xfRULER"] > 0
+    end)
+
+    array :object_list,
+        onlyif: lambda { _options & OPTIONS["xfNULL"] == 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def to_formatted_s(indent = 0); to_s; end
+
+    def options
+      _tag_options
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/matrix.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/matrix.rb
new file mode 100644
index 0000000..d555d29
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/matrix.rb
@@ -0,0 +1,80 @@
+require_relative "snapshot"
+
+# MATRIX record (5):
+# record type (5)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [valign] vertical alignment of matrix within container
+# [h_just] horizontal alignment within columns
+# [v_just] vertical alignment within columns
+# [rows] number of rows
+# [cols] number of columns
+# [row_parts] row partition line types (see below)
+# [col_parts] column partition line types (see below)
+# [object list] list of lines, one for each element of the matrix, in order from
+# left-to-right and top-to-bottom
+# The values for valign, h_just, and v_just are described in PILE above.
+
+# The row partition line type list consists of two-bit values for each possible
+# partition line (one more than the number of rows), rounded out to the nearest
+# byte. Each value determines the line style of the corresponding partition line
+# (0 for none, 1 for solid, 2 for dashed, or 3 for dotted). Similarly for the
+# column partition lines.
+
+module Mathtype3
+  class RecordMatrix < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge valign h_just v_just rows cols
+      row_parts col_parts object_list)
+
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_valign
+    int8 :_h_just
+    int8 :_v_just
+    int8 :rows
+    int8 :cols
+
+    array :row_parts, initial_length: lambda { rows + 1 } do
+      bit nbits: 2
+    end
+
+    bit :_realign_rows, nbits: lambda { realign(rows) }
+
+    array :col_parts, initial_length: lambda { cols + 1 } do
+      bit nbits: 2
+    end
+
+    bit :_realign_cols, nbits: lambda { realign(cols) }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+
+    def h_just
+      HALIGN[_h_just]
+    end
+
+    def v_just
+      VALIGN[_v_just]
+    end
+
+    def options
+      _tag_options
+    end
+
+    def realign (nparts)
+      offset = (((nparts +  1) * 2) % 8)
+      return offset == 0 ? 0 : (8 - offset)
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/mtef.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/mtef.rb
new file mode 100644
index 0000000..3ef0e0e
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/mtef.rb
@@ -0,0 +1,97 @@
+require_relative "line"
+require_relative "embell"
+require_relative "char"
+require_relative "pile"
+require_relative "tmpl"
+require_relative "font"
+require_relative "matrix"
+require_relative "size"
+
+module Mathtype3
+  class RecordEnd < Mathtype::RecordEnd; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordRuler < Mathtype::RecordRuler; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordFull < Mathtype::RecordFull; end
+  class RecordSub < Mathtype::RecordSub; end
+  class RecordSub2 < Mathtype::RecordSub2; end
+  class RecordSym < Mathtype::RecordSym; end
+  class RecordSubsym < Mathtype::RecordSubsym; end
+
+  HALIGN = Mathtype::HALIGN
+  VALIGN = Mathtype::VALIGN
+
+  RECORD_NAMES = {
+    0 => "end",
+    1 => "slot",
+    2 => "char",
+    3 => "tmpl",
+    4 => "pile",
+    5 => "matrix",
+    6 => "embell",
+    7 => "ruler",
+    8 => "font",
+    9 => "size",
+    10 => "full",
+    11 => "sub",
+    12 => "sub2",
+    13 => "sym",
+    14 => "subsym",
+  }
+
+  OPTIONS = {
+    # value => symbol                     # description
+    # Option flag values for all equation structure records:
+    "xfLMOVE" => 0x08,              # nudge values follow tag
+    # Option flag values for CHAR records:
+    "xfLAUTO" => 0x01,        # character is followed by an embellishment list
+    "xfEMBELL" => 0x02,    # character starts a function (sin, cos, etc.)
+    # Option flag values for LINE records:
+    "xfNULL" => 0x01,          # line is a placeholder only (i.e. not displayed)
+    "xfLSPACE" => 0x04,        # line spacing value follows tag
+    # Option flag values for LINE and PILE records:
+    "xfRULER" => 0x02,           # RULER record follows LINE or PILE record
+  }
+
+  class Payload < BinData::Choice
+    opt = {:_options => :options}
+    record_end 0 # end is a reserved keyword
+    record_line 1, opt
+    record_char 2, opt
+    record_tmpl 3, opt
+    record_pile 4, opt
+    record_matrix 5, opt
+    record_embell 6, opt
+    record_ruler 7, opt
+    record_font 8, opt
+    record_size 9, opt
+    record_full 10, opt
+    record_sub 11, opt
+    record_sub2 12, opt
+    record_sym 13, opt
+    record_subsym 14, opt
+  end
+
+  ## Payload is the most important class to understand.
+  ## This abstraction allows recursive formats.
+  ## eg. lists can contain lists can contain lists.
+
+  class NamedRecord < BinData::Record
+    bit4 :record_options
+    bit4 :record_type
+    payload :payload, :onlyif => :not_end_tag?, :selection => :record_type, :options => :record_options
+
+    def not_end_tag?
+      record_type != 0
+    end
+  end
+
+  class Equation < Mathtype::Equation
+    EXPOSED_IN_SNAPSHOT = %i(mtef_version platform product product_version
+      product_subversion equation)
+
+    array :equation, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/options.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/options.rb
new file mode 100644
index 0000000..b387269
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/options.rb
@@ -0,0 +1,5 @@
+module Mathtype3
+  class mtef_options < BinData::Record
+    
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/pile.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/pile.rb
new file mode 100644
index 0000000..63b7511
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/pile.rb
@@ -0,0 +1,43 @@
+require_relative "snapshot"
+
+# PILE record (4):
+
+# Consists of:
+
+# record type (4)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [halign] horizontal alignment
+# [valign] vertical alignment
+# [[RULER record]] if mtefOPT_LP_RULER is set
+# [object list] list of lines contained by the pile
+
+module Mathtype3
+  class RecordPile < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options halign valign object_list)
+
+    mandatory_parameter :_options
+
+    virtual :options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_halign
+    int8 :_valign
+
+    record_ruler :ruler, onlyif: lambda { _options & OPTIONS["xfRULER"] > 0 }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def halign
+      HALIGN[_halign]
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/size.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/size.rb
new file mode 100644
index 0000000..3ea2f3b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/size.rb
@@ -0,0 +1,75 @@
+require_relative "snapshot"
+
+# SIZE record (9):
+# Consists of one of the following cases:
+
+# if lsize < 0 (explicit point size):
+# record type (9)
+# 101
+# -point size (16 bit integer)
+# else if -128 < dsize < +128:
+# record type (9)
+# lsize (typesize)
+# dsize + 128
+# else: (large delta)
+# record type (9)
+# 100
+# lsize (typesize)
+# dsize (16 bit integer)
+# Sizes in MathType are represented as a pair of values, lsize and dsize. Lsize
+# stands for "logical size", dsize for "delta size". If it is negative, it is an
+# explicit point size (in 32nds of a point) negated and dsize is ignored.
+# Otherwise, lsize is a typesize value and dsize is a delta from that size:
+# Simple typesizes, without a delta value, are written using the records
+# described in the next section.
+
+module Mathtype3
+  class RecordSize < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options lsize dsize point_size)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    int8 :_size_select
+
+    mtef16 :_point_size, onlyif: lambda { _size_select == 101 }
+    uint8 :_lsize_large_delta, onlyif: lambda { _size_select == 100 }
+
+    uint8 :_dsize, onlyif: lambda { _size_select != 100 && _size_select != 101 }
+    mtef16 :_dsize_large, onlyif: lambda { _size_select == 100 }
+
+    def dsize
+      case _size_select
+      when 100
+        _dsize_large / 32
+      when 101
+        nil
+      else
+        (_dsize - 128) / 32 # in 32nds of a point
+      end
+    end
+
+    def lsize
+      case _size_select
+      when 100
+        _lsize_large_delta
+      when 101
+        nil
+      else
+        _size_select
+      end
+    end
+
+    def point_size
+      -_point_size if _point_size != 0
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/snapshot.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/snapshot.rb
new file mode 100644
index 0000000..013f8a6
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/snapshot.rb
@@ -0,0 +1,19 @@
+require "bindata"
+
+module Mathtype3
+  module Snapshot
+    def snapshot
+      snapshot = BinData::Record::Snapshot.new
+      exposed = self.class.const_get(:EXPOSED_IN_SNAPSHOT)
+      exposed.each do |name|
+        obj = find_obj_for_name(name)
+        if obj
+          snapshot[name] = obj.snapshot if include_obj?(obj)
+        else
+          snapshot[name] = self.send(name)
+        end
+      end
+      snapshot
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/tmpl.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/tmpl.rb
new file mode 100644
index 0000000..1484c4b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records3/tmpl.rb
@@ -0,0 +1,751 @@
+require_relative "snapshot"
+
+# TMPL record (3):
+
+# Consists of:
+# record type (3)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [selector] template selector code
+# [variation] template variation code (1 or 2 bytes; see below)
+# [options] template-specific options
+# [subobject list] either a single character (e.g. sigma in a summation) and/or lines
+# The template selector and variation codes determine the class of the
+# template and various properties of the template, such as which subobjects
+# can be deleted by the user (see Templates). The class of a template
+# determines the order and meaning of each of its subobjects (see Template
+# subobject order).
+
+# The variation code may be 1 or 2 bytes long. If the first byte value has the
+# high bit set (0x80), the next byte is read and combined with the first
+# according to this formula:
+
+# variation code = (byte1 & 0x7F)  |  (byte2 << 8)
+
+# Template-specific options field only used for integrals & fence templates:
+# Fence template option field values (fence alignment):
+# 0 center fence on math axis, place math axis of contents on math axis of
+# containing line (default);
+# 1 center fence on contents, place math axis of contents on math axis of
+# containing line;
+# 2 center fence on contents, center contents on math axis of containing line.
+# Warning: the expanding integral property is duplicated in the integral
+# templates variation codes (see Limit variations). On reading, MathType only
+# looks at the variation code.
+
+# Integral template option field values:
+# 0 fixed-size integral;
+# 1 the integral expands vertically to fit its contents.
+
+# Limit variations:
+
+# The following variation codes apply to all templates whose class is BigOpBoxClass or LimBoxClass:
+
+# variation bits  symbol  description
+# 0x0001  tvBO_LOWER  lower limit is present
+# 0x0002  tvBO_UPPER  upper limit is present
+# 0x0040  tvBO_SUM  summation-style limit positions, else integral-style
+
+# Template selectors and variations:
+# Fences (parentheses, etc.):
+# selector  symbol  description class
+# 0 tmANGLE angle brackets  ParBoxClass
+# 1 tmPAREN parentheses ParBoxClass
+# 2 tmBRACE braces (curly brackets) ParBoxClass
+# 3 tmBRACK square brackets ParBoxClass
+# 4 tmBAR vertical bars ParBoxClass
+# 5 tmDBAR  double vertical bars  ParBoxClass
+# 6 tmFLOOR floor brackets  ParBoxClass
+# 7 tmCEILING ceiling brackets  ParBoxClass
+# 8 tmOBRACK  open (white) brackets ParBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvFENCE_L left fence is present
+# 0x0002  tvFENCE_R right fence is present
+# Intervals:
+# selector  symbol  description class
+# 9 tmINTERVAL  unmatched brackets and parentheses  ParBoxClass
+# variations  variation bits  symbol  description
+# 0x0000  tvINTV_LEFT_LP  left fence is left parenthesis
+# 0x0001  tvINTV_LEFT_RP  left fence is right parenthesis
+# 0x0002  tvINTV_LEFT_LB  left fence is left bracket
+# 0x0003  tvINTV_LEFT_RB  left fence is right bracket
+# 0x0000  tvINTV_RIGHT_LP right fence is left parenthesis
+# 0x0010  tvINTV_RIGHT_RP right fence is right parenthesis
+# 0x0020  tvINTV_RIGHT_LB right fence is left bracket
+# 0x0030  tvINTV_RIGHT_RB right fence is right bracket
+# Radicals (square and nth roots):
+# selector  symbol  description class
+# 10  tmROOT  radical RootBoxClass
+# variations  variation symbol  description
+# 0 tvROOT_SQ square root
+# 1 tvROOT_NTH  nth root
+# Fractions:
+# selector  symbol  description class
+# 11  tmFRACT fractions FracBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvFR_SMALL  subscript-size slots (piece fraction)
+# 0x0002  tvFR_SLASH  fraction bar is a slash
+# 0x0004  tvFR_BASE num. and denom. are baseline aligned
+# Over and Underbars:
+# selector  symbol  description class
+# 12  tmUBAR  underbar  BarBoxClass
+# 13  tmOBAR  overbar BarBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvBAR_DOUBLE  bar is doubled, else single
+# Arrows:
+# selector  symbol  description class
+# 14  tmARROW arrow ArroBoxClass
+# variations  variation symbol  description
+# 0x0000  tvAR_SINGLE single arrow
+# 0x0001  tvAR_DOUBLE double arrow
+# 0x0002  tvAR_HARPOON  harpoon
+# 0x0004  tvAR_TOP  top slot is present
+# 0x0008  tvAR_BOTTOM bottom slot is present
+# 0x0010  tvAR_LEFT if single, arrow points left
+# 0x0020  tvAR_RIGHT  if single, arrow points right
+# 0x0010  tvAR_LOS  if double or harpoon, large over small
+# 0x0020  tvAR_SOL  if double or harpoon, small over large
+# Integrals (see Limit Variations):
+# selector  symbol  description class
+# 15  tmINTEG integral  BigOpBoxClass
+# variations  variation symbol  description
+# 0x0001  tvINT_1 single integral sign
+# 0x0002  tvINT_2 double integral sign
+# 0x0003  tvINT_3 triple integral sign
+# 0x0004  tvINT_LOOP  has loop w/o arrows
+# 0x0008  tvINT_CW_LOOP has clockwise loop
+# 0x000C  tvINT_CCW_LOOP  has counter-clockwise loop
+# 0x0100  tvINT_EXPAND  integral signs expand
+# Sums, products, coproducts, unions, intersections, etc. (see Limit Variations):
+# selector  symbol  description class
+# 16  tmSUM sum BigOpBoxClass
+# 17  tmPROD  product BigOpBoxClass
+# 18  tmCOPROD  coproduct BigOpBoxClass
+# 19  tmUNION union BigOpBoxClass
+# 20  tmINTER intersection  BigOpBoxClass
+# 21  tmINTOP integral-style big operator BigOpBoxClass
+# 22  tmSUMOP summation-style big operator  BigOpBoxClass
+# Limits (see Limit Variations):
+# selector  symbol  description class
+# 23  tmLIM limits  LimBoxClass
+# variations  variation symbol  description
+# 0 tvSUBAR single underbar
+# 1 tvDUBAR double underbar
+# Horizontal braces and brackets:
+# selector  symbol  description class
+# 24  tmHBRACE  horizontal brace  HFenceBoxClass
+# 25  tmHBRACK  horizontal bracket  HFenceBoxClass
+#   variation symbol  description
+# 0x0001  tvHB_TOP  slot is on the top, else on the bottom
+# Long division:
+# selector  symbol  description class
+# 26  tmLDIV  long division LDivBoxClass
+#   variation symbol  description
+# 0x0001  tvLD_UPPER  upper slot is present
+# Subscripts and superscripts:
+# selector  symbol  description class
+# 27  tmSUB subscript ScrBoxClass
+# 28  tmSUP superscript ScrBoxClass
+# 29  tmSUBSUP  subscript and superscript ScrBoxClass
+#   variation symbol  description
+# 0x0001  tvSU_PRECEDES script precedes scripted item,
+# else follows
+# Dirac bra-ket notation:
+# selector  symbol  description class
+# 30  tmDIRAC bra-ket notation  DiracBoxClass
+#   variation symbol  description
+# 0x0001  tvDI_LEFT left part is present
+# 0x0002  tvDI_RIGHT  right part is present
+# Vectors:
+# selector  symbol  description class
+# 31  tmVEC vector  HatBoxClass
+#   variation symbol  description
+# 0x0001  tvVE_LEFT arrow points left
+# 0x0002  tvVE_RIGHT  arrow points right
+# 0x0004  tvVE_UNDER  arrow under slot, else over slot
+# 0x0008  tvVE_HARPOON  harpoon
+# Hats, arcs, tilde, joint status:
+# selector  symbol  description class
+# 32  tmTILDE tilde over characters HatBoxClass
+# 33  tmHAT hat over characters HatBoxClass
+# 34  tmARC arc over characters HatBoxClass
+# 35  tmJSTATUS joint status construct  HatBoxClass
+# Overstrikes (cross-outs):
+# selector  symbol  description class
+# 36  tmSTRIKE  overstrike (cross-out)  StrikeBoxClass
+#   variation symbol  description
+# 0x0001  tvST_HORIZ  line is horizontal, else slashes
+# 0x0002  tvST_UP if slashes, slash from lower-left to upper-right is present
+# 0x0004  tvST_DOWN if slashes, slash from upper-left to lower-right is present
+# Boxes:
+# selector  symbol  description class
+# 37  tmBOX box TBoxBoxClass
+#   variation symbol  description
+# 0x0001  tvBX_ROUND  corners are round, else square
+# 0x0002  tvBX_LEFT left side is present
+# 0x0004  tvBX_RIGHT  right side is present
+# 0x0008  tvBX_TOP  top side is present
+# 0x0010  tvBX_BOTTOM bottom side is present
+
+module Mathtype3
+  class RecordTmpl < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options selector variation template_specific_options nudge
+      subobject_list)
+
+    SCRIPT_SELECTOR = {
+      0 => "tmSUP",
+      1 => "tmSUB",
+      2 => "tmSUBSUP"
+    }
+
+    SELECTORS = {
+      0 => "tmANGLE",
+      1 => "tmPAREN",
+      2 => "tmBRACE",
+      3 => "tmBRACK",
+      4 => "tmBAR",
+      5 => "tmDBAR",
+      6 => "tmFLOOR",
+      7 => "tmCEILING",
+      8 => "tmINTERVAL",
+      9 => "tmINTERVAL",
+      10 => "tmINTERVAL",
+      11 => "tmINTERVAL",
+      12 => "tmINTERVAL",
+      13 => "tmROOT",
+      14 => "tmFRACT",
+      15 => "tmSCRIPT",
+      16 => "tmUBAR",
+      17 => "tmOBAR",
+      18 => "tmARROW",
+      19 => "tmARROW",
+      20 => "tmARROW",
+      21 => "tmINTEG",
+      22 => "tmINTEG",
+      23 => "tmINTEG",
+      24 => "tmINTEG",
+      25 => "tmINTEG",
+      26 => "tmINTEG",
+      27 => "tmHBRACE",
+      28 => "tmHBRACE",
+      29 => "tmSUM",
+      30 => "tmSUM",
+      31 => "tmPROD",
+      32 => "tmPROD",
+      33 => "tmCOPROD",
+      34 => "tmCOPROD",
+      35 => "tmUNION",
+      36 => "tmUNION",
+      37 => "tmINTER",
+      38 => "tmINTER",
+      39 => "tmLIM",
+      40 => "tmLDIV",
+      41 => "tmFRACT",
+      42 => "tmINTOP",
+      43 => "tmSUMOP",
+      44 => "tmSCRIPT",
+      45 => "tmDIRAC",
+      46 => "tmVEC",
+      47 => "tmVEC",
+      48 => "tmBOX"
+    }
+    FENCE_BOTH = [
+                  "tvFENCE_L",
+                  "tvFENCE_R"
+                 ]
+
+    FENCE_VARIATIONS = {
+      0 => FENCE_BOTH,
+      1 => ["tvFENCE_L"], # left fence is present
+      2 => ["tvFENCE_R"] # right fence is present
+    }
+
+    BAR_VARIATIONS = {
+      0 => ["tvBAR_SINGLE"],
+      1 => ["tvBAR_DOUBLE"] #  bar is doubled, else single
+    }
+
+
+    VARIATIONS = {
+      # Fences (parentheses, etc.):
+      0 => FENCE_VARIATIONS,
+      1 => FENCE_VARIATIONS,
+      2 => FENCE_VARIATIONS,
+      3 => FENCE_VARIATIONS,
+      4 => FENCE_VARIATIONS,
+      5 => FENCE_VARIATIONS,
+      6 => {
+        0 => FENCE_BOTH
+      },
+      7 => {
+        0 => FENCE_BOTH
+      },
+      # Intervals:
+      # 0x0000 => "tvINTV_LEFT_LP", #  left fence is left parenthesis
+      # 0x0001 => "tvINTV_LEFT_RP", #  left fence is right parenthesis
+      # 0x0002 => "tvINTV_LEFT_LB", #  left fence is left bracket
+      # 0x0003 => "tvINTV_LEFT_RB", #  left fence is right bracket
+      # 0x0004 => "tvINTV_RIGHT_LP", # right fence is left parenthesis # WARNING: DOCUMENTATION SAYS 0x0000?
+      # 0x0010 => "tvINTV_RIGHT_RP", # right fence is right parenthesis
+      # 0x0020 => "tvINTV_RIGHT_LB", # right fence is left bracket
+      # 0x0030 => "tvINTV_RIGHT_RB", # right fence is right bracket
+      # Replaced above to match MathML translator
+      8 => {
+        0 => FENCE_BOTH
+      },
+      9 => {
+        0 => FENCE_BOTH
+      },
+      10 => {
+        0 => FENCE_BOTH
+      },
+      11 => {
+        0 => FENCE_BOTH
+      },
+      12 => {
+        0 => FENCE_BOTH
+      },
+
+      # Radicals (square and nth roots):
+      13 => {
+        0 => ["tvROOT_SQ"], # square root
+        1 => ["tvROOT_NTH"] # nth root
+      },
+
+      # Fractions:
+      14 => {
+        #TODO: full-size slots?
+        0 => ["tvFR_FULL"],
+        1 => ["tvFR_SMALL"] #  subscript-size slots (piece fraction)
+      },
+
+      # Over and Underbars:
+      16 => BAR_VARIATIONS,
+      17 => BAR_VARIATIONS,
+
+      # Arrows:
+      18 => {
+        0 => [
+          "tvAR_SINGLE",
+          "tvAR_LEFT",
+          "tvAR_TOP",
+        ], # single arrow
+        1 => [
+          "tvAR_SINGLE",
+          "tvAR_LEFT",
+          "tvAR_BOTTOM"
+        ]
+      },
+
+      19 => {
+        0 => [
+          "tvAR_SINGLE",
+          "tvAR_RIGHT",
+          "tvAR_TOP"
+        ],
+        1 => [
+          "tvAR_SINGLE",
+          "tvAR_RIGHT",
+          "tvAR_TOP"
+        ]
+      },
+
+      20 => {
+        0 => [
+          "tvAR_SINGLE",
+          "tvAR_RIGHT",
+          "tvAR_LEFT",
+          "tvAR_TOP"
+        ],
+        1 => [
+          "tvAR_SINGLE",
+          "tvAR_RIGHT",
+          "tvAR_LEFT",
+          "tvAR_TOP"
+        ]
+      },
+
+      # Integrals (see Limit Variations):
+      21 => {
+        0 => [
+          "tvINT_1" # single integral sign
+        ],
+        1 => [
+          "tvINT_1",
+          "tvBO_LOWER"
+        ],
+        2 => [
+          "tvINT_1",
+          "tvBO_LOWER",
+          "tvBO_UPPER"
+        ],
+        3 => [
+          "tvINT_1",
+        ],
+        4 => [
+          "tvINT_1",
+          "tvBO_LOWER"
+        ]
+      },
+
+      22 => {
+        0 => [
+          "tvINT_2" # double integral sign
+        ],
+        1 => [
+          "tvINT_2",
+          "tvBO_LOWER"
+        ],
+        2 => [
+          "tvINT_2",
+          "tvBO_LOWER",
+          "tvBO_UPPER"
+        ],
+        3 => [
+          "tvINT_2",
+        ],
+        4 => [
+          "tvINT_2",
+          "tvBO_LOWER"
+        ]
+      },
+
+      23 => {
+        0 => [
+          "tvINT_3" # triple integral sign
+        ],
+        1 => [
+          "tvINT_3",
+          "tvBO_LOWER"
+        ],
+        2 => [
+          "tvINT_3",
+          "tvBO_LOWER",
+          "tvBO_UPPER"
+        ],
+        3 => ["tvINT_3"],
+        4 => [
+          "tvINT_3",
+          "tvBO_LOWER"
+        ]
+      },
+
+      24 => {
+        0 => [
+          "tvINT_1", # single integral sign
+          "tvBO_SUM",
+          "tvBO_LOWER",
+          "tvBO_UPPER"
+        ],
+        1 => [
+          "tvINT_1",
+          "tvBO_SUM",
+          "tvBO_LOWER"
+        ],
+        2 => [
+          "tvINT_1",
+          "tvBO_SUM",
+          "tvBO_LOWER",
+        ]
+      },
+
+      25 => {
+        0 => [
+          "tvINT_2", # double integral sign
+          "tvBO_SUM",
+          "tvBO_LOWER",
+        ],
+        1 => [
+          "tvINT_2",
+          "tvBO_SUM",
+          "tvBO_LOWER"
+        ]
+      },
+
+      26 => {
+        0 => [
+          "tvINT_3", # triple integral sign
+          "tvBO_SUM",
+          "tvBO_LOWER"
+        ],
+        1 => [
+          "tvINT_3",
+          "tvBO_SUM",
+          "tvBO_LOWER"
+        ]
+      },
+
+      # Horizontal braces and brackets:
+      27 => {
+        0 => ["tvHB_TOP"] # slot is on the top
+      },
+
+      28 => {
+        #  default on the bottom
+        0 => ["tvHB_BOT"]
+      },
+
+      # Sums, products, coproducts, unions, intersections, etc.:
+      29 => {
+        0 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_SUM" # summation-style limit positions,
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER", # upper limit is present
+          "tvBO_SUM"
+        ],
+        2 => ["tvBO_SUM"]
+      },
+
+      30 => {
+        0 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      31 => {
+        0 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_SUM" # summation-style limit positions,
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER", # upper limit is present
+          "tvBO_SUM"
+        ],
+        2 => ["tvBO_SUM"]
+      },
+
+      32 => {
+        0 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      33 => {
+        0 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_SUM" # summation-style limit positions,
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER", # upper limit is present
+          "tvBO_SUM"
+        ],
+        2 => ["tvBO_SUM"]
+      },
+
+      34 => {
+        0 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      35 => {
+        0 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_SUM" # summation-style limit positions,
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER", # upper limit is present
+          "tvBO_SUM"
+        ],
+        2 => ["tvBO_SUM"]
+      },
+
+      36 => {
+        0 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      37 => {
+        0 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_SUM" # summation-style limit positions,
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER", # upper limit is present
+          "tvBO_SUM"
+        ],
+        2 => ["tvBO_SUM"]
+      },
+
+      38 => {
+        0 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        1 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      39 => {
+        0 => [
+          "tvBO_UPPER" # upper limit is present
+        ],
+        1 => [
+          "tvBO_LOWER" # lower limit is present
+        ],
+        2 => [
+          "tvBO_LOWER", # lower limit is present
+          "tvBO_UPPER" # upper limit is present
+        ]
+      },
+
+      # Long division:
+      40 => {
+        0 => ["tvLD_UPPER"]
+      },
+
+      # Frac with Slash:
+      41 => {
+        0 => ["tvFR_SLASH"],
+        1 => [
+              "tvFR_SLASH",
+              "tvFR_BASE"
+             ],
+        2 => [
+              "tvFR_SLASH",
+              "tvFR_SMALL"
+             ]
+      },
+
+      # Big integral-style operators:
+      42 => {
+        0 => ["tvBO_LOWER"],
+        1 => ["tvBO_UPPER"],
+        2 => [
+              "tvBO_LOWER",
+              "tvBO_UPPER"
+             ]
+      },
+
+      # Big summation-style operators:
+      43 => {
+        0 => [
+              "tvBO_SUM",
+              "tvBO_LOWER"
+             ],
+        1 => [
+              "tvBO_SUM",
+              "tvBO_UPPER"
+             ],
+        2 => [
+              "tvBO_SUM",
+              "tvBO_LOWER",
+              "tvBO_UPPER"
+             ]
+      },
+
+      44 => {
+        0 => ["tvSU_PRECEDES"],
+        1 => ["tvSU_PRECEDES"],
+        2 => ["tvSU_PRECEDES"],
+        3 => ["tvSU_PRECEDES"]
+      },
+
+      45 => {
+        0 => [
+              "tvDI_LEFT",
+              "tvDI_RIGHT"
+             ],
+        1 => ["tvDI_LEFT"],
+        2 => ["tvDI_RIGHT"]
+      },
+
+      46 => {
+        0 => [
+              "tvVE_UNDER",
+              "tvVE_LEFT"
+              ],
+        1 => [
+              "tvVE_UNDER",
+              "tvVE_RIGHT"
+              ],
+        2 => [
+              "tvVE_UNDER",
+              "tvVE_LEFT",
+              "tvVE_RIGHT"
+              ],
+      },
+
+      47 => {
+        0 => ["tvVE_LEFT"],
+        1 => ["tvVE_RIGHT"],
+        2 => [
+              "tvVE_LEFT",
+              "tvVE_RIGHT"
+              ],
+      },
+
+      # Selectors with empty variation:
+      15 => {0=>nil,1=>nil,2=>nil,3=>nil,4=>nil},
+      48 => {0=>nil,1=>nil,2=>nil,3=>nil,4=>nil}
+    }
+
+
+    # When options overlap in the binary space, ordinary bitmasks
+    # are not the correct tool to use for detection. We use digit
+    # position and presence instead.
+
+    DIGIT_MODE_VARIATIONS = [9]
+
+    # Top-level keys are template identifiers, defined in TEMPLATES.
+    # Second-level keys are bits for certain variations, negative keys mean
+    # that the variation is present if the bit is absent.
+
+    mandatory_parameter :_options
+
+    virtual :options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_selector
+
+    int8 :_variation
+
+    int8 :template_specific_options
+
+    array :subobject_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def selector
+      if is_script _selector 
+          #SCRIPT has to be handled separate
+        SCRIPT_SELECTOR[_variation]
+      else
+        SELECTORS[_selector]
+      end
+    end
+    def is_script(sel)
+      return sel == 44 || sel == 15
+    end
+  	 def variation
+      VARIATIONS[_selector][_variation]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/char.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/char.rb
new file mode 100644
index 0000000..02fce53
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/char.rb
@@ -0,0 +1,130 @@
+# CHAR record (2):
+# Consists of:
+# record type (2)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [typeface] typeface value (signed integer; see FONT_STYLE_DEF record below)
+# [character] character value (see below)
+# [embellishment list] if mtefOPT_CHAR_EMBELL is set (embellishments)
+# The character value itself is represented by one or more values. The presence or absence of these value is indicated by options and appear in this order:
+# 16-bit integer MTCode value present unless the mtefOPT_CHAR_ENC_NO_MTCODE option is set
+# 8-bit font position present if the mtefOPT_CHAR_ENC_CHAR_8 option is set
+# 16-bit integer font position  present if the mtefOPT_CHAR_ENC_CHAR_16 option is set
+# The MTCode value defines the character independent of its font. MTCode is a superset of Unicode and is described in MTCode Encoding Tables. The 8-bit and 16-bit font positions are mutually exclusive but may both be absent. This is the position of the character within its font. Some of the common font encodings are given in Font Encoding Tables.
+
+require_relative "snapshot"
+
+module Mathtype5
+  class RecordEmbell < BinData::Record; end
+  class RecordChar < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(nudge typeface mt_code_value options font_position
+      variation embellishment_list)
+
+    endian :little
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_typeface
+
+    mtef16 :_mt_code_value, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_CHAR_ENC_NO_MTCODE"] == 0
+    end)
+
+    font_position_choice = lambda do
+      char_enc_char_8 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_8"] > 0
+      char_enc_char_16 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_16"] > 0
+
+      if char_enc_char_8
+        8
+      elsif char_enc_char_16
+        16
+      end
+    end
+
+    font_position_present = lambda do
+      char_enc_char_8 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_8"] > 0
+      char_enc_char_16 = options & OPTIONS["mtefOPT_CHAR_ENC_CHAR_16"] > 0
+
+      char_enc_char_8 || char_enc_char_16
+    end
+
+    choice :font_position,
+        selection: font_position_choice,
+        onlyif: font_position_present do
+
+      uint8 8
+      mtef16 16
+    end
+
+    array :embellishment_list,
+        onlyif: lambda { options & OPTIONS["mtefOPT_CHAR_EMBELL"] > 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def mt_code_value
+      sprintf("0x%04X", _mt_code_value)
+    end
+
+    def typeface
+      _typeface + 128
+    end
+
+    def variation
+      # Check for overrides from eqn_prefs
+      # typeface < 128 implies it's a style index
+      if typeface < 128
+        prefs = find_eqn_prefs
+        # Check if styles exist and index is valid
+        # Note: styles is a BinData::Array, access via [] works
+        if prefs && prefs.respond_to?(:styles)
+          # BinData arrays might be lazy or behave differently, but generally index access works
+          # We need to ensure we don't access out of bounds
+          if typeface < prefs.styles.length
+            style = prefs.styles[typeface]
+            # Check italic bit (bit 1, value 2). If 0, it is upright (textmode)
+            if (style.font_style & 2) == 0
+              return "textmode"
+            end
+          end
+        end
+      end
+
+      case typeface
+      when 1, 9, 10
+        "textmode"
+      else
+        "mathmode"
+      end
+    end
+
+    private
+
+    def find_eqn_prefs
+      # Traverse up parent chain to find the equation array
+      # Hierarchy: RecordChar -> Payload (Choice) -> NamedRecord -> Array -> Equation
+      node = parent
+      while node
+        # BinData::Array usually behaves like an Array
+        if node.respond_to?(:find) && node.respond_to?(:each)
+           # We suspect this is the record list.
+           # Verify if it contains records with record_type
+           # We can check the first element or just try to find
+           # Note: We need to use safe navigation if elements aren't populated yet?
+           # But parsing is done sequentially. If we are in Char, EqnPrefs (usually earlier) should be readable.
+
+           # Search for record_type 18 (eqn_prefs)
+           # Element is NamedRecord
+           prefs_record = node.find { |r| r.respond_to?(:record_type) && r.record_type == 18 }
+           if prefs_record
+             return prefs_record.payload
+           end
+        end
+        node = node.parent
+      end
+      nil
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color.rb
new file mode 100644
index 0000000..3537410
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color.rb
@@ -0,0 +1,13 @@
+# COLOR records (15):
+# Consists of:
+# record type (15)
+# [color_def_index] index of corresponding COLOR_DEF record (unsigned integer)
+# The appearance of this record in the stream indicates that all following
+# equation records (until the next COLOR record) have the color defined by the
+# indicated COLOR_DEF record.
+
+module Mathtype5
+  class RecordColor < BinData::Record
+    mt_uint :color_def_index
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color_def.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color_def.rb
new file mode 100644
index 0000000..acb74d8
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/color_def.rb
@@ -0,0 +1,37 @@
+# COLOR_DEF records (16):
+# Consists of:
+# record type (16)
+# [options] model is RGB unless mtefCOLOR_CMYK bit is set; type is process
+# unless mtefCOLOR_SPOT bit is set; color is unnamed unless mtefCOLOR_NAME bit is set
+# [color values] if RGB, 3 values (red, green, blue); if CMYK, 4 values (cyan,
+# magenta, yellow, black); see below for details
+# [name] null-terminated color name appears only if mtefCOLOR_NAME is set
+# This record defines a color (see Definition records). Each color value is
+# written as a 16-bit integer that ranges between 0 and 1000 where 0 is the
+# absence of the color and 1000 is a fully saturated color. So, an RGB color
+# definition for black has all three components at 0.
+
+module Mathtype5
+  class RecordColorDef < BinData::Record
+    endian :little
+
+    int8 :options
+
+    struct :rgb, onlyif: lambda { options & OPTIONS["mtefCOLOR_CMYK"] == 0 } do
+      mtef16 :r
+      mtef16 :g
+      mtef16 :b
+    end
+
+    struct :cmyk, onlyif: lambda { options & OPTIONS["mtefCOLOR_CMYK"] > 0} do
+      mtef16 :c
+      mtef16 :m
+      mtef16 :y
+      mtef16 :k
+    end
+
+    stringz :color_name, onlyif: (lambda do
+      options & OPTIONS["mtefCOLOR_NAME"] > 0
+    end)
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/comment.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/comment.rb
new file mode 100644
index 0000000..80b413b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/comment.rb
@@ -0,0 +1,15 @@
+# If the record type is 100 or greater, it represents a record that will be
+# defined in a future version of MTEF. For now, readers can assume that an
+# unsigned integer follows the record type and is the number of bytes following
+# it in the record (i.e. it doesn't include the record type and length). This
+# makes it easy for software that reads MTEF to skip these records. Although it
+# might be handy if all records had such a length value, it will only be present
+# on future expansion records (i.e. those with record types >= 100).
+
+module Mathtype5
+  class RecordMtComment < BinData::Record
+    mt_uint :comment_length
+    stringz :comment_type
+    stringz :comment_data
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/embell.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/embell.rb
new file mode 100644
index 0000000..0504567
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/embell.rb
@@ -0,0 +1,103 @@
+require_relative "snapshot"
+
+# EMBELL record (6):
+# Consists of:
+# record type (6)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [embell] embellishment type
+# The embellishment types are:
+
+# value symbol  description
+# 2 emb1DOT over single dot
+# 3 emb2DOT over double dot
+# 4 emb3DOT over triple dot
+# 5 emb1PRIME single prime
+# 6 emb2PRIME double prime
+# 7 embBPRIME backwards prime (left of character)
+# 8 embTILDE  tilde
+# 9 embHAT  hat (circumflex)
+# 10  embNOT  diagonal slash through character
+# 11  embRARROW over right arrow
+# 12  embLARROW over left arrow
+# 13  embBARROW over both arrow (left and right)
+# 14  embR1ARROW  over right single-barbed arrow
+# 15  embL1ARROW  over left single-barbed arrow
+# 16  embMBAR mid-height horizontal bar
+# 17  embOBAR over-bar
+# 18  emb3PRIME triple prime
+# 19  embFROWN  over-arc, concave downward
+# 20  embSMILE  over-arc, concave upward
+# 21  embX_BARS double diagonal bars
+# 22  embUP_BAR bottom-left to top-right diagonal bar
+# 23  embDOWN_BAR top-left to bottom-right diagonal bar
+# 24  emb4DOT over quad dot
+# 25  embU_1DOT under single dot
+# 26  embU_2DOT under double dot
+# 27  embU_3DOT under triple dot
+# 28  embU_4DOT under quad dot
+# 29  embU_BAR  under bar
+# 30  embU_TILDE  under tilde (~)
+# 31  embU_FROWN  under arc (ends point down)
+# 32  embU_SMILE  under arc (ends point up)
+# 33  embU_RARROW under right arrow
+# 34  embU_LARROW under left arrow
+# 35  embU_BARROW under both arrow (left and right)
+# 36  embU_R1ARROW  under right arrow (1 barb)
+# 37  embU_L1ARROW  under left arrow (1 barb)
+
+module Mathtype5
+  class RecordEmbell < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge embell)
+
+    EMBELL = {
+      2 => "emb1DOT", # over single dot
+      3 => "emb2DOT", # over double dot
+      4 => "emb3DOT", # over triple dot
+      5 => "emb1PRIME", # single prime
+      6 => "emb2PRIME", # double prime
+      7 => "embBPRIME", # backwards prime (left of character)
+      8 => "embTILDE", #  tilde
+      9 => "embHAT", #  hat (circumflex)
+      10 => "embNOT", #  diagonal slash through character
+      11 => "embRARROW", # over right arrow
+      12 => "embLARROW", # over left arrow
+      13 => "embBARROW", # over both arrow (left and right)
+      14 => "embR1ARROW", #  over right single-barbed arrow
+      15 => "embL1ARROW", #  over left single-barbed arrow
+      16 => "embMBAR", # mid-height horizontal bar
+      17 => "embOBAR", # over-bar
+      18 => "emb3PRIME", # triple prime
+      19 => "embFROWN", #  over-arc, concave downward
+      20 => "embSMILE", #  over-arc, concave upward
+      21 => "embX_BARS", # double diagonal bars
+      22 => "embUP_BAR", # bottom-left to top-right diagonal bar
+      23 => "embDOWN_BAR", # top-left to bottom-right diagonal bar
+      24 => "emb4DOT", # over quad dot
+      25 => "embU_1DOT", # under single dot
+      26 => "embU_2DOT", # under double dot
+      27 => "embU_3DOT", # under triple dot
+      28 => "embU_4DOT", # under quad dot
+      29 => "embU_BAR", #  under bar
+      30 => "embU_TILDE", #  under tilde (~)
+      31 => "embU_FROWN", #  under arc (ends point down)
+      32 => "embU_SMILE", #  under arc (ends point up)
+      33 => "embU_RARROW", # under right arrow
+      34 => "embU_LARROW", # under left arrow
+      35 => "embU_BARROW", # under both arrow (left and right)
+      36 => "embU_R1ARROW", #  under right arrow (1 barb)
+      37 => "embU_L1ARROW", #  under left arrow (1 barb)
+    }
+
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_embell
+
+    def embell
+      EMBELL[_embell]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/encoding_def.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/encoding_def.rb
new file mode 100644
index 0000000..5a1aee1
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/encoding_def.rb
@@ -0,0 +1,22 @@
+# ENCODING_DEF records (19):
+# Consists of:
+# record type (19)
+# [name] null-terminated encoding name
+# This record defines (see Definition records) a font encoding and is referred
+# to by a FONT_DEF record. In order to reduce the size of the MTEF stream,
+# the following 4 encodings are predefined:
+
+# ENCODING_DEF index  encoding name
+# 1 MTCode
+# 2 Unknown
+# 3 Symbol
+# 4 MTExtra
+# This means that the first ENCODING_DEF record in the MTEF stream is considered
+# to have an index of 5. See Extending MathType's Font and Character Information
+# and MathType's Character Encodings for more information on font encodings.
+
+module Mathtype5
+  class RecordEncodingDef < BinData::Record
+    stringz :name
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/eqn_prefs.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/eqn_prefs.rb
new file mode 100644
index 0000000..616f56a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/eqn_prefs.rb
@@ -0,0 +1,44 @@
+# EQN_PREFS records (18):
+
+# Consists of:
+
+# record type (18)
+# [options] none defined in this version of MTEF
+# [sizes] dimension array for typesize definitions
+# [spaces] dimension array for spacing definitions (see below)
+# [styles] array of style definitions (see below)
+# When reading arrays, the number of values may be less than or greater than
+# expected. MTEF readers should be driven by the array count.
+# If the array is shorter than expected, assume defaults for the missing values.
+# If the array is longer than expected, the extra values must be skipped to stay
+# in sync with the MTEF stream.
+
+module Mathtype5
+  class Entry < BinData::Record
+    bit4 :unit
+    array :nibbles, read_until: lambda { element == 0xF } do
+      bit4
+    end
+  end
+
+  class RecordEqnPrefs < BinData::Record
+    int8 :options
+
+    int8 :sizes_count
+    array :sizes, initial_length: :sizes_count do
+      entry
+    end
+
+    int8 :spaces_count
+    array :spaces, initial_length: :spaces_count do
+      entry
+    end
+
+    int8 :styles_count
+    array :styles, initial_length: :styles_count do
+      int8 :font_def
+      int8 :font_style, onlyif: lambda { font_def != 0x00 }
+    end
+    resume_byte_alignment
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_def.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_def.rb
new file mode 100644
index 0000000..9daa6b3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_def.rb
@@ -0,0 +1,14 @@
+# FONT_DEF records (17):
+# Consists of:
+# record type (17)
+# [enc_def_index] index of corresponding ENCODING_DEF record (unsigned integer)
+# [name] null-terminated font name
+# This record associates an font encoding with a font name. See Definition
+# records.
+
+module Mathtype5
+  class RecordFontDef < BinData::Record
+    mt_uint :enc_def_index
+    stringz :font_name
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_style_def.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_style_def.rb
new file mode 100644
index 0000000..4dda805
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/font_style_def.rb
@@ -0,0 +1,14 @@
+# FONT_STYLE_DEF record (8):
+# Consists of:
+# record type (8)
+# [font_def_index] index of mtefFONT_DEF record (unsigned integer)
+# [char_style] character style bits
+# This record associates a character style with a font. See Definition records.
+
+module Mathtype5
+  class RecordFontStyleDef < BinData::Record
+    mt_uint :font_def_index
+
+    int8 :char_style
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/future.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/future.rb
new file mode 100644
index 0000000..a25b253
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/future.rb
@@ -0,0 +1,14 @@
+# If the record type is 100 or greater, it represents a record that will be
+# defined in a future version of MTEF. For now, readers can assume that an
+# unsigned integer follows the record type and is the number of bytes following
+# it in the record (i.e. it doesn't include the record type and length). This
+# makes it easy for software that reads MTEF to skip these records. Although it
+# might be handy if all records had such a length value, it will only be present
+# on future expansion records (i.e. those with record types >= 100).
+
+module Mathtype5
+  class RecordFuture < BinData::Record
+    uint8 :skip
+    skip length: :skip
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/line.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/line.rb
new file mode 100644
index 0000000..2f9f4ae
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/line.rb
@@ -0,0 +1,36 @@
+# LINE record (1):
+# Consists of:
+# record type (1)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [line spacing] if mtefOPT_LINE_LSPACE is set (16-bit integer)
+# [RULER record] if mtefOPT_LP_RULER is set
+# object list of line (single pile, characters and templates, or nothing)
+# The line spacing value, if present, is the distance between the baseline of
+# this line and the line above it.
+
+module Mathtype5
+  class NamedRecord < BinData::Record; end
+  class RecordLine < BinData::Record
+    endian :little
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    mtef16 :line_spacing, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_LINE_LSPACE"] > 0
+    end)
+
+    record_ruler :ruler, onlyif: (lambda do
+      options & OPTIONS["mtefOPT_LP_RULER"] > 0
+    end)
+
+    array :object_list,
+        onlyif: lambda { options & OPTIONS["mtefOPT_LINE_NULL"] == 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def to_formatted_s(indent = 0); to_s; end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/matrix.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/matrix.rb
new file mode 100644
index 0000000..99b820b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/matrix.rb
@@ -0,0 +1,77 @@
+require_relative "snapshot"
+
+# MATRIX record (5):
+# record type (5)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [valign] vertical alignment of matrix within container
+# [h_just] horizontal alignment within columns
+# [v_just] vertical alignment within columns
+# [rows] number of rows
+# [cols] number of columns
+# [row_parts] row partition line types (see below)
+# [col_parts] column partition line types (see below)
+# [object list] list of lines, one for each element of the matrix, in order from
+# left-to-right and top-to-bottom
+# The values for valign, h_just, and v_just are described in PILE above.
+
+# The row partition line type list consists of two-bit values for each possible
+# partition line (one more than the number of rows), rounded out to the nearest
+# byte. Each value determines the line style of the corresponding partition line
+# (0 for none, 1 for solid, 2 for dashed, or 3 for dotted). Similarly for the
+# column partition lines.
+
+module Mathtype5
+  class RecordMatrix < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge valign h_just v_just rows cols
+      row_parts col_parts object_list)
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_valign
+    int8 :_h_just
+    int8 :_v_just
+    int8 :rows
+    int8 :cols
+
+    array :_row_parts, initial_length: lambda { (rows + 4) / 4 } do
+      matrix_line_byte
+    end
+
+    array :_col_parts, initial_length: lambda { (cols + 4) / 4 } do
+      matrix_line_byte
+    end
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+
+    def h_just
+      HALIGN[_h_just]
+    end
+
+    def v_just
+      VALIGN[_v_just]
+    end
+
+    def truncate_parts parts, cnt
+      full_parts = cnt / 4
+      all = [parts.first(full_parts), parts.last]
+      all.flatten[0 .. (full_parts*4 + cnt%4)]
+    end
+
+    def row_parts
+      truncate_parts _row_parts, rows
+    end
+
+    def col_parts
+      truncate_parts _col_parts, cols
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtef.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtef.rb
new file mode 100644
index 0000000..c9ef91a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtef.rb
@@ -0,0 +1,134 @@
+require_relative 'mtuint'
+
+require_relative "line"
+require_relative "embell"
+require_relative "char"
+require_relative "pile"
+require_relative "tmpl"
+require_relative "eqn_prefs"
+require_relative "font_def"
+require_relative "font_style_def"
+require_relative "matrix"
+require_relative "encoding_def"
+require_relative "embell"
+require_relative "size"
+require_relative "color"
+require_relative "color_def"
+require_relative "future"
+require_relative "comment"
+
+module Mathtype5
+  class RecordEnd < Mathtype::RecordEnd; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordRuler < Mathtype::RecordRuler; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordFull < Mathtype::RecordFull; end
+  class RecordSub < Mathtype::RecordSub; end
+  class RecordSub2 < Mathtype::RecordSub2; end
+  class RecordSym < Mathtype::RecordSym; end
+  class RecordSubsym < Mathtype::RecordSubsym; end
+
+  HALIGN = Mathtype::HALIGN
+  VALIGN = Mathtype::VALIGN
+
+  RECORD_NAMES = {
+    0 => "end",
+    1 => "slot",
+    2 => "char",
+    3 => "tmpl",
+    4 => "pile",
+    5 => "matrix",
+    6 => "embell",
+    7 => "ruler",
+    8 => "font_style_def",
+    9 => "size",
+    10 => "full",
+    11 => "sub",
+    12 => "sub2",
+    13 => "sym",
+    14 => "subsym",
+    15 => "color",
+    16 => "color_def",
+    17 => "font_def",
+    18 => "eqn_prefs",
+    19 => "encoding_def",
+    100 => "future",
+    102 => "mt_comment"
+  }
+
+  OPTIONS = {
+    # value => symbol                     # description
+    # Option flag values for all equation structure records:
+    "mtefOPT_NUDGE" => 0x08,              # nudge values follow tag
+    # Option flag values for CHAR records:
+    "mtefOPT_CHAR_EMBELL" => 0x01,        # character is followed by an embellishment list
+    "mtefOPT_CHAR_FUNC_START" => 0x02,    # character starts a function (sin, cos, etc.)
+    "mtefOPT_CHAR_ENC_CHAR_8" => 0x04,    # character is written with an 8-bit encoded value
+    "mtefOPT_CHAR_ENC_CHAR_16" => 0x10,   # character is written with an 16-bit encoded value
+    "mtefOPT_CHAR_ENC_NO_MTCODE" => 0x20, # character is written without an 16-bit MTCode value
+    # Option flag values for LINE records:
+    "mtefOPT_LINE_NULL" => 0x01,          # line is a placeholder only (i.e. not displayed)
+    "mtefOPT_LINE_LSPACE" => 0x04,        # line spacing value follows tag
+    # Option flag values for LINE and PILE records:
+    "mtefOPT_LP_RULER" => 0x02,           # RULER record follows LINE or PILE record
+    # Option flag values for COLOR_DEF records:
+    "mtefCOLOR_CMYK" => 0x01,             # color model is CMYK, else RGB
+    "mtefCOLOR_SPOT" => 0x02,             # color is a spot color, else a process color
+    "mtefCOLOR_NAME" => 0x04,             # color has a name, else no name
+  }
+
+  ## Payload is the most important class to understand.
+  ## This abstraction allows recursive formats.
+  ## eg. lists can contain lists can contain lists.
+
+  class Payload < BinData::Choice
+    opt = {:_options => :options}
+    record_end 0 # end is a reserved keyword
+    record_line 1
+    record_char 2
+    record_tmpl 3
+    record_pile 4
+    record_matrix 5
+    record_embell 6
+    record_ruler 7
+    record_font_style_def 8
+    record_size 9
+    record_full 10
+    record_sub 11
+    record_sub2 12
+    record_sym 13
+    record_subsym 14
+    record_color 15
+    record_color_def 16
+    record_font_def 17
+    record_eqn_prefs 18
+    record_encoding_def 19
+    record_future 100
+    record_mt_comment 102
+  end
+
+  class NamedRecord < BinData::Record
+    int8 :record_type
+    payload :payload, :onlyif => :not_end_tag?, :selection => :record_type, :options => :record_options
+
+    def not_end_tag?
+      record_type != 0
+    end
+  end
+
+  class Equation < Mathtype::Equation
+    EXPOSED_IN_SNAPSHOT = %i(mtef_version platform product product_version
+      product_subversion application_key equation_options equation)
+
+    stringz :application_key
+    uint8 :_equation_options
+
+    def equation_options
+      _equation_options == 1 ? "inline" : "block"
+    end
+
+    array :equation, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtuint.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtuint.rb
new file mode 100644
index 0000000..57831a1
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/mtuint.rb
@@ -0,0 +1,14 @@
+module Mathtype
+  class Mt_uint < BinData::Primitive
+    uint8 :_first
+    uint8 :_second, onlyif: lambda { _first == 0xFF }
+    uint8 :_third, onlyif: lambda { _first == 0xFF }
+
+    def get
+      _first < 0xFF ?
+        _first :
+        _third << 0x8 | _second
+    end
+  end
+end
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/pile.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/pile.rb
new file mode 100644
index 0000000..d2b3a7c
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/pile.rb
@@ -0,0 +1,41 @@
+require_relative "snapshot"
+
+# PILE record (4):
+
+# Consists of:
+
+# record type (4)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [halign] horizontal alignment
+# [valign] vertical alignment
+# [[RULER record]] if mtefOPT_LP_RULER is set
+# [object list] list of lines contained by the pile
+
+module Mathtype5
+  class RecordPile < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options halign valign object_list)
+
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_halign
+    int8 :_valign
+
+    record_ruler :ruler, onlyif: lambda { options & OPTIONS["mtefOPT_LP_RULER"] > 0 }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def halign
+      HALIGN[_halign]
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/size.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/size.rb
new file mode 100644
index 0000000..2eb272e
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/size.rb
@@ -0,0 +1,72 @@
+require_relative "snapshot"
+
+# SIZE record (9):
+# Consists of one of the following cases:
+
+# if lsize < 0 (explicit point size):
+# record type (9)
+# 101
+# -point size (16 bit integer)
+# else if -128 < dsize < +128:
+# record type (9)
+# lsize (typesize)
+# dsize + 128
+# else: (large delta)
+# record type (9)
+# 100
+# lsize (typesize)
+# dsize (16 bit integer)
+# Sizes in MathType are represented as a pair of values, lsize and dsize. Lsize
+# stands for "logical size", dsize for "delta size". If it is negative, it is an
+# explicit point size (in 32nds of a point) negated and dsize is ignored.
+# Otherwise, lsize is a typesize value and dsize is a delta from that size:
+# Simple typesizes, without a delta value, are written using the records
+# described in the next section.
+
+module Mathtype5
+  class RecordSize < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(lsize dsize point_size)
+
+    endian :little
+    int8 :_size_select
+
+    mtef16 :_point_size, onlyif: lambda { _size_select == 101 }
+    uint8 :_lsize_large_delta, onlyif: lambda { _size_select == 100 }
+
+    uint8 :_dsize, onlyif: lambda { _size_select != 100 && _size_select != 101 }
+    mtef16 :_dsize_large, onlyif: lambda { _size_select == 100 }
+
+    def dsize
+      __dsize = nil
+      case _size_select
+      when 100
+        if _dsize_large > 255
+         __dsize = -(_dsize_large.getlow)
+        else
+         __dsize = _dsize_large
+        end
+      when 101
+        __dsize = _dsize
+      else
+        __dsize = (_dsize - 128) # in 32nds of a point
+      end
+      __dsize / 32
+    end
+
+    def lsize
+      case _size_select
+      when 100
+        _lsize_large_delta
+      when 101
+        nil
+      else
+        _size_select
+      end
+    end
+
+    def point_size
+      -_point_size if _point_size != 0
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/snapshot.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/snapshot.rb
new file mode 100644
index 0000000..65b9e3b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/snapshot.rb
@@ -0,0 +1,19 @@
+require "bindata"
+
+module Mathtype5
+  module Snapshot
+    def snapshot
+      snapshot = BinData::Record::Snapshot.new
+      exposed = self.class.const_get(:EXPOSED_IN_SNAPSHOT)
+      exposed.each do |name|
+        obj = find_obj_for_name(name)
+        if obj
+          snapshot[name] = obj.snapshot if include_obj?(obj)
+        else
+          snapshot[name] = self.send(name)
+        end
+      end
+      snapshot
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/tmpl.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/tmpl.rb
new file mode 100644
index 0000000..794fdf6
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/lib/records5/tmpl.rb
@@ -0,0 +1,498 @@
+require_relative "snapshot"
+
+# TMPL record (3):
+
+# Consists of:
+# record type (3)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [selector] template selector code
+# [variation] template variation code (1 or 2 bytes; see below)
+# [options] template-specific options
+# [subobject list] either a single character (e.g. sigma in a summation) and/or lines
+# The template selector and variation codes determine the class of the
+# template and various properties of the template, such as which subobjects
+# can be deleted by the user (see Templates). The class of a template
+# determines the order and meaning of each of its subobjects (see Template
+# subobject order).
+
+# The variation code may be 1 or 2 bytes long. If the first byte value has the
+# high bit set (0x80), the next byte is read and combined with the first
+# according to this formula:
+
+# variation code = (byte1 & 0x7F)  |  (byte2 << 8)
+
+# Template-specific options field only used for integrals & fence templates:
+# Fence template option field values (fence alignment):
+# 0 center fence on math axis, place math axis of contents on math axis of
+# containing line (default);
+# 1 center fence on contents, place math axis of contents on math axis of
+# containing line;
+# 2 center fence on contents, center contents on math axis of containing line.
+# Warning: the expanding integral property is duplicated in the integral
+# templates variation codes (see Limit variations). On reading, MathType only
+# looks at the variation code.
+
+# Integral template option field values:
+# 0 fixed-size integral;
+# 1 the integral expands vertically to fit its contents.
+
+# Limit variations:
+
+# The following variation codes apply to all templates whose class is BigOpBoxClass or LimBoxClass:
+
+# variation bits  symbol  description
+# 0x0001  tvBO_LOWER  lower limit is present
+# 0x0002  tvBO_UPPER  upper limit is present
+# 0x0040  tvBO_SUM  summation-style limit positions, else integral-style
+
+# Template selectors and variations:
+# Fences (parentheses, etc.):
+# selector  symbol  description class
+# 0 tmANGLE angle brackets  ParBoxClass
+# 1 tmPAREN parentheses ParBoxClass
+# 2 tmBRACE braces (curly brackets) ParBoxClass
+# 3 tmBRACK square brackets ParBoxClass
+# 4 tmBAR vertical bars ParBoxClass
+# 5 tmDBAR  double vertical bars  ParBoxClass
+# 6 tmFLOOR floor brackets  ParBoxClass
+# 7 tmCEILING ceiling brackets  ParBoxClass
+# 8 tmOBRACK  open (white) brackets ParBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvFENCE_L left fence is present
+# 0x0002  tvFENCE_R right fence is present
+# Intervals:
+# selector  symbol  description class
+# 9 tmINTERVAL  unmatched brackets and parentheses  ParBoxClass
+# variations  variation bits  symbol  description
+# 0x0000  tvINTV_LEFT_LP  left fence is left parenthesis
+# 0x0001  tvINTV_LEFT_RP  left fence is right parenthesis
+# 0x0002  tvINTV_LEFT_LB  left fence is left bracket
+# 0x0003  tvINTV_LEFT_RB  left fence is right bracket
+# 0x0000  tvINTV_RIGHT_LP right fence is left parenthesis
+# 0x0010  tvINTV_RIGHT_RP right fence is right parenthesis
+# 0x0020  tvINTV_RIGHT_LB right fence is left bracket
+# 0x0030  tvINTV_RIGHT_RB right fence is right bracket
+# Radicals (square and nth roots):
+# selector  symbol  description class
+# 10  tmROOT  radical RootBoxClass
+# variations  variation symbol  description
+# 0 tvROOT_SQ square root
+# 1 tvROOT_NTH  nth root
+# Fractions:
+# selector  symbol  description class
+# 11  tmFRACT fractions FracBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvFR_SMALL  subscript-size slots (piece fraction)
+# 0x0002  tvFR_SLASH  fraction bar is a slash
+# 0x0004  tvFR_BASE num. and denom. are baseline aligned
+# Over and Underbars:
+# selector  symbol  description class
+# 12  tmUBAR  underbar  BarBoxClass
+# 13  tmOBAR  overbar BarBoxClass
+# variations  variation bits  symbol  description
+# 0x0001  tvBAR_DOUBLE  bar is doubled, else single
+# Arrows:
+# selector  symbol  description class
+# 14  tmARROW arrow ArroBoxClass
+# variations  variation symbol  description
+# 0x0000  tvAR_SINGLE single arrow
+# 0x0001  tvAR_DOUBLE double arrow
+# 0x0002  tvAR_HARPOON  harpoon
+# 0x0004  tvAR_TOP  top slot is present
+# 0x0008  tvAR_BOTTOM bottom slot is present
+# 0x0010  tvAR_LEFT if single, arrow points left
+# 0x0020  tvAR_RIGHT  if single, arrow points right
+# 0x0010  tvAR_LOS  if double or harpoon, large over small
+# 0x0020  tvAR_SOL  if double or harpoon, small over large
+# Integrals (see Limit Variations):
+# selector  symbol  description class
+# 15  tmINTEG integral  BigOpBoxClass
+# variations  variation symbol  description
+# 0x0001  tvINT_1 single integral sign
+# 0x0002  tvINT_2 double integral sign
+# 0x0003  tvINT_3 triple integral sign
+# 0x0004  tvINT_LOOP  has loop w/o arrows
+# 0x0008  tvINT_CW_LOOP has clockwise loop
+# 0x000C  tvINT_CCW_LOOP  has counter-clockwise loop
+# 0x0100  tvINT_EXPAND  integral signs expand
+# Sums, products, coproducts, unions, intersections, etc. (see Limit Variations):
+# selector  symbol  description class
+# 16  tmSUM sum BigOpBoxClass
+# 17  tmPROD  product BigOpBoxClass
+# 18  tmCOPROD  coproduct BigOpBoxClass
+# 19  tmUNION union BigOpBoxClass
+# 20  tmINTER intersection  BigOpBoxClass
+# 21  tmINTOP integral-style big operator BigOpBoxClass
+# 22  tmSUMOP summation-style big operator  BigOpBoxClass
+# Limits (see Limit Variations):
+# selector  symbol  description class
+# 23  tmLIM limits  LimBoxClass
+# variations  variation symbol  description
+# 0 tvSUBAR single underbar
+# 1 tvDUBAR double underbar
+# Horizontal braces and brackets:
+# selector  symbol  description class
+# 24  tmHBRACE  horizontal brace  HFenceBoxClass
+# 25  tmHBRACK  horizontal bracket  HFenceBoxClass
+#   variation symbol  description
+# 0x0001  tvHB_TOP  slot is on the top, else on the bottom
+# Long division:
+# selector  symbol  description class
+# 26  tmLDIV  long division LDivBoxClass
+#   variation symbol  description
+# 0x0001  tvLD_UPPER  upper slot is present
+# Subscripts and superscripts:
+# selector  symbol  description class
+# 27  tmSUB subscript ScrBoxClass
+# 28  tmSUP superscript ScrBoxClass
+# 29  tmSUBSUP  subscript and superscript ScrBoxClass
+#   variation symbol  description
+# 0x0001  tvSU_PRECEDES script precedes scripted item,
+# else follows
+# Dirac bra-ket notation:
+# selector  symbol  description class
+# 30  tmDIRAC bra-ket notation  DiracBoxClass
+#   variation symbol  description
+# 0x0001  tvDI_LEFT left part is present
+# 0x0002  tvDI_RIGHT  right part is present
+# Vectors:
+# selector  symbol  description class
+# 31  tmVEC vector  HatBoxClass
+#   variation symbol  description
+# 0x0001  tvVE_LEFT arrow points left
+# 0x0002  tvVE_RIGHT  arrow points right
+# 0x0004  tvVE_UNDER  arrow under slot, else over slot
+# 0x0008  tvVE_HARPOON  harpoon
+# Hats, arcs, tilde, joint status:
+# selector  symbol  description class
+# 32  tmTILDE tilde over characters HatBoxClass
+# 33  tmHAT hat over characters HatBoxClass
+# 34  tmARC arc over characters HatBoxClass
+# 35  tmJSTATUS joint status construct  HatBoxClass
+# Overstrikes (cross-outs):
+# selector  symbol  description class
+# 36  tmSTRIKE  overstrike (cross-out)  StrikeBoxClass
+#   variation symbol  description
+# 0x0001  tvST_HORIZ  line is horizontal, else slashes
+# 0x0002  tvST_UP if slashes, slash from lower-left to upper-right is present
+# 0x0004  tvST_DOWN if slashes, slash from upper-left to lower-right is present
+# Boxes:
+# selector  symbol  description class
+# 37  tmBOX box TBoxBoxClass
+#   variation symbol  description
+# 0x0001  tvBX_ROUND  corners are round, else square
+# 0x0002  tvBX_LEFT left side is present
+# 0x0004  tvBX_RIGHT  right side is present
+# 0x0008  tvBX_TOP  top side is present
+# 0x0010  tvBX_BOTTOM bottom side is present
+
+module Mathtype5
+  class RecordTmpl < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(selector variation template_specific_options nudge
+      subobject_list)
+
+    SELECTORS = {
+      # Fences (parentheses, etc.):
+      0 => "tmANGLE",
+      1 => "tmPAREN",
+      2 => "tmBRACE",
+      3 => "tmBRACK",
+      4 => "tmBAR",
+      5 => "tmDBAR",
+      6 => "tmFLOOR",
+      7 => "tmCEILING",
+      8 => "tmOBRACK",
+      # Intervals:
+      9 => "tmINTERVAL",
+      # Radicals (square and nth roots):
+      10 => "tmROOT",
+      # Fractions:
+      11 => "tmFRACT",
+      # Over and Underbars:
+      12 => "tmUBAR",
+      13 => "tmOBAR",
+      # Arrows:
+      14  => "tmARROW",
+      # Integrals (see Limit Variations):
+      15  => "tmINTEG",
+      # Sums, products, coproducts, unions, intersections, etc. (see Limit Variations):
+      16 => "tmSUM",
+      17 => "tmPROD",
+      18 => "tmCOPROD",
+      19 => "tmUNION",
+      20 => "tmINTER",
+      21 => "tmINTOP",
+      22 => "tmSUMOP",
+      # Limits (see Limit Variations):
+      23 => "tmLIM",
+      # Horizontal braces and brackets:
+      24 => "tmHBRACE",
+      25 => "tmHBRACK",
+      # Long division:
+      26 => "tmLDIV",
+      # Subscripts and superscripts:
+      27 => "tmSUB",
+      28 => "tmSUP",
+      29 => "tmSUBSUP",
+      # Dirac bra-ket notation:
+      30 => "tmDIRAC",
+      # Vectors:
+      31 => "tmVEC",
+      # Hats, arcs, tilde, joint status:
+      32 => "tmTILDE",
+      33 => "tmHAT",
+      34 => "tmARC",
+      35 => "tmJSTATUS",
+      # Overstrikes (cross-outs):
+      36 => "tmSTRIKE",
+      # Boxes:
+      37 => "tmBOX"
+    }
+
+
+    # When options overlap in the binary space, ordinary bitmasks
+    # are not the correct tool to use for detection. We use digit
+    # position and presence instead.
+
+    DIGIT_MODE_VARIATIONS = [9]
+
+    # Top-level keys are template identifiers, defined in TEMPLATES.
+    # Second-level keys are bits for certain variations, negative keys mean
+    # that the variation is present if the bit is absent.
+
+    VARIATIONS = {
+      # Fences (parentheses, etc.):
+      0..8 => {
+        0x0001 => "tvFENCE_L", # left fence is present
+        0x0002 => "tvFENCE_R", # right fence is present
+      },
+
+      # Intervals:
+      9 => {
+        # 0x0000 => "tvINTV_LEFT_LP", #  left fence is left parenthesis
+        # 0x0001 => "tvINTV_LEFT_RP", #  left fence is right parenthesis
+        # 0x0002 => "tvINTV_LEFT_LB", #  left fence is left bracket
+        # 0x0003 => "tvINTV_LEFT_RB", #  left fence is right bracket
+        # 0x0004 => "tvINTV_RIGHT_LP", # right fence is left parenthesis # WARNING: DOCUMENTATION SAYS 0x0000?
+        # 0x0010 => "tvINTV_RIGHT_RP", # right fence is right parenthesis
+        # 0x0020 => "tvINTV_RIGHT_LB", # right fence is left bracket
+        # 0x0030 => "tvINTV_RIGHT_RB", # right fence is right bracket
+        # Replaced above to match MathML translator
+        0x0002 => {
+          0x0020 => "tvINTV_LBLB", # left bracket, left bracket
+          0x0010 => "tvINTV_LBRP", # left bracket, right parenthesis
+        },
+        0x0003 => {
+          0x0030 => "tvINTV_RBRB", # right bracket, right bracket
+          0x0020 => "tvINTV_RBLB", # right bracket, left bracket
+        },
+        0x0000 => {
+          0x0030 => "tvINTV_LPRB", # left parenthesis, right bracket
+        }
+      },
+
+      # Radicals (square and nth roots):
+      10 => {
+        0 => "tvROOT_SQ", # square root
+        1 => "tvROOT_NTH", # nth root
+      },
+
+      # Fractions:
+      11 => {
+        0x0001 => "tvFR_SMALL", #  subscript-size slots (piece fraction)
+        0x0002 => "tvFR_SLASH", #  fraction bar is a slash
+        0x0004 => "tvFR_BASE", # num. and denom. are baseline aligned
+      },
+
+      # Over and Underbars:
+      12..13 => {
+        0x0001 => "tvBAR_DOUBLE", #  bar is doubled, else single
+      },
+
+      # Arrows:
+      14 => {
+        0x0000 => "tvAR_SINGLE", # single arrow
+        0x0001 => "tvAR_DOUBLE", # double arrow
+        0x0010 => {
+          0x0001 => "tvAR_LOS", # if double, large over small,
+          0x0002 => "tvAR_LOS", # if harpoon, large over small,
+          0x0010 => "tvAR_LEFT" # if single, arrow points left
+        },
+        0x0020 => {
+          0x0001 => "tvAR_SOL", # if double, small over large
+          0x0002 => "tvAR_SOL", # if harpoon, small over large
+          0x0010 => "tvAR_RIGHT", # if single, arrow points right
+        },
+        0x0002 => "tvAR_HARPOON", # harpoon
+        0x0004 => { # top slot is present
+          0x0008 => "tvAR_TOPBOTTOM", # both slots are present
+          0x0004 => "tvAR_TOP"
+        },
+        0x0008 => { # bottom slot is present
+          0x0004 => "tvAR_TOPBOTTOM", # both slots are present
+          0x0008 => "tvAR_BOTTOM"
+        }
+      },
+
+      # Integrals (see Limit Variations):
+      15 => {
+        0x0001 => "tvINT_1", # single integral sign
+        0x0002 => "tvINT_2", # double integral sign
+        0x0003 => "tvINT_3", # triple integral sign
+        0x0004 => "tvINT_LOOP", # has loop w/o arrows
+        0x0008 => "tvINT_CW_LOOP", # has clockwise loop
+        0x000C => "tvINT_CCW_LOOP", # has counter-clockwise loop
+        0x0100 => "tvINT_EXPAND", #  integral signs expand
+      },
+
+      # Limit variations
+      15..23 => {
+        0x0010 => "tvBO_LOWER", # lower limit is present
+        0x0020 => "tvBO_UPPER", # upper limit is present
+        0x0040 => "tvBO_SUM", # summation-style limit positions,
+        -0x0040 => "tvBO_INT" # else integral-style
+      },
+
+      # Sums, products, coproducts, unions, intersections, etc. (see Limit Variations):
+      23 => {
+        0 => "tvSUBAR", # single underbar
+        1 => "tvDUBAR", # double underbar
+      },
+
+      # Horizontal braces and brackets:
+      24..25 => {
+        0x0001 => "tvHB_TOP", #  slot is on the top, else on the bottom
+      },
+
+      # Long division:
+      26 => {
+        0x0001 => "tvLD_UPPER", #  upper slot is present
+      },
+
+      # Subscripts and superscripts:
+      27..29 => {
+        0x0001 => "tvSU_PRECEDES", # script precedes scripted item, else follows
+      },
+
+      # Dirac bra-ket notation:
+      30 => {
+        0x0001 => "tvDI_LEFT", # left part is present
+        0x0002 => "tvDI_RIGHT", #  right part is present
+      },
+
+      # Vectors:
+      31 => {
+        0x0001 => "tvVE_LEFT", # arrow points left
+        0x0002 => "tvVE_RIGHT", #  arrow points right
+        0x0004 => "tvVE_UNDER", #  arrow under slot, else over slot
+        0x0008 => "tvVE_HARPOON", #  harpoon
+      },
+
+      # Hats, arcs, tilde, joint status:
+      32..35 => {},
+
+      # Overstrikes (cross-outs):
+      36 => {
+        0x0001 => "tvST_HORIZ", #  line is horizontal, else slashes
+        0x0002 => "tvST_UP", # if slashes, slash from lower-left to upper-right is present
+        0x0004 => "tvST_DOWN", # if slashes, slash from upper-left to lower-right is present
+      },
+
+      # Boxes:
+      37 => {
+        0x0001 => "tvBX_ROUND", #  corners are round, else square
+        0x0002 => "tvBX_LEFT", # left side is present
+        0x0004 => "tvBX_RIGHT", #  right side is present
+        0x0008 => "tvBX_TOP", #  top side is present
+        0x0010 => "tvBX_BOTTOM", # bottom side is present
+      }
+    }
+
+    int8 :options
+
+    record_nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :_selector
+
+    int8 :_variation_first_byte
+    int8 :_variation_second_byte, onlyif: (lambda do
+      _variation_first_byte & 0x80 > 0
+    end)
+
+    int8 :template_specific_options
+
+    array :subobject_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def variation
+      @variation = (_variation_first_byte & 0x7F) | (_variation_second_byte << 8)
+      @variations = VARIATIONS.select do |selector, _|
+        selector === _selector
+      end.values.reduce(Hash.new, :merge)
+
+      process_variations
+    end
+
+    def process_variations
+      @variations.select do |flag, _|
+        if flag < 0 # flag should NOT be active
+          !check_flag(-flag)
+        else # flag should be active
+          check_flag(flag)
+        end
+      end.map do |flag, value|
+        case value
+        when Hash # Conditional variations
+          result = value.detect do |conditional, _|
+            check_flag(conditional)
+          end
+          result.last if result
+        else
+          value
+        end
+      end.uniq
+    end
+
+    def check_flag(flag)
+      case mode
+      when :bitmask
+        check_bitmask(flag)
+      when :digit
+        check_digit(flag)
+      end
+    end
+
+    def check_bitmask(flag)
+      if flag == 0
+        @variation & 0xf == 0
+      else
+        @variation & flag == flag
+      end
+    end
+
+    # E.g. is 0x3 present in 0x33
+    def check_digit(flag)
+      digits = if flag == 0
+        1
+      else
+        (Math.log(flag+1)/Math.log(16)).ceil # digits in a hex number
+      end
+      mask = (15<<(4*digits-4)) # e.g. 0xf0
+      variation_digit = (@variation & mask) >> (digits * 4 - 4)
+      flag_digit = (flag & mask) >> (digits * 4 - 4)
+      variation_digit == flag_digit
+    end
+
+
+    def mode
+      DIGIT_MODE_VARIATIONS.include?(_selector) ? :digit : :bitmask
+    end
+
+    def selector
+      SELECTORS[_selector]
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/mathtype.gemspec b/scripts/mathtype2mathml/vendor/gems/mathtype/mathtype.gemspec
new file mode 100644
index 0000000..15e6436
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/mathtype.gemspec
@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mathtype/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathtype"
+  spec.version       = Mathtype::VERSION
+  spec.authors       = ["Jure Triglav", "Sebastian Bulka"]
+  spec.email         = ["juretriglav@gmail.com", "sebastian.bulka@le-tex.de"]
+  spec.summary       = %q{ A Ruby gem for reading MathType binaries and converting them to an XML form. }
+  spec.description   = %q{ This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = Dir.glob("{lib,spec}/**/*")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "> 1.7"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_dependency "bindata", "~> 2.1"
+  spec.add_dependency "nokogiri", "~> 1.6"
+  spec.add_dependency "ruby-ole", "~> 1.2"
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/ceil.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/ceil.xml
new file mode 100644
index 0000000..4e67409
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/ceil.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <options>0</options>
+        <selector>tmCEILING</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xF8EE</mt_code_value>
+        </char>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xF8F9</mt_code_value>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/fence.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/fence.xml
new file mode 100644
index 0000000..e8f04e3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/fence.xml
@@ -0,0 +1,77 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <options>1</options>
+        <typeface>3</typeface>
+        <mt_code_value>0x0044</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmBAR</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x004B</mt_code_value>
+          </char>
+          <sub2/>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+          </char>
+          <full/>
+          <char>
+            <options>0</options>
+            <typeface>6</typeface>
+            <mt_code_value>0x2212</mt_code_value>
+          </char>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x004B</mt_code_value>
+          </char>
+          <sub2/>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <full/>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xEC07</mt_code_value>
+        </char>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xEC08</mt_code_value>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/floor.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/floor.xml
new file mode 100644
index 0000000..4ad3fb6
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/floor.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <options>0</options>
+        <selector>tmFLOOR</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xF8F0</mt_code_value>
+        </char>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0xF8FB</mt_code_value>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/frac.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/frac.xml
new file mode 100644
index 0000000..8388466
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/frac.xml
@@ -0,0 +1,136 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <options>0</options>
+        <selector>tmFRACT</selector>
+        <variation>tvFR_FULL</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>24</typeface>
+            <mt_code_value>0xEB04</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>1</typeface>
+            <mt_code_value>0x0064</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0030</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0034</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>24</typeface>
+            <mt_code_value>0xEB04</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>1</typeface>
+            <mt_code_value>0x0064</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x22C5</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0031</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0030</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0030</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>24</typeface>
+        <mt_code_value>0xEB04</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>2</typeface>
+        <mt_code_value>0x0025</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0030</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>2</typeface>
+        <mt_code_value>0x002C</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0039</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>8</typeface>
+        <mt_code_value>0x0038</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>24</typeface>
+        <mt_code_value>0xEB04</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>2</typeface>
+        <mt_code_value>0x0025</mt_code_value>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/large_nudge.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/large_nudge.xml
new file mode 100644
index 0000000..c4deac6
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/large_nudge.xml
@@ -0,0 +1,135 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <options>0</options>
+        <selector>tmFRACT</selector>
+        <variation>tvFR_FULL</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>4</typeface>
+            <mt_code_value>0x03B1</mt_code_value>
+          </char>
+          <font>
+            <options>0</options>
+            <name>Symbol</name>
+            <typeface>131</typeface>
+            <style>0</style>
+          </font>
+          <char>
+            <options>0</options>
+            <typeface>253</typeface>
+            <mt_code_value>0x03C0</mt_code_value>
+          </char>
+          <tmpl>
+            <options>0</options>
+            <selector>tmPAREN</selector>
+            <variation>tvFENCE_L</variation>
+            <variation>tvFENCE_R</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>6</typeface>
+                <mt_code_value>0x002B</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0062</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <char>
+              <options>0</options>
+              <typeface>22</typeface>
+              <mt_code_value>0x0028</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>22</typeface>
+              <mt_code_value>0x0029</mt_code_value>
+            </char>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0038</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0030</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <char>
+        <options>8</options>
+        <nudge>
+          <dx>-176</dx>
+          <dy>-256</dy>
+        </nudge>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+      </char>
+      <char>
+        <options>9</options>
+        <nudge>
+          <dx>160</dx>
+          <dy>0</dy>
+        </nudge>
+        <typeface>3</typeface>
+        <mt_code_value>0x0065</mt_code_value>
+      </char>
+      <char>
+        <options>8</options>
+        <nudge>
+          <dx>160</dx>
+          <dy>0</dy>
+        </nudge>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+      </char>
+      <char>
+        <options>9</options>
+        <nudge>
+          <dx>160</dx>
+          <dy>0</dy>
+        </nudge>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/lim_embell.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/lim_embell.xml
new file mode 100644
index 0000000..b60ec18
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/lim_embell.xml
@@ -0,0 +1,247 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>1</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <options>1</options>
+        <typeface>3</typeface>
+        <mt_code_value>0x0041</mt_code_value>
+      </char>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmLIM</selector>
+        <variation>tvBO_LOWER</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x006C</mt_code_value>
+          </char>
+          <char>
+            <options>1</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+          </char>
+          <char>
+            <options>1</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x006D</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <pile>
+          <options>0</options>
+          <halign>center</halign>
+          <valign>center_baseline</valign>
+          <slot>
+            <options>0</options>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x006E</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x2192</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x221E</mt_code_value>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <options>0</options>
+              <typeface>5</typeface>
+              <mt_code_value>0x0394</mt_code_value>
+            </char>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0078</mt_code_value>
+            </char>
+            <tmpl>
+              <options>0</options>
+              <selector>tmSUB</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub2/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <options>1</options>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x006B</mt_code_value>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <end/>
+            </tmpl>
+            <sub/>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x2192</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </pile>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <tmpl>
+        <options>0</options>
+        <selector>tmSUM</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_UPPER</variation>
+        <variation>tvBO_SUM</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x0066</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+          </char>
+          <char>
+            <options>3</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x0078</mt_code_value>
+            <embell>
+              <options>0</options>
+              <embell>embTILDE</embell>
+            </embell>
+            <end/>
+          </char>
+          <tmpl>
+            <options>0</options>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006B</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <full/>
+          <char>
+            <options>0</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>5</typeface>
+            <mt_code_value>0x0394</mt_code_value>
+          </char>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x0078</mt_code_value>
+          </char>
+          <tmpl>
+            <options>0</options>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006B</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x006B</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>6</typeface>
+            <mt_code_value>0x003D</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x006E</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <sym/>
+        <char>
+          <options>0</options>
+          <typeface>6</typeface>
+          <mt_code_value>0x2211</mt_code_value>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/matrix_2x1.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/matrix_2x1.xml
new file mode 100644
index 0000000..39916bd
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/matrix_2x1.xml
@@ -0,0 +1,500 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <options>0</options>
+        <typeface>4</typeface>
+        <mt_code_value>0x03C9</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmSUBSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x0072</mt_code_value>
+          </char>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x0073</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x002A</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmBRACE</selector>
+        <variation>tvFENCE_L</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <matrix>
+            <options>0</options>
+            <valign>center_baseline</valign>
+            <h_just>left</h_just>
+            <v_just>center_baseline</v_just>
+            <rows>2</rows>
+            <cols>1</cols>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>8</typeface>
+                <mt_code_value>0x0031</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0066</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB01</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0067</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006F</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006E</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0073</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006E</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0064</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0073</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0073</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0068</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0063</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006F</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006D</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006D</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006F</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006E</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0062</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006F</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0075</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006E</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0064</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0079</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>2</typeface>
+                <mt_code_value>0x0028</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0064</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0067</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>2</typeface>
+                <mt_code_value>0x0029</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>8</typeface>
+                <mt_code_value>0x0030</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006F</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0074</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0068</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0077</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0073</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB04</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <char>
+                <options>0</options>
+                <typeface>24</typeface>
+                <mt_code_value>0xEB05</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </matrix>
+          <end/>
+        </slot>
+        <char>
+          <options>0</options>
+          <typeface>22</typeface>
+          <mt_code_value>0x007B</mt_code_value>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/pile.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/pile.xml
new file mode 100644
index 0000000..10899b1
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/pile.xml
@@ -0,0 +1,188 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <pile>
+      <options>0</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <font>
+          <options>0</options>
+          <name>Arial Narrow</name>
+          <typeface>131</typeface>
+          <style>2</style>
+        </font>
+        <char>
+          <options>0</options>
+          <typeface>253</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+        </char>
+        <char>
+          <options>0</options>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+        </char>
+        <char>
+          <options>1</options>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+        </char>
+        <char>
+          <options>0</options>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+        </char>
+        <tmpl>
+          <options>0</options>
+          <selector>tmROOT</selector>
+          <variation>tvROOT_SQ</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+            </char>
+            <sub/>
+            <char>
+              <options>8</options>
+              <nudge>
+                <dx>-256</dx>
+                <dy>-96</dy>
+              </nudge>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+            </char>
+            <full/>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+            </char>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0066</mt_code_value>
+            </char>
+            <sub/>
+            <char>
+              <options>8</options>
+              <nudge>
+                <dx>-256</dx>
+                <dy>-96</dy>
+              </nudge>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <char>
+          <options>0</options>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+        </char>
+        <tmpl>
+          <options>0</options>
+          <selector>tmROOT</selector>
+          <variation>tvROOT_SQ</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <options>0</options>
+              <typeface>2</typeface>
+              <mt_code_value>0x0028</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>253</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x2212</mt_code_value>
+            </char>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x2212</mt_code_value>
+            </char>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0066</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>2</typeface>
+              <mt_code_value>0x0029</mt_code_value>
+            </char>
+            <sub/>
+            <char>
+              <options>8</options>
+              <nudge>
+                <dx>-256</dx>
+                <dy>-96</dy>
+              </nudge>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+            </char>
+            <full/>
+            <char>
+              <options>0</options>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+            </char>
+            <char>
+              <options>1</options>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+            </char>
+            <sub/>
+            <char>
+              <options>8</options>
+              <nudge>
+                <dx>-256</dx>
+                <dy>-96</dy>
+              </nudge>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sigma_subsup.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sigma_subsup.xml
new file mode 100644
index 0000000..5ce7332
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sigma_subsup.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <options>0</options>
+        <typeface>4</typeface>
+        <mt_code_value>0x03B4</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmSUBSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>1</options>
+            <typeface>3</typeface>
+            <mt_code_value>0x006A</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>2</typeface>
+            <mt_code_value>0x002A</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/small_nudge.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/small_nudge.xml
new file mode 100644
index 0000000..b972a6b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/small_nudge.xml
@@ -0,0 +1,90 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <options>0</options>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_SQ</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <tmpl>
+            <options>0</options>
+            <selector>tmPAREN</selector>
+            <variation>tvFENCE_L</variation>
+            <variation>tvFENCE_R</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x006C</mt_code_value>
+              </char>
+              <sub/>
+              <char>
+                <options>8</options>
+                <nudge>
+                  <dx>-256</dx>
+                  <dy>-96</dy>
+                </nudge>
+                <typeface>8</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+              </char>
+              <full/>
+              <char>
+                <options>0</options>
+                <typeface>6</typeface>
+                <mt_code_value>0x002B</mt_code_value>
+              </char>
+              <char>
+                <options>1</options>
+                <typeface>3</typeface>
+                <mt_code_value>0x0065</mt_code_value>
+              </char>
+              <sub/>
+              <char>
+                <options>8</options>
+                <nudge>
+                  <dx>-256</dx>
+                  <dy>-96</dy>
+                </nudge>
+                <typeface>8</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <full/>
+            <char>
+              <options>0</options>
+              <typeface>22</typeface>
+              <mt_code_value>0x0028</mt_code_value>
+            </char>
+            <char>
+              <options>0</options>
+              <typeface>22</typeface>
+              <mt_code_value>0x0029</mt_code_value>
+            </char>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sqrt.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sqrt.xml
new file mode 100644
index 0000000..0ef2c18
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype3/sqrt.xml
@@ -0,0 +1,132 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>3</mtef_version>
+    <platform>1</platform>
+    <product>1</product>
+    <product_version>3</product_version>
+    <product_subversion>10</product_subversion>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <options>0</options>
+        <typeface>4</typeface>
+        <mt_code_value>0x03C3</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <font>
+            <options>0</options>
+            <name>Arial</name>
+            <typeface>130</typeface>
+            <style>0</style>
+          </font>
+          <char>
+            <options>0</options>
+            <typeface>254</typeface>
+            <mt_code_value>0x0074</mt_code_value>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <options>0</options>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+      </char>
+      <tmpl>
+        <options>0</options>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_SQ</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <options>0</options>
+            <typeface>4</typeface>
+            <mt_code_value>0x03C3</mt_code_value>
+          </char>
+          <tmpl>
+            <options>0</options>
+            <selector>tmSUBSUP</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>254</typeface>
+                <mt_code_value>0x0052</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>8</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <full/>
+          <char>
+            <options>0</options>
+            <typeface>6</typeface>
+            <mt_code_value>0x002B</mt_code_value>
+          </char>
+          <char>
+            <options>0</options>
+            <typeface>4</typeface>
+            <mt_code_value>0x03C3</mt_code_value>
+          </char>
+          <tmpl>
+            <options>0</options>
+            <selector>tmSUBSUP</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>254</typeface>
+                <mt_code_value>0x0050</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <options>0</options>
+                <typeface>8</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/299.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/299.xml
new file mode 100644
index 0000000..c770938
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/299.xml
@@ -0,0 +1,1097 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <pile>
+      <options>0</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF02</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmLIM</selector>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <variation>tvSUBAR</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <color_def>
+              <options>0</options>
+              <rgb>
+                <r>0</r>
+                <g>0</g>
+                <b>0</b>
+              </rgb>
+            </color_def>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x006D</mt_code_value>
+              <options>2</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x006E</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0077</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>4</typeface>
+              <mt_code_value>0x03BE</mt_code_value>
+              <options>4</options>
+              <font_position>120</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF04</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0077</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUP</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0054</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0077</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0043</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUMOP</selector>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_UPPER</variation>
+          <variation>tvBO_SUM</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sub/>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x003D</mt_code_value>
+              <options>4</options>
+              <font_position>61</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sym/>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x2211</mt_code_value>
+              <options>4</options>
+              <font_position>229</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>4</typeface>
+          <mt_code_value>0x03BE</mt_code_value>
+          <options>4</options>
+          <font_position>120</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0073</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0075</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0062</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006A</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0074</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF04</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0074</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006F</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x00A0</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF04</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0079</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0077</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUP</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0054</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <char>
+          <typeface>4</typeface>
+          <mt_code_value>0x03D5</mt_code_value>
+          <options>4</options>
+          <font_position>102</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmPAREN</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0078</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <color>
+              <color_def_index>0</color_def_index>
+            </color>
+            <tmpl>
+              <selector>tmSUB</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <color>
+                  <color_def_index>1</color_def_index>
+                </color>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0069</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <color>
+                <color_def_index>0</color_def_index>
+              </color>
+              <slot>
+                <options>1</options>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0062</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x00A0</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF04</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2265</mt_code_value>
+          <options>4</options>
+          <font_position>179</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF04</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>4</typeface>
+          <mt_code_value>0x03BE</mt_code_value>
+          <options>4</options>
+          <font_position>120</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>4</typeface>
+          <mt_code_value>0x03BE</mt_code_value>
+          <options>4</options>
+          <font_position>120</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <color>
+              <color_def_index>1</color_def_index>
+            </color>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <color>
+          <color_def_index>1</color_def_index>
+        </color>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2265</mt_code_value>
+          <options>4</options>
+          <font_position>179</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF05</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2200</mt_code_value>
+          <options>4</options>
+          <font_position>34</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0069</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/arrows.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/arrows.xml
new file mode 100644
index 0000000..cc8024f
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/arrows.xml
@@ -0,0 +1,1780 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <pile>
+      <options>0</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation></variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation></variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation></variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_RIGHT</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2194</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_RIGHT</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2194</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LEFT</variation>
+          <variation>tvAR_RIGHT</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2194</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_DOUBLE</variation>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2192</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2190</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_LOS</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_BOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0063</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmARROW</selector>
+          <variation>tvAR_SOL</variation>
+          <variation>tvAR_HARPOON</variation>
+          <variation>tvAR_TOPBOTTOM</variation>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21C0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x21BD</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embedded.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embedded.xml
new file mode 100644
index 0000000..1d1226d
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embedded.xml
@@ -0,0 +1,365 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>inline</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <encoding_def>
+      <name>WinAllCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>6</enc_def_index>
+      <font_name>&#x2CE;&#x325;</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>5</font_def>
+        <font_style>0</font_style>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0072</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0072</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x003E</mt_code_value>
+        <options>4</options>
+        <font_position>62</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>8</typeface>
+        <mt_code_value>0x0031</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embellishments.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embellishments.xml
new file mode 100644
index 0000000..fd789b2
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/embellishments.xml
@@ -0,0 +1,926 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb1PRIME</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb2PRIME</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0063</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb3PRIME</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0064</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embBPRIME</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0065</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embNOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embMBAR</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0067</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embX_BARS</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0068</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embUP_BAR</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0069</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embDOWN_BAR</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006A</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb1DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006B</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb2DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006C</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb3DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006D</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb4DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006E</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_1DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006F</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_2DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0070</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_3DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0071</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embFROWN</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0072</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_4DOT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0073</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embOBAR</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0074</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embTILDE</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0075</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embSMILE</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0076</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embHAT</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0078</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_BAR</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0079</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_TILDE</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x007A</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_FROWN</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_SMILE</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embRARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0063</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embLARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0064</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embBARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0065</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embR1ARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embL1ARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0067</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_RARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0068</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_LARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0069</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_BARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006A</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_R1ARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006B</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>embU_L1ARROW</embell>
+        </embell>
+        <end/>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation1.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation1.xml
new file mode 100644
index 0000000..6a5203f
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation1.xml
@@ -0,0 +1,446 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>MT Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>8</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>4</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>3</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0064</mt_code_value>
+        <options>1</options>
+        <variation>mathmode</variation>
+        <embell>
+          <options>0</options>
+          <embell>emb1PRIME</embell>
+        </embell>
+        <end/>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2248</mt_code_value>
+        <options>4</options>
+        <font_position>187</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>8</typeface>
+        <mt_code_value>0x0032</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x002C</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>8</typeface>
+        <mt_code_value>0x0037</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x22C5</mt_code_value>
+        <options>4</options>
+        <font_position>215</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_NTH</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <tmpl>
+            <selector>tmFRACT</selector>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0054</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>4</typeface>
+                <mt_code_value>0x03C4</mt_code_value>
+                <options>4</options>
+                <font_position>116</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>1</typeface>
+                    <mt_code_value>0x0074</mt_code_value>
+                    <options>0</options>
+                    <variation>textmode</variation>
+                  </char>
+                  <char>
+                    <typeface>1</typeface>
+                    <mt_code_value>0x0044</mt_code_value>
+                    <options>0</options>
+                    <variation>textmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <nudge>
+              <dx>-18</dx>
+              <dy>-24</dy>
+            </nudge>
+            <typeface>8</typeface>
+            <mt_code_value>0x0033</mt_code_value>
+            <options>8</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation2.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation2.xml
new file mode 100644
index 0000000..597f9c8
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation2.xml
@@ -0,0 +1,530 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>MT Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>8</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>4</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>3</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>4</typeface>
+        <mt_code_value>0x03C3</mt_code_value>
+        <options>4</options>
+        <font_position>115</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0076</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_SQ</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>4</typeface>
+            <mt_code_value>0x03C3</mt_code_value>
+            <options>4</options>
+            <font_position>115</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <tmpl>
+            <selector>tmSUBSUP</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>1</typeface>
+                <mt_code_value>0x0062</mt_code_value>
+                <options>0</options>
+                <variation>textmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>1</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+                <options>0</options>
+                <variation>textmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <full/>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x002B</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0033</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x22C5</mt_code_value>
+            <options>4</options>
+            <font_position>215</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <tmpl>
+            <selector>tmPAREN</selector>
+            <variation>tvFENCE_L</variation>
+            <variation>tvFENCE_R</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>4</typeface>
+                <mt_code_value>0x03B1</mt_code_value>
+                <options>4</options>
+                <font_position>97</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>1</typeface>
+                    <mt_code_value>0x0030</mt_code_value>
+                    <options>0</options>
+                    <variation>textmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <full/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x22C5</mt_code_value>
+                <options>4</options>
+                <font_position>215</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>4</typeface>
+                <mt_code_value>0x03C4</mt_code_value>
+                <options>4</options>
+                <font_position>116</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>1</typeface>
+                    <mt_code_value>0x0074</mt_code_value>
+                    <options>0</options>
+                    <variation>textmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <char>
+              <typeface>22</typeface>
+              <mt_code_value>0x0028</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>22</typeface>
+              <mt_code_value>0x0029</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </tmpl>
+          <tmpl>
+            <selector>tmSUP</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>1</options>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>1</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+                <options>0</options>
+                <variation>textmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation3.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation3.xml
new file mode 100644
index 0000000..e4ec724
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/eps-equation3.xml
@@ -0,0 +1,2593 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Minion Pro</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>MT Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>6</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>6</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>3</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <pile>
+      <options>2</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0041</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0075</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0066</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006C</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0061</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0067</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0072</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006B</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0072</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <font_style_def>
+          <font_def_index>3</font_def_index>
+          <char_style>0</char_style>
+        </font_style_def>
+        <char>
+          <typeface>255</typeface>
+          <mt_code_value>0x00E4</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0066</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0074</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0041</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0041</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0072</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0042</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0042</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0072</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0042</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0043</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0043</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0072</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0043</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0034</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0044</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x0056</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0044</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>4</options>
+        <line_spacing>65216</line_spacing>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x004B</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006F</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006E</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0074</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0072</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006F</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006C</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006C</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0035</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x22C5</mt_code_value>
+          <options>4</options>
+          <font_position>215</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0035</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x22C5</mt_code_value>
+          <options>4</options>
+          <font_position>215</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0035</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0039</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>24</typeface>
+          <mt_code_value>0xEF02</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0069</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x002E</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x004F</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>4</options>
+        <line_spacing>65216</line_spacing>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0046</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006C</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0064</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006D</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006F</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006D</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x006E</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0074</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <char>
+          <typeface>1</typeface>
+          <mt_code_value>0x0065</mt_code_value>
+          <options>0</options>
+          <variation>textmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>4</options>
+        <line_spacing>64</line_spacing>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x004D</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x006D</mt_code_value>
+              <options>2</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0078</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0056</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUBSUP</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0041</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0072</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>8</typeface>
+                  <mt_code_value>0x0032</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0071</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUP</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>1</options>
+              </slot>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>8</typeface>
+                  <mt_code_value>0x0032</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x22C5</mt_code_value>
+              <options>4</options>
+              <font_position>215</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0035</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0036</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>4</options>
+        <line_spacing>64</line_spacing>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x004D</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x006D</mt_code_value>
+              <options>2</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0078</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x004D</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUB</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0043</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0042</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <end/>
+            </tmpl>
+            <full/>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x004D</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUB</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0042</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0043</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x2212</mt_code_value>
+              <options>4</options>
+              <font_position>45</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0039</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0038</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0033</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x2212</mt_code_value>
+              <options>4</options>
+              <font_position>45</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0033</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0037</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0034</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x22C5</mt_code_value>
+              <options>4</options>
+              <font_position>215</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0037</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0030</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0034</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0032</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0035</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>4</options>
+        <line_spacing>64</line_spacing>
+        <char>
+          <typeface>3</typeface>
+          <mt_code_value>0x004D</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmSUB</selector>
+          <template_specific_options>0</template_specific_options>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0033</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x006D</mt_code_value>
+              <options>2</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x0078</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0034</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0056</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUBSUP</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0043</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0072</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>8</typeface>
+                  <mt_code_value>0x0032</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0071</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2212</mt_code_value>
+          <options>4</options>
+          <font_position>45</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0031</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0034</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFRACT</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0031</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>2</typeface>
+              <mt_code_value>0x002C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0034</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmSUP</selector>
+              <template_specific_options>0</template_specific_options>
+              <sub/>
+              <slot>
+                <options>1</options>
+              </slot>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>8</typeface>
+                  <mt_code_value>0x0032</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <full/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0032</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x22C5</mt_code_value>
+              <options>4</options>
+              <font_position>215</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0033</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>8</typeface>
+              <mt_code_value>0x0036</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>23</typeface>
+          <mt_code_value>0x0009</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x003D</mt_code_value>
+          <options>4</options>
+          <font_position>61</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0033</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0038</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>2</typeface>
+          <mt_code_value>0x002C</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0030</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>8</typeface>
+          <mt_code_value>0x0037</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation1.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation1.xml
new file mode 100644
index 0000000..3e3fa90
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation1.xml
@@ -0,0 +1,523 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0070</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0072</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+        <options>4</options>
+        <font_position>61</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmFRACT</selector>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x006D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0072</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <tmpl>
+        <selector>tmSUM</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_UPPER</variation>
+        <variation>tvBO_SUM</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <tmpl>
+            <selector>tmFRACT</selector>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0070</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x2212</mt_code_value>
+                <options>4</options>
+                <font_position>45</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x002B</mt_code_value>
+                <options>4</options>
+                <font_position>43</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0031</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x003D</mt_code_value>
+            <options>4</options>
+            <font_position>61</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0030</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0072</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2212</mt_code_value>
+            <options>4</options>
+            <font_position>45</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2211</mt_code_value>
+          <options>4</options>
+          <font_position>229</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation10.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation10.xml
new file mode 100644
index 0000000..bdab7bc
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation10.xml
@@ -0,0 +1,388 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmUNION</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_UPPER</variation>
+        <variation>tvBO_SUM</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>11</typeface>
+          <mt_code_value>0x222A</mt_code_value>
+          <options>4</options>
+          <font_position>85</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation11.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation11.xml
new file mode 100644
index 0000000..360030e
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation11.xml
@@ -0,0 +1,391 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation12.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation12.xml
new file mode 100644
index 0000000..8c1dd43
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation12.xml
@@ -0,0 +1,460 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmPAREN</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x002B</mt_code_value>
+            <options>4</options>
+            <font_position>43</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation13.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation13.xml
new file mode 100644
index 0000000..3f0c1db
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation13.xml
@@ -0,0 +1,734 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x005B</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0064</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x005D</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0034</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUBSUP</selector>
+        <variation>tvSU_PRECEDES</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0063</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUBSUP</selector>
+        <variation>tvSU_PRECEDES</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0065</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0064</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmPAREN</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0067</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2212</mt_code_value>
+            <options>4</options>
+            <font_position>45</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0068</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006A</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x006B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <variation>tvSU_PRECEDES</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x006C</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006D</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <variation>tvSU_PRECEDES</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x006E</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x006F</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0070</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0072</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation2.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation2.xml
new file mode 100644
index 0000000..88f4937
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation2.xml
@@ -0,0 +1,452 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmFRACT</selector>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2212</mt_code_value>
+            <options>4</options>
+            <font_position>45</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x00B1</mt_code_value>
+            <options>4</options>
+            <font_position>177</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <tmpl>
+            <selector>tmROOT</selector>
+            <variation>tvROOT_SQ</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0062</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUP</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <end/>
+              </tmpl>
+              <full/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x2212</mt_code_value>
+                <options>4</options>
+                <font_position>45</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0034</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0063</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <sub/>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <full/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation3.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation3.xml
new file mode 100644
index 0000000..d68590b
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation3.xml
@@ -0,0 +1,1452 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmSUM</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_UPPER</variation>
+        <variation>tvBO_SUM</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0074</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <tmpl>
+            <selector>tmINTER</selector>
+            <variation>tvBO_LOWER</variation>
+            <variation>tvBO_UPPER</variation>
+            <variation>tvBO_SUM</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0058</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x0069</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0069</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x003D</mt_code_value>
+                <options>4</options>
+                <font_position>61</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0031</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x006E</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <sym/>
+            <char>
+              <typeface>11</typeface>
+              <mt_code_value>0x2229</mt_code_value>
+              <options>4</options>
+              <font_position>73</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </tmpl>
+          <full/>
+          <tmpl>
+            <selector>tmBRACE</selector>
+            <variation>tvFENCE_L</variation>
+            <variation>tvFENCE_R</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <tmpl>
+                <selector>tmBRACK</selector>
+                <variation>tvFENCE_L</variation>
+                <variation>tvFENCE_R</variation>
+                <template_specific_options>0</template_specific_options>
+                <slot>
+                  <options>0</options>
+                  <tmpl>
+                    <selector>tmPAREN</selector>
+                    <variation>tvFENCE_L</variation>
+                    <variation>tvFENCE_R</variation>
+                    <template_specific_options>0</template_specific_options>
+                    <slot>
+                      <options>0</options>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x00B1</mt_code_value>
+                        <options>4</options>
+                        <font_position>177</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x2260</mt_code_value>
+                        <options>4</options>
+                        <font_position>185</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x2264</mt_code_value>
+                        <options>4</options>
+                        <font_position>163</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x2202</mt_code_value>
+                        <options>4</options>
+                        <font_position>182</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x2192</mt_code_value>
+                        <options>4</options>
+                        <font_position>174</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>6</typeface>
+                        <mt_code_value>0x2192</mt_code_value>
+                        <options>4</options>
+                        <font_position>174</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>4</typeface>
+                        <mt_code_value>0x03B8</mt_code_value>
+                        <options>4</options>
+                        <font_position>113</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <char>
+                        <typeface>4</typeface>
+                        <mt_code_value>0x03C0</mt_code_value>
+                        <options>4</options>
+                        <font_position>112</font_position>
+                        <variation>mathmode</variation>
+                      </char>
+                      <tmpl>
+                        <selector>tmDIRAC</selector>
+                        <variation>tvDI_LEFT</variation>
+                        <variation>tvDI_RIGHT</variation>
+                        <template_specific_options>0</template_specific_options>
+                        <slot>
+                          <options>0</options>
+                          <char>
+                            <typeface>3</typeface>
+                            <mt_code_value>0x0064</mt_code_value>
+                            <options>0</options>
+                            <variation>mathmode</variation>
+                          </char>
+                          <end/>
+                        </slot>
+                        <slot>
+                          <options>0</options>
+                          <char>
+                            <typeface>3</typeface>
+                            <mt_code_value>0x0062</mt_code_value>
+                            <options>0</options>
+                            <variation>mathmode</variation>
+                          </char>
+                          <end/>
+                        </slot>
+                        <char>
+                          <typeface>22</typeface>
+                          <mt_code_value>0x2329</mt_code_value>
+                          <options>0</options>
+                          <variation>mathmode</variation>
+                        </char>
+                        <char>
+                          <typeface>22</typeface>
+                          <mt_code_value>0xEC07</mt_code_value>
+                          <options>0</options>
+                          <variation>mathmode</variation>
+                        </char>
+                        <char>
+                          <typeface>22</typeface>
+                          <mt_code_value>0x232A</mt_code_value>
+                          <options>0</options>
+                          <variation>mathmode</variation>
+                        </char>
+                        <end/>
+                      </tmpl>
+                      <end/>
+                    </slot>
+                    <char>
+                      <typeface>22</typeface>
+                      <mt_code_value>0x0028</mt_code_value>
+                      <options>0</options>
+                      <variation>mathmode</variation>
+                    </char>
+                    <char>
+                      <typeface>22</typeface>
+                      <mt_code_value>0x0029</mt_code_value>
+                      <options>0</options>
+                      <variation>mathmode</variation>
+                    </char>
+                    <end/>
+                  </tmpl>
+                  <end/>
+                </slot>
+                <char>
+                  <typeface>22</typeface>
+                  <mt_code_value>0x005B</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>22</typeface>
+                  <mt_code_value>0x005D</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <char>
+              <typeface>22</typeface>
+              <mt_code_value>0x007B</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>22</typeface>
+              <mt_code_value>0x007D</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x003D</mt_code_value>
+            <options>4</options>
+            <font_position>61</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0034</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x003D</mt_code_value>
+            <options>4</options>
+            <font_position>61</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0033</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x2211</mt_code_value>
+          <options>4</options>
+          <font_position>229</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <full/>
+      <tmpl>
+        <selector>tmPAREN</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <matrix>
+            <options>0</options>
+            <valign>center_baseline</valign>
+            <h_just>left</h_just>
+            <v_just>center_baseline</v_just>
+            <rows>3</rows>
+            <cols>3</cols>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x2026</mt_code_value>
+                <options>4</options>
+                <font_position>75</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x006E</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x22EE</mt_code_value>
+                <options>4</options>
+                <font_position>77</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x22F1</mt_code_value>
+                <options>4</options>
+                <font_position>79</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x22EE</mt_code_value>
+                <options>4</options>
+                <font_position>77</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x006D</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x22EF</mt_code_value>
+                <options>4</options>
+                <font_position>76</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x006D</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x006E</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <end/>
+          </matrix>
+          <end/>
+        </slot>
+        <full/>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <tmpl>
+        <selector>tmPAREN</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <matrix>
+            <options>0</options>
+            <valign>center_baseline</valign>
+            <h_just>left</h_just>
+            <v_just>center_baseline</v_just>
+            <rows>3</rows>
+            <cols>3</cols>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0032</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0033</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <end/>
+          </matrix>
+          <end/>
+        </slot>
+        <full/>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <tmpl>
+        <selector>tmPAREN</selector>
+        <variation>tvFENCE_L</variation>
+        <variation>tvFENCE_R</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <matrix>
+            <options>0</options>
+            <valign>center_baseline</valign>
+            <h_just>left</h_just>
+            <v_just>center_baseline</v_just>
+            <rows>3</rows>
+            <cols>3</cols>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <row_parts>0</row_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <col_parts>0</col_parts>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>8</typeface>
+                    <mt_code_value>0x0031</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0031</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <size>
+              <lsize>0</lsize>
+              <dsize>5</dsize>
+            </size>
+            <slot>
+              <options>0</options>
+              <char>
+                <nudge>
+                  <dx>-30</dx>
+                  <dy>-160</dy>
+                </nudge>
+                <typeface>8</typeface>
+                <mt_code_value>0x0030</mt_code_value>
+                <options>8</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0034</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0x22F1</mt_code_value>
+                <options>4</options>
+                <font_position>79</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0032</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <size>
+              <lsize>0</lsize>
+              <dsize>5</dsize>
+            </size>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0030</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>8</typeface>
+                <mt_code_value>0x0033</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <slot>
+              <options>0</options>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0061</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x006E</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <end/>
+          </matrix>
+          <end/>
+        </slot>
+        <full/>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0028</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x0029</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation4.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation4.xml
new file mode 100644
index 0000000..2624ba3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation4.xml
@@ -0,0 +1,374 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_NTH</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0037</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0033</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation5.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation5.xml
new file mode 100644
index 0000000..488f2e6
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation5.xml
@@ -0,0 +1,395 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmARROW</selector>
+        <variation>tvAR_LOS</variation>
+        <variation>tvAR_HARPOON</variation>
+        <variation>tvAR_TOPBOTTOM</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <full/>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x21C0</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x21BD</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0063</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation6.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation6.xml
new file mode 100644
index 0000000..11ce6d9
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation6.xml
@@ -0,0 +1,382 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmARROW</selector>
+        <variation>tvAR_LEFT</variation>
+        <variation>tvAR_RIGHT</variation>
+        <variation>tvAR_TOP</variation>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <full/>
+        <char>
+          <typeface>22</typeface>
+          <mt_code_value>0x2194</mt_code_value>
+          <options>0</options>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation7.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation7.xml
new file mode 100644
index 0000000..b6c02b1
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation7.xml
@@ -0,0 +1,388 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmUNION</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_UPPER</variation>
+        <variation>tvBO_INT</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>11</typeface>
+          <mt_code_value>0x222A</mt_code_value>
+          <options>4</options>
+          <font_position>85</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation8.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation8.xml
new file mode 100644
index 0000000..3be5ec9
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation8.xml
@@ -0,0 +1,380 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmUNION</selector>
+        <variation>tvBO_LOWER</variation>
+        <variation>tvBO_SUM</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0062</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0061</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>11</typeface>
+          <mt_code_value>0x222A</mt_code_value>
+          <options>4</options>
+          <font_position>85</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation9.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation9.xml
new file mode 100644
index 0000000..969c206
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/equation9.xml
@@ -0,0 +1,372 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <tmpl>
+        <selector>tmUNION</selector>
+        <variation>tvBO_INT</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0073</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <sym/>
+        <char>
+          <typeface>11</typeface>
+          <mt_code_value>0x222A</mt_code_value>
+          <options>4</options>
+          <font_position>85</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/fences.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/fences.xml
new file mode 100644
index 0000000..02dd6a9
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/fences.xml
@@ -0,0 +1,1551 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <pile>
+      <options>0</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmPAREN</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBRACK</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBRACE</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x007B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x007D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmANGLE</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0064</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2329</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x232A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBAR</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0065</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC07</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC08</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDBAR</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0066</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC09</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC0A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmFLOOR</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0067</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xF8F0</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xF8FB</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmCEILING</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0068</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xF8EE</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xF8F9</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTERVAL</selector>
+          <variation>tvINTV_LBRP</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0069</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTERVAL</selector>
+          <variation>tvINTV_LPRB</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006A</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDIRAC</selector>
+          <variation>tvDI_RIGHT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006B</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC07</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x232A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDIRAC</selector>
+          <variation>tvDI_LEFT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006C</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2329</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC07</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTERVAL</selector>
+          <variation>tvINTV_LBLB</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006D</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTERVAL</selector>
+          <variation>tvINTV_RBRB</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006E</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTERVAL</selector>
+          <variation>tvINTV_RBLB</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x006F</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmOBRACK</selector>
+          <variation>tvFENCE_L</variation>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0070</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x301A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x301B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmPAREN</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0072</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmPAREN</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0073</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBRACK</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0074</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBRACK</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0075</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x005D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBRACE</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0076</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmBRACE</selector>
+              <variation>tvFENCE_R</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0078</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <char>
+                <typeface>22</typeface>
+                <mt_code_value>0x007D</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x007B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmANGLE</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0079</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2329</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmANGLE</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x007A</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x232A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBAR</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC07</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmBAR</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC08</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDBAR</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC09</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDBAR</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC0A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmOBRACK</selector>
+          <variation>tvFENCE_L</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x301A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmOBRACK</selector>
+          <variation>tvFENCE_R</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x301B</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmDIRAC</selector>
+          <variation>tvDI_LEFT</variation>
+          <variation>tvDI_RIGHT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x2329</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC07</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0x232A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <end/>
+      </slot>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmHBRACE</selector>
+          <variation>tvHB_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xFE37</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmHBRACE</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xFE38</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmHBRACK</selector>
+          <variation>tvHB_TOP</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC0D</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmHBRACK</selector>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <full/>
+          <char>
+            <typeface>22</typeface>
+            <mt_code_value>0xEC0C</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/integrals.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/integrals.xml
new file mode 100644
index 0000000..c84f3af
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/integrals.xml
@@ -0,0 +1,1766 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <pile>
+      <options>0</options>
+      <halign>left</halign>
+      <valign>center_baseline</valign>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_1</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_UPPER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>6</typeface>
+                  <mt_code_value>0x002B</mt_code_value>
+                  <options>4</options>
+                  <font_position>43</font_position>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0063</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_UPPER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0063</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_1</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_2</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_2</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>6</typeface>
+                  <mt_code_value>0x002B</mt_code_value>
+                  <options>4</options>
+                  <font_position>43</font_position>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_2</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_3</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_1</variation>
+              <variation>tvINT_2</variation>
+              <variation>tvINT_3</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>6</typeface>
+                  <mt_code_value>0x002B</mt_code_value>
+                  <options>4</options>
+                  <font_position>43</font_position>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_3</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE11</mt_code_value>
+            <options>4</options>
+            <font_position>209</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_SUM</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE11</mt_code_value>
+            <options>4</options>
+            <font_position>209</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE11</mt_code_value>
+            <options>4</options>
+            <font_position>209</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_2</variation>
+              <variation>tvINT_LOOP</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0xEE12</mt_code_value>
+                <options>4</options>
+                <font_position>210</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE12</mt_code_value>
+            <options>4</options>
+            <font_position>210</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE12</mt_code_value>
+            <options>4</options>
+            <font_position>210</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_3</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_1</variation>
+              <variation>tvINT_2</variation>
+              <variation>tvINT_3</variation>
+              <variation>tvINT_LOOP</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0xEE13</mt_code_value>
+                <options>4</options>
+                <font_position>211</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE13</mt_code_value>
+            <options>4</options>
+            <font_position>211</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_2</variation>
+          <variation>tvINT_3</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE13</mt_code_value>
+            <options>4</options>
+            <font_position>211</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_LOOP</variation>
+          <variation>tvINT_CW_LOOP</variation>
+          <variation>tvINT_CCW_LOOP</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <char>
+              <typeface>6</typeface>
+              <mt_code_value>0x002B</mt_code_value>
+              <options>4</options>
+              <font_position>43</font_position>
+              <variation>mathmode</variation>
+            </char>
+            <tmpl>
+              <selector>tmINTEG</selector>
+              <variation>tvINT_1</variation>
+              <variation>tvINT_LOOP</variation>
+              <variation>tvINT_CW_LOOP</variation>
+              <variation>tvINT_CCW_LOOP</variation>
+              <variation>tvBO_LOWER</variation>
+              <variation>tvBO_SUM</variation>
+              <template_specific_options>0</template_specific_options>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0061</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <char>
+                  <typeface>6</typeface>
+                  <mt_code_value>0x002B</mt_code_value>
+                  <options>4</options>
+                  <font_position>43</font_position>
+                  <variation>mathmode</variation>
+                </char>
+                <tmpl>
+                  <selector>tmINTEG</selector>
+                  <variation>tvINT_1</variation>
+                  <variation>tvINT_LOOP</variation>
+                  <variation>tvINT_CW_LOOP</variation>
+                  <variation>tvINT_CCW_LOOP</variation>
+                  <variation>tvBO_LOWER</variation>
+                  <variation>tvBO_INT</variation>
+                  <template_specific_options>0</template_specific_options>
+                  <slot>
+                    <options>0</options>
+                    <char>
+                      <typeface>3</typeface>
+                      <mt_code_value>0x0061</mt_code_value>
+                      <options>0</options>
+                      <variation>mathmode</variation>
+                    </char>
+                    <end/>
+                  </slot>
+                  <sub/>
+                  <slot>
+                    <options>0</options>
+                    <char>
+                      <typeface>3</typeface>
+                      <mt_code_value>0x0062</mt_code_value>
+                      <options>0</options>
+                      <variation>mathmode</variation>
+                    </char>
+                    <end/>
+                  </slot>
+                  <slot>
+                    <options>1</options>
+                  </slot>
+                  <sym/>
+                  <char>
+                    <typeface>11</typeface>
+                    <mt_code_value>0xEE00</mt_code_value>
+                    <options>4</options>
+                    <font_position>105</font_position>
+                    <variation>mathmode</variation>
+                  </char>
+                  <char>
+                    <typeface>6</typeface>
+                    <mt_code_value>0x222B</mt_code_value>
+                    <options>4</options>
+                    <font_position>242</font_position>
+                    <variation>mathmode</variation>
+                  </char>
+                  <end/>
+                </tmpl>
+                <end/>
+              </slot>
+              <sub/>
+              <slot>
+                <options>0</options>
+                <char>
+                  <typeface>3</typeface>
+                  <mt_code_value>0x0062</mt_code_value>
+                  <options>0</options>
+                  <variation>mathmode</variation>
+                </char>
+                <end/>
+              </slot>
+              <slot>
+                <options>1</options>
+              </slot>
+              <sym/>
+              <char>
+                <typeface>11</typeface>
+                <mt_code_value>0xEE00</mt_code_value>
+                <options>4</options>
+                <font_position>105</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x222B</mt_code_value>
+                <options>4</options>
+                <font_position>242</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </tmpl>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE00</mt_code_value>
+            <options>4</options>
+            <font_position>105</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_CW_LOOP</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>1</options>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE01</mt_code_value>
+            <options>4</options>
+            <font_position>106</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <full/>
+      <slot>
+        <options>0</options>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_CW_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_SUM</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE01</mt_code_value>
+            <options>4</options>
+            <font_position>106</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <full/>
+        <char>
+          <typeface>6</typeface>
+          <mt_code_value>0x002B</mt_code_value>
+          <options>4</options>
+          <font_position>43</font_position>
+          <variation>mathmode</variation>
+        </char>
+        <tmpl>
+          <selector>tmINTEG</selector>
+          <variation>tvINT_1</variation>
+          <variation>tvINT_CW_LOOP</variation>
+          <variation>tvBO_LOWER</variation>
+          <variation>tvBO_INT</variation>
+          <template_specific_options>0</template_specific_options>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0061</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <sub/>
+          <slot>
+            <options>0</options>
+            <char>
+              <typeface>3</typeface>
+              <mt_code_value>0x0062</mt_code_value>
+              <options>0</options>
+              <variation>mathmode</variation>
+            </char>
+            <end/>
+          </slot>
+          <slot>
+            <options>1</options>
+          </slot>
+          <sym/>
+          <char>
+            <typeface>11</typeface>
+            <mt_code_value>0xEE01</mt_code_value>
+            <options>4</options>
+            <font_position>106</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x222B</mt_code_value>
+            <options>4</options>
+            <font_position>242</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </tmpl>
+        <end/>
+      </slot>
+      <end/>
+    </pile>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/long_uint_comment.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/long_uint_comment.xml
new file mode 100644
index 0000000..2fd9416
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/long_uint_comment.xml
@@ -0,0 +1,936 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>inline</equation_options>
+    <mt_comment>
+      <comment_length>298</comment_length>
+      <comment_type>TeX Input Language</comment_type>
+      <comment_data>E_{\mathrm{e}\mathrm{q}}=E^{\emptyset}(\displaystyle \mathrm{I})-E^{\emptyset}(\mathrm{I}\mathrm{I})+\frac{RT}{z_{\mathrm{r}}F}\ln a_{\mathrm{M}(\mathrm{I})}^{\nu(\mathrm{I})_{+}}-\frac{RT}{z_{\mathrm{r}}F}\ln a_{\mathrm{M}(\mathrm{I}\mathrm{I})}^{\nu(\mathrm{I}\mathrm{I})_{+}}</comment_data>
+    </mt_comment>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <color_def>
+        <options>0</options>
+        <rgb>
+          <r>0</r>
+          <g>0</g>
+          <b>0</b>
+        </rgb>
+      </color_def>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0065</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0071</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+        <options>4</options>
+        <font_position>61</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2205</mt_code_value>
+            <options>4</options>
+            <font_position>198</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2205</mt_code_value>
+            <options>4</options>
+            <font_position>198</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x002B</mt_code_value>
+        <options>4</options>
+        <font_position>43</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmFRACT</selector>
+        <template_specific_options>0</template_specific_options>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0052</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0054</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x007A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <tmpl>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <color>
+                <color_def_index>1</color_def_index>
+              </color>
+              <char>
+                <typeface>1</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+                <options>0</options>
+                <variation>textmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <color>
+              <color_def_index>0</color_def_index>
+            </color>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <full/>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0046</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x006C</mt_code_value>
+        <options>2</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x006E</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUBSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x004D</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>4</typeface>
+            <mt_code_value>0x03BD</mt_code_value>
+            <options>4</options>
+            <font_position>110</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <tmpl>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub2/>
+            <slot>
+              <options>0</options>
+              <color>
+                <color_def_index>1</color_def_index>
+              </color>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x002B</mt_code_value>
+                <options>4</options>
+                <font_position>43</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <color>
+              <color_def_index>0</color_def_index>
+            </color>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <tmpl>
+        <selector>tmFRACT</selector>
+        <template_specific_options>0</template_specific_options>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0052</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0054</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x007A</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <tmpl>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub/>
+            <slot>
+              <options>0</options>
+              <color>
+                <color_def_index>1</color_def_index>
+              </color>
+              <char>
+                <typeface>1</typeface>
+                <mt_code_value>0x0072</mt_code_value>
+                <options>0</options>
+                <variation>textmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <color>
+              <color_def_index>0</color_def_index>
+            </color>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <full/>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>3</typeface>
+            <mt_code_value>0x0046</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x006C</mt_code_value>
+        <options>2</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x006E</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUBSUP</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x004D</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>4</typeface>
+            <mt_code_value>0x03BD</mt_code_value>
+            <options>4</options>
+            <font_position>110</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0028</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0049</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>2</typeface>
+            <mt_code_value>0x0029</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <color>
+            <color_def_index>0</color_def_index>
+          </color>
+          <tmpl>
+            <selector>tmSUB</selector>
+            <template_specific_options>0</template_specific_options>
+            <sub2/>
+            <slot>
+              <options>0</options>
+              <color>
+                <color_def_index>1</color_def_index>
+              </color>
+              <char>
+                <typeface>6</typeface>
+                <mt_code_value>0x002B</mt_code_value>
+                <options>4</options>
+                <font_position>43</font_position>
+                <variation>mathmode</variation>
+              </char>
+              <end/>
+            </slot>
+            <color>
+              <color_def_index>0</color_def_index>
+            </color>
+            <slot>
+              <options>1</options>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mathtype5_frac_sub.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mathtype5_frac_sub.xml
new file mode 100644
index 0000000..7e35f18
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mathtype5_frac_sub.xml
@@ -0,0 +1,517 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>5</product_version>
+    <product_subversion>0</product_subversion>
+    <application_key>DSMT5</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Arial</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <size>
+        <dsize>0</dsize>
+        <point_size>-320</point_size>
+      </size>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0050</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <full/>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0073</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0074</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <size>
+        <dsize>0</dsize>
+        <point_size>-320</point_size>
+      </size>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+        <options>4</options>
+        <font_position>61</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>24</typeface>
+        <mt_code_value>0xEB02</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>8</typeface>
+        <mt_code_value>0x0030</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x002C</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>8</typeface>
+        <mt_code_value>0x0038</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x002A</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <full/>
+      <tmpl>
+        <selector>tmROOT</selector>
+        <variation>tvROOT_SQ</variation>
+        <template_specific_options>0</template_specific_options>
+        <slot>
+          <options>0</options>
+          <tmpl>
+            <selector>tmFRACT</selector>
+            <variation>tvFR_SMALL</variation>
+            <template_specific_options>0</template_specific_options>
+            <slot>
+              <options>0</options>
+              <size>
+                <dsize>0</dsize>
+                <point_size>-320</point_size>
+              </size>
+              <char>
+                <typeface>3</typeface>
+                <mt_code_value>0x0053</mt_code_value>
+                <options>0</options>
+                <variation>mathmode</variation>
+              </char>
+              <size>
+                <dsize>0</dsize>
+                <point_size>-256</point_size>
+              </size>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <size>
+                    <dsize>0</dsize>
+                    <point_size>-256</point_size>
+                  </size>
+                  <char>
+                    <typeface>1</typeface>
+                    <mt_code_value>0x0041</mt_code_value>
+                    <options>0</options>
+                    <variation>textmode</variation>
+                  </char>
+                  <end/>
+                </slot>
+                <sub/>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <full/>
+            <slot>
+              <options>0</options>
+              <tmpl>
+                <selector>tmSUB</selector>
+                <template_specific_options>0</template_specific_options>
+                <sub/>
+                <slot>
+                  <options>0</options>
+                  <size>
+                    <dsize>0</dsize>
+                    <point_size>-320</point_size>
+                  </size>
+                  <char>
+                    <typeface>3</typeface>
+                    <mt_code_value>0x0053</mt_code_value>
+                    <options>0</options>
+                    <variation>mathmode</variation>
+                  </char>
+                  <full/>
+                  <tmpl>
+                    <selector>tmSUB</selector>
+                    <template_specific_options>0</template_specific_options>
+                    <sub/>
+                    <slot>
+                      <options>0</options>
+                      <size>
+                        <dsize>0</dsize>
+                        <point_size>-256</point_size>
+                      </size>
+                      <char>
+                        <typeface>8</typeface>
+                        <mt_code_value>0x0030</mt_code_value>
+                        <options>0</options>
+                        <variation>mathmode</variation>
+                      </char>
+                      <end/>
+                    </slot>
+                    <sub/>
+                    <slot>
+                      <options>1</options>
+                    </slot>
+                    <end/>
+                  </tmpl>
+                  <end/>
+                </slot>
+                <slot>
+                  <options>1</options>
+                </slot>
+                <end/>
+              </tmpl>
+              <end/>
+            </slot>
+            <end/>
+          </tmpl>
+          <end/>
+        </slot>
+        <full/>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border.xml
new file mode 100644
index 0000000..3966e16
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border.xml
@@ -0,0 +1,365 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>5</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Euclid Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <matrix>
+        <options>0</options>
+        <valign>center_baseline</valign>
+        <h_just>left</h_just>
+        <v_just>center_baseline</v_just>
+        <rows>3</rows>
+        <cols>1</cols>
+        <row_parts>1</row_parts>
+        <row_parts>3</row_parts>
+        <row_parts>1</row_parts>
+        <row_parts>0</row_parts>
+        <col_parts>1</col_parts>
+        <col_parts>2</col_parts>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0033</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </matrix>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border2.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border2.xml
new file mode 100644
index 0000000..3a85cca
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix-border2.xml
@@ -0,0 +1,603 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>5</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>3</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>3</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>4</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>6</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>6</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>9</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>6</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>9</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <matrix>
+        <options>0</options>
+        <valign>center_baseline</valign>
+        <h_just>left</h_just>
+        <v_just>center_baseline</v_just>
+        <rows>8</rows>
+        <cols>8</cols>
+        <row_parts>2</row_parts>
+        <row_parts>0</row_parts>
+        <row_parts>1</row_parts>
+        <row_parts>2</row_parts>
+        <row_parts>3</row_parts>
+        <row_parts>0</row_parts>
+        <row_parts>1</row_parts>
+        <row_parts>3</row_parts>
+        <row_parts>1</row_parts>
+        <col_parts>2</col_parts>
+        <col_parts>1</col_parts>
+        <col_parts>0</col_parts>
+        <col_parts>3</col_parts>
+        <col_parts>2</col_parts>
+        <col_parts>1</col_parts>
+        <col_parts>0</col_parts>
+        <col_parts>3</col_parts>
+        <col_parts>1</col_parts>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <end/>
+        </slot>
+        <end/>
+      </matrix>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix.xml
new file mode 100644
index 0000000..8f36165
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/matrix.xml
@@ -0,0 +1,382 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>5</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Euclid Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <matrix>
+        <options>0</options>
+        <valign>center_baseline</valign>
+        <h_just>left</h_just>
+        <v_just>center_baseline</v_just>
+        <rows>2</rows>
+        <cols>2</cols>
+        <row_parts>0</row_parts>
+        <row_parts>0</row_parts>
+        <row_parts>0</row_parts>
+        <col_parts>0</col_parts>
+        <col_parts>0</col_parts>
+        <col_parts>0</col_parts>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0031</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>6</typeface>
+            <mt_code_value>0x2212</mt_code_value>
+            <options>4</options>
+            <font_position>45</font_position>
+            <variation>mathmode</variation>
+          </char>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0037</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0032</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <slot>
+          <options>0</options>
+          <char>
+            <typeface>8</typeface>
+            <mt_code_value>0x0035</mt_code_value>
+            <options>0</options>
+            <variation>mathmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <end/>
+      </matrix>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mtcomment.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mtcomment.xml
new file mode 100644
index 0000000..f7c416e
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/mtcomment.xml
@@ -0,0 +1,560 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>1</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>9</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>inline</equation_options>
+    <mt_comment>
+      <comment_length>198</comment_length>
+      <comment_type>TeX Input Language</comment_type>
+      <comment_data>E_{\mathrm{e}\mathrm{q}}=E(\mathrm{I})_{\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{h}\mathrm{t}\mathrm{s}}-E(\mathrm{I}\mathrm{I})_{\mathrm{L}\mathrm{i}\mathrm{n}\mathrm{k}\mathrm{s}}</comment_data>
+    </mt_comment>
+    <encoding_def>
+      <name>WinAllBasicCodePages</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Times New Roman</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier New</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>30</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>0</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <color_def>
+        <options>0</options>
+        <rgb>
+          <r>0</r>
+          <g>0</g>
+          <b>0</b>
+        </rgb>
+      </color_def>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0065</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0071</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x003D</mt_code_value>
+        <options>4</options>
+        <font_position>61</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0052</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0065</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0063</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0068</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0074</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0073</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <full/>
+      <color>
+        <color_def_index>1</color_def_index>
+      </color>
+      <char>
+        <typeface>6</typeface>
+        <mt_code_value>0x2212</mt_code_value>
+        <options>4</options>
+        <font_position>45</font_position>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0045</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0028</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>1</typeface>
+        <mt_code_value>0x0049</mt_code_value>
+        <options>0</options>
+        <variation>textmode</variation>
+      </char>
+      <char>
+        <typeface>2</typeface>
+        <mt_code_value>0x0029</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <color>
+        <color_def_index>0</color_def_index>
+      </color>
+      <tmpl>
+        <selector>tmSUB</selector>
+        <template_specific_options>0</template_specific_options>
+        <sub/>
+        <slot>
+          <options>0</options>
+          <color>
+            <color_def_index>1</color_def_index>
+          </color>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x004C</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0069</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x006E</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x006B</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <char>
+            <typeface>1</typeface>
+            <mt_code_value>0x0073</mt_code_value>
+            <options>0</options>
+            <variation>textmode</variation>
+          </char>
+          <end/>
+        </slot>
+        <color>
+          <color_def_index>0</color_def_index>
+        </color>
+        <slot>
+          <options>1</options>
+        </slot>
+        <end/>
+      </tmpl>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/sizes.xml b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/sizes.xml
new file mode 100644
index 0000000..ab7b200
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/expected/mathtype5/sizes.xml
@@ -0,0 +1,401 @@
+<?xml version="1.0"?>
+<root>
+  <mtef>
+    <mtef_version>5</mtef_version>
+    <platform>0</platform>
+    <product>0</product>
+    <product_version>6</product_version>
+    <product_subversion>7</product_subversion>
+    <application_key>DSMT6</application_key>
+    <equation_options>block</equation_options>
+    <future>
+      <skip>3</skip>
+    </future>
+    <encoding_def>
+      <name>MacRoman</name>
+    </encoding_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Cambria</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>3</enc_def_index>
+      <font_name>Symbol</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>5</enc_def_index>
+      <font_name>Courier</font_name>
+    </font_def>
+    <font_def>
+      <enc_def_index>4</enc_def_index>
+      <font_name>MT Extra</font_name>
+    </font_def>
+    <eqn_prefs>
+      <options>0</options>
+      <sizes_count>8</sizes_count>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>7</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <sizes>
+        <unit>2</unit>
+        <nibbles>1</nibbles>
+        <nibbles>15</nibbles>
+      </sizes>
+      <spaces_count>33</spaces_count>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>3</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>7</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>8</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>2</nibbles>
+        <nibbles>10</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>4</nibbles>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>5</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>1</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <spaces>
+        <unit>4</unit>
+        <nibbles>2</nibbles>
+        <nibbles>0</nibbles>
+        <nibbles>15</nibbles>
+      </spaces>
+      <styles_count>12</styles_count>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>2</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>2</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>1</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>3</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>1</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>4</font_def>
+        <font_style>0</font_style>
+      </styles>
+      <styles>
+        <font_def>0</font_def>
+      </styles>
+    </eqn_prefs>
+    <full/>
+    <slot>
+      <options>0</options>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0061</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <sub/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0062</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <size>
+        <lsize>4</lsize>
+        <dsize>3</dsize>
+      </size>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0063</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <size>
+        <lsize>0</lsize>
+        <dsize>-4</dsize>
+      </size>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0064</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <sub2/>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0065</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <size>
+        <lsize>0</lsize>
+        <dsize>2</dsize>
+      </size>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0066</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <size>
+        <lsize>0</lsize>
+        <dsize>-2</dsize>
+      </size>
+      <char>
+        <typeface>3</typeface>
+        <mt_code_value>0x0067</mt_code_value>
+        <options>0</options>
+        <variation>mathmode</variation>
+      </char>
+      <end/>
+    </slot>
+    <end/>
+  </mtef>
+</root>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/ceil.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/ceil.bin
new file mode 100644
index 0000000..d13aaec
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/ceil.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/fence.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/fence.bin
new file mode 100644
index 0000000..799b8d0
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/fence.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/floor.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/floor.bin
new file mode 100644
index 0000000..82c90cf
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/floor.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/frac.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/frac.bin
new file mode 100644
index 0000000..8746543
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/frac.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/large_nudge.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/large_nudge.bin
new file mode 100644
index 0000000..a89d379
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/large_nudge.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/lim_embell.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/lim_embell.bin
new file mode 100644
index 0000000..f6b8228
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/lim_embell.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/matrix_2x1.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/matrix_2x1.bin
new file mode 100644
index 0000000..9806cd1
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/matrix_2x1.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/pile.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/pile.bin
new file mode 100644
index 0000000..e771e50
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/pile.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sigma_subsup.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sigma_subsup.bin
new file mode 100644
index 0000000..34693ea
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sigma_subsup.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/small_nudge.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/small_nudge.bin
new file mode 100644
index 0000000..6b9a861
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/small_nudge.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sqrt.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sqrt.bin
new file mode 100644
index 0000000..5712b11
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype3/sqrt.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/299.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/299.bin
new file mode 100644
index 0000000..e55f186
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/299.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/arrows.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/arrows.bin
new file mode 100644
index 0000000..706d319
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/arrows.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embedded.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embedded.bin
new file mode 100644
index 0000000..0a10bbf
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embedded.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embellishments.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embellishments.bin
new file mode 100644
index 0000000..1bcb92a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/embellishments.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation1.eps b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation1.eps
new file mode 100644
index 0000000..4fd1922
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation1.eps differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation2.eps b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation2.eps
new file mode 100644
index 0000000..37b157f
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation2.eps differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation3.eps b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation3.eps
new file mode 100644
index 0000000..000f51a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/eps-equation3.eps differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation1.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation1.bin
new file mode 100644
index 0000000..a941b2b
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation1.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation10.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation10.bin
new file mode 100644
index 0000000..4d03682
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation10.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation11.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation11.bin
new file mode 100644
index 0000000..2b78e9a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation11.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation12.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation12.bin
new file mode 100644
index 0000000..88d4d6b
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation12.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation13.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation13.bin
new file mode 100644
index 0000000..03f6d0d
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation13.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation2.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation2.bin
new file mode 100644
index 0000000..f55b628
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation2.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation3.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation3.bin
new file mode 100644
index 0000000..3c0cd6a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation3.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation4.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation4.bin
new file mode 100644
index 0000000..c5646aa
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation4.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation5.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation5.bin
new file mode 100644
index 0000000..ee99ae2
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation5.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation6.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation6.bin
new file mode 100644
index 0000000..b086021
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation6.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation7.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation7.bin
new file mode 100644
index 0000000..6d206ee
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation7.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation8.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation8.bin
new file mode 100644
index 0000000..4a5e918
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation8.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation9.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation9.bin
new file mode 100644
index 0000000..f7db3fb
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/equation9.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/fences.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/fences.bin
new file mode 100644
index 0000000..8cfba81
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/fences.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/integrals.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/integrals.bin
new file mode 100644
index 0000000..871419a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/integrals.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/long_uint_comment.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/long_uint_comment.bin
new file mode 100644
index 0000000..a58edd4
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/long_uint_comment.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mathtype5_frac_sub.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mathtype5_frac_sub.bin
new file mode 100644
index 0000000..3d75982
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mathtype5_frac_sub.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border.bin
new file mode 100644
index 0000000..c8a05e5
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border2.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border2.bin
new file mode 100644
index 0000000..da6072f
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix-border2.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix.bin
new file mode 100644
index 0000000..1a62c5a
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/matrix.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mtcomment.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mtcomment.bin
new file mode 100644
index 0000000..4e0fe02
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/mtcomment.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/sizes.bin b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/sizes.bin
new file mode 100644
index 0000000..e224be5
Binary files /dev/null and b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/fixtures/input/mathtype5/sizes.bin differ
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/mathtype_spec.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/mathtype_spec.rb
new file mode 100644
index 0000000..d4c471f
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/mathtype_spec.rb
@@ -0,0 +1,18 @@
+require "spec_helper"
+
+require "pry"
+RSpec.describe Mathtype do
+  Dir.glob("spec/fixtures/input/mathtype*") do |dir|
+    Dir.glob("#{dir}/*.{bin,wmf,eps}") do |equation|
+      it "converted #{equation} matches expected output" do
+        xml = Mathtype::Converter.new(equation).to_xml
+        expected_xml = "#{File.basename(equation, ".*")}.xml"
+        # File.open("spec/fixtures/expected/" + expected_xml, "w+") do |file|
+        #   file.write xml
+        # end
+        expected = File.open(dir.gsub("input","expected") + "/" + expected_xml).read
+        expect(xml).to eq(expected)
+      end
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/spec/spec_helper.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/spec_helper.rb
new file mode 100644
index 0000000..ae3fe5c
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/spec/spec_helper.rb
@@ -0,0 +1,59 @@
+require "bindata"
+require "ole/storage"
+require "nokogiri"
+require "mathtype"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype/test-mathtype.rb b/scripts/mathtype2mathml/vendor/gems/mathtype/test-mathtype.rb
new file mode 100644
index 0000000..5ec6dd5
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype/test-mathtype.rb
@@ -0,0 +1,2 @@
+require_relative 'lib/mathtype'
+Mathtype::Converter.new("/home/sbulka/sandbox/normen/18379/oleObject3.bin").to_xml
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Gemfile b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Gemfile
new file mode 100644
index 0000000..726370f
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Gemfile
@@ -0,0 +1,6 @@
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mathtype_to_mathml.gemspec
+
+gemspec
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/LICENSE.txt b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/LICENSE.txt
new file mode 100644
index 0000000..370c190
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jure Triglav
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/README.md b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/README.md
new file mode 100644
index 0000000..a2812d2
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/README.md
@@ -0,0 +1,45 @@
+# MathTypeToMathML
+
+This gem can be used to convert MathType equations from a binary format (e.g. embedded in Word documents) to an open MathML representation. It achieves that in several stages, first using the [`mathtype`](https://github.com/jure/mathtype) gem to convert from a binary to an XML form of MTEF, and second, using XSLTs to convert XML to MathML.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mathtype_to_mathml'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathtype_to_mathml
+
+## Usage
+
+To convert a MathType equation embedded in a Word document (the file is usually named something like `oleObject1.bin`):
+
+```
+mathml = MathTypeToMathML::Converter.new(`oleObject1.bin`).convert
+```
+
+This will return a MathML string of the MathType equation.
+
+# Testing
+
+Run `bundle exec rspec` to run specs. Additionally, you can create a visual output using `html_output.rb`, like so:
+
+```
+bundle exec ruby spec/html_output.rb > test.html
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/jure/mathtype_to_mathml/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Rakefile b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Rakefile
new file mode 100644
index 0000000..9cdfeae
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/Rakefile
@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml.rb b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml.rb
new file mode 100644
index 0000000..290a0f3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml.rb
@@ -0,0 +1,544 @@
+require_relative "mathtype_to_mathml/version"
+require "nokogiri"
+require_relative '../../mathtype/lib/mathtype'
+require_relative "mathtype_to_mathml/mover"
+require_relative "mathtype_to_mathml/char_replacer"
+require_relative "mathtype_to_mathml/function_recognizer"
+
+module MathTypeToMathML
+  class Converter
+    # Use a class-level mutex to synchronize XSLT transformations for thread safety
+    @@xslt_mutex = Mutex.new
+    @@xslt_cache = {}
+
+    def initialize(mathtype)
+      @mathtype = Mathtype::Converter.new(mathtype).xml.doc
+
+      # Pre-process: Mark characters that should be bold BEFORE Mover disturbs the structure
+      # This is necessary because Mover moves elements into new parents, breaking the
+      # immediate sibling relationship between font_style_def and char elements.
+      mark_bold_characters(@mathtype)
+
+      # Addresses lack of scaning mode in our translator. See "Mover" for more.
+      mover = Mover.new(@mathtype)
+      mover.move
+
+      # Character ranges are tricky in XSLT 1.0, so we deal with them in Ruby
+      char_replacer = CharReplacer.new(@mathtype)
+      char_replacer.replace
+
+      # Recognize and replace function names
+      function_recognizer = FunctionRecognizer.new(@mathtype)
+      function_recognizer.recognize
+
+      # Handle Version 3 compatibility - add missing equation_options for XSLT
+      handle_version3_compatibility
+    end
+
+    def convert
+      @mathtype.xpath(".//tmpl[selector='tmINTEG']").each do |ele|
+        ele.xpath('.//slot/text()').each do |text|
+          element = Nokogiri::XML::Element.new("mi", @mathtype)
+          t = Nokogiri::XML::Text.new(text.text, @mathtype)
+          element.prepend_child(t)
+          text.replace(element)
+        end
+      end
+
+      @mathtype.xpath('.//text()').each do |text|
+        if text.parent.name == "slot" or text.parent.name == "pile"
+          element = Nokogiri::XML::Element.new("mi", @mathtype)
+          t = Nokogiri::XML::Text.new(text.text, @mathtype)
+          element.prepend_child(t)
+          text.replace(element)
+        end
+      end
+
+      # Thread-safe XSLT transformation
+      out = thread_safe_xslt_transform(@mathtype)
+
+      # Check if XSLT transformation was successful
+      if out.root.nil?
+        raise StandardError, "XSLT transformation failed - this may be a MathType version compatibility issue. Please check if the file is Version 3 (not fully supported) or corrupted."
+      end
+
+      # This is a hack, but XML namespaces are such a pain to get
+      # right, especially in nokogiri, so... We assume all content is
+      # mathml, remove namespaces & set the root default namespace to
+      # mathml
+      out.remove_namespaces!
+      out.root.default_namespace = 'http://www.w3.org/1998/Math/MathML'
+      # Post-process: fix bracket positioning for superscripts (must come before other transformations)
+      fix_bracket_superscript_positioning(out)
+      # Post-process: wrap cases tables with mfenced instead of a literal left brace
+      wrap_cases_with_mfenced(out)
+      # Post-process: clean up empty subscript/superscript elements
+      clean_empty_subsup(out)
+      # Post-process: clean up empty under/over elements (summations, integrals, etc.)
+      clean_empty_underover(out)
+      # Post-process: remove redundant nested mrow structures
+      clean_redundant_mrow(out)
+      # Post-process: remove empty text elements
+      clean_empty_text_elements(out)
+      # Post-process: remove stretchy="false" attributes (keep stretchy="true")
+      clean_stretchy_false_attributes(out)
+      out.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
+    end
+
+    private
+
+    def thread_safe_xslt_transform(mathtype)
+      @@xslt_mutex.synchronize do
+        # Lazy load and cache the XSLT object
+        unless @@xslt_cache[:xslt]
+          @@xslt_cache[:xslt] = Nokogiri::XSLT(File.open(path_to_xslt))
+        end
+
+        @@xslt_cache[:xslt].transform(mathtype)
+      end
+    end
+
+    def path_to_xslt
+      File.join(File.dirname(File.expand_path(__FILE__)), "transform.xsl")
+    end
+
+    def handle_version3_compatibility
+      # Check if this is a Version 3 file (lacks equation_options)
+      version_element = @mathtype.xpath("//mtef_version").first
+      if version_element && version_element.text == "3"
+        mtef_element = @mathtype.xpath("//mtef").first
+
+        # Check if equation_options already exists
+        unless @mathtype.xpath("//equation_options").any?
+          # Add equation_options element for XSLT compatibility
+          options_element = Nokogiri::XML::Element.new("equation_options", @mathtype)
+          options_element.content = "inline"  # Default to inline for Version 3
+
+          # Insert after mtef_version for proper ordering
+          version_element.add_next_sibling(options_element)
+
+        end
+      end
+    end
+
+    # Mark characters that should be bold by adding a 'should_be_bold' attribute.
+    # This must run BEFORE Mover, because Mover rearranges elements and breaks the
+    # immediate sibling relationship between font_style_def and char elements.
+    def mark_bold_characters(doc)
+      doc.xpath('//char').each do |char|
+        # Check for bold via typeface values first (legacy approach)
+        typeface_node = char.xpath("typeface")
+        if !typeface_node.empty?
+          typeface_value = typeface_node.text.to_i
+          # Common MathType bold typeface values
+          if [7, 131, 132, 134, 135].include?(typeface_value)
+            char['should_be_bold'] = 'true'
+            next
+          end
+        end
+
+        # Check for bold via IMMEDIATELY preceding font_style_def with char_style=1
+        # IMPORTANT: font_style_def only applies to the immediately following char element
+        immediate_preceding_sibling = char.xpath("preceding-sibling::*[1]").first
+        if immediate_preceding_sibling &&
+           immediate_preceding_sibling.name == 'font_style_def' &&
+           immediate_preceding_sibling.xpath("char_style").text == '1'
+          char['should_be_bold'] = 'true'
+        end
+      end
+    end
+
+    # Convert patterns like:
+    # <mrow>
+    #   <mo stretchy="true">{</mo>
+    #   <mrow>
+    #     <mtable> ... </mtable>
+    #   </mrow>
+    # </mrow>
+    # into:
+    # <mfenced open="{" close="">
+    #   <mtable class="tml-array"> ... </mtable>
+    # </mfenced>
+    # This better represents MathML cases notation.
+    def wrap_cases_with_mfenced(doc)
+      return unless doc && doc.root
+
+      # Find left curly operators
+      doc.xpath("//mo[normalize-space(text())='{']").each do |lbrace_mo|
+        parent = lbrace_mo.parent
+        next unless parent && parent.name == 'mrow'
+
+        # Identify the immediate following element sibling
+        following = lbrace_mo.xpath("following-sibling::*[1]").first
+        next unless following
+
+        # Detect mtable possibly wrapped by mrow
+        mtable = nil
+        if following.name == 'mrow'
+          mtable = following.at_xpath("./mtable")
+        elsif following.name == 'mtable'
+          mtable = following
+        end
+        next unless mtable
+
+        # Ensure there is no matching right brace in the same parent (avoid normal sets)
+        right_brace = lbrace_mo.xpath("following-sibling::mo[normalize-space(text())='}']").first
+        next if right_brace
+
+        # Build mfenced and move the table inside
+        mfenced = Nokogiri::XML::Element.new('mfenced', doc)
+        mfenced['open'] = '{'
+        mfenced['close'] = ''
+
+        # Ensure class="tml-array" on mtable
+        existing_class = mtable['class']
+        if existing_class
+          classes = existing_class.split(/\s+/)
+          unless classes.include?('tml-array')
+            mtable['class'] = (classes + ['tml-array']).join(' ')
+          end
+        else
+          mtable['class'] = 'tml-array'
+        end
+        # Ensure left alignment for cases arrays so TeX uses \begin{array}{l}
+        mtable['columnalign'] = 'left' unless mtable['columnalign']
+
+        # Remove the original nodes and insert mfenced at the lbrace position
+        # Detach mtable from its current parent (might be an inner mrow)
+        mtable.remove
+
+        # Clean up the wrapper mrow if it becomes empty
+        if following.name == 'mrow' && following.element_children.empty?
+          following.remove
+        end
+
+        # Insert mfenced where the left brace was
+        lbrace_mo.add_next_sibling(mfenced)
+        mfenced.add_child(mtable)
+
+        # Finally remove the left brace token
+        lbrace_mo.remove
+      end
+    end
+
+    # Clean up empty subscript and superscript elements that result from
+    # inappropriate MathType symbols (like cap with empty sub/sup positions).
+    # This converts:
+    # - msubsup with both empty → base element only
+    # - msubsup with empty sub → msup
+    # - msubsup with empty sup → msub
+    # - msub with empty sub → base element only
+    # - msup with empty sup → base element only
+    def clean_empty_subsup(doc)
+      return unless doc && doc.root
+
+      # Handle msubsup elements
+      doc.xpath("//msubsup").each do |elem|
+        children = elem.element_children
+        next unless children.length == 3
+
+        base, sub, sup = children
+        sub_empty = is_empty_mrow?(sub)
+        sup_empty = is_empty_mrow?(sup)
+
+        if sub_empty && sup_empty
+          # Replace with just the base element
+          elem.replace(base)
+        elsif sub_empty
+          # Convert to msup
+          new_elem = create_msup(doc, base, sup)
+          elem.replace(new_elem)
+        elsif sup_empty
+          # Convert to msub
+          new_elem = create_msub(doc, base, sub)
+          elem.replace(new_elem)
+        end
+      end
+
+      # Handle msub with empty subscript
+      doc.xpath("//msub").each do |elem|
+        children = elem.element_children
+        next unless children.length == 2
+
+        base, sub = children
+        if is_empty_mrow?(sub)
+          elem.replace(base)
+        end
+      end
+
+      # Handle msup with empty superscript
+      doc.xpath("//msup").each do |elem|
+        children = elem.element_children
+        next unless children.length == 2
+
+        base, sup = children
+        if is_empty_mrow?(sup)
+          elem.replace(base)
+        end
+      end
+    end
+
+    # Check if an element is an empty mrow (contains no non-whitespace content)
+    def is_empty_mrow?(elem)
+      return false unless elem && elem.name == 'mrow'
+
+      # Check if the mrow has no element children and no significant text content
+      elem.element_children.empty? && elem.content.strip.empty?
+    end
+
+    # Create a new msup element with the given base and superscript
+    def create_msup(doc, base, sup)
+      msup = Nokogiri::XML::Element.new('msup', doc)
+      msup.add_child(base.dup)
+      msup.add_child(sup.dup)
+      msup
+    end
+
+    # Create a new msub element with the given base and subscript
+    def create_msub(doc, base, sub)
+      msub = Nokogiri::XML::Element.new('msub', doc)
+      msub.add_child(base.dup)
+      msub.add_child(sub.dup)
+      msub
+    end
+
+    # Clean up empty under/over elements (munder, mover, munderover)
+    # Similar to subscript/superscript cleanup but for summations, integrals, etc.
+    def clean_empty_underover(doc)
+      return unless doc && doc.root
+
+      # Handle munderover elements
+      doc.xpath("//munderover").each do |elem|
+        children = elem.element_children
+        next unless children.length == 3
+
+        base, under, over = children
+        under_empty = is_empty_mrow?(under)
+        over_empty = is_empty_mrow?(over)
+
+        if under_empty && over_empty
+          # Replace with just the base element
+          elem.replace(base)
+        elsif under_empty
+          # Convert to mover
+          new_elem = create_mover(doc, base, over)
+          elem.replace(new_elem)
+        elsif over_empty
+          # Convert to munder
+          new_elem = create_munder(doc, base, under)
+          elem.replace(new_elem)
+        end
+      end
+
+      # Handle munder with empty under element
+      doc.xpath("//munder").each do |elem|
+        children = elem.element_children
+        next unless children.length == 2
+
+        base, under = children
+        if is_empty_mrow?(under)
+          elem.replace(base)
+        end
+      end
+
+      # Handle mover with empty over element
+      doc.xpath("//mover").each do |elem|
+        children = elem.element_children
+        next unless children.length == 2
+
+        base, over = children
+        if is_empty_mrow?(over)
+          elem.replace(base)
+        end
+      end
+    end
+
+    # Remove redundant nested mrow structures
+    # Converts <mrow><mrow>content</mrow></mrow> to <mrow>content</mrow>
+    def clean_redundant_mrow(doc)
+      return unless doc && doc.root
+
+      # Find mrow elements that contain only a single mrow child
+      doc.xpath("//mrow[count(*)=1 and mrow]").each do |outer_mrow|
+        inner_mrow = outer_mrow.children.first
+
+        # Replace the outer mrow with its inner content
+        # Move all children from inner to outer, then remove inner
+        inner_mrow.children.each do |child|
+          outer_mrow.add_child(child)
+        end
+        inner_mrow.remove
+      end
+    end
+
+    # Remove empty text elements (mi, mo, mn with no content)
+    def clean_empty_text_elements(doc)
+      return unless doc && doc.root
+
+      # Remove mi, mo, mn elements that are truly empty
+      doc.xpath("//mi[normalize-space(text())=''] | //mo[normalize-space(text())=''] | //mn[normalize-space(text())='']").each do |elem|
+        # Don't remove if it has attributes that might be meaningful
+        if elem.attributes.empty?
+          elem.remove
+        end
+      end
+    end
+
+    # Remove stretchy="false" attributes while keeping stretchy="true"
+    # This is because stretchy="false" is the default behavior for most operators,
+    # and removing it reduces output size without changing rendering behavior
+    def clean_stretchy_false_attributes(doc)
+      return unless doc && doc.root
+
+      # Find all elements with stretchy="false" attribute and remove it
+      doc.xpath("//*[@stretchy='false']").each do |elem|
+        elem.remove_attribute('stretchy')
+      end
+    end
+
+    # Create a new mover element with the given base and over script
+    def create_mover(doc, base, over)
+      mover = Nokogiri::XML::Element.new('mover', doc)
+      mover.add_child(base.dup)
+      mover.add_child(over.dup)
+      mover
+    end
+
+    # Create a new munder element with the given base and under script
+    def create_munder(doc, base, under)
+      munder = Nokogiri::XML::Element.new('munder', doc)
+      munder.add_child(base.dup)
+      munder.add_child(under.dup)
+      munder
+    end
+
+    # Fence pairs mapping for bracket positioning fix
+    FENCE_PAIRS = {
+      '[' => ']',
+      '(' => ')',
+      '{' => '}',
+      '⟨' => '⟩',  # angle brackets
+      '|' => '|',
+      '⌊' => '⌋',  # floor
+      '⌈' => '⌉',  # ceiling
+      '‖' => '‖'   # double bar
+    }.freeze
+
+    # Fix bracket positioning bug where MathType encodes brackets as plain
+    # characters rather than fence templates, causing superscripts to be
+    # incorrectly positioned.
+    #
+    # Detects pattern: <mo>[</mo> content <mo>]</mo> <msup><mrow><mo>DIFFERENT_FENCE...
+    # Restructures to: <msup><mrow><mo>[</mo> content <mo>DIFFERENT_FENCE</mo>... <mo>]</mo></mrow>...
+    #
+    # SAFETY: Only triggers when msup base starts with a DIFFERENT fence type than
+    # the preceding closing fence. This prevents false positives like [a]b^2 → [ab]^2
+    #
+    # This handles cases where users type brackets manually in MathType instead
+    # of using the bracket template, which the binary parser encodes as separate
+    # char elements rather than a tmBRACK template.
+    def fix_bracket_superscript_positioning(doc)
+      return unless doc && doc.root
+
+      # Allow disabling this fix via environment variable if issues arise
+      return if ENV['DISABLE_BRACKET_FIX']
+
+      # Find all msup elements (superscripts)
+      doc.xpath("//msup").each do |msup|
+        children = msup.element_children
+        next unless children.length == 2
+
+        base, superscript = children
+
+        # SAFETY CHECK 1: Base must be mrow with fence content
+        next unless base.name == 'mrow'
+        base_children = base.element_children
+        next if base_children.empty?
+
+        first_base_child = base_children.first
+        next unless first_base_child.name == 'mo'
+
+        # Look at previous sibling - should be a closing fence
+        prev_sibling = msup.xpath("preceding-sibling::*[1]").first
+        next unless prev_sibling && prev_sibling.name == 'mo'
+
+        closing_fence = prev_sibling.text.strip
+        # Check if it's a valid closing fence
+        opening_fence = FENCE_PAIRS.key(closing_fence)
+        next unless opening_fence
+
+        # SAFETY CHECK 2: The msup base must start with a DIFFERENT fence type
+        # This prevents false positives like [a]b^2 being changed to [ab]^2
+        # The bug pattern is: [f](x)^2 where ] is followed by (
+        base_fence = first_base_child.text.strip
+        next unless FENCE_PAIRS.key?(base_fence) || FENCE_PAIRS.value?(base_fence)
+
+        # If the closing fence before msup matches the opening fence in msup base,
+        # this is likely NOT the bug pattern (e.g., [a][b]^2 should stay as-is)
+        if FENCE_PAIRS[base_fence] == closing_fence || FENCE_PAIRS.key(base_fence) == closing_fence
+          next
+        end
+
+        # Scan backward from closing fence to find opening and collect content
+        siblings_before_closing = prev_sibling.xpath("preceding-sibling::*")
+
+        opening_fence_elem = nil
+        content_elements = []
+
+        # Reverse scan to find matching opening bracket
+        siblings_before_closing.reverse_each do |elem|
+          if elem.name == 'mo' && elem.text.strip == opening_fence
+            opening_fence_elem = elem
+            break
+          else
+            content_elements.unshift(elem)
+          end
+        end
+
+        next unless opening_fence_elem
+        next if content_elements.empty?
+
+        # Debug logging if enabled
+        if ENV['MATHML_DEBUG']
+          STDERR.puts "DEBUG: Bracket superscript pattern detected"
+          STDERR.puts "  Opening: #{opening_fence.inspect}"
+          STDERR.puts "  Content: #{content_elements.map(&:name).join(', ')}"
+          STDERR.puts "  Closing: #{closing_fence.inspect}"
+          STDERR.puts "  Base fence: #{base_fence.inspect}"
+          STDERR.puts "  Msup base: #{base.to_s[0..100]}"
+        end
+
+        # Restructure: create new msup with proper base containing all elements
+        new_base = Nokogiri::XML::Element.new('mrow', doc)
+
+        # Build new base: opening + content + (original base content) + closing
+        new_base.add_child(opening_fence_elem.dup)
+
+        content_elements.each do |elem|
+          new_base.add_child(elem.dup)
+        end
+
+        # Add original msup base content
+        base.element_children.each do |child|
+          new_base.add_child(child.dup)
+        end
+
+        # Add closing bracket at the end
+        new_base.add_child(prev_sibling.dup)
+
+        # Create new msup structure
+        new_msup = Nokogiri::XML::Element.new('msup', doc)
+        new_msup.add_child(new_base)
+        new_msup.add_child(superscript.dup)
+
+        # Replace old structure with new one
+        msup.replace(new_msup)
+
+        # Remove now-duplicated elements
+        opening_fence_elem.remove
+        content_elements.each(&:remove)
+        prev_sibling.remove
+      end
+    end
+  end
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/char_replacer.rb b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/char_replacer.rb
new file mode 100644
index 0000000..2b2124a
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/char_replacer.rb
@@ -0,0 +1,588 @@
+require "nokogiri"
+
+# XSLT 1.0 has virtually non-existent capabilities for character ranges,
+# codepoints, hex to decimal, etc., so we replace characters within character
+# ranges with Ruby. Additonally, it's not possible to get the actual character
+# represented by a hexadecimal number in XSLT, so we deal with those here too.
+# Regular single character translations are still done with XSLT (char.xsl).
+
+
+
+
+module MathTypeToMathML
+  class CharReplacer
+    # UNSUPPORTED = "Unsupported (Char)"
+    UNSUPPORTED = ""
+
+    DEFAULT_TEXTMODE = "(Char)"
+    DEFAULT_MATHMODE = "<mi>(Char)<mi>"
+
+    REPLACEMENTS = {
+      0x0021 => { # Exclamation mark
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x0028 => { # Left parenthesis
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x0029 => { # Right parenthesis
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002A => { # Asterisk
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002B => { # Plus sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002C => { # Plus sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002D => { # Hyphen-minus
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002E => { # Full stop
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x002F => { # Solidus
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x003D => { # Equals sign
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x003F => { # Question mark
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x005B => { # Left square bracket
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x005D => { # Right square bracket
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x007E => { # Tilda
+        mathmode: "<mo>(Char)</mo>"
+      },
+      0x0000..0x0008 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x000B..0x001F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x0030..0x0039 => { # (range) DIGITS 0-9
+        mathmode: "<mn>(Char)</mn>",
+        number: "(Char)",
+        textmode: "(Char)"
+      },
+      0x003A..0x003B => { # (range) COLON, SEMICOLON
+        mathmode: "<mo>(Char)</mo>",
+        textmode: "(Char)"
+      },
+      0x0041..0x005A => { # range: Basic Latin
+        mathmode: "<mi>(Char)</mi>",
+        textmode: "(Char)"
+      },
+      0x0061..0x007A => { # range: Basic Latin
+        mathmode: "<mi>(Char)</mi>",
+        textmode: "(Char)"
+      },
+      0x0080..0x009F => { # range: C1 Controls
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x00A0..0x00B0 => { # range: Latin-1 Supplement
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x00B2..0x00BB => { # range: Latin-1 Supplement
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x00BC..0x00BE => { # range: Latin-1 Supplement
+        mathmode: "<mn>(CharHex)</mn>"
+      },
+      0x02C6..0x02FF => { # range: Spacing Modifier Letters
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x0300..0x036F => { # range: Combining Diacritical Marks
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2000..0x200B => { # range: Spaces
+        mathmode: "<mtext>(CharHex)</mtext>"
+      },
+      0x200C..0x200F => { # range: Formatting Characters
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2010..0x2027 => { # range: General Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2028..0x202F => { # range: Formatting Characters
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2030..0x2069 => { # range: General Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x206A..0x206F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0x2070..0x209F => { # range: Superscripts and Subscripts
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x20A0..0x20CF => { # range: Currency Symbols
+        mathmode: "<mi>(CharHex)</mi>"
+      },
+      0x20D0..0x20FF => { # range: Combining Diacritical Marks for Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2100..0x2101 => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2103..0x210A => { # range: CJK Symbols and Punctuation
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2116..0x2117 => { # range: Supplemental Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x213C..0x2146 => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2150..0x218F => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mn>(CharHex)</mn>"
+      },
+      0x2190..0x21FF => { # range: Miscellaneous Mathematical Symbols-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2200..0x2211 => { # range: Supplemental Arrows-B
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2212 => { # minus sign (U+2212)
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2213..0x221D => { # range: Supplemental Arrows-A
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x221F..0x22FF => { # range: Dingbats
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2300..0x23FF => { # range: Miscellaneous Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2400..0x243F => { # range: Geometric Shapes
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2500..0x257F => { # range: Block Elements
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2580..0x259F => { # range: Box Drawing
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x25A0..0x25FF => { # range: Control Pictures
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2600..0x267F => { # range: Miscellaneous Technical
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2700..0x27BF => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x27F0..0x27FF => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2900..0x297F => { # range: Mathematical Operators
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2980..0x29AF => { # range: Arrows
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x29B1..0x29DB => { # range: Number Forms
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x29DD..0x29FF => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0x2A00..0x2AFF => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      # Greek letters
+      # Uppercase Greek letters
+      0x0391..0x03A9 => { mathmode: "<mi>(Char)</mi>", textmode: "(Char)" }, # Alpha
+      
+      
+      # Lowercase Greek letters
+      0x03B1..0x03C9 => { mathmode: "<mi>(Char)</mi>", textmode: "(Char)" }, # alpha
+      
+      # Mathematical symbols
+      0x221E => { mathmode: "<mo>(Char)</mo>" }, # infinity
+      0x2211 => { mathmode: "<mo>(Char)</mo>" }, # summation
+      0x222B => { mathmode: "<mo>(Char)</mo>" }, # integral
+      0x2206 => { mathmode: "<mo>(Char)</mo>" }, # delta
+      0x2207 => { mathmode: "<mo>(Char)</mo>" }, # nabla
+      0x2208 => { mathmode: "<mo>(Char)</mo>" }, # element of
+      0x2209 => { mathmode: "<mo>(Char)</mo>" }, # not element of
+      0x220B => { mathmode: "<mo>(Char)</mo>" }, # contains
+      0x2260 => { mathmode: "<mo>(Char)</mo>" }, # not equal
+      0x2264 => { mathmode: "<mo>(Char)</mo>" }, # less than or equal
+      0x2265 => { mathmode: "<mo>(Char)</mo>" }, # greater than or equal
+      0x00B1 => { mathmode: "<mo>(Char)</mo>" }, # plus-minus
+      0x00D7 => { mathmode: "<mo>(Char)</mo>" }, # multiplication
+      0x00F7 => { mathmode: "<mo>(Char)</mo>" }, # division
+      0x3000..0x303F => { # range: Letterlike Symbols
+        mathmode: "<mo>(CharHex)</mo>"
+      },
+      0xE000..0xE900 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE905..0xE90A => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE90D..0xE921 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE926..0xE92C => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE92E..0xE931 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE934..0xE939 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE93C..0xE98E => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xE990..0xEA05 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEA08..0xEA0A => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEA0D..0xEA31 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEA36..0xEA39 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEA3C..0xEA3F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEA46..0xEB00 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEB03..0xEB04 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEB07..0xED09 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xED14..0xED15 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xED17..0xEE03 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEE04..0xEE0C => {
+        textmode: UNSUPPORTED
+      },
+      0xEE0D..0xEE18 => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEE1A..0xEEFF => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xEF09..0xEFFF => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xF000..0xF033 => {
+        textmode: UNSUPPORTED
+      },
+      0xF034..0xF07F => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xF080..0xF0B3 => {
+        textmode: UNSUPPORTED
+      },
+      0xF0B4..0xF0BF => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xF0C0..0xF0C9 => {
+        textmode: UNSUPPORTED
+      },
+      0xF0CA..0xF0FF => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xF100..0xF133 => {
+        textmode: UNSUPPORTED
+      },
+      0xF134..0xF8FF => {
+        mathmode: UNSUPPORTED,
+        textmode: UNSUPPORTED
+      },
+      0xFB00..0xFB4F => { # range: Alphabetic Presentation Forms
+        mathmode: "<mtext>(CharHex)</mtext>"
+      },
+      0xFE35..0xFE4F => { # range: CJK Compatibility Forms
+        mathmode: "<mo>(CharHex)</mo>"
+      }
+    }
+
+    attr_accessor :mathtype
+
+    def initialize(mathtype)
+      @mathtype = mathtype
+    end
+
+    def replace
+      chars = @mathtype.css("char")
+
+      # Batch process characters to reduce overhead
+      chars.each do |char|
+        # Cache mt_code_value lookup (used multiple times)
+        mt_code_value = char.xpath("mt_code_value").text
+        char_code = mt_code_value.hex
+
+        # Check if character is bold
+        if bold_character?(char)
+          replace_bold_character_fast(char, mt_code_value, char_code)
+        # Check if character is in textmode (upright/normal style)
+        elsif textmode_character?(char)
+          replace_textmode_character_fast(char, mt_code_value, char_code)
+        else
+          replacement = REPLACEMENTS.find do |range, _|
+            range === char_code
+          end
+          replace_character(replacement, char) if replacement
+        end
+      end
+
+      # Reparse XML to merge adjacent text nodes (optimized: only if needed)
+      @mathtype = Nokogiri::XML(@mathtype.to_xml) if chars.any?
+    end
+
+    def replace_character(replacement, char)
+      if char.xpath("variation = 'textmode'")
+        replacement = replacement[1][:textmode] || DEFAULT_TEXTMODE
+        xml = replacement_xml(replacement, char)
+      else
+        replacement = replacement[1][:mathmode] || DEFAULT_MATHMODE
+        xml = replacement_xml_with_color(replacement, char)
+      end
+
+      char.replace Nokogiri::HTML::DocumentFragment.parse(xml)
+    end
+
+    def replacement_xml(string, char)
+      string.gsub("(Char)") do
+        char.xpath("mt_code_value").text.hex.chr("UTF-8") # e.g. π
+      end.gsub("(CharHex)") do
+        "&#x#{char.xpath('mt_code_value').text[2..-1]};" # e.g. &#x2229;
+      end
+    end
+
+    def replacement_xml_with_color(string, char)
+      # Get the base XML
+      xml = replacement_xml(string, char)
+
+      # Find the active color
+      color_value = get_active_color_for_char(char)
+      if color_value && color_value != '#000000'
+        # Add mathcolor attribute to the element
+        xml = xml.gsub(/^<(\w+)/, "<\\1 mathcolor=\"#{color_value}\"")
+      end
+
+      xml
+    end
+
+    def get_active_color_for_char(char)
+      # Use recursive parent-chain search to find color elements
+      # This matches MathType specification: "all following equation records have the color"
+
+      # Start by checking immediate preceding siblings
+      sibling_colors = char.xpath("preceding-sibling::color").select do |color|
+        color.xpath("color_def_index").text.to_i != 0
+      end
+
+      if sibling_colors.any?
+        # Found color in immediate siblings - use the last one (most recent)
+        return convert_color_to_hex(sibling_colors.last)
+      end
+
+      # No sibling colors - search up the parent chain recursively
+      parent = char.parent
+      return search_parent_chain_for_color(parent)
+    end
+
+    def search_parent_chain_for_color(node)
+      return nil unless node
+
+      # Stop if we've reached the document root
+      return nil if node.is_a?(Nokogiri::XML::Document)
+
+      # Check if current node has preceding sibling colors
+      parent_colors = node.xpath("preceding-sibling::color").select do |color|
+        color.xpath("color_def_index").text.to_i != 0
+      end
+
+      if parent_colors.any?
+        # Found color - use the last one (most recent in document order)
+        return convert_color_to_hex(parent_colors.last)
+      end
+
+      # Get parent, checking if it exists and is not the document
+      parent = node.parent
+      return nil if parent.nil? || parent.is_a?(Nokogiri::XML::Document)
+
+      # Recurse to parent's parent
+      return search_parent_chain_for_color(parent)
+    end
+
+    def convert_color_to_hex(color_elem)
+      color_def_index = color_elem.xpath("color_def_index").text.to_i
+
+      # Skip reset colors (index 0)
+      return nil if color_def_index == 0
+
+      # Find all color_def elements in the document
+      all_color_defs = @mathtype.xpath("//color_def")
+
+      # Get the color_def at the specified index (1-based)
+      color_def = all_color_defs[color_def_index - 1]
+      return nil unless color_def
+
+      # Extract RGB values
+      rgb = color_def.xpath("rgb").first
+      return nil unless rgb
+
+      r = rgb.xpath("r").text.to_i
+      g = rgb.xpath("g").text.to_i
+      b = rgb.xpath("b").text.to_i
+
+      # Convert to hex
+      return "##{(r * 255 / 1000).to_s(16).rjust(2, '0')}#{(g * 255 / 1000).to_s(16).rjust(2, '0')}#{(b * 255 / 1000).to_s(16).rjust(2, '0')}"
+    end
+
+    # Check if a character has bold formatting based on typeface or pre-marked attribute
+    def bold_character?(char)
+      # Check if this char was pre-marked as bold (set by mark_bold_characters before Mover)
+      # This is necessary because Mover moves elements and breaks sibling relationships
+      return true if char['should_be_bold'] == 'true'
+
+      # Legacy: Check for bold via typeface values (for older files or direct usage)
+      typeface_node = char.xpath("typeface")
+      if !typeface_node.empty?
+        typeface_value = typeface_node.text.to_i
+        # Common MathType bold typeface values
+        return true if [7, 131, 132, 134, 135].include?(typeface_value)
+      end
+
+      # Legacy: Check for bold via IMMEDIATELY preceding font_style_def with char_style=1
+      # This is kept for compatibility but may not work after Mover has run
+      immediate_preceding_sibling = char.xpath("preceding-sibling::*[1]").first
+      if immediate_preceding_sibling &&
+         immediate_preceding_sibling.name == 'font_style_def' &&
+         immediate_preceding_sibling.xpath("char_style").text == '1'
+        return true
+      end
+
+      false
+    end
+
+    # Replace a bold character with appropriate MathML
+    def replace_bold_character(char)
+      mt_code_value = char.xpath("mt_code_value").text
+      char_code = mt_code_value.hex
+      replace_bold_character_fast(char, mt_code_value, char_code)
+    end
+
+    # Optimized version with cached values
+    def replace_bold_character_fast(char, mt_code_value, char_code)
+      # Determine if it's a numeric character (0-9)
+      if (0x0030..0x0039).include?(char_code)
+        # Numeric character - use <mn> element
+        xml = "<mn mathvariant=\"bold\">&#x#{mt_code_value[2..-1]};</mn>"
+      else
+        # Regular character - use <mi> element
+        xml = "<mi mathvariant=\"bold\">&#x#{mt_code_value[2..-1]};</mi>"
+      end
+
+      char.replace Nokogiri::HTML::DocumentFragment.parse(xml)
+    end
+
+    # Check if a character is in textmode (upright/normal style)
+    def textmode_character?(char)
+      variation_node = char.xpath("variation")
+      !variation_node.empty? && variation_node.text == 'textmode'
+    end
+
+    # Replace a textmode character with appropriate MathML including mathvariant="normal"
+    def replace_textmode_character(char)
+      mt_code_value = char.xpath("mt_code_value").text
+      char_code = mt_code_value.hex
+      replace_textmode_character_fast(char, mt_code_value, char_code)
+    end
+
+    # Optimized version with cached values
+    def replace_textmode_character_fast(char, mt_code_value, char_code)
+      # Find the replacement rule for this character
+      replacement = REPLACEMENTS.find do |range, _|
+        range === char_code
+      end
+
+      if replacement
+        # Get the mathmode replacement (textmode replacements are usually just plain text)
+        mathmode_replacement = replacement[1][:mathmode] || DEFAULT_MATHMODE
+
+        # Check if it's a numeric character (0-9)
+        if (0x0030..0x0039).include?(char_code)
+          # Numeric character - use <mn> element with mathvariant="normal"
+          xml = "<mn mathvariant=\"normal\">#{char_code.chr('UTF-8')}</mn>"
+        # Check if the mathmode replacement uses <mi> tag
+        elsif mathmode_replacement.include?("<mi>")
+          # Regular character - use <mi> element with mathvariant="normal"
+          xml = "<mi mathvariant=\"normal\">#{char_code.chr('UTF-8')}</mi>"
+        # Check if it's an operator character
+        elsif mathmode_replacement.include?("<mo>")
+          # Operator character - use <mo> element (operators don't need mathvariant)
+          xml = "<mo>#{char_code.chr('UTF-8')}</mo>"
+        else
+          # Default to plain text for other cases
+          xml = char_code.chr('UTF-8')
+        end
+      else
+        # No replacement found - use default <mi> with mathvariant="normal"
+        xml = "<mi mathvariant=\"normal\">#{char_code.chr('UTF-8')}</mi>"
+      end
+
+      # Apply color if present
+      color_value = get_active_color_for_char(char)
+      if color_value && color_value != '#000000' && xml.start_with?('<')
+        xml = xml.gsub(/^<(\w+)/, "<\\1 mathcolor=\"#{color_value}\"")
+      end
+
+      char.replace Nokogiri::HTML::DocumentFragment.parse(xml)
+    end
+  end
+end
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/function_recognizer.rb b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/function_recognizer.rb
new file mode 100644
index 0000000..14722a3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/function_recognizer.rb
@@ -0,0 +1,46 @@
+# match math predefined function name in the mathml, like sin, cos, tan, cot, log, ln
+module MathTypeToMathML
+  class FunctionRecognizer
+    FUNCTIONS = %w(sin cos tan cot sec csc arcsin arccos arctan arccot arccsc sinh cosh tanh coth sech csch arsinh arcosh artanh arctanh min max log ln lg lim mol kg).sort_by(&:length).reverse
+
+    def initialize(document)
+      @doc = document
+    end
+
+    def recognize
+      @doc.xpath('//slot | //pile').each do |container|
+        restart_scan = true
+        while restart_scan
+          restart_scan = false
+          children = container.children.to_a
+          i = 0
+          while i < children.length
+            # Try to match functions starting at current node
+            FUNCTIONS.each do |func|
+              next if i + func.length > children.length
+              
+              sub_nodes = children[i, func.length]
+              if sub_nodes.all? { |n| n.name == 'mi' && n.text.length == 1 && n.text =~ /[a-z]/ }
+                word = sub_nodes.map(&:text).join
+                if word == func
+                  new_mi = Nokogiri::XML::Node.new('mi', @doc)
+                  new_mi.content = func
+                  new_mo = Nokogiri::XML::Node.new('mo', @doc)
+
+                  sub_nodes.first.add_previous_sibling(new_mi)
+                  new_mi.add_next_sibling(new_mo)
+                  sub_nodes.each(&:remove)
+                  
+                  restart_scan = true
+                  break
+                end
+              end
+            end
+            break if restart_scan
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end 
\ No newline at end of file
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/mover.rb b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/mover.rb
new file mode 100644
index 0000000..abee122
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/mover.rb
@@ -0,0 +1,181 @@
+require "nokogiri"
+
+# We're moving elements around to avoid "scanning" for characters when
+# using the /scan translator mode. The original issue is that MathType
+# considers subscripts and superscripts to be stand-alone, while MathML
+# considers them subscripts and superscripts of an object, and the object
+# is then included in the sub/superscript element.
+
+# MathType's translator has a scan mode, which does the following:
+# 1. Scanning goes to the right for commands with the "pre" option,
+#   otherwise left;
+# 2. If we are scanning right and the object next to the template is an
+#   opening "fence" character (parenthesis, bracket, brace, etc.),
+#   the slot is scanned for the corresponding closing fence character;
+# 3. If we are scanning left and the object next to the template is an closing
+#   "fence" character (parenthesis, bracket, brace, etc.), the slot is scanned
+#   for the corresponding opening fence character;
+# 4. If the fenced expression is found, it is used as #1 in the template translation.
+
+# Additionally, Mover inverts <emb>ellishments from <char><emb></emb></char> to
+# <emb><char></char></emb>.
+
+module MathTypeToMathML
+  class Mover
+    attr_reader :mathtype
+    attr_accessor :last_preceding_siblings
+
+    PARENS_SELECTOR = "selector='tmPARENS' or "\
+      "selector='tmBRACK' or " \
+      "selector='tmBRACE' or " \
+      "selector='tmOBRACK' or " \
+      "selector='tmOBRACE' or " \
+      "selector='tmHBRACK' or " \
+      "selector='tmHBRACE'"
+
+    SUBSUP_SELECTOR = "selector='tmSUP' or " \
+      "selector='tmSUB' or " \
+      "selector='tmSUBSUP'"
+
+    PRE = "variation='tvSU_PRECEDES'"
+
+    OPEN_PAREN = "mt_code_value = '0x0028' or " \
+      "mt_code_value = '0x005B' or " \
+      "mt_code_value = '0x007B'"
+
+    CLOSE_PAREN = "mt_code_value = '0x0029' or " \
+      "mt_code_value = '0x005D' or " \
+      "mt_code_value = '0x007D'"
+
+    OPEN_CLOSE_PAIRS = {
+      "0x0028" => "0x0029", # ( )
+      "0x005B" => "0x005D", # [ ]
+      "0x007B" => "0x007D", # { }
+    }
+
+    def initialize(mathtype)
+      @mathtype = mathtype
+      @last_preceding_siblings = Nokogiri::XML::NodeSet.new(@mathtype)
+    end
+
+    def move_until_mt_code(elements, mt_code_value, parent)
+      elements.each do |element|
+        element.parent = parent
+        break if element.xpath("mt_code_value = '#{mt_code_value}'")
+      end
+    end
+
+    def move_paren(siblings, node)
+      OPEN_CLOSE_PAIRS.each do |open, close|
+        if siblings[0].xpath("mt_code_value = '#{open}'") # ( )
+          move_until_mt_code(siblings, close, node)
+        end
+      end
+    end
+
+    def new_preceding_siblings(el)
+      all_siblings = el.xpath("preceding-sibling::tmpl | preceding-sibling::char")
+      siblings = all_siblings - last_preceding_siblings
+      self.last_preceding_siblings = all_siblings
+      siblings
+    end
+
+    def new_following_siblings(el)
+      el.xpath("following-sibling::tmpl | following-sibling::char")
+    end
+
+    def move_following_subsup
+      mathtype.xpath("//tmpl[(#{SUBSUP_SELECTOR}) and not(#{PRE})]").each do |el|
+        siblings = new_preceding_siblings(el)
+
+        node = Nokogiri::XML::Node.new "slot", mathtype
+
+        # NIL SAFETY: Check if siblings exist before accessing siblings.last
+        if siblings.any? && siblings.last.xpath(CLOSE_PAREN)
+          # BUG FIX: Find the MATCHING opening fence, not just any opening fence
+          # Get the closing fence code to determine which opener to search for
+          close_code = siblings.last.xpath("mt_code_value").text
+          matching_open = OPEN_CLOSE_PAIRS.key(close_code)
+
+          if matching_open
+            # Scan backward looking for the MATCHING opening fence only
+            matching_open_xpath = "mt_code_value = '#{matching_open}'"
+            siblings = siblings.reverse.take_while do |sibling|
+              !sibling.next_element.xpath(matching_open_xpath)
+            end.reverse
+          else
+            # Fallback to original behavior if no matching pair found
+            siblings = siblings.reverse.take_while do |sibling|
+              !sibling.next_element.xpath(OPEN_PAREN)
+            end.reverse
+          end
+
+          move_paren(siblings, node)
+        elsif siblings.any? && siblings.last.xpath("self::tmpl[#{PARENS_SELECTOR}]")
+          siblings.last.parent = node
+        elsif siblings.any?
+          siblings.last.parent = node
+        end
+
+        el.at_css("slot").add_previous_sibling node
+      end
+    end
+
+    def move_preceding_subsup
+      mathtype.xpath("//tmpl[(#{SUBSUP_SELECTOR}) and #{PRE}]").each do |el|
+        siblings = new_following_siblings(el)
+
+        node = Nokogiri::XML::Node.new "slot", mathtype
+
+        # NIL SAFETY: Check if siblings exist before accessing siblings.first
+        if siblings.any? && siblings.first.xpath(OPEN_PAREN)
+          # BUG FIX: Find the MATCHING closing fence, not just any closing fence
+          # Get the opening fence code to determine which closer to search for
+          open_code = siblings.first.xpath("mt_code_value").text
+          matching_close = OPEN_CLOSE_PAIRS[open_code]
+
+          if matching_close
+            # Scan forward looking for the MATCHING closing fence only
+            matching_close_xpath = "mt_code_value = '#{matching_close}'"
+            siblings = siblings.reverse.take_while do |sibling|
+              !sibling.next_element.xpath(matching_close_xpath)
+            end.reverse
+          else
+            # Fallback to original behavior if no matching pair found
+            siblings = siblings.reverse.take_while do |sibling|
+              !sibling.next_element.xpath(CLOSE_PAREN)
+            end.reverse
+          end
+
+          move_paren(siblings, node)
+        elsif siblings.any? && siblings.first.xpath("self::tmpl[#{PARENS_SELECTOR}]")
+          siblings.first.parent = node
+        elsif siblings.any?
+          siblings.first.parent = node
+        end
+
+        el.at_css("slot").add_previous_sibling node
+      end
+    end
+
+    def invert_char_embell
+      # Invert char -> embell to embell -> char.
+      mathtype.xpath("//char[embell]").each do |el|
+        embell = el.xpath("embell").first.remove
+        char = el.clone
+        char.parent = embell
+        el.replace(embell)
+      end
+    end
+
+    def move
+      move_following_subsup
+      move_preceding_subsup
+      invert_char_embell
+    end
+  end
+end
+
+
+
+
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/version.rb b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/version.rb
new file mode 100644
index 0000000..fe6ba64
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/mathtype_to_mathml/version.rb
@@ -0,0 +1,3 @@
+module MathTypeToMathML
+  VERSION = "0.0.7"
+end
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/transform.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/transform.xsl
new file mode 100644
index 0000000..3472319
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/transform.xsl
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+    <xsl:template match="/">
+        <xsl:apply-templates select=".//mtef" />
+    </xsl:template>
+
+    <xsl:template match="mtef[equation_options = 'inline']">
+        <math>
+            <xsl:apply-templates select="pile | slot"/>
+        </math>
+    </xsl:template>
+
+    <xsl:template match="mtef[equation_options = 'block']">
+        <math display="block">
+            <xsl:apply-templates select="pile | slot"/>
+        </math>
+    </xsl:template>
+
+    <xsl:template match="slot[count(*)=1 and matrix]">
+        <xsl:apply-templates/>
+    </xsl:template>
+
+    <xsl:template match="mi | mo | mn">
+        <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:apply-templates/>
+        </xsl:copy>
+    </xsl:template>
+
+    <xsl:template match="slot">
+        <mrow>
+            <xsl:apply-templates/>
+        </mrow>
+    </xsl:template>
+
+    <!-- Non-empty text nodes -->
+    <xsl:template match="text()[normalize-space()]">
+        <xsl:value-of select="."/>
+    </xsl:template>
+
+    <xsl:template match="*" />
+
+    <xsl:include href="xsl/int.xsl" />
+    <xsl:include href="xsl/lim.xsl" />
+    <xsl:include href="xsl/frac.xsl" />
+    <xsl:include href="xsl/pile.xsl" />
+    <xsl:include href="xsl/char.xsl" />
+    <xsl:include href="xsl/embellishment.xsl" />
+    <xsl:include href="xsl/subsup.xsl"/>
+    <xsl:include href="xsl/sum.xsl"/>
+    <xsl:include href="xsl/product_coproduct.xsl"/>
+    <xsl:include href="xsl/union_intersection.xsl"/>
+    <xsl:include href="xsl/box.xsl" />
+    <xsl:include href="xsl/fence.xsl" />
+    <xsl:include href="xsl/arrow.xsl"/>
+    <xsl:include href="xsl/root.xsl"/>
+    <xsl:include href="xsl/matrix.xsl"/>
+    <xsl:include href="xsl/long_embellishment.xsl"/>
+    <xsl:include href="xsl/long_division.xsl"/>
+    <xsl:include href="xsl/color.xsl"/>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/arrow.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/arrow.xsl
new file mode 100644
index 0000000..e73e6bc
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/arrow.xsl
@@ -0,0 +1,319 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Arrows -->
+    <xsl:template match="tmpl[selector='tmARROW']">
+        <mover>
+            <mo>&#x2192;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_LEFT']">
+        <mover>
+            <mo>&#x2190;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x2192;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_TOPBOTTOM']">
+        <munderover>
+            <mo>&#x2192;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE']">
+        <mover>
+            <mo>&#x21C4;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_LEFT' and variation='tvAR_RIGHT' )]">
+        <mover>
+            <mo>&#x2194;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_LEFT' and variation='tvAR_TOPBOTTOM']">
+        <munderover>
+            <mo>&#x2190;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_TOPBOTTOM']">
+        <munderover>
+            <mo>&#x21C4;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_LOS']">
+        <mover>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_SOL']">
+        <mover>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON']">
+        <mover>
+            <mo>&#x21CC;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_LEFT' and variation='tvAR_RIGHT' ) and variation='tvAR_TOPBOTTOM']">
+        <munderover>
+            <mo>&#x2194;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON']">
+        <mover>
+            <mo>&#x21CC;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_LOS' and variation='tvAR_TOPBOTTOM']">
+        <munderover accentunder="true">
+            <mstyle scriptlevel="-1"><mo>&#x2192;</mo></mstyle>
+            <munder>
+                <mstyle scriptlevel="+1"><mo>&#x2190;</mo></mstyle>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_SOL' and variation='tvAR_TOPBOTTOM']">
+        <munderover accentunder="true">
+            <mstyle scriptlevel="+1"><mo>&#x2192;</mo></mstyle>
+            <munder>
+                <mstyle scriptlevel="-1"><mo>&#x2190;</mo></mstyle>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_SOL']">
+        <mover>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_LOS']">
+        <mover>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_TOPBOTTOM']">
+        <munderover>
+            <mo>&#x21CC;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_LOS' and variation='tvAR_TOPBOTTOM']">
+        <munderover accentunder="true">
+            <mstyle scriptlevel="-1"><mo>&#x21C0;</mo></mstyle>
+            <munder>
+                <mstyle scriptlevel="+1"><mo>&#x21BD;</mo></mstyle>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_SOL' and variation='tvAR_TOPBOTTOM']">
+        <munderover accentunder="true">
+            <mstyle scriptlevel="+1"><mo>&#x21C0;</mo></mstyle>
+            <munder>
+                <mstyle scriptlevel="-1"><mo>&#x21BD;</mo></mstyle>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_LEFT' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x2190;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_LEFT' and variation='tvAR_RIGHT' ) and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x2194;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x21C4;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_LOS' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_SOL' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x21CC;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_LOS' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_SOL' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_LEFT' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x2190;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_LEFT' and variation='tvAR_RIGHT' ) and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x2194;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x21C4;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_LOS' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and variation='tvAR_DOUBLE' and variation='tvAR_SOL' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x2192;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x2190;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_BOTTOM']">
+        <munder>
+            <mo>&#x21CC;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_LOS' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="-1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="+1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARROW' and (variation='tvAR_DOUBLE' or variation='tvAR_HARPOON') and variation='tvAR_HARPOON' and variation='tvAR_SOL' and variation='tvAR_BOTTOM']">
+        <munder>
+            <munder accentunder="true">
+                <mstyle scriptlevel="+1"><mo>&#x21C0;</mo></mstyle>
+                <mstyle scriptlevel="-1"><mo>&#x21BD;</mo></mstyle>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/box.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/box.xsl
new file mode 100644
index 0000000..707a983
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/box.xsl
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Boxes -->
+
+    <xsl:template match="tmpl[selector='tmBOX' and (variation='tvBX_TOP' and variation='tvBX_LEFT')]">
+        <menclose notation="top left">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmBOX' and (variation='tvBX_TOP' and variation='tvBX_RIGHT')]">
+        <menclose notation="actuarial">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmBOX' and (variation='tvBX_BOTTOM' and variation='tvBX_LEFT')]">
+        <menclose notation="bottom left">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmBOX' and (variation='tvBX_BOTTOM' and variation='tvBX_RIGHT')]">
+        <menclose notation="bottom right">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </menclose>
+    </xsl:template>
+
+     <xsl:template match="tmpl[selector='tmBOX' and variation='tvBX_TOP' and variation='tvBX_BOTTOM' and variation='tvBX_LEFT' and variation='tvBX_RIGHT']">
+        <menclose notation="box">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </menclose>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/char.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/char.xsl
new file mode 100644
index 0000000..aa14b68
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/char.xsl
@@ -0,0 +1,1876 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <xsl:template match="mi | mo | mn | mtext">
+        <xsl:copy-of select="."/>
+    </xsl:template>
+
+    <xsl:template name="charhex">
+        <xsl:param name="mt_code_value"/>
+        <xsl:text disable-output-escaping="yes">&amp;#</xsl:text>
+        <xsl:value-of select="substring($mt_code_value, 2)"/>
+        <xsl:text>;</xsl:text>
+    </xsl:template>
+
+    <!-- Default char translation for mathmode -->
+    <xsl:template match="char[not(variation) or variation != 'textmode']">
+        <mi>
+            <xsl:attribute name="debug">default-char-template</xsl:attribute>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+            </xsl:call-template>
+        </mi>
+    </xsl:template>
+
+    <xsl:template match="char[variation = 'textmode']">
+        <xsl:call-template name="charhex">
+            <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+        </xsl:call-template>
+    </xsl:template>
+
+    <xsl:template match="char[typeface = '2']">
+        <mn>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+            </xsl:call-template>
+        </mn>
+    </xsl:template>
+
+    <xsl:template match="char[typeface = '8']">
+        <mn>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+            </xsl:call-template>
+        </mn>
+    </xsl:template>
+
+    <xsl:template match="char[typeface = '3']">
+        <mi>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+            </xsl:call-template>
+        </mi>
+    </xsl:template>
+
+    <xsl:template match="char[typeface = '6']">
+        <mo>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()" />
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+<!--     <xsl:template match="char[mt_code_value='0x2026']">
+        <mo>&#x2026;</mo>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x22EE' ]">
+      <mo>&#x22EE;</mo>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x22F1' ]">
+      <mo>&#x22F1;</mo>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x22EF' ]">
+      <mo>&#x22EF;</mo>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x03C0' ]">
+        <mi>π</mi>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x03B8' ]">
+        <mi>θ</mi>
+    </xsl:template> -->
+
+    <!-- All Char rules -->
+
+    <!-- HORIZONTAL TABULATION -->
+    <xsl:template match="char[mt_code_value='0x0009' and variation='mathmode']">
+        <mtext>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mtext>
+    </xsl:template>
+
+    <!-- LINE FEED -->
+    <xsl:template match="char[mt_code_value='0x000A' and variation='mathmode']">
+        <mtext>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mtext>
+    </xsl:template>
+
+    <!-- SPACE -->
+    <xsl:template match="char[mt_code_value='0x0020' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x00A0;</xsl:text>
+    </xsl:template>
+
+    <!-- QUOTATION MARK -->
+    <xsl:template match="char[mt_code_value='0x0022' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- NUMBER SIGN -->
+    <xsl:template match="char[mt_code_value='0x0023' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- AMPERSAND -->
+    <xsl:template match="char[mt_code_value='0x0026' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="apply-color-attribute"/>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- APOSTROPHE -->
+    <xsl:template match="char[mt_code_value='0x0027' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- LESS-THAN SIGN -->
+    <xsl:template match="char[mt_code_value='0x003C' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x003C;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- GREATER-THAN SIGN -->
+    <xsl:template match="char[mt_code_value='0x003E' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x003E;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- COMMERCIAL AT -->
+    <xsl:template match="char[mt_code_value='0x0040' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- REVERSE SOLIDUS -->
+    <xsl:template match="char[mt_code_value='0x005C' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- CIRCUMFLEX ACCENT -->
+    <xsl:template match="char[mt_code_value='0x005E' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- LOW LINE -->
+    <xsl:template match="char[mt_code_value='0x005F' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- GRAVE ACCENT -->
+    <xsl:template match="char[mt_code_value='0x0060' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- LEFT CURLY BRACKET -->
+    <xsl:template match="char[mt_code_value='0x007B' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- VERTICAL LINE -->
+    <xsl:template match="char[mt_code_value='0x007C' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- RIGHT CURLY BRACKET -->
+    <xsl:template match="char[mt_code_value='0x007D' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: DELETE -->
+    <xsl:template match="char[mt_code_value='0x007F']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- range: Latin-1 Supplement -->
+    <xsl:template match="char[mt_code_value='0x00B1' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+
+    <!-- INVERTED QUESTION MARK -->
+    <xsl:template match="char[mt_code_value='0x00BF' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- MULTIPLICATION SIGN -->
+    <xsl:template match="char[mt_code_value='0x00D7' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- DIVISION SIGN -->
+    <xsl:template match="char[mt_code_value='0x00F7' and variation='mathmode']">
+        <mo>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mo>
+    </xsl:template>
+
+    <!-- DOUBLE-STRUCK CAPITAL C -->
+    <xsl:template match="char[mt_code_value='0x2102' and variation='mathmode']">
+        <mi>
+            <xsl:call-template name="charhex">
+                <xsl:with-param name="mt_code_value" select="mt_code_value/text()"/>
+            </xsl:call-template>
+        </mi>
+    </xsl:template>
+
+
+    <!-- PLUS ABOVE EQUALS -->
+    <xsl:template match="char[mt_code_value='0xE901' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A72;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PLUS ABOVE EQUALS -->
+    <xsl:template match="char[mt_code_value='0xE901' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A72;</xsl:text>
+    </xsl:template>
+
+    <!-- PLUS BELOW EQUALS -->
+    <xsl:template match="char[mt_code_value='0xE902' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A71;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PLUS BELOW EQUALS -->
+    <xsl:template match="char[mt_code_value='0xE902' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A71;</xsl:text>
+    </xsl:template>
+
+    <!-- PLUS ABOVE TILDE -->
+    <xsl:template match="char[mt_code_value='0xE903' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A26;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PLUS ABOVE TILDE -->
+    <xsl:template match="char[mt_code_value='0xE903' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A26;</xsl:text>
+    </xsl:template>
+
+    <!-- PLUS BELOW TILDE -->
+    <xsl:template match="char[mt_code_value='0xE904' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A24;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PLUS BELOW TILDE -->
+    <xsl:template match="char[mt_code_value='0xE904' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A24;</xsl:text>
+    </xsl:template>
+
+    <!-- SUPERSET OF OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE90B' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2287;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUPERSET OF OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE90B' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2287;</xsl:text>
+    </xsl:template>
+
+    <!-- SUBSET OF OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE90C' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2286;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUBSET OF OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE90C' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2286;</xsl:text>
+    </xsl:template>
+
+    <!-- LESS-THAN EQUAL TO (DOUBLE) OR GREATER-THAN -->
+    <xsl:template match="char[mt_code_value='0xE922' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x22DA;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- LESS-THAN EQUAL TO (DOUBLE) OR GREATER-THAN -->
+    <xsl:template match="char[mt_code_value='0xE922' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x22DA;</xsl:text>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: EQUIVALENT TO OR GREATER-THAN -->
+    <xsl:template match="char[mt_code_value='0xE923' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: EQUIVALENT TO OR GREATER-THAN -->
+    <xsl:template match="char[mt_code_value='0xE923' and variation='textmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- TILDE WITH DOT -->
+    <xsl:template match="char[mt_code_value='0xE924' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A6A;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- TILDE WITH DOT -->
+    <xsl:template match="char[mt_code_value='0xE924' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A6A;</xsl:text>
+    </xsl:template>
+
+    <!-- TILDE WITH TWO DOTS -->
+    <xsl:template match="char[mt_code_value='0xE925' and variation='mathmode']">
+        <mover accent='true'><mo><xsl:text disable-output-escaping="yes">&amp;#x223B;</xsl:text></mo><mo><xsl:text disable-output-escaping="yes">&amp;#x00A8;</xsl:text></mo></mover>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: TILDE WITH TWO DOTS -->
+    <xsl:template match="char[mt_code_value='0xE925' and variation='textmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- GREATER-THAN EQUAL TO (DOUBLE) OR LESS-THAN -->
+    <xsl:template match="char[mt_code_value='0xE92D' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x22DB;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- GREATER-THAN EQUAL TO (DOUBLE) OR LESS-THAN -->
+    <xsl:template match="char[mt_code_value='0xE92D' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x22DB;</xsl:text>
+    </xsl:template>
+
+    <!-- LESS-THAN OR APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xE932' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2272;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- LESS-THAN OR APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xE932' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2272;</xsl:text>
+    </xsl:template>
+
+    <!-- GREATER-THAN OR APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xE933' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2273;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- GREATER-THAN OR APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xE933' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2273;</xsl:text>
+    </xsl:template>
+
+    <!-- PRECEDES OR EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE93A' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x227E;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PRECEDES OR EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE93A' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x227E;</xsl:text>
+    </xsl:template>
+
+    <!-- SUCCEEDS OR EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE93B' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x227F;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUCCEEDS OR EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xE93B' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x227F;</xsl:text>
+    </xsl:template>
+
+    <!-- MEDIUM DOT OPERATOR (FREE RADICAL) -->
+    <xsl:template match="char[mt_code_value='0xE98F' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x00B7;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- MEDIUM DOT OPERATOR (FREE RADICAL) -->
+    <xsl:template match="char[mt_code_value='0xE98F' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x00B7;</xsl:text>
+    </xsl:template>
+
+
+    <!-- MEDIUM DOT OPERATOR (FREE RADICAL) -->
+    <xsl:template match="char[mt_code_value='0xE98F' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x22C5;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- MEDIUM DOT OPERATOR (FREE RADICAL) -->
+    <xsl:template match="char[mt_code_value='0xE98F' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x22C5;</xsl:text>
+    </xsl:template>
+
+
+
+    <!-- NOT LESS-THAN OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA06' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2270;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NOT LESS-THAN OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA06' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2270;</xsl:text>
+    </xsl:template>
+
+    <!-- NOT GREATER-THAN OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA07' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2271;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NOT GREATER-THAN OR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA07' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2271;</xsl:text>
+    </xsl:template>
+
+    <!-- NEITHER SUPERSET OF NOR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA0B' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2289;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NEITHER SUPERSET OF NOR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA0B' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2289;</xsl:text>
+    </xsl:template>
+
+    <!-- NEITHER SUBSET OF NOR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA0C' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2288;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NEITHER SUBSET OF NOR EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA0C' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2288;</xsl:text>
+    </xsl:template>
+
+    <!-- LESS-THAN BUT NOT APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA32' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A89;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- LESS-THAN BUT NOT APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA32' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A89;</xsl:text>
+    </xsl:template>
+
+    <!-- GREATER-THAN BUT NOT APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA33' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2A8A;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- GREATER-THAN BUT NOT APPROXIMATELY EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA33' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2A8A;</xsl:text>
+    </xsl:template>
+
+    <!-- LESS-THAN OR NOT EQUAL TO (SINGLE) -->
+    <xsl:template match="char[mt_code_value='0xEA34' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2268;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- LESS-THAN OR NOT EQUAL TO (SINGLE) -->
+    <xsl:template match="char[mt_code_value='0xEA34' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2268;</xsl:text>
+    </xsl:template>
+
+    <!-- GREATER-THAN OR NOT EQUAL TO (SINGLE) -->
+    <xsl:template match="char[mt_code_value='0xEA35' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2269;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- GREATER-THAN OR NOT EQUAL TO (SINGLE) -->
+    <xsl:template match="char[mt_code_value='0xEA35' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2269;</xsl:text>
+    </xsl:template>
+
+    <!-- PRECEDES BUT NOT EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA3A' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x22E8;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PRECEDES BUT NOT EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA3A' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x22E8;</xsl:text>
+    </xsl:template>
+
+    <!-- SUCCEEDS BUT NOT EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA3B' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x22E9;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUCCEEDS BUT NOT EQUIVALENT TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA3B' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x22E9;</xsl:text>
+    </xsl:template>
+
+    <!-- PRECEDES BUT NOT EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA40' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2AB5;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- PRECEDES BUT NOT EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA40' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2AB5;</xsl:text>
+    </xsl:template>
+
+    <!-- SUCCEEDS BUT NOT EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA41' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2AB6;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUCCEEDS BUT NOT EQUAL TO (DOUBLE) -->
+    <xsl:template match="char[mt_code_value='0xEA41' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2AB6;</xsl:text>
+    </xsl:template>
+
+    <!-- NOT SUBSET OF NOR EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA42' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2288;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NOT SUBSET OF NOR EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA42' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2288;</xsl:text>
+    </xsl:template>
+
+    <!-- NOT SUPERSET OF NOR EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA43' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2289;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- NOT SUPERSET OF NOR EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA43' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2289;</xsl:text>
+    </xsl:template>
+
+    <!-- SUBSET OF ABOVE NOT EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA44' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2ACB;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUBSET OF ABOVE NOT EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA44' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2ACB;</xsl:text>
+    </xsl:template>
+
+    <!-- SUPERSET OF ABOVE NOT EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA45' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2ACC;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SUPERSET OF ABOVE NOT EQUAL TO -->
+    <xsl:template match="char[mt_code_value='0xEA45' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2ACC;</xsl:text>
+    </xsl:template>
+
+    <!-- RIGHTWARDS ARROW ABOVE SHORT LEFTWARDS ARROW -->
+    <xsl:template match="char[mt_code_value='0xEB01' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2942;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- SHORT RIGHTWARDS ARROW ABOVE LEFTWARDS ARROW -->
+    <xsl:template match="char[mt_code_value='0xEB02' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2944;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- DOUBLE ARROW NORTHEAST SOUTHWEST -->
+    <xsl:template match="char[mt_code_value='0xEB05' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2922;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- DOUBLE ARROW NORTHWEST SOUTHEAST -->
+    <xsl:template match="char[mt_code_value='0xEB06' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2921;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- COMBINING TILDE TWO SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE04' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x02DC;</mo>
+    </xsl:template>
+
+    <!-- COMBINING TILDE THREE SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE05' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x02DC;</mo>
+    </xsl:template>
+
+    <!-- COMBINING TILDE FOUR SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE06' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x02DC;</mo>
+    </xsl:template>
+
+    <!-- COMBINING CIRCUMFLEX TWO SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE07' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x005E;</mo>
+    </xsl:template>
+
+    <!-- COMBINING CIRCUMFLEX THREE SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE08' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x005E;</mo>
+    </xsl:template>
+
+    <!-- COMBINING CIRCUMFLEX FOUR SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE09' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x005E;</mo>
+    </xsl:template>
+
+    <!-- COMBINING ARC TWO SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE0A' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x2322;</mo>
+    </xsl:template>
+
+    <!-- COMBINING ARC THREE SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE0B' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x2322;</mo>
+    </xsl:template>
+
+    <!-- COMBINING ARC FOUR SPACE -->
+    <xsl:template match="char[mt_code_value='0xEE0C' and variation='mathmode']">
+        <mo stretchy='true'>&amp;#x2322;</mo>
+    </xsl:template>
+
+    <!-- QUADRUPLE PRIME -->
+    <xsl:template match="char[mt_code_value='0xEE19' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2057;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- QUADRUPLE PRIME -->
+    <xsl:template match="char[mt_code_value='0xEE19' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2057;</xsl:text>
+    </xsl:template>
+
+    <!-- ALIGNMENT MARK -->
+    <xsl:template match="char[mt_code_value='0xEF00' and variation='mathmode']">
+        <malignmark/>
+    </xsl:template>
+
+    <!-- ALIGNMENT MARK -->
+    <xsl:template match="char[mt_code_value='0xEF00' and variation='textmode']">
+        <malignmark/>
+    </xsl:template>
+
+    <!-- MT ZERO SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF01' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x200B;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT ZERO SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF01' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x200B;</xsl:text>
+    </xsl:template>
+
+    <!-- MT THIN SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF02' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x2009;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT THIN SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF02' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2009;</xsl:text>
+    </xsl:template>
+
+    <!-- MT MEDIUM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF03' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x205F;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT MEDIUM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF03' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x205F;</xsl:text>
+    </xsl:template>
+
+    <!-- MT THICK SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF04' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x2009;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT THICK SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF04' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2009;</xsl:text>
+    </xsl:template>
+
+    <!-- MT EM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF05' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x2003;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT EM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF05' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2003;</xsl:text>
+    </xsl:template>
+
+    <!-- MT 2 EM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF06' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x2003;</xsl:text>&amp;#x2003;</mtext>
+    </xsl:template>
+
+    <!-- MT 2 EM SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF06' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2003;&amp;#x2003;</xsl:text>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: range: Private Use Area -->
+    <xsl:template match="char[mt_code_value='0xEF07' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: range: Private Use Area -->
+    <xsl:template match="char[mt_code_value='0xEF07' and variation='textmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MT 1 POINT SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF08' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#x200A;</xsl:text></mtext>
+    </xsl:template>
+
+    <!-- MT 1 POINT SPACE -->
+    <xsl:template match="char[mt_code_value='0xEF08' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x200A;</xsl:text>
+    </xsl:template>
+
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL A -->
+    <xsl:template match="char[mt_code_value='0xF000' and variation='mathmode']">
+        <mi mathvariant='fraktur'>A</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL B -->
+    <xsl:template match="char[mt_code_value='0xF001' and variation='mathmode']">
+        <mi mathvariant='fraktur'>B</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL C -->
+    <xsl:template match="char[mt_code_value='0x212D' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x212D;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED: range: Private Use Area -->
+    <xsl:template match="char[mt_code_value='0xF002' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL D -->
+    <xsl:template match="char[mt_code_value='0xF003' and variation='mathmode']">
+        <mi mathvariant='fraktur'>D</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL E -->
+    <xsl:template match="char[mt_code_value='0xF004' and variation='mathmode']">
+        <mi mathvariant='fraktur'>E</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL F -->
+    <xsl:template match="char[mt_code_value='0xF005' and variation='mathmode']">
+        <mi mathvariant='fraktur'>F</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL G -->
+    <xsl:template match="char[mt_code_value='0xF006' and variation='mathmode']">
+        <mi mathvariant='fraktur'>G</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL H -->
+    <xsl:template match="char[mt_code_value='0x210C' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x210C;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF007' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL I -->
+    <xsl:template match="char[mt_code_value='0x2111' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2111;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF008' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL FRAKTUR CAPITAL J -->
+    <xsl:template match="char[mt_code_value='0xF009' and variation='mathmode']">
+        <mi mathvariant='fraktur'>J</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL K -->
+    <xsl:template match="char[mt_code_value='0xF00A' and variation='mathmode']">
+        <mi mathvariant='fraktur'>K</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL L -->
+    <xsl:template match="char[mt_code_value='0xF00B' and variation='mathmode']">
+        <mi mathvariant='fraktur'>L</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL M -->
+    <xsl:template match="char[mt_code_value='0xF00C' and variation='mathmode']">
+        <mi mathvariant='fraktur'>M</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL N -->
+    <xsl:template match="char[mt_code_value='0xF00D' and variation='mathmode']">
+        <mi mathvariant='fraktur'>N</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL O -->
+    <xsl:template match="char[mt_code_value='0xF00E' and variation='mathmode']">
+        <mi mathvariant='fraktur'>O</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL P -->
+    <xsl:template match="char[mt_code_value='0xF00F' and variation='mathmode']">
+        <mi mathvariant='fraktur'>P</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL Q -->
+    <xsl:template match="char[mt_code_value='0xF010' and variation='mathmode']">
+        <mi mathvariant='fraktur'>Q</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL R -->
+    <xsl:template match="char[mt_code_value='0x211C' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x211C;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF011' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL FRAKTUR CAPITAL S -->
+    <xsl:template match="char[mt_code_value='0xF012' and variation='mathmode']">
+        <mi mathvariant='fraktur'>S</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL T -->
+    <xsl:template match="char[mt_code_value='0xF013' and variation='mathmode']">
+        <mi mathvariant='fraktur'>T</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL U -->
+    <xsl:template match="char[mt_code_value='0xF014' and variation='mathmode']">
+        <mi mathvariant='fraktur'>U</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL V -->
+    <xsl:template match="char[mt_code_value='0xF015' and variation='mathmode']">
+        <mi mathvariant='fraktur'>V</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL W -->
+    <xsl:template match="char[mt_code_value='0xF016' and variation='mathmode']">
+        <mi mathvariant='fraktur'>W</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL X -->
+    <xsl:template match="char[mt_code_value='0xF017' and variation='mathmode']">
+        <mi mathvariant='fraktur'>X</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL Y -->
+    <xsl:template match="char[mt_code_value='0xF018' and variation='mathmode']">
+        <mi mathvariant='fraktur'>Y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR CAPITAL Z -->
+    <xsl:template match="char[mt_code_value='0x2128' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2128;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF019' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL FRAKTUR SMALL A -->
+    <xsl:template match="char[mt_code_value='0xF01A' and variation='mathmode']">
+        <mi mathvariant='fraktur'>a</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL B -->
+    <xsl:template match="char[mt_code_value='0xF01B' and variation='mathmode']">
+        <mi mathvariant='fraktur'>b</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL C -->
+    <xsl:template match="char[mt_code_value='0xF01C' and variation='mathmode']">
+        <mi mathvariant='fraktur'>c</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL D -->
+    <xsl:template match="char[mt_code_value='0xF01D' and variation='mathmode']">
+        <mi mathvariant='fraktur'>d</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL E -->
+    <xsl:template match="char[mt_code_value='0xF01E' and variation='mathmode']">
+        <mi mathvariant='fraktur'>e</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL F -->
+    <xsl:template match="char[mt_code_value='0xF01F' and variation='mathmode']">
+        <mi mathvariant='fraktur'>f</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL G -->
+    <xsl:template match="char[mt_code_value='0xF020' and variation='mathmode']">
+        <mi mathvariant='fraktur'>g</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL H -->
+    <xsl:template match="char[mt_code_value='0xF021' and variation='mathmode']">
+        <mi mathvariant='fraktur'>h</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL I -->
+    <xsl:template match="char[mt_code_value='0xF022' and variation='mathmode']">
+        <mi mathvariant='fraktur'>i</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL J -->
+    <xsl:template match="char[mt_code_value='0xF023' and variation='mathmode']">
+        <mi mathvariant='fraktur'>j</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL K -->
+    <xsl:template match="char[mt_code_value='0xF024' and variation='mathmode']">
+        <mi mathvariant='fraktur'>k</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL L -->
+    <xsl:template match="char[mt_code_value='0xF025' and variation='mathmode']">
+        <mi mathvariant='fraktur'>l</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL M -->
+    <xsl:template match="char[mt_code_value='0xF026' and variation='mathmode']">
+        <mi mathvariant='fraktur'>m</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL N -->
+    <xsl:template match="char[mt_code_value='0xF027' and variation='mathmode']">
+        <mi mathvariant='fraktur'>n</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL O -->
+    <xsl:template match="char[mt_code_value='0xF028' and variation='mathmode']">
+        <mi mathvariant='fraktur'>o</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL P -->
+    <xsl:template match="char[mt_code_value='0xF029' and variation='mathmode']">
+        <mi mathvariant='fraktur'>p</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL Q -->
+    <xsl:template match="char[mt_code_value='0xF02A' and variation='mathmode']">
+        <mi mathvariant='fraktur'>q</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL R -->
+    <xsl:template match="char[mt_code_value='0xF02B' and variation='mathmode']">
+        <mi mathvariant='fraktur'>r</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL S -->
+    <xsl:template match="char[mt_code_value='0xF02C' and variation='mathmode']">
+        <mi mathvariant='fraktur'>s</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL T -->
+    <xsl:template match="char[mt_code_value='0xF02D' and variation='mathmode']">
+        <mi mathvariant='fraktur'>t</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL U -->
+    <xsl:template match="char[mt_code_value='0xF02E' and variation='mathmode']">
+        <mi mathvariant='fraktur'>u</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL V -->
+    <xsl:template match="char[mt_code_value='0xF02F' and variation='mathmode']">
+        <mi mathvariant='fraktur'>v</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL W -->
+    <xsl:template match="char[mt_code_value='0xF030' and variation='mathmode']">
+        <mi mathvariant='fraktur'>w</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL X -->
+    <xsl:template match="char[mt_code_value='0xF031' and variation='mathmode']">
+        <mi mathvariant='fraktur'>x</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL Y -->
+    <xsl:template match="char[mt_code_value='0xF032' and variation='mathmode']">
+        <mi mathvariant='fraktur'>y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL FRAKTUR SMALL Z -->
+    <xsl:template match="char[mt_code_value='0xF033' and variation='mathmode']">
+        <mi mathvariant='fraktur'>z</mi>
+    </xsl:template>
+
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL A -->
+    <xsl:template match="char[mt_code_value='0xF080' and variation='mathmode']">
+        <mi mathvariant='double-struck'>A</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL B -->
+    <xsl:template match="char[mt_code_value='0xF081' and variation='mathmode']">
+        <mi mathvariant='double-struck'>B</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL C -->
+    <xsl:template match="char[mt_code_value='0x2102' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2102;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF082' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL D -->
+    <xsl:template match="char[mt_code_value='0xF083' and variation='mathmode']">
+        <mi mathvariant='double-struck'>D</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL E -->
+    <xsl:template match="char[mt_code_value='0xF084' and variation='mathmode']">
+        <mi mathvariant='double-struck'>E</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL F -->
+    <xsl:template match="char[mt_code_value='0xF085' and variation='mathmode']">
+        <mi mathvariant='double-struck'>F</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL G -->
+    <xsl:template match="char[mt_code_value='0xF086' and variation='mathmode']">
+        <mi mathvariant='double-struck'>G</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL H -->
+    <xsl:template match="char[mt_code_value='0x210D' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x210D;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF087' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL I -->
+    <xsl:template match="char[mt_code_value='0xF088' and variation='mathmode']">
+        <mi mathvariant='double-struck'>I</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL J -->
+    <xsl:template match="char[mt_code_value='0xF089' and variation='mathmode']">
+        <mi mathvariant='double-struck'>J</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL K -->
+    <xsl:template match="char[mt_code_value='0xF08A' and variation='mathmode']">
+        <mi mathvariant='double-struck'>K</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL L -->
+    <xsl:template match="char[mt_code_value='0xF08B' and variation='mathmode']">
+        <mi mathvariant='double-struck'>L</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL M -->
+    <xsl:template match="char[mt_code_value='0xF08C' and variation='mathmode']">
+        <mi mathvariant='double-struck'>M</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL N -->
+    <xsl:template match="char[mt_code_value='0x2115' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2115;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF08D' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL O -->
+    <xsl:template match="char[mt_code_value='0xF08E' and variation='mathmode']">
+        <mi mathvariant='double-struck'>O</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL P -->
+    <xsl:template match="char[mt_code_value='0x2119' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2119;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF08F' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL Q -->
+    <xsl:template match="char[mt_code_value='0x211A' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x211A;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF090' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL R -->
+    <xsl:template match="char[mt_code_value='0x211D' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x211D;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF091' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL S -->
+    <xsl:template match="char[mt_code_value='0xF092' and variation='mathmode']">
+        <mi mathvariant='double-struck'>S</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL T -->
+    <xsl:template match="char[mt_code_value='0xF093' and variation='mathmode']">
+        <mi mathvariant='double-struck'>T</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL U -->
+    <xsl:template match="char[mt_code_value='0xF094' and variation='mathmode']">
+        <mi mathvariant='double-struck'>U</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL V -->
+    <xsl:template match="char[mt_code_value='0xF095' and variation='mathmode']">
+        <mi mathvariant='double-struck'>V</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL W -->
+    <xsl:template match="char[mt_code_value='0xF096' and variation='mathmode']">
+        <mi mathvariant='double-struck'>W</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL X -->
+    <xsl:template match="char[mt_code_value='0xF097' and variation='mathmode']">
+        <mi mathvariant='double-struck'>X</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -->
+    <xsl:template match="char[mt_code_value='0xF098' and variation='mathmode']">
+        <mi mathvariant='double-struck'>Y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK CAPITAL Z -->
+    <xsl:template match="char[mt_code_value='0x2124' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2124;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF099' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL A -->
+    <xsl:template match="char[mt_code_value='0xF09A' and variation='mathmode']">
+        <mi mathvariant='double-struck'>a</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL B -->
+    <xsl:template match="char[mt_code_value='0xF09B' and variation='mathmode']">
+        <mi mathvariant='double-struck'>b</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL C -->
+    <xsl:template match="char[mt_code_value='0xF09C' and variation='mathmode']">
+        <mi mathvariant='double-struck'>c</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL D -->
+    <xsl:template match="char[mt_code_value='0xF09D' and variation='mathmode']">
+        <mi mathvariant='double-struck'>d</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL E -->
+    <xsl:template match="char[mt_code_value='0xF09E' and variation='mathmode']">
+        <mi mathvariant='double-struck'>e</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL F -->
+    <xsl:template match="char[mt_code_value='0xF09F' and variation='mathmode']">
+        <mi mathvariant='double-struck'>f</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL G -->
+    <xsl:template match="char[mt_code_value='0xF0A0' and variation='mathmode']">
+        <mi mathvariant='double-struck'>g</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL H -->
+    <xsl:template match="char[mt_code_value='0xF0A1' and variation='mathmode']">
+        <mi mathvariant='double-struck'>h</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL I -->
+    <xsl:template match="char[mt_code_value='0xF0A2' and variation='mathmode']">
+        <mi mathvariant='double-struck'>i</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL J -->
+    <xsl:template match="char[mt_code_value='0xF0A3' and variation='mathmode']">
+        <mi mathvariant='double-struck'>j</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL K -->
+    <xsl:template match="char[mt_code_value='0xF0A4' and variation='mathmode']">
+        <mi mathvariant='double-struck'>k</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL L -->
+    <xsl:template match="char[mt_code_value='0xF0A5' and variation='mathmode']">
+        <mi mathvariant='double-struck'>l</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL M -->
+    <xsl:template match="char[mt_code_value='0xF0A6' and variation='mathmode']">
+        <mi mathvariant='double-struck'>m</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL N -->
+    <xsl:template match="char[mt_code_value='0xF0A7' and variation='mathmode']">
+        <mi mathvariant='double-struck'>n</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL O -->
+    <xsl:template match="char[mt_code_value='0xF0A8' and variation='mathmode']">
+        <mi mathvariant='double-struck'>o</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL P -->
+    <xsl:template match="char[mt_code_value='0xF0A9' and variation='mathmode']">
+        <mi mathvariant='double-struck'>p</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL Q -->
+    <xsl:template match="char[mt_code_value='0xF0AA' and variation='mathmode']">
+        <mi mathvariant='double-struck'>q</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL R -->
+    <xsl:template match="char[mt_code_value='0xF0AB' and variation='mathmode']">
+        <mi mathvariant='double-struck'>r</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL S -->
+    <xsl:template match="char[mt_code_value='0xF0AC' and variation='mathmode']">
+        <mi mathvariant='double-struck'>s</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL T -->
+    <xsl:template match="char[mt_code_value='0xF0AD' and variation='mathmode']">
+        <mi mathvariant='double-struck'>t</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL U -->
+    <xsl:template match="char[mt_code_value='0xF0AE' and variation='mathmode']">
+        <mi mathvariant='double-struck'>u</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL V -->
+    <xsl:template match="char[mt_code_value='0xF0AF' and variation='mathmode']">
+        <mi mathvariant='double-struck'>v</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL W -->
+    <xsl:template match="char[mt_code_value='0xF0B0' and variation='mathmode']">
+        <mi mathvariant='double-struck'>w</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL X -->
+    <xsl:template match="char[mt_code_value='0xF0B1' and variation='mathmode']">
+        <mi mathvariant='double-struck'>x</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL Y -->
+    <xsl:template match="char[mt_code_value='0xF0B2' and variation='mathmode']">
+        <mi mathvariant='double-struck'>y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL DOUBLE-STRUCK SMALL Z -->
+    <xsl:template match="char[mt_code_value='0xF0B3' and variation='mathmode']">
+        <mi mathvariant='double-struck'>z</mi>
+    </xsl:template>
+
+
+
+    <!-- BLACKBOARD-BOLD DIGIT ZERO -->
+    <xsl:template match="char[mt_code_value='0xF0C0' and variation='mathmode']">
+        <mn mathvariant='double-struck'>0</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT ONE -->
+    <xsl:template match="char[mt_code_value='0xF0C1' and variation='mathmode']">
+        <mn mathvariant='double-struck'>1</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT TWO -->
+    <xsl:template match="char[mt_code_value='0xF0C2' and variation='mathmode']">
+        <mn mathvariant='double-struck'>2</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT THREE -->
+    <xsl:template match="char[mt_code_value='0xF0C3' and variation='mathmode']">
+        <mn mathvariant='double-struck'>3</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT FOUR -->
+    <xsl:template match="char[mt_code_value='0xF0C4' and variation='mathmode']">
+        <mn mathvariant='double-struck'>4</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT FIVE -->
+    <xsl:template match="char[mt_code_value='0xF0C5' and variation='mathmode']">
+        <mn mathvariant='double-struck'>5</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT SIX -->
+    <xsl:template match="char[mt_code_value='0xF0C6' and variation='mathmode']">
+        <mn mathvariant='double-struck'>6</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT SEVEN -->
+    <xsl:template match="char[mt_code_value='0xF0C7' and variation='mathmode']">
+        <mn mathvariant='double-struck'>7</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT EIGHT -->
+    <xsl:template match="char[mt_code_value='0xF0C8' and variation='mathmode']">
+        <mn mathvariant='double-struck'>8</mn>
+    </xsl:template>
+
+    <!-- BLACKBOARD-BOLD DIGIT NINE -->
+    <xsl:template match="char[mt_code_value='0xF0C9' and variation='mathmode']">
+        <mn mathvariant='double-struck'>9</mn>
+    </xsl:template>
+
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL A -->
+    <xsl:template match="char[mt_code_value='0xF100' and variation='mathmode']">
+        <mi mathvariant='script'>A</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL B -->
+    <xsl:template match="char[mt_code_value='0x212C' and variation='mathmode']">
+        <mi mathvariant='script'>B</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL B -->
+    <xsl:template match="char[mt_code_value='0xF101' and variation='mathmode']">
+        <mi mathvariant='script'>B</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF101' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL C -->
+    <xsl:template match="char[mt_code_value='0xF102' and variation='mathmode']">
+        <mi mathvariant='script'>C</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL D -->
+    <xsl:template match="char[mt_code_value='0xF103' and variation='mathmode']">
+        <mi mathvariant='script'>D</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL E -->
+    <xsl:template match="char[mt_code_value='0x2130' and variation='mathmode']">
+        <mi mathvariant='script'>E</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL E -->
+    <xsl:template match="char[mt_code_value='0xF104' and variation='mathmode']">
+        <mi mathvariant='script'>E</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF104' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL F -->
+    <xsl:template match="char[mt_code_value='0x2131' and variation='mathmode']">
+        <mi mathvariant='script'>F</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL F -->
+    <xsl:template match="char[mt_code_value='0xF105' and variation='mathmode']">
+        <mi mathvariant='script'>F</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF105' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL G -->
+    <xsl:template match="char[mt_code_value='0xF106' and variation='mathmode']">
+        <mi mathvariant='script'>G</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL H -->
+    <xsl:template match="char[mt_code_value='0x210B' and variation='mathmode']">
+        <mi mathvariant='script'>H</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL H -->
+    <xsl:template match="char[mt_code_value='0xF107' and variation='mathmode']">
+        <mi mathvariant='script'>H</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF107' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL I -->
+    <xsl:template match="char[mt_code_value='0x2110' and variation='mathmode']">
+        <mi mathvariant='script'>I</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL I -->
+    <xsl:template match="char[mt_code_value='0xF108' and variation='mathmode']">
+        <mi mathvariant='script'>I</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF108' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL J -->
+    <xsl:template match="char[mt_code_value='0xF109' and variation='mathmode']">
+        <mi mathvariant='script'>J</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL K -->
+    <xsl:template match="char[mt_code_value='0xF10A' and variation='mathmode']">
+        <mi mathvariant='script'>K</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL L -->
+    <xsl:template match="char[mt_code_value='0x2112' and variation='mathmode']">
+        <mi mathvariant='script'>L</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL L -->
+    <xsl:template match="char[mt_code_value='0xF10B' and variation='mathmode']">
+        <mi mathvariant='script'>L</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF10B' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL M -->
+    <xsl:template match="char[mt_code_value='0x2133' and variation='mathmode']">
+        <mi mathvariant='script'>M</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL M -->
+    <xsl:template match="char[mt_code_value='0xF10C' and variation='mathmode']">
+        <mi mathvariant='script'>M</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF10C' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL N -->
+    <xsl:template match="char[mt_code_value='0xF10D' and variation='mathmode']">
+        <mi mathvariant='script'>N</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL O -->
+    <xsl:template match="char[mt_code_value='0xF10E' and variation='mathmode']">
+        <mi mathvariant='script'>O</mi>
+    </xsl:template>
+
+    <!-- Weierstrass Elliptic Function -->
+    <xsl:template match="char[mt_code_value='0x2118' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x2118;</xsl:text></mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL P -->
+    <xsl:template match="char[mt_code_value='0x2118' and variation='mathmode']">
+        <mi><xsl:text disable-output-escaping="yes">&amp;#x1D4AB</xsl:text>;</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL P -->
+    <xsl:template match="char[mt_code_value='0xF10F' and variation='mathmode']">
+        <mi mathvariant='script'>P</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF10F' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL Q -->
+    <xsl:template match="char[mt_code_value='0xF110' and variation='mathmode']">
+        <mi mathvariant='script'>Q</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL R -->
+    <xsl:template match="char[mt_code_value='0x211B' and variation='mathmode']">
+        <mi mathvariant='script'>R</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL R -->
+    <xsl:template match="char[mt_code_value='0xF111' and variation='mathmode']">
+        <mi mathvariant='script'>R</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF111' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL S -->
+    <xsl:template match="char[mt_code_value='0xF112' and variation='mathmode']">
+        <mi mathvariant='script'>S</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL T -->
+    <xsl:template match="char[mt_code_value='0xF113' and variation='mathmode']">
+        <mi mathvariant='script'>T</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL U -->
+    <xsl:template match="char[mt_code_value='0xF114' and variation='mathmode']">
+        <mi mathvariant='script'>U</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL V -->
+    <xsl:template match="char[mt_code_value='0xF115' and variation='mathmode']">
+        <mi mathvariant='script'>V</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL W -->
+    <xsl:template match="char[mt_code_value='0xF116' and variation='mathmode']">
+        <mi mathvariant='script'>W</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL X -->
+    <xsl:template match="char[mt_code_value='0xF117' and variation='mathmode']">
+        <mi mathvariant='script'>X</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL Y -->
+    <xsl:template match="char[mt_code_value='0xF118' and variation='mathmode']">
+        <mi mathvariant='script'>Y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT CAPITAL Z -->
+    <xsl:template match="char[mt_code_value='0xF119' and variation='mathmode']">
+        <mi mathvariant='script'>Z</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL A -->
+    <xsl:template match="char[mt_code_value='0xF11A' and variation='mathmode']">
+        <mi mathvariant='script'>a</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL B -->
+    <xsl:template match="char[mt_code_value='0xF11B' and variation='mathmode']">
+        <mi mathvariant='script'>b</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL C -->
+    <xsl:template match="char[mt_code_value='0xF11C' and variation='mathmode']">
+        <mi mathvariant='script'>c</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL D -->
+    <xsl:template match="char[mt_code_value='0xF11D' and variation='mathmode']">
+        <mi mathvariant='script'>d</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL E -->
+    <xsl:template match="char[mt_code_value='0xF11E' and variation='mathmode']">
+        <mi mathvariant='script'>e</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL E -->
+    <xsl:template match="char[mt_code_value='0x212F' and variation='mathmode']">
+        <mi mathvariant='script'>e</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF11E' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL F -->
+    <xsl:template match="char[mt_code_value='0xF11F' and variation='mathmode']">
+        <mi mathvariant='script'>f</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL G -->
+    <xsl:template match="char[mt_code_value='0x210A' and variation='mathmode']">
+        <mi mathvariant='script'>g</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL G -->
+    <xsl:template match="char[mt_code_value='0xF120' and variation='mathmode']">
+        <mi mathvariant='script'>g</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF120' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL H -->
+    <xsl:template match="char[mt_code_value='0xF121' and variation='mathmode']">
+        <mi mathvariant='script'>h</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL I -->
+    <xsl:template match="char[mt_code_value='0xF122' and variation='mathmode']">
+        <mi mathvariant='script'>i</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL J -->
+    <xsl:template match="char[mt_code_value='0xF123' and variation='mathmode']">
+        <mi mathvariant='script'>j</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL K -->
+    <xsl:template match="char[mt_code_value='0xF124' and variation='mathmode']">
+        <mi mathvariant='script'>k</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL L -->
+    <xsl:template match="char[mt_code_value='0x2113' and variation='mathmode']">
+        <mi mathvariant='script'>l</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL L -->
+    <xsl:template match="char[mt_code_value='0xF125' and variation='mathmode']">
+        <mi mathvariant='script'>l</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF125' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL M -->
+    <xsl:template match="char[mt_code_value='0xF126' and variation='mathmode']">
+        <mi mathvariant='script'>m</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL N -->
+    <xsl:template match="char[mt_code_value='0xF127' and variation='mathmode']">
+        <mi mathvariant='script'>n</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL O -->
+    <xsl:template match="char[mt_code_value='0x2134' and variation='mathmode']">
+        <mi mathvariant='script'>o</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL O -->
+    <xsl:template match="char[mt_code_value='0xF128' and variation='mathmode']">
+        <mi mathvariant='script'>o</mi>
+    </xsl:template>
+
+    <!-- UNSUPPORTED -->
+    <xsl:template match="char[mt_code_value='0xF128' and variation='mathmode']">
+        <xsl:text>Unsupported character</xsl:text>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL P -->
+    <xsl:template match="char[mt_code_value='0xF129' and variation='mathmode']">
+        <mi mathvariant='script'>p</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL Q -->
+    <xsl:template match="char[mt_code_value='0xF12A' and variation='mathmode']">
+        <mi mathvariant='script'>q</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL R -->
+    <xsl:template match="char[mt_code_value='0xF12B' and variation='mathmode']">
+        <mi mathvariant='script'>r</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL S -->
+    <xsl:template match="char[mt_code_value='0xF12C' and variation='mathmode']">
+        <mi mathvariant='script'>s</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL T -->
+    <xsl:template match="char[mt_code_value='0xF12D' and variation='mathmode']">
+        <mi mathvariant='script'>t</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL U -->
+    <xsl:template match="char[mt_code_value='0xF12E' and variation='mathmode']">
+        <mi mathvariant='script'>u</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL V -->
+    <xsl:template match="char[mt_code_value='0xF12F' and variation='mathmode']">
+        <mi mathvariant='script'>v</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL W -->
+    <xsl:template match="char[mt_code_value='0xF130' and variation='mathmode']">
+        <mi mathvariant='script'>w</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL X -->
+    <xsl:template match="char[mt_code_value='0xF131' and variation='mathmode']">
+        <mi mathvariant='script'>x</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL Y -->
+    <xsl:template match="char[mt_code_value='0xF132' and variation='mathmode']">
+        <mi mathvariant='script'>y</mi>
+    </xsl:template>
+
+    <!-- MATHEMATICAL SCRIPT SMALL Z -->
+    <xsl:template match="char[mt_code_value='0xF133' and variation='mathmode']">
+        <mi mathvariant='script'>z</mi>
+    </xsl:template>
+
+    <!-- ZERO WIDTH NO-BREAK SPACE -->
+    <xsl:template match="char[mt_code_value='0xFEFF' and variation='mathmode']">
+        <mtext><xsl:text disable-output-escaping="yes">&amp;#xFEFF;</xsl:text></mtext>
+    </xsl:template>
+
+    <xsl:template match="char[mt_code_value='0x2212' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2212;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- DifferentialD -->
+    <xsl:template match="char[mt_code_value='0xED10' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2146;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- DifferentialD -->
+    <xsl:template match="char[mt_code_value='0xED10' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2146;</xsl:text>
+    </xsl:template>
+
+    <!-- ExponentialE -->
+    <xsl:template match="char[mt_code_value='0xED11' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2147;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- ExponentialE -->
+    <xsl:template match="char[mt_code_value='0xED11' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2147;</xsl:text>
+    </xsl:template>
+
+    <!-- ImaginaryI -->
+    <xsl:template match="char[mt_code_value='0xED12' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2148;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- ImaginaryI -->
+    <xsl:template match="char[mt_code_value='0xED12' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2148;</xsl:text>
+    </xsl:template>
+
+    <!-- ImaginaryJ -->
+    <xsl:template match="char[mt_code_value='0xED13' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2149;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- ImaginaryJ -->
+    <xsl:template match="char[mt_code_value='0xED13' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2149;</xsl:text>
+    </xsl:template>
+
+    <!-- CapitalDifferentialD -->
+    <xsl:template match="char[mt_code_value='0xED16' and variation='mathmode']">
+        <mo><xsl:text disable-output-escaping="yes">&amp;#x2145;</xsl:text></mo>
+    </xsl:template>
+
+    <!-- CapitalDifferentialD -->
+    <xsl:template match="char[mt_code_value='0xED16' and variation='textmode']">
+        <xsl:text disable-output-escaping="yes">&amp;#x2145;</xsl:text>
+    </xsl:template>
+
+
+
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/color.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/color.xsl
new file mode 100644
index 0000000..3d80425
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/color.xsl
@@ -0,0 +1,288 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Color processing templates -->
+
+    <!-- Function to convert RGB values (0-1000) to hex -->
+    <xsl:template name="rgb-to-hex">
+        <xsl:param name="r"/>
+        <xsl:param name="g"/>
+        <xsl:param name="b"/>
+        <xsl:variable name="r-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="round($r * 255 div 1000)"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="g-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="round($g * 255 div 1000)"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="b-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="round($b * 255 div 1000)"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:value-of select="concat('#', $r-hex, $g-hex, $b-hex)"/>
+    </xsl:template>
+
+    <!-- Helper function to convert decimal to 2-digit hex -->
+    <xsl:template name="decimal-to-hex">
+        <xsl:param name="decimal"/>
+        <xsl:variable name="hex-digits" select="'0123456789ABCDEF'"/>
+        <xsl:variable name="high-digit" select="floor($decimal div 16)"/>
+        <xsl:variable name="low-digit" select="$decimal mod 16"/>
+        <xsl:value-of select="concat(substring($hex-digits, $high-digit + 1, 1), substring($hex-digits, $low-digit + 1, 1))"/>
+    </xsl:template>
+
+    <!-- Function to get color value from color_def by index -->
+    <xsl:template name="get-color-by-index">
+        <xsl:param name="index"/>
+        <!-- Find all color_def elements in document order and select the one at the specified index -->
+        <xsl:for-each select="//color_def">
+            <xsl:if test="position() = $index">
+
+                <xsl:choose>
+                    <xsl:when test="rgb">
+                        <xsl:call-template name="rgb-to-hex">
+                            <xsl:with-param name="r" select="rgb/r/text()"/>
+                            <xsl:with-param name="g" select="rgb/g/text()"/>
+                            <xsl:with-param name="b" select="rgb/b/text()"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:when test="cmyk">
+                        <!-- For CMYK, convert to RGB approximation -->
+                        <xsl:call-template name="cmyk-to-hex">
+                            <xsl:with-param name="c" select="cmyk/c/text()"/>
+                            <xsl:with-param name="m" select="cmyk/m/text()"/>
+                            <xsl:with-param name="y" select="cmyk/y/text()"/>
+                            <xsl:with-param name="k" select="cmyk/k/text()"/>
+                        </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <xsl:text>#000000</xsl:text> <!-- Default to black -->
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
+    <!-- Function to convert CMYK to hex (approximation) -->
+    <xsl:template name="cmyk-to-hex">
+        <xsl:param name="c"/>
+        <xsl:param name="m"/>
+        <xsl:param name="y"/>
+        <xsl:param name="k"/>
+        <!-- CMYK to RGB conversion formula -->
+        <xsl:variable name="r" select="round((1 - $c div 1000) * (1 - $k div 1000) * 255)"/>
+        <xsl:variable name="g" select="round((1 - $m div 1000) * (1 - $k div 1000) * 255)"/>
+        <xsl:variable name="b" select="round((1 - $y div 1000) * (1 - $k div 1000) * 255)"/>
+        <xsl:variable name="r-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="$r"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="g-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="$g"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="b-hex">
+            <xsl:call-template name="decimal-to-hex">
+                <xsl:with-param name="decimal" select="$b"/>
+            </xsl:call-template>
+        </xsl:variable>
+        <xsl:value-of select="concat('#', $r-hex, $g-hex, $b-hex)"/>
+    </xsl:template>
+
+    <!-- Function to find active color in current scope -->
+    <xsl:template name="get-active-color">
+        <xsl:call-template name="find-active-color"/>
+    </xsl:template>
+
+    <!-- Debug template to show color resolution -->
+    <xsl:template name="debug-color-resolution">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+        <xsl:if test="$colorValue != ''">
+            <xsl:attribute name="debug-color">
+                <xsl:value-of select="$colorValue"/>
+            </xsl:attribute>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Helper template to find the most recent color element in document hierarchy -->
+    <!--  Uses a combination of preceding axis and ancestor sibling search -->
+    <!-- This matches MathType specification: "all following equation records have the color" -->
+    <xsl:template name="find-active-color">
+        <xsl:variable name="currentElement" select="."/>
+
+        <!-- Strategy: Find the most recent color in document order by checking:
+             1. Preceding sibling colors
+             2. Ancestor's preceding sibling colors (going up the tree)
+        -->
+
+        <!-- First check immediate preceding siblings -->
+        <xsl:variable name="siblingColors" select="$currentElement/preceding-sibling::color"/>
+
+        <!-- Find the last non-zero color index -->
+        <xsl:call-template name="find-last-nonzero-color">
+            <xsl:with-param name="colors" select="$siblingColors"/>
+            <xsl:with-param name="fallback-node" select="$currentElement/parent::*"/>
+        </xsl:call-template>
+    </xsl:template>
+
+    <!-- Recursive template to search up the parent chain -->
+    <xsl:template name="find-color-in-parent-chain">
+        <xsl:param name="node"/>
+
+        <xsl:if test="$node">
+            <xsl:variable name="parentColors" select="$node/preceding-sibling::color"/>
+
+            <!-- Find the last non-zero color index or recurse to parent -->
+            <xsl:call-template name="find-last-nonzero-color">
+                <xsl:with-param name="colors" select="$parentColors"/>
+                <xsl:with-param name="fallback-node" select="$node/parent::*"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Helper template to find last non-zero color or fallback to parent chain -->
+    <xsl:template name="find-last-nonzero-color">
+        <xsl:param name="colors"/>
+        <xsl:param name="fallback-node"/>
+
+        <xsl:choose>
+            <xsl:when test="count($colors) > 0">
+                <!-- Iterate through colors in reverse to find last non-zero -->
+                <xsl:call-template name="iterate-colors-reverse">
+                    <xsl:with-param name="colors" select="$colors"/>
+                    <xsl:with-param name="position" select="count($colors)"/>
+                    <xsl:with-param name="fallback-node" select="$fallback-node"/>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- No colors at this level - recurse to parent -->
+                <xsl:if test="$fallback-node">
+                    <xsl:call-template name="find-color-in-parent-chain">
+                        <xsl:with-param name="node" select="$fallback-node"/>
+                    </xsl:call-template>
+                </xsl:if>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Iterate through colors in reverse order -->
+    <xsl:template name="iterate-colors-reverse">
+        <xsl:param name="colors"/>
+        <xsl:param name="position"/>
+        <xsl:param name="fallback-node"/>
+
+        <xsl:if test="$position > 0">
+            <xsl:variable name="currentColor" select="$colors[$position]"/>
+            <xsl:variable name="colorDefIndex" select="$currentColor/color_def_index/text()"/>
+
+            <xsl:choose>
+                <xsl:when test="$colorDefIndex and $colorDefIndex > 0">
+                    <!-- Found non-zero color -->
+                    <xsl:call-template name="resolve-color-from-element">
+                        <xsl:with-param name="colorElement" select="$currentColor"/>
+                    </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise>
+                    <!-- Keep looking backwards -->
+                    <xsl:call-template name="iterate-colors-reverse">
+                        <xsl:with-param name="colors" select="$colors"/>
+                        <xsl:with-param name="position" select="$position - 1"/>
+                        <xsl:with-param name="fallback-node" select="$fallback-node"/>
+                    </xsl:call-template>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+
+        <!-- If we've exhausted all colors at this level, try parent -->
+        <xsl:if test="$position = 0 and $fallback-node">
+            <xsl:call-template name="find-color-in-parent-chain">
+                <xsl:with-param name="node" select="$fallback-node"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Helper template to resolve color from a color element -->
+    <xsl:template name="resolve-color-from-element">
+        <xsl:param name="colorElement"/>
+
+        <xsl:variable name="colorDefIndex" select="$colorElement/color_def_index/text()"/>
+
+        <!-- Skip index 0 (default/black) -->
+        <xsl:if test="$colorDefIndex != 0">
+            <xsl:call-template name="get-color-by-index">
+                <xsl:with-param name="index" select="$colorDefIndex"/>
+            </xsl:call-template>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Template to apply color to MathML elements -->
+    <xsl:template name="apply-color-attribute">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+        <xsl:if test="$colorValue != '' and $colorValue != '#000000'">
+            <xsl:attribute name="mathcolor">
+                <xsl:value-of select="$colorValue"/>
+            </xsl:attribute>
+        </xsl:if>
+    </xsl:template>
+
+
+    <!-- Template to determine if color should be applied as mstyle (for operators) -->
+    <xsl:template name="should-use-mstyle">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+        <xsl:variable name="currentElement" select="."/>
+
+        <!-- Check if there's a color element in ancestor scopes (slot, pile, etc.) -->
+        <xsl:variable name="slotAncestor" select="$currentElement/ancestor::slot[1]"/>
+            <xsl:variable name="pileAncestor" select="$currentElement/ancestor::pile[1]"/>
+            <xsl:variable name="tmplAncestor" select="$currentElement/ancestor::tmpl[1]"/>
+
+        <!-- Check for colors in different scopes -->
+        <xsl:variable name="slotHasColor" select="count($slotAncestor/color[color_def_index != 0]) > 0"/>
+        <xsl:variable name="pileHasColor" select="count($pileAncestor/color[color_def_index != 0]) > 0"/>
+        <xsl:variable name="tmplHasColor" select="count($tmplAncestor/color[color_def_index != 0]) > 0"/>
+
+        <!-- Return 'true' if color exists in any ancestor scope -->
+        <xsl:value-of select="($slotHasColor or $pileHasColor or $tmplHasColor) and $colorValue != '' and $colorValue != '#000000'"/>
+    </xsl:template>
+
+    <!-- Template to apply mstyle wrapper when needed -->
+    <xsl:template name="apply-mstyle-wrapper">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+        <xsl:variable name="useMstyle">
+            <xsl:call-template name="should-use-mstyle"/>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$useMstyle = 'true'">
+                <mstyle mathcolor="{$colorValue}">
+                    <xsl:apply-templates/>
+                </mstyle>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:apply-templates/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Ignore color and color_def elements during normal processing -->
+    <xsl:template match="color"/>
+    <xsl:template match="color_def"/>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/embellishment.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/embellishment.xsl
new file mode 100644
index 0000000..51fdfd9
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/embellishment.xsl
@@ -0,0 +1,419 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+
+    <!--
+    edot        = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x02D9;</(ns)mo>$-$n</(ns)mover>$n";
+    edot/2      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x00A8;</(ns)mo>$-$n</(ns)mover>$n";
+    edot/3      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x20DB;</(ns)mo>$-$n</(ns)mover>$n";
+    edot/4      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x20DC;</(ns)mo>$-$n</(ns)mover>$n";
+
+    2 => "emb1DOT", # over single dot
+    3 => "emb2DOT", # over double dot
+    4 => "emb3DOT", # over triple dot
+    24 => "emb4DOT", # over quad dot
+    -->
+    <!-- Dots -->
+
+    <xsl:template match="embell[embell='emb1DOT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2D9;</mo>
+        </mover>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='emb2DOT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#xA8;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='emb3DOT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x20DB;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='emb4DOT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x20DC;</mo>
+        </mover>
+    </xsl:template>
+
+    <!--
+    edot/u      = "<(ns)munder>$+$n#$n<(ns)mo>&$#x02D9;</(ns)mo>$-$n</(ns)munder>$n";
+    edot/u/2    = "<(ns)munder>$+$n#$n<(ns)mo>&$#x00A8;</(ns)mo>$-$n</(ns)munder>$n";
+    edot/u/3    = "<(ns)munder>$+$n#$n<(ns)mo>&$#x20DB;</(ns)mo>$-$n</(ns)munder>$n";
+    edot/u/4    = "<(ns)munder>$+$n#$n<(ns)mo>&$#x20DC;</(ns)mo>$-$n</(ns)munder>$n";
+
+    25 => "embU_1DOT", # under single dot
+    26 => "embU_2DOT", # under double dot
+    27 => "embU_3DOT", # under triple dot
+    28 => "embU_4DOT", # under quad dot
+    -->
+    <!-- Under-dots -->
+
+    <xsl:template match="embell[embell='embU_1DOT']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2D9;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_2DOT']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#xA8;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_3DOT']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x20DB;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_4DOT']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x20DC;</mo>
+        </munder>
+    </xsl:template>
+
+    <!--
+    eprime      = "<(ns)msup>$+$n#$n<(ns)mo>&$#x2032;</(ns)mo>$-$n</(ns)msup>$n";
+    eprime/2    = "<(ns)msup>$+$n#$n<(ns)mo>&$#x2033;</(ns)mo>$-$n</(ns)msup>$n";
+    eprime/3    = "<(ns)msup>$+$n#$n<(ns)mo>&$#x2034;</(ns)mo>$-$n</(ns)msup>$n";
+    eprime/b    = "<(ns)mmultiscripts>$+$n#$n<(ns)mprescripts/>$n<(ns)none/>$n<(ns)mo>&$#x2035;</(ns)mo>$-$n</(ns)mmultiscripts>$n";
+
+    5 => "emb1PRIME", # single prime
+    6 => "emb2PRIME", # double prime
+    7 => "embBPRIME", # backwards prime (left of character)
+    18 => "emb3PRIME", # triple prime
+     -->
+    <!-- Primes -->
+
+    <xsl:template match="embell[embell='emb1PRIME']">
+        <msup>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2032;</mo>
+        </msup>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='emb2PRIME']">
+        <msup>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2033;</mo>
+        </msup>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='emb3PRIME']">
+        <msup>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2034;</mo>
+        </msup>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embBPRIME']">
+        <mmultiscripts>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mprescripts/><none/>
+            <mo>&#x2035;</mo>
+        </mmultiscripts>
+    </xsl:template>
+
+    <!--
+    etilde      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x02DC;</(ns)mo>$-$n</(ns)mover>$n";
+    etilde/u    = "<(ns)munder accentunder='true'>$+$n#$n<(ns)mo>&$#x02DC;</(ns)mo>$-$n</(ns)munder>$n";
+
+    8 => "embTILDE", #  tilde
+    30 => "embU_TILDE", #  under tilde (~)
+    -->
+    <!-- Tilde -->
+
+    <xsl:template match="embell[embell='embTILDE']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2DC;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embU_TILDE']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2DC;</mo>
+        </munder>
+    </xsl:template>
+
+    <!--
+    ehat        = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x005E;</(ns)mo>$-$n</(ns)mover>$n";
+    9 => "embHAT", #  hat (circumflex)
+    -->
+    <!-- Hat -->
+
+    <xsl:template match="embell[embell='embHAT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>^</mo>
+        </mover>
+    </xsl:template>
+    <!--
+    evec        = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x2192;</(ns)mo>$-$n</(ns)mover>$n";
+    evec/l      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x2190;</(ns)mo>$-$n</(ns)mover>$n";
+    evec/lr     = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x2194;</(ns)mo>$-$n</(ns)mover>$n";
+    evec/h      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x21C0;</(ns)mo>$-$n</(ns)mover>$n";
+    evec/h/l    = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x21BC;</(ns)mo>$-$n</(ns)mover>$n";
+    evec/u      = "<(ns)munder>$+$n#$n<(ns)mo>&$#x2192;</(ns)mo>$-$n</(ns)munder>$n";
+    evec/u/l    = "<(ns)munder>$+$n#$n<(ns)mo>&$#x2190;</(ns)mo>$-$n</(ns)munder>$n";
+    evec/u/lr   = "<(ns)munder>$+$n#$n<(ns)mo>&$#x2194;</(ns)mo>$-$n</(ns)munder>$n";
+    evec/u/h    = "<(ns)munder>$+$n#$n<(ns)mo>&$#x21C1;</(ns)mo>$-$n</(ns)munder>$n";
+    evec/u/h/l  = "<(ns)munder>$+$n#$n<(ns)mo>&$#x21BD;</(ns)mo>$-$n</(ns)munder>$n";
+
+    11 => "embRARROW", # over right arrow
+    12 => "embLARROW", # over left arrow
+    13 => "embBARROW", # over both arrow (left and right)
+    14 => "embR1ARROW", #  over right single-barbed arrow
+    15 => "embL1ARROW", #  over left single-barbed arrow
+    33 => "embU_RARROW", # under right arrow
+    34 => "embU_LARROW", # under left arrow
+    35 => "embU_BARROW", # under both arrow (left and right)
+    36 => "embU_R1ARROW", #  under right arrow (1 barb)
+    37 => "embU_L1ARROW", #  under left arrow (1 barb)
+
+    -->
+    <!-- Arrows -->
+
+    <xsl:template match="embell[embell='embRARROW']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2192;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embLARROW']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2190;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embBARROW']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2194;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embR1ARROW']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x21C0;</mo>
+        </mover>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embL1ARROW']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x21BC;</mo>
+        </mover>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_RARROW']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2192;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_LARROW']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2190;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_BARROW']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2194;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_R1ARROW']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x21C1;</mo>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_L1ARROW']">
+        <munder>
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x21BD;</mo>
+        </munder>
+    </xsl:template>
+
+    <!--
+    eobar       = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x00AF;</(ns)mo>$-$n</(ns)mover>$n";
+    eubar       = "<(ns)munder accentunder='true'>$+$n#$n<(ns)mo>_</(ns)mo>$-$n</(ns)munder>$n";
+
+    17 => "embOBAR", # over-bar
+    29 => "embU_BAR", #  under bar
+     -->
+    <!-- Bars -->
+
+    <xsl:template match="embell[embell='embOBAR']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#xAF;</mo>
+        </mover>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embU_BAR']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>_</mo>
+        </munder>
+    </xsl:template>
+
+    <!--
+    earc        = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x2322;</(ns)mo>$-$n</(ns)mover>$n";
+    earc/u      = "<(ns)munder accentunder='true'>$+$n#$n<(ns)mo>&$#x2322;</(ns)mo>$-$n</(ns)munder>$n";
+    earc/s      = "<(ns)mover accent='true'>$+$n#$n<(ns)mo>&$#x2323;</(ns)mo>$-$n</(ns)mover>$n";
+    earc/u/s    = "<(ns)munder accentunder='true'>$+$n#$n<(ns)mo>&$#x2323;</(ns)mo>$-$n</(ns)munder>$n";
+    19 => "embFROWN", #  over-arc, concave downward
+    20 => "embSMILE", #  over-arc, concave upward
+    31 => "embU_FROWN", #  under arc (ends point down)
+    32 => "embU_SMILE", #  under arc (ends point up)
+    -->
+    <!-- Arcs -->
+
+    <xsl:template match="embell[embell='embFROWN']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2322;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embSMILE']">
+        <mover accent="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2323;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embU_FROWN']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2322;</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embU_SMILE']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+            <mo>&#x2323;</mo>
+        </munder>
+    </xsl:template>
+
+    <!--
+    enot = "<(ns)menclose notation='updiagonalstrike'>$+$n#$-$n</(ns)menclose>$n";
+    estrike = "<(ns)menclose notation='updiagonalstrike downdiagonalstrike'>$+$n#$-$n</(ns)menclose>$n";
+    estrike/m = "<(ns)menclose notation='horizontalstrike'>$+$n#$-$n</(ns)menclose>$n";
+    estrike/up = "<(ns)menclose notation='updiagonalstrike'>$+$n#$-$n</(ns)menclose>$n";
+    estrike/dn = "<(ns)menclose notation='downdiagonalstrike'>$+$n#$-$n</(ns)menclose>$n";
+
+    10 => "embNOT", #  diagonal slash through character
+    21 => "embX_BARS", # double diagonal bars
+    16 => "embMBAR", # mid-height horizontal bar
+    22 => "embUP_BAR", # bottom-left to top-right diagonal bar
+    23 => "embDOWN_BAR", # top-left to bottom-right diagonal bar
+    -->
+    <!-- Strikes -->
+
+    <!-- Special case: NOT SUBSET character (Unicode 0x2284) -->
+    <xsl:template match="embell[embell='embNOT' and mo[text()='⊂']]">
+        <mo>&#x2284;</mo>
+    </xsl:template>
+
+    <!-- Special case: NOT ELEMENT OF character (Unicode 0x2209) -->
+    <xsl:template match="embell[embell='embNOT' and mo[text()='∈']]">
+        <mo>&#x2209;</mo>
+    </xsl:template>
+
+    <!-- Special case: NOT SUBSET OR EQUAL character (Unicode 0x2288) -->
+    <xsl:template match="embell[embell='embNOT' and mo[text()='⊆']]">
+        <mo>&#x2288;</mo>
+    </xsl:template>
+
+    <!-- Special case: NOT SUPERSET OR EQUAL character (Unicode 0x2289) -->
+    <xsl:template match="embell[embell='embNOT' and mo[text()='⊇']]">
+        <mo>&#x2289;</mo>
+    </xsl:template>
+
+    <!-- Special case: NOT SUPERSET character (Unicode 0x2285) -->
+    <xsl:template match="embell[embell='embNOT' and mo[text()='⊃']]">
+        <mo>&#x2285;</mo>
+    </xsl:template>
+
+    <!-- Special case: SUPERSET OF ABOVE NOT EQUAL TO (Unicode 0x2ACC) -->
+    <xsl:template match="embell[embell='embNOT' and char/mt_code_value='0xE90B']">
+        <mo>&#x2ACC;</mo>
+    </xsl:template>
+
+    <xsl:template match="embell[embell='embNOT' and not(mo[text()='⊂']) and not(mo[text()='∈']) and not(mo[text()='⊆']) and not(mo[text()='⊇']) and not(mo[text()='⊃']) and not(char/mt_code_value='0xE90B')]">
+        <menclose notation="updiagonalstrike">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embX_BARS']">
+        <menclose notation="updiagonalstrike downdiagonalstrike">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embMBAR']">
+        <menclose notation="horizontalstrike">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embUP_BAR']">
+        <menclose notation="updiagonalstrike">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+        </menclose>
+    </xsl:template>
+
+
+    <xsl:template match="embell[embell='embDOWN_BAR']">
+        <menclose notation="downdiagonalstrike">
+            <xsl:apply-templates select="(char | mn | mo | mtext | mi)[1]"/>
+        </menclose>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/fence.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/fence.xsl
new file mode 100644
index 0000000..7a5cb20
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/fence.xsl
@@ -0,0 +1,292 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="xs" version="1.0">
+
+    <!-- Fences -->
+    <xsl:template match="tmpl[selector='tmPAREN']">
+        <mrow>
+            <mo stretchy="true">(</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">)</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPAREN' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">(</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPAREN' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">)</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACK']">
+        <mrow>
+            <mo stretchy="true">[</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">]</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACE']">
+        <xsl:choose>
+            <!-- Check if it is a top-level element (direct child of the first slot of the root equation) -->
+            <xsl:when test="parent::slot/parent::mtef and count(parent::slot/*) = 1">
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <mrow>
+                    <mo stretchy="true">{</mo>
+                    <xsl:apply-templates select="slot[1] | pile[1]"/>
+                    <mo stretchy="true">}</mo>
+                </mrow>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmANGLE']">
+        <mrow>
+            <mo stretchy="true">&#x2329;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x232A;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmANGLE' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">&#x2329;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmANGLE' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x232A;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBAR']">
+        <mrow>
+            <mo stretchy="true">|</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">|</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBAR' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">|</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBAR' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">|</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmFLOOR']">
+        <mrow>
+            <mo stretchy="true">&#x230A;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x230B;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCEILING']">
+        <mrow>
+            <mo stretchy="true">&#x2308;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x2309;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTERVAL' and variation='tvINTV_LBLB']">
+        <mrow>
+            <mo stretchy="true">[</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">[</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTERVAL' and variation='tvINTV_RBRB']">
+        <mrow>
+            <mo stretchy="true">]</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">]</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTERVAL' and variation='tvINTV_RBLB']">
+        <mrow>
+            <mo stretchy="true">]</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">[</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTERVAL' and variation='tvINTV_LBRP']">
+        <mrow>
+            <mo stretchy="true">[</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">)</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTERVAL' and variation='tvINTV_LPRB']">
+        <mrow>
+            <mo stretchy="true">(</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">]</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACK' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">[</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACK' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">]</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACE' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">{</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmBRACE' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">}</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDIRAC']">
+        <mrow>
+            <mo stretchy="true">&#x2329;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">|</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <mo stretchy="true">&#x232A;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDIRAC' and variation='tvDI_RIGHT' and not(variation='tvDI_LEFT')]">
+        <mrow>
+            <mo stretchy="true">|</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <mo stretchy="true">&#x232A;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDIRAC' and variation='tvDI_LEFT' and not(variation='tvDI_RIGHT')]">
+        <mrow>
+            <mo stretchy="true">&#x2329;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">|</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDBAR']">
+        <mrow>
+            <mo stretchy="true">&#x2016;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x2016;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDBAR' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">&#x2016;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmDBAR' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x2016;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmOBRACK']">
+        <mrow>
+            <mo stretchy="true">&#x301A;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x301B;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmOBRACK' and variation='tvFENCE_L' and not(variation='tvFENCE_R')]">
+        <mrow>
+            <mo stretchy="true">&#x301A;</mo>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmOBRACK' and variation='tvFENCE_R' and not(variation='tvFENCE_L')]">
+        <mrow>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mo stretchy="true">&#x301B;</mo>
+        </mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmHBRACE']">
+        <munder>
+            <munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <mo stretchy="true">&#xFE38;</mo>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmHBRACE' and variation='tvHB_TOP']">
+        <mover>
+            <mover>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <mo stretchy="true">&#xFE37;</mo>
+            </mover>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmHBRACK']">
+        <munder>
+            <munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <mo stretchy="true">&#x23B5;</mo>
+            </munder>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmHBRACK' and variation='tvHB_TOP']">
+        <mover>
+            <mover>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <mo stretchy="true">&#x23B4;</mo>
+            </mover>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </mover>
+    </xsl:template>
+
+
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/frac.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/frac.xsl
new file mode 100644
index 0000000..511ace4
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/frac.xsl
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Fractions -->
+
+     <xsl:template match="tmpl[selector='tmFRACT']">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$colorValue != '' and $colorValue != '#000000'">
+                <mstyle mathcolor="{$colorValue}">
+                    <mfrac>
+                        <xsl:apply-templates select="slot[1] | pile[1]"/>
+                        <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    </mfrac>
+                </mstyle>
+            </xsl:when>
+            <xsl:otherwise>
+                <mfrac>
+                    <xsl:apply-templates select="slot[1] | pile[1]"/>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </mfrac>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmFRACT' and variation='tvFR_SLASH']">
+        <mfrac bevelled="true">
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </mfrac>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmFRACT' and variation='tvFR_SMALL']">
+        <mstyle scriptlevel="+1">
+            <mfrac>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </mfrac>
+        </mstyle>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmFRACT' and variation='tvFR_SLASH' and variation='tvFR_BASE']">
+        <mrow><xsl:apply-templates select="slot[1] | pile[1]"/><mo>/</mo><xsl:apply-templates select="slot[2] | pile[2]"/></mrow>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmFRACT' and variation='tvFR_SLASH' and variation='tvFR_SMALL']">
+        <mstyle scriptlevel="+1">
+            <mfrac bevelled="true">
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <xsl:apply-templates select="slot[2] | pile[2]"/>
+            </mfrac>
+        </mstyle>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/int.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/int.xsl
new file mode 100644
index 0000000..6b98528
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/int.xsl
@@ -0,0 +1,622 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Integral operators -->
+    <!-- The order is important because it would be very messy to address all
+         conditions for each template, and so we rely on the fact that the
+         last matching rule has precedence -->
+
+    <xsl:template match="tmpl[selector='tmINTOP']">
+        <msubsup>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTOP' and variation='tvBO_UPPER']">
+        <msup>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msup>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTOP' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        <msub>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+    </xsl:template>
+
+    <!-- Integrals -->
+
+    <xsl:template match="tmpl[selector='tmINTEG']">
+        
+            <mrow>
+                <msubsup>
+                    <mo>&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    <xsl:apply-templates select="slot[3] | pile[3]"/>
+                </msubsup>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow><mo>&#x222B;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munderover>
+                    <mo>&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    <xsl:apply-templates select="slot[3] | pile[3]"/>
+                </munderover>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND']">
+        
+            <mrow>
+                <msubsup>
+                    <mo stretchy="true">&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    <xsl:apply-templates select="slot[3] | pile[3]"/>
+                </msubsup>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_1' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x222C;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x222C;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x222D;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x222E;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CW_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x2232;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CCW_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x2233;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x222E;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvBO_SUM' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munderover>
+                    <mo stretchy="true">&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    <xsl:apply-templates select="slot[3] | pile[3]"/>
+                </munderover>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x222C;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x222F;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x222C;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x222C;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x222E;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CW_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x2232;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CCW_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x2233;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x222D;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo>&#x2230;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x222D;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CW_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x2232;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CCW_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x2233;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x222E;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x222F;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x222F;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x222F;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x222D;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x222D;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo>&#x2230;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND' and variation='tvINT_LOOP']">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x2230;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CW_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x2232;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_CCW_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x2233;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        
+            <mrow>
+                <msub>
+                    <mo stretchy="true">&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msub>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x222E;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CCW_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x2233;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CW_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x2232;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x222B;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x222C;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x222D;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvBO_SUM' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x222B;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo>&#x2230;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x2230;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CCW_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x2233;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x222E;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and variation='tvBO_SUM']">
+        
+            <mrow>
+                <munder>
+                    <mo stretchy="true">&#x222F;</mo>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </munder>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_EXPAND' and variation='tvINT_CW_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x2232;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_2' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x222F;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTEG' and variation='tvINT_3' and variation='tvINT_EXPAND' and variation='tvINT_LOOP' and (not(variation='tvBO_UPPER') and not(variation='tvBO_LOWER'))]">
+        
+            <mrow>
+                <mo stretchy="true">&#x2230;</mo>
+                <xsl:apply-templates select="slot[1] | pile[1]"/>
+            </mrow>
+        
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/lim.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/lim.xsl
new file mode 100644
index 0000000..4bdb43d
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/lim.xsl
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Limits -->
+
+    <xsl:template match="tmpl[selector='tmLIM']">
+        <munder>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+
+    <xsl:template match="tmpl[selector='tmLIM' and variation='tvBO_UPPER']">
+        <mover>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmLIM' and (variation='tvBO_UPPER' and variation='tvBO_LOWER')]">
+        <munderover>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_division.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_division.xsl
new file mode 100644
index 0000000..36020bd
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_division.xsl
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Long division -->
+
+     <xsl:template match="tmpl[selector='tmLDIV']">
+        <mtable>
+            <mtr>
+                <mtd columnalign="right">
+                    <xsl:apply-templates select="(slot | pile)[2]"/>
+                </mtd>
+            </mtr>
+            <mtr>
+                <mtd columnalign="right">
+                    <menclose notation="longdiv">
+                        <xsl:apply-templates select="(slot | pile)[1]"/>
+                    </menclose>
+                </mtd>
+            </mtr>
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmLDIV' and not(variation='tvLD_UPPER')]">
+        <menclose notation="longdiv">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+        </menclose>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_embellishment.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_embellishment.xsl
new file mode 100644
index 0000000..642cfb3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/long_embellishment.xsl
@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Long embellishments -->
+
+     <xsl:template match="tmpl[selector='tmTILDE']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2DC;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmARC']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2322;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmHAT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">^</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmJSTATUS']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#xFE39;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmOBAR']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#xAF;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmOBAR' and variation='tvBAR_DOUBLE']">
+        <mover accent="true">
+            <mover accent="true">
+                <xsl:apply-templates select="(slot | pile)[1]"/>
+                <mo stretchy="true">&#xAF;</mo>
+            </mover>
+            <mo stretchy="true">&#xAF;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUBAR']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">_</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUBAR' and variation='tvBAR_DOUBLE']">
+        <munder accentunder="true">
+            <munder accentunder="true">
+                <xsl:apply-templates select="(slot | pile)[1]"/>
+                <mo stretchy="true">_</mo>
+            </munder>
+            <mo stretchy="true">_</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2192;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_LEFT']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2190;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and (variation='tvVE_LEFT' and variation='tvVE_RIGHT' )]">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2194;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_HARPOON']">
+        <mover accent="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x21C0;</mo>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_UNDER']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2192;</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_UNDER' and variation='tvVE_LEFT']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2190;</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_UNDER' and (variation='tvVE_LEFT' and variation='tvVE_RIGHT' )]">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x2194;</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmVEC' and variation='tvVE_UNDER' and variation='tvVE_HARPOON']">
+        <munder accentunder="true">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+            <mo stretchy="true">&#x21C1;</mo>
+        </munder>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSTRIKE']">
+        <menclose notation="updiagonalstrike downdiagonalstrike">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+        </menclose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSTRIKE' and variation='tvST_HORIZ' and not(variation='tvST_UP' or variation='tvST_DOWN')]">
+        <menclose notation="horizontalstrike">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+        </menclose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSTRIKE' and variation='tvST_UP' and not(variation='tvST_HORIZ' or variation='tvST_DOWN')]">
+        <menclose notation="updiagonalstrike">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+        </menclose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSTRIKE' and variation='tvST_DOWN' and not(variation='tvST_UP' or variation='tvST_HORIZ')]">
+        <menclose notation="downdiagonalstrike">
+            <xsl:apply-templates select="(slot | pile)[1]"/>
+        </menclose>
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/matrix.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/matrix.xsl
new file mode 100644
index 0000000..ff247b3
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/matrix.xsl
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+// =====================================================
+// Matrices
+// =====================================================
+
+// matrix translation (left, center, right)
+matrix/l    = "<(ns)mtable columnalign='left'>$+$n#$-$n</(ns)mtable>";
+matrix      = "<(ns)mtable>$+$n#$-$n</(ns)mtable>";
+matrix/r    = "<(ns)mtable columnalign='right'>$+$n#$-$n</(ns)mtable>";
+
+// matrix line translation (left, center, right)
+matrow/l   = "<(ns)mtr columnalign='left'>$+$n#$-$n</(ns)mtr>$n";
+matrow     = "<(ns)mtr>$+$n#$-$n</(ns)mtr>$n";
+matrow/r   = "<(ns)mtr columnalign='right'>$+$n#$-$n</(ns)mtr>$n";
+
+// matrix element translation (except for last element) (left, center, right)
+matelem/l   = "<(ns)mtd columnalign='left'>$+$n#$-$n</(ns)mtd>$n";
+matelem     = "<(ns)mtd>$+$n#$-$n</(ns)mtd>$n";
+matelem/r   = "<(ns)mtd columnalign='right'>$+$n#$-$n</(ns)mtd>$n";
+
+// matrix element translation (last element only) (left, center, right)
+matelem/last/l   = "<(ns)mtd columnalign='left'>$+$n#$-$n</(ns)mtd>";
+matelem/last     = "<(ns)mtd>$+$n#$-$n</(ns)mtd>";
+matelem/last/r   = "<(ns)mtd columnalign='right'>$+$n#$-$n</(ns)mtd>";
+ -->
+
+
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Matrices -->
+    <xsl:template match="matrix[h_just='left']">
+        <mtable columnalign="left">
+            <xsl:variable name="cols" select="number(cols)"/>
+            <xsl:apply-templates select="(slot | pile)[$cols = 0 or (position() - 1) mod $cols = 0]" mode="rows-left" />
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="matrix[h_just='center']">
+        <mtable>
+            <xsl:variable name="cols" select="number(cols)"/>
+            <xsl:apply-templates select="(slot | pile)[$cols = 0 or (position() - 1) mod $cols = 0]" mode="rows-center" />
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="matrix[h_just='right']">
+        <mtable columnalign="right">
+            <xsl:variable name="cols" select="number(cols)"/>
+            <xsl:apply-templates select="(slot | pile)[$cols = 0 or (position() - 1) mod $cols = 0]" mode="rows-right" />
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="matrix">
+        <mtable>
+            <xsl:variable name="cols" select="number(cols)"/>
+            <xsl:apply-templates select="(slot | pile)[$cols = 0 or (position() - 1) mod $cols = 0]" mode="rows-center" />
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="slot | pile" mode="rows-left">
+        <xsl:variable name="cols" select="number(parent::*/cols)"/>
+        <mtr columnalign="left">
+            <xsl:apply-templates select="." mode="columns-left" />
+            <xsl:apply-templates select="(following-sibling::slot | following-sibling::pile)[position() &lt; $cols]" mode="columns-left" />
+        </mtr>
+    </xsl:template>
+
+    <xsl:template match="slot | pile" mode="rows-center">
+        <xsl:variable name="cols" select="number(parent::*/cols)"/>
+        <mtr>
+            <xsl:apply-templates select="." mode="columns-center" />
+            <xsl:apply-templates select="(following-sibling::slot | following-sibling::pile)[position() &lt; $cols]" mode="columns-center" />
+        </mtr>
+    </xsl:template>
+
+    <xsl:template match="slot | pile" mode="rows-right">
+        <xsl:variable name="cols" select="number(parent::*/cols)"/>
+        <mtr columnalign="right">
+            <xsl:apply-templates select="." mode="columns-right" />
+            <xsl:apply-templates select="(following-sibling::slot | following-sibling::pile)[position() &lt; $cols]" mode="columns-right" />
+        </mtr>
+    </xsl:template>
+
+    <xsl:template match="pile" mode="columns-left">
+        <mtd columnalign="left">
+            <xsl:apply-templates select="."/>
+        </mtd>
+    </xsl:template>
+
+    <xsl:template match="pile" mode="columns-center">
+        <mtd>
+            <xsl:apply-templates select="."/>
+        </mtd>
+    </xsl:template>
+
+    <xsl:template match="pile" mode="columns-right">
+        <mtd columnalign="right">
+            <xsl:apply-templates select="."/>
+        </mtd>
+    </xsl:template>
+
+    <xsl:template match="slot" mode="columns-left">
+        <mtd columnalign="left">
+            <xsl:apply-templates />
+        </mtd>
+    </xsl:template>
+
+    <xsl:template match="slot" mode="columns-center">
+        <mtd>
+            <xsl:apply-templates />
+        </mtd>
+    </xsl:template>
+
+    <xsl:template match="slot" mode="columns-right">
+        <mtd columnalign="right">
+            <xsl:apply-templates />
+        </mtd>
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/pile.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/pile.xsl
new file mode 100644
index 0000000..3bedfca
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/pile.xsl
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- The translation of a pile using this form of translation string is performed with the following steps:
+
+    The <start> part of the translation string is output;
+    The first line is translated;
+    The <repeat> part of the translation string is output;
+    The next line is translated;
+    If there are any more lines, go back to Step 3. Otherwise, continue with the next step;
+    The <end> part of the translation string is output.
+    -->
+    <xsl:template match="pile">
+        <mtable>
+            <xsl:apply-templates select="slot" mode="wrap"/>
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="pile[halign='left']">
+        <mtable columnalign="left">
+            <xsl:apply-templates select="slot" mode="wrap"/>
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="pile/slot" mode="wrap">
+        <mtr>
+            <mtd>
+                <xsl:apply-templates select="."/>
+            </mtd>
+        </mtr>
+    </xsl:template>
+
+    <xsl:template match="pile[halign='right']">
+        <mtable columnalign="right">
+            <xsl:apply-templates select="slot" mode="wrap"/>
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="pile[halign='dec']">
+        <mtable groupalign="decimalpoint">
+            <xsl:apply-templates select="slot" mode="wrap"/>
+        </mtable>
+    </xsl:template>
+
+    <xsl:template match="pile[halign='al']">
+        <mtable>
+            <xsl:apply-templates select="slot" mode="wrap"/>
+        </mtable>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/product_coproduct.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/product_coproduct.xsl
new file mode 100644
index 0000000..d79c236
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/product_coproduct.xsl
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Product and coproduct -->
+
+    <xsl:template match="tmpl[selector='tmPROD']">
+        <munderover>
+            <mo>&#x220F;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPROD' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        <munder>
+            <mo>&#x220F;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPROD' and (not(variation='tvBO_UPPER')  and not(variation='tvBO_LOWER'))]">
+        <mo>&#x220F;</mo> <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPROD' and not(variation='tvBO_SUM')  and variation='tvBO_LOWER']">
+        <msub>
+            <mo>&#x220F;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmPROD' and not(variation='tvBO_SUM') ]">
+        <msubsup>
+            <mo>&#x220F;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCOPROD']">
+        <munderover>
+            <mo>&#x2210;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCOPROD' and not(variation='tvBO_SUM') ]">
+        <msubsup>
+            <mo>&#x2210;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCOPROD' and (not(variation='tvBO_UPPER')  and not(variation='tvBO_LOWER'))]">
+        <mo>&#x2210;</mo> <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCOPROD' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        <munder>
+            <mo>&#x2210;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmCOPROD' and not(variation='tvBO_SUM')  and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        <msub>
+            <mo>&#x2210;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/root.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/root.xsl
new file mode 100644
index 0000000..0df467c
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/root.xsl
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- SQRT -->
+
+     <xsl:template match="tmpl[selector='tmROOT' and variation='tvROOT_SQ']">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$colorValue != '' and $colorValue != '#000000'">
+                <mstyle mathcolor="{$colorValue}">
+                    <msqrt>
+                        <xsl:apply-templates select="slot[1] | pile[1]"/>
+                        <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    </msqrt>
+                </mstyle>
+            </xsl:when>
+            <xsl:otherwise>
+                <msqrt>
+                    <xsl:apply-templates select="slot[1] | pile[1]"/>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </msqrt>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmROOT' and variation='tvROOT_NTH']">
+        <xsl:variable name="colorValue">
+            <xsl:call-template name="get-active-color"/>
+        </xsl:variable>
+
+        <xsl:choose>
+            <xsl:when test="$colorValue != '' and $colorValue != '#000000'">
+                <mstyle mathcolor="{$colorValue}">
+                    <mroot>
+                        <xsl:apply-templates select="slot[1] | pile[1]"/>
+                        <xsl:apply-templates select="slot[2] | pile[2]"/>
+                    </mroot>
+                </mstyle>
+            </xsl:when>
+            <xsl:otherwise>
+                <mroot>
+                    <xsl:apply-templates select="slot[1] | pile[1]"/>
+                    <xsl:apply-templates select="slot[2] | pile[2]"/>
+                </mroot>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/subsup.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/subsup.xsl
new file mode 100644
index 0000000..e393923
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/subsup.xsl
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <xsl:template match="tmpl[selector='tmSUP' and not(variation='tvSU_PRECEDES')]">
+        <msup>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msup>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUB' and not(variation='tvSU_PRECEDES')]">
+        <msub>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUBSUP' and not(variation='tvSU_PRECEDES')]">
+        <msubsup>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUP' and variation='tvSU_PRECEDES']">
+        <mmultiscripts>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mprescripts/>
+            <none/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </mmultiscripts>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUB' and variation='tvSU_PRECEDES']">
+        <mmultiscripts>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mprescripts/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <none/>
+        </mmultiscripts>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUBSUP' and variation='tvSU_PRECEDES']">
+        <mmultiscripts>
+            <xsl:apply-templates select="slot[1] | pile[1]"/>
+            <mprescripts/>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </mmultiscripts>
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/sum.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/sum.xsl
new file mode 100644
index 0000000..6fc49d2
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/sum.xsl
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+     <!-- Summations -->
+
+    <xsl:template match="tmpl[selector='tmSUM' and (not(variation='tvBO_UPPER') and not(variation='tvBO_UPPER'))]">
+        <mo>&#x2211;</mo>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUM' and variation='tvBO_LOWER']">
+        <munder>
+            <mo>&#x2211;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUM']">
+        <munderover>
+            <mo>&#x2211;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUM' and not(variation='tvBO_SUM') and variation='tvBO_LOWER']">
+        <msub>
+            <mo>&#x2211;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUM' and not(variation='tvBO_SUM')]">
+        <msubsup>
+            <mo>&#x2211;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <!-- Sum operator -->
+    <xsl:template match="tmpl[selector='tmSUMOP']">
+        <munderover>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUMOP' and variation='tvBO_UPPER' and not(variation='tvBO_LOWER')]">
+        <mover>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmSUMOP' and variation='tvBO_LOWER' and not(variation='tvBO_UPPER')]">
+        <munder>
+            <mo mathsize="140%"><xsl:apply-templates select="slot[4] | pile[4]"/></mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+    </xsl:template>
+
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/union_intersection.xsl b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/union_intersection.xsl
new file mode 100644
index 0000000..6296c55
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/lib/xsl/union_intersection.xsl
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    exclude-result-prefixes="xs"
+    version="1.0">
+
+    <!-- Unions and intersections -->
+
+    <xsl:template match="tmpl[selector='tmINTER' and (not(variation='tvBO_UPPER') and not(variation='tvBO_UPPER'))]">
+        <mo>&#x2229;</mo> <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTER' and variation='tvBO_LOWER']">
+        <munder>
+            <mo>&#x2229;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTER']">
+        <munderover>
+            <mo>&#x2229;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTER' and not(variation='tvBO_SUM') and variation='tvBO_LOWER']">
+        <msub>
+            <mo>&#x2229;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmINTER' and not(variation='tvBO_SUM')]">
+        <msubsup>
+            <mo>&#x2229;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUNION' and (not(variation='tvBO_UPPER') and not(variation='tvBO_UPPER'))]">
+        <mo>&#x222A;</mo> <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUNION' and variation='tvBO_LOWER']">
+        <munder>
+            <mo>&#x222A;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </munder>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUNION']">
+        <munderover>
+            <mo>&#x222A;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </munderover>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUNION' and not(variation='tvBO_SUM') and variation='tvBO_LOWER']">
+        <msub>
+            <mo>&#x222A;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+        </msub>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+
+    <xsl:template match="tmpl[selector='tmUNION' and not(variation='tvBO_SUM') ]">
+        <msubsup>
+            <mo>&#x222A;</mo>
+            <xsl:apply-templates select="slot[2] | pile[2]"/>
+            <xsl:apply-templates select="slot[3] | pile[3]"/>
+        </msubsup>
+        <xsl:apply-templates select="slot[1] | pile[1]"/>
+    </xsl:template>
+</xsl:stylesheet>
diff --git a/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/mathtype_to_mathml.gemspec b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/mathtype_to_mathml.gemspec
new file mode 100644
index 0000000..acbb34f
--- /dev/null
+++ b/scripts/mathtype2mathml/vendor/gems/mathtype_to_mathml/mathtype_to_mathml.gemspec
@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mathtype_to_mathml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathtype_to_mathml"
+  spec.version       = MathTypeToMathML::VERSION
+  spec.authors       = ["Jure Triglav"]
+  spec.email         = ["juretriglav@gmail.com"]
+  spec.summary       = %q{Converts from a binary MathType format (MTEF) to MathML.}
+  spec.description   = %q{This gem can be used to convert MathType equations from a binary format (e.g. embedded in Word documents) to an open MathML representation. It achieves that in several stages, first using the "mathtype" gem to convert from a binary to an XML form of MTEF, and second, using XSLTs to convert XML to MathML.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = Dir.glob("{lib,spec}/**/*")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+
+  spec.add_dependency "nokogiri", "~> 1.6"
+  spec.add_dependency "mathtype", "~> 0.1.0"
+end
diff --git a/scripts/omml_mathml2latex/README.md b/scripts/omml_mathml2latex/README.md
new file mode 100644
index 0000000..56d50c2
--- /dev/null
+++ b/scripts/omml_mathml2latex/README.md
@@ -0,0 +1,204 @@
+# Refactor - Standalone OMML/MathML to LaTeX Converter
+
+**Version:** 1.0.0
+**Status:** Production-ready standalone module
+**Size:** 836KB | 75 Python files | ~19,000 lines of code
+
+## Overview
+
+This is a fully standalone, production-ready OMML/MathML to LaTeX converter module that has been refactored from the original `omml_to_tex` package. It uses modern design patterns and has **zero external dependencies** on the parent package.
+
+### Key Features
+
+- ✅ **Fully Standalone**: No dependencies on `omml_to_tex` package
+- ✅ **Production Ready**: All necessary code copied and integrated
+- ✅ **Clean Architecture**: Uses Visitor, Strategy, and Pipeline patterns
+- ✅ **Comprehensive**: Includes all data, utils, processing, and core modules
+- ✅ **Modular**: Well-organized package structure
+
+## Architecture
+
+```
+refactor/
+├── __init__.py              # Package entry point
+├── __main__.py              # CLI entry point
+│
+├── data/                    # Symbol mappings and constants (7 files)
+│   ├── symbols.py           # Unicode to LaTeX mappings (200+ symbols)
+│   ├── functions.py         # Mathematical functions (50+)
+│   ├── operators.py         # Operator definitions
+│   ├── patterns.py          # Regex patterns for processing
+│   └── units.py             # Common units
+│
+├── utils/                   # Utility functions (6 files)
+│   ├── xml_utils.py         # XML/MathML processing
+│   ├── helpers.py           # Helper functions
+│   ├── chemistry.py         # Chemistry detection
+│   ├── text_processing.py   # Text I/O and LaTeX formatting
+│   └── color_helpers.py     # Color processing
+│
+├── core/                    # Core infrastructure (6 files)
+│   ├── interfaces.py        # Abstract base classes
+│   ├── context.py           # Conversion context
+│   ├── pipeline.py          # Pipeline orchestrator
+│   ├── xslt_transformer.py  # OMML to MathML transformation
+│   └── omml_parser_core.py  # OMML parser (84K lines)
+│
+├── parsers/                 # Input parsers (5 files)
+│   ├── factory.py           # Parser factory
+│   ├── docx_parser.py       # DOCX file parsing
+│   ├── omml_parser.py       # OMML parsing
+│   └── mathml_parser.py     # MathML parsing
+│
+├── processing/              # Processing modules (5 files)
+│   ├── omml_extractor.py    # Extract OMML from DOCX
+│   ├── docx_processor.py    # DOCX processing
+│   ├── output_formatter.py  # LaTeX formatting
+│   └── result.py            # Result data structures
+│
+├── visitors/                # Visitor pattern (35 files)
+│   ├── mi_visitor.py        # <mi> identifier handling
+│   ├── mo_visitor.py        # <mo> operator handling
+│   ├── mn_visitor.py        # <mn> number handling
+│   ├── mfrac_visitor.py     # <mfrac> fraction handling
+│   └── ...                  # 30+ more element visitors
+│
+├── strategies/              # Strategy pattern (5 files)
+│   ├── math_strategy.py     # Mathematical notation
+│   ├── chemistry_strategy.py # Chemical equations
+│   ├── physics_strategy.py  # Physics notation
+│   └── statistics_strategy.py # Statistical notation
+│
+├── builders/                # Builder pattern (2 files)
+│   └── latex_builder.py     # LaTeX construction
+│
+├── compat/                  # Compatibility layer (2 files)
+│   └── legacy_adapter.py    # Legacy converter adapter
+│
+└── converters/              # Converters (2 files)
+    └── post_processor.py    # LaTeX post-processing
+```
+
+## Usage
+
+### Command Line
+
+```bash
+# Convert DOCX file
+uv run python -m refactor --docx document.docx --output equations.tex 
+# Convert MathML
+uv run python -m refactor --mathml input.xml --output output.tex
+
+# Convert with chemistry mode
+uv run python -m refactor  --subject chemistry --docx chemistry.docx 
+
+# Convert OMML
+uv run python -m refactor --omml input.xml --output output.tex
+```
+
+### Python API
+
+```python
+from refactor.compat import LegacyMathMLToTeXConverter
+from refactor.parsers import InputParserFactory
+
+# Create converter
+converter = LegacyMathMLToTeXConverter(subject_mode='chemistry')
+
+# Parse input
+parser = InputParserFactory.create_parser('mathml', 'input.xml')
+mathml_equations = parser.parse()
+
+# Convert to LaTeX
+for mathml in mathml_equations:
+    latex = converter.convert(mathml)
+    print(latex)
+```
+
+## Dependencies
+
+This module is **completely standalone** and only requires:
+- Python 3.7+
+- lxml (for XML processing)
+
+No dependency on the parent `omml_to_tex` package!
+
+## Design Patterns Used
+
+1. **Visitor Pattern**: Each MathML element type has its own visitor class
+2. **Strategy Pattern**: Subject-specific formatting (math, chemistry, physics)
+3. **Pipeline Pattern**: Explicit conversion stages
+4. **Builder Pattern**: Fluent LaTeX construction
+5. **Factory Pattern**: Unified input parsing
+
+## What Was Changed
+
+### Copied Modules (from omml_to_tex/)
+
+- ✅ `data/` - All symbol mappings and constants
+- ✅ `utils/` - XML utilities, helpers, chemistry detection
+- ✅ `processing/` - DOCX processing, OMML extraction, formatting
+- ✅ `core/` - XSLT transformer, OMML parser
+
+### Updated Imports
+
+All 53 files that imported from `omml_to_tex` were updated to use relative imports:
+- `from omml_to_tex.data import X` → `from ..data import X`
+- `from omml_to_tex.utils import Y` → `from ..utils import Y`
+- etc.
+
+### Removed Files
+
+- ❌ All test files (`tests/` directory, ~50 files)
+- ❌ All documentation files (`*.md`, ~15 files)
+- ❌ Demo and benchmark files
+- ❌ Empty `stages/` directory
+- ❌ Nested `refactor/refactor/` directory
+
+## File Statistics
+
+```
+Total Python files:     75
+Total lines of code:    ~19,000
+Package size:           836KB
+Visitor files:          35
+Strategy files:         4
+Data modules:           5
+Utility modules:        5
+```
+
+## Testing
+
+The module has been verified to:
+- ✅ Import successfully as a standalone module
+- ✅ Have no dependencies on `omml_to_tex` package
+- ✅ Contain all necessary code and data
+- ✅ Use consistent relative imports throughout
+
+## Production Deployment
+
+To deploy this module to your system:
+
+1. **Copy the entire `refactor/` directory** to your target location
+2. **Install dependencies**: `pip install lxml`
+3. **Verify installation**: `python -m refactor --help`
+4. **Test conversion**: `python -m refactor --docx your_file.docx`
+
+The module is completely self-contained and ready for production use!
+
+## Version History
+
+**v1.0.0** (2025-10-26)
+- Initial standalone release
+- Copied all necessary modules from omml_to_tex
+- Updated all imports to use relative imports
+- Removed test and documentation files
+- Verified standalone functionality
+
+## License
+
+Same as parent project (omml_to_tex)
+
+## Contact
+
+For issues or questions, refer to the parent project documentation.
diff --git a/scripts/omml_mathml2latex/__init__.py b/scripts/omml_mathml2latex/__init__.py
new file mode 100644
index 0000000..b944c6a
--- /dev/null
+++ b/scripts/omml_mathml2latex/__init__.py
@@ -0,0 +1,26 @@
+"""
+Refactored OMML/MathML to LaTeX converter using design patterns.
+
+This package implements a refactored architecture of the converter using:
+- Visitor pattern for element conversion
+- Strategy pattern for subject-specific formatting
+- Pipeline pattern for conversion stages
+- Parallel processing for high-performance batch conversion
+- XSL transformer caching for optimized performance
+"""
+
+from .compat import LegacyMathMLToTeXConverter
+from .parallel import ParallelConverter, BatchProcessor
+from .core.cache import XSLTransformerCache, ConverterObjectPool
+from .batch import BatchJSONConverter
+
+__version__ = '1.1.0'  # Performance optimization release
+
+__all__ = [
+    'LegacyMathMLToTeXConverter',
+    'ParallelConverter',
+    'BatchProcessor',
+    'BatchJSONConverter',
+    'XSLTransformerCache',
+    'ConverterObjectPool',
+]
diff --git a/scripts/omml_mathml2latex/__main__.py b/scripts/omml_mathml2latex/__main__.py
new file mode 100644
index 0000000..708247f
--- /dev/null
+++ b/scripts/omml_mathml2latex/__main__.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+CLI entry point for refactored MathML to LaTeX converter.
+
+Usage:
+    python -m refactor --docx file.docx
+    uv run python -m refactor --docx file.docx --subject chemistry
+"""
+
+import argparse
+import sys
+import os
+from pathlib import Path
+import time
+
+# Use relative imports for standalone module
+from .compat import LegacyMathMLToTeXConverter
+from .parsers import InputParserFactory
+from .utils.timer import PerformanceTimer
+
+
+def handle_json_batch(args, timer):
+    """
+    Handle JSON batch conversion mode.
+
+    Args:
+        args: Parsed command-line arguments
+        timer: PerformanceTimer instance
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    import json
+    from .batch import BatchJSONConverter
+
+    try:
+        # Read input JSON
+        with timer.measure("json_read"):
+            if args.verbose and not args.quiet:
+                print(f"Reading JSON from {args.json}...", file=sys.stderr)
+
+            with open(args.json, 'r', encoding='utf-8') as f:
+                input_data = json.load(f)
+
+        # Validate input format
+        if not isinstance(input_data, dict):
+            print("Error: Input JSON must be a dictionary (key -> equation mapping)", file=sys.stderr)
+            return 1
+
+        # Support both flat dict and nested "mathml_dict" format
+        if "mathml_dict" in input_data:
+            equations_dict = input_data["mathml_dict"]
+            if args.verbose and not args.quiet:
+                print("Detected nested 'mathml_dict' format", file=sys.stderr)
+        else:
+            equations_dict = input_data
+
+        if not equations_dict:
+            print("Error: No equations found in input JSON", file=sys.stderr)
+            return 1
+
+        if not args.quiet:
+            print(f"INFO: Found {len(equations_dict)} equations in JSON file", file=sys.stderr)
+
+        # Create batch converter
+        with timer.measure("converter_init"):
+            converter = BatchJSONConverter(
+                subject_mode=args.subject,
+                wrap_identifiers=args.wrap_mathrm,
+                prefer_xlongequal=not args.no_xlongequal,
+                universal_delimiter_scaling=not args.no_universal_delimiters,
+                verbose=args.verbose and not args.quiet,
+            )
+
+        # Convert (parallel or sequential)
+        if args.parallel and len(equations_dict) >= 10:
+            if not args.quiet:
+                print(f"INFO: Using parallel processing with {args.workers or 'auto'} workers", file=sys.stderr)
+
+            with timer.measure("parallel_batch_conversion", {"equations": len(equations_dict)}):
+                results = converter.convert_batch_parallel(
+                    equations_dict,
+                    workers=args.workers,
+                    quiet=args.quiet
+                )
+        else:
+            if args.parallel and not args.quiet:
+                print("INFO: Sequential mode (< 10 equations, parallel not beneficial)", file=sys.stderr)
+
+            with timer.measure("sequential_batch_conversion", {"equations": len(equations_dict)}):
+                results = converter.convert_batch(equations_dict, quiet=args.quiet)
+
+        # Format output JSON
+        with timer.measure("json_format"):
+            output_json = json.dumps(results, ensure_ascii=False, indent=2)
+
+        # Write output
+        with timer.measure("file_output"):
+            if args.output:
+                with open(args.output, 'w', encoding='utf-8') as f:
+                    f.write(output_json)
+                if not args.quiet:
+                    print(f"Wrote {len(results)} results to {args.output}", file=sys.stderr)
+            else:
+                print(output_json)
+
+        # Show timing report if requested
+        if args.show_timing and not args.quiet:
+            print("\n", file=sys.stderr)
+            print(timer.format_report(), file=sys.stderr)
+
+        return 0
+
+    except FileNotFoundError:
+        print(f"Error: Input file not found: {args.json}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in input file: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Refactored OMML/MathML → LaTeX converter with design patterns",
+        epilog="Examples:\n"
+               "  python -m omml2tex --docx document.docx --output output.tex\n"
+               "  python -m omml2tex --mathml input.xml --subject chemistry\n"
+               "  python -m omml2tex --json equations.json -o results.json\n"
+               "  python -m omml2tex --json equations.json --parallel --workers 4\n"
+               "  uv run python -m omml2tex --docx file.docx\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    # Input options (mutually exclusive)
+    input_group = parser.add_mutually_exclusive_group(required=True)
+    input_group.add_argument("--omml", help="Path to input OMML XML file")
+    input_group.add_argument("--docx", help="Path to input DOCX file")
+    input_group.add_argument("--mathml", help="Path to input MathML XML file (use '-' for stdin)")
+    input_group.add_argument("--json", help="Path to input JSON file (key -> equation mapping for batch conversion)")
+
+    # Output options
+    parser.add_argument("--output", "-o", help="Output file path (default: stdout)")
+    parser.add_argument("--output-format", choices=["latex", "json"], default="latex",
+                       help="Output format (default: latex)")
+
+    # Conversion options
+    parser.add_argument("--wrap-mathrm", action="store_true",
+                       help="Wrap multi-character identifiers in \\mathrm{...} (disabled by default)")
+    parser.add_argument("--no-xlongequal", action="store_true",
+                       help="Do not prefer \\xlongequal for overset '='")
+    parser.add_argument("--subject", choices=["auto", "math", "physics", "chemistry", "statistics"],
+                        default="math", help="Subject mode for specialized formatting (default: math for MathML, auto for DOCX)")
+    parser.add_argument("--no-universal-delimiters", action="store_true",
+                       help="Disable universal \\left\\right scaling for all delimiters (enabled by default)")
+
+    # Advanced options
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    parser.add_argument("--quiet", "-q", action="store_true", help="Quiet mode (errors only)")
+    parser.add_argument("--numbered", action="store_true", help="Number equations in output")
+
+    # Performance options
+    parser.add_argument("--parallel", action="store_true",
+                       help="Enable parallel processing for faster conversion (recommended for 5+ equations)")
+    parser.add_argument("--workers", type=int, default=None,
+                       help="Number of worker processes (default: CPU count, max 8)")
+    parser.add_argument("--show-timing", action="store_true",
+                       help="Show detailed performance timing report at the end")
+
+    args = parser.parse_args()
+
+    # Initialize performance timer
+    timer = PerformanceTimer(enabled=args.show_timing)
+
+    try:
+        # Start total timing
+        with timer.measure("total_execution"):
+            # JSON batch mode has different I/O semantics - handle separately
+            if args.json:
+                return handle_json_batch(args, timer)
+
+            # Determine input source and type (single-file modes)
+            with timer.measure("input_detection"):
+                if args.docx:
+                    input_path = args.docx
+                    input_type = "docx"
+                    # Auto-detect subject mode for DOCX if not explicitly set
+                    if args.subject == "math":
+                        args.subject = "auto"
+                elif args.omml:
+                    input_path = args.omml
+                    input_type = "omml"
+                elif args.mathml:
+                    input_path = args.mathml
+                    input_type = "mathml"
+                else:
+                    print("Error: No input file specified", file=sys.stderr)
+                    return 1
+
+            # Handle stdin ("-")
+            if input_path == "-":
+                if args.verbose and not args.quiet:
+                    print("Reading from stdin...", file=sys.stderr)
+                input_path = sys.stdin.read()
+
+            # Parse input file to get MathML equations
+            if args.verbose and not args.quiet:
+                print(f"Parsing input: {input_path if input_path != '-' else 'stdin'}", file=sys.stderr)
+
+            try:
+                with timer.measure("input_parsing", {"type": input_type}):
+                    parser_obj = InputParserFactory.create_parser(input_path, parser_type=input_type)
+                    mathml_equations = parser_obj.parse(input_path)
+            except Exception as e:
+                print(f"Error parsing input: {e}", file=sys.stderr)
+                return 1
+
+            if args.verbose and not args.quiet:
+                print(f"Found {len(mathml_equations)} equation(s)", file=sys.stderr)
+
+            # Print info messages to stderr (like original converter)
+            if not args.quiet:
+                print(f"INFO: Processing {'DOCX' if args.docx else 'MathML' if args.mathml else 'OMML'} file: {input_path}", file=sys.stderr)
+                print(f"INFO: Found {len(mathml_equations)} equations in {input_path}", file=sys.stderr)
+                print(f"INFO: Auto-detected subject mode: {args.subject}", file=sys.stderr)
+
+            # Convert equations - use parallel processing if enabled
+            if args.parallel and len(mathml_equations) >= 5:
+                # PARALLEL MODE: Use multiprocessing for faster conversion
+                if not args.quiet:
+                    print(f"INFO: Using parallel processing with {args.workers or 'auto'} workers", file=sys.stderr)
+
+                from .parallel import ParallelConverter
+
+                with timer.measure("parallel_conversion", {"equations": len(mathml_equations)}):
+                    parallel_converter = ParallelConverter(
+                        workers=args.workers,
+                        subject_mode=args.subject,
+                        wrap_identifiers=args.wrap_mathrm,
+                        prefer_xlongequal=not args.no_xlongequal,
+                        universal_delimiter_scaling=not args.no_universal_delimiters,
+                        show_progress=not args.quiet,
+                    )
+
+                    # Convert in parallel
+                    conversion_results = parallel_converter.convert_batch(mathml_equations, quiet=args.quiet)
+
+                # Format results
+                with timer.measure("format_results"):
+                    results = []
+                    for i, result in enumerate(conversion_results, 1):
+                        if result['success']:
+                            latex = result['latex']
+
+                            # Wrap in $ ... $ for inline math
+                            if '\\begin{' in latex or latex.startswith('\\['):
+                                wrapped = f"${latex}$"
+                            else:
+                                wrapped = f"${latex}$"
+
+                            if args.numbered:
+                                results.append(f"% Equation {i}\n{wrapped}")
+                            else:
+                                results.append(wrapped)
+                        else:
+                            error_msg = result.get('error', 'Unknown error')
+                            if not args.quiet:
+                                print(f"Warning: Failed to convert equation {i}: {error_msg}", file=sys.stderr)
+                            results.append(f"% Error: {error_msg}")
+
+            else:
+                # SEQUENTIAL MODE: Original single-threaded conversion
+                if args.parallel and not args.quiet:
+                    print("INFO: Sequential mode (< 5 equations, parallel not beneficial)", file=sys.stderr)
+
+                with timer.measure("converter_init"):
+                    converter = LegacyMathMLToTeXConverter(
+                        wrap_identifiers_in_mathrm=args.wrap_mathrm,
+                        prefer_xlongequal=not args.no_xlongequal,
+                        subject_mode=args.subject,
+                        universal_delimiter_scaling=not args.no_universal_delimiters,
+                    )
+
+                # Convert equations
+                results = []
+                for i, mathml in enumerate(mathml_equations, 1):
+                    try:
+                        with timer.measure("equation_conversion"):
+                            latex = converter.convert(mathml)
+
+                        # Wrap in $ ... $ for inline math (match original behavior)
+                        # Use $$ ... $$ if equation contains \begin{...} or is display-style
+                        if '\\begin{' in latex or latex.startswith('\\['):
+                            wrapped = f"${latex}$"
+                        else:
+                            wrapped = f"${latex}$"
+
+                        if args.numbered:
+                            results.append(f"% Equation {i}\n{wrapped}")
+                        else:
+                            results.append(wrapped)
+
+                    except Exception as e:
+                        if not args.quiet:
+                            print(f"Warning: Failed to convert equation {i}: {e}", file=sys.stderr)
+                        results.append(f"% Error: {e}")
+
+            # Calculate success stats
+            with timer.measure("statistics_calculation"):
+                successful = sum(1 for r in results if not r.startswith("% Error"))
+                failed = len(results) - successful
+                success_rate = (successful / len(results) * 100) if results else 0
+
+            # Format output
+            with timer.measure("output_formatting"):
+                if args.output_format == "json":
+                    import json
+                    output = json.dumps({
+                        "equations": results,
+                        "count": len(results),
+                        "subject_mode": args.subject,
+                        "successful": successful,
+                        "failed": failed,
+                    }, indent=2)
+                else:  # latex
+                    # Add summary header (matching original format)
+                    if not args.quiet:
+                        summary = [
+                            "",
+                            "Conversion Results:",
+                            f"  Total equations: {len(results)}",
+                            f"  Successful: {successful}",
+                            f"  Failed: {failed}",
+                            f"  Success rate: {success_rate:.1f}%",
+                            "",
+                            "=" * 50,
+                            "CONVERTED EQUATIONS:",
+                            "=" * 50,
+                        ]
+                        output = "\n".join(summary) + "\n" + "\n\n".join(results)
+                    else:
+                        output = "\n\n".join(results)
+
+            # Write output
+            with timer.measure("file_output"):
+                if args.output:
+                    with open(args.output, 'w', encoding='utf-8') as f:
+                        f.write(output)
+                    if not args.quiet:
+                        print(f"Wrote {len(results)} equation(s) to {args.output}", file=sys.stderr)
+                else:
+                    print(output)
+
+        # Show timing report if requested
+        if args.show_timing and not args.quiet:
+            print("\n", file=sys.stderr)
+            print(timer.format_report(), file=sys.stderr)
+
+        return 0
+
+    except KeyboardInterrupt:
+        print("\nInterrupted", file=sys.stderr)
+        return 130
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/scripts/omml_mathml2latex/batch.py b/scripts/omml_mathml2latex/batch.py
new file mode 100644
index 0000000..f31c0f9
--- /dev/null
+++ b/scripts/omml_mathml2latex/batch.py
@@ -0,0 +1,261 @@
+"""
+Batch JSON converter for omml2tex with key preservation.
+
+Handles conversion of multiple equations in JSON format while preserving
+unique identifiers. Supports both sequential and parallel processing.
+"""
+
+from typing import Dict, Any
+import sys
+
+from .compat import LegacyMathMLToTeXConverter
+from .parsers.omml_parser import OmmlParser
+
+
+class BatchJSONConverter:
+    """
+    Batch converter for JSON format with key preservation.
+
+    Converts a dictionary of equations (key -> XML) to LaTeX while preserving
+    the original keys. Supports both OMML and MathML input formats with
+    automatic detection.
+
+    Example:
+        >>> converter = BatchJSONConverter(subject_mode="chemistry")
+        >>> equations = {"eq1": "<math><mi>x</mi></math>", "eq2": "..."}
+        >>> results = converter.convert_batch(equations)
+        >>> print(results["eq1"])  # LaTeX output
+    """
+
+    def __init__(
+        self,
+        subject_mode: str = "math",
+        wrap_identifiers: bool = True,
+        prefer_xlongequal: bool = True,
+        universal_delimiter_scaling: bool = True,
+        verbose: bool = False
+    ):
+        """
+        Initialize batch converter.
+
+        Args:
+            subject_mode: Subject mode for conversion (math, chemistry, physics, statistics)
+            wrap_identifiers: Whether to wrap identifiers in \\mathrm{}
+            prefer_xlongequal: Whether to prefer \\xlongequal for overset equations
+            universal_delimiter_scaling: Whether to add \\left\\right to all delimiters
+            verbose: Enable verbose output
+        """
+        self.subject_mode = subject_mode
+        self.wrap_identifiers = wrap_identifiers
+        self.prefer_xlongequal = prefer_xlongequal
+        self.universal_delimiter_scaling = universal_delimiter_scaling
+        self.verbose = verbose
+
+        # Initialize converter
+        self.converter = LegacyMathMLToTeXConverter(
+            wrap_identifiers_in_mathrm=wrap_identifiers,
+            prefer_xlongequal=prefer_xlongequal,
+            subject_mode=subject_mode,
+            universal_delimiter_scaling=universal_delimiter_scaling,
+        )
+
+        # OMML parser for OMML input
+        self.omml_parser = OmmlParser()
+
+    def detect_input_type(self, content: str) -> str:
+        """
+        Detect if input is OMML or MathML.
+
+        Args:
+            content: XML content string
+
+        Returns:
+            "omml" or "mathml"
+        """
+        content_stripped = content.strip()
+
+        # Check for OMML namespace
+        if 'm:oMath' in content_stripped or 'm:oMathPara' in content_stripped:
+            return "omml"
+
+        # Check for MathML namespace
+        if '<math' in content_stripped or 'xmlns="http://www.w3.org/1998/Math/MathML"' in content_stripped:
+            return "mathml"
+
+        # Default to mathml
+        return "mathml"
+
+    def convert_single(self, key: str, equation_xml: str) -> Dict[str, Any]:
+        """
+        Convert a single equation while preserving the key.
+
+        Args:
+            key: Unique identifier for the equation
+            equation_xml: OMML or MathML XML string
+
+        Returns:
+            Dict with 'key', 'latex', 'success', and optional 'error'
+        """
+        try:
+            # Detect input type
+            input_type = self.detect_input_type(equation_xml)
+
+            if self.verbose:
+                print(f"  {key}: {input_type} -> ", end="", file=sys.stderr)
+
+            # Convert OMML to MathML if needed
+            if input_type == "omml":
+                mathml_list = self.omml_parser.parse(equation_xml)
+                # OmmlParser.parse() returns a list - take the first element
+                if not mathml_list:
+                    raise ValueError("OMML parser returned empty result")
+                mathml = mathml_list[0]
+            else:
+                mathml = equation_xml
+
+            # Convert MathML to LaTeX
+            latex = self.converter.convert(mathml)
+
+            if self.verbose:
+                print(f"LaTeX ({len(latex)} chars)", file=sys.stderr)
+
+            return {
+                "key": key,
+                "latex": latex,
+                "success": True,
+            }
+
+        except Exception as e:
+            if self.verbose:
+                print(f"FAILED: {e}", file=sys.stderr)
+
+            return {
+                "key": key,
+                "latex": "",
+                "success": False,
+                "error": str(e),
+            }
+
+    def convert_batch(self, input_dict: Dict[str, str], quiet: bool = False) -> Dict[str, str]:
+        """
+        Convert a batch of equations from JSON dict (sequential).
+
+        Args:
+            input_dict: Dict mapping unique keys to equation XML strings
+            quiet: Suppress progress messages
+
+        Returns:
+            Dict mapping same keys to LaTeX strings (failed conversions get empty string)
+        """
+        if self.verbose and not quiet:
+            print(f"Converting {len(input_dict)} equations...", file=sys.stderr)
+
+        results = {}
+        successful = 0
+        failed = 0
+
+        for key, equation_xml in input_dict.items():
+            equation_xml = equation_xml.replace("JBYSIMJBY", "~")
+            result = self.convert_single(key, equation_xml)
+
+            # Store LaTeX string (or empty string if failed)
+            results[key] = result["latex"]
+
+            if result["success"]:
+                successful += 1
+            else:
+                failed += 1
+                if not self.verbose and not quiet:
+                    print(
+                        f"Warning: Failed to convert {key}: {result.get('error', 'Unknown error')}",
+                        file=sys.stderr
+                    )
+
+        if (self.verbose or failed > 0) and not quiet:
+            print(f"\nConversion complete:", file=sys.stderr)
+            print(f"  Total: {len(input_dict)}", file=sys.stderr)
+            print(f"  Successful: {successful}", file=sys.stderr)
+            print(f"  Failed: {failed}", file=sys.stderr)
+            print(f"  Success rate: {successful/len(input_dict)*100:.1f}%", file=sys.stderr)
+
+        return results
+
+    def convert_batch_parallel(
+        self,
+        input_dict: Dict[str, str],
+        workers: int = None,
+        quiet: bool = False
+    ) -> Dict[str, str]:
+        """
+        Convert batch using parallel processing (for large batches).
+
+        Args:
+            input_dict: Dict mapping unique keys to equation XML strings
+            workers: Number of worker processes (default: CPU count, max 8)
+            quiet: Suppress progress messages
+
+        Returns:
+            Dict mapping same keys to LaTeX strings
+        """
+        from .parallel import ParallelConverter
+
+        if self.verbose and not quiet:
+            print(f"Converting {len(input_dict)} equations in parallel...", file=sys.stderr)
+
+        # Create parallel converter
+        parallel_converter = ParallelConverter(
+            workers=workers,
+            subject_mode=self.subject_mode,
+            wrap_identifiers=self.wrap_identifiers,
+            prefer_xlongequal=self.prefer_xlongequal,
+            show_progress=self.verbose and not quiet,
+        )
+
+        # Prepare input list (keys and equations)
+        keys = list(input_dict.keys())
+        equations = list(input_dict.values())
+
+        # Detect input types and convert OMML to MathML if needed
+        mathml_equations = []
+        for equation_xml in equations:
+            equation_xml = equation_xml.replace("JBYSIMJBY", "~")
+            input_type = self.detect_input_type(equation_xml)
+            if input_type == "omml":
+                mathml_list = self.omml_parser.parse(equation_xml)
+                # OmmlParser.parse() returns a list - take the first element
+                if not mathml_list:
+                    raise ValueError("OMML parser returned empty result")
+                mathml = mathml_list[0]
+            else:
+                mathml = equation_xml
+            mathml_equations.append(mathml)
+
+        # Convert in parallel
+        conversion_results = parallel_converter.convert_batch(mathml_equations, quiet=quiet)
+
+        # Build result dict
+        results = {}
+        successful = 0
+        failed = 0
+
+        for key, result in zip(keys, conversion_results):
+            if result['success']:
+                results[key] = result['latex']
+                successful += 1
+            else:
+                results[key] = ""
+                failed += 1
+                if not self.verbose and not quiet:
+                    print(
+                        f"Warning: Failed to convert {key}: {result.get('error', 'Unknown error')}",
+                        file=sys.stderr
+                    )
+
+        if (self.verbose or failed > 0) and not quiet:
+            print(f"\nConversion complete:", file=sys.stderr)
+            print(f"  Total: {len(input_dict)}", file=sys.stderr)
+            print(f"  Successful: {successful}", file=sys.stderr)
+            print(f"  Failed: {failed}", file=sys.stderr)
+            print(f"  Success rate: {successful/len(input_dict)*100:.1f}%", file=sys.stderr)
+
+        return results
diff --git a/scripts/omml_mathml2latex/builders/__init__.py b/scripts/omml_mathml2latex/builders/__init__.py
new file mode 100644
index 0000000..364ae09
--- /dev/null
+++ b/scripts/omml_mathml2latex/builders/__init__.py
@@ -0,0 +1,12 @@
+"""
+Builder classes for fluent construction of LaTeX and MathML expressions.
+
+This package contains builder classes that provide fluent interfaces for
+constructing complex expressions.
+"""
+
+from .latex_builder import LaTeXBuilder
+
+__all__ = [
+    'LaTeXBuilder',
+]
diff --git a/scripts/omml_mathml2latex/builders/latex_builder.py b/scripts/omml_mathml2latex/builders/latex_builder.py
new file mode 100644
index 0000000..d36d2de
--- /dev/null
+++ b/scripts/omml_mathml2latex/builders/latex_builder.py
@@ -0,0 +1,320 @@
+"""
+LaTeX Builder for fluent construction of LaTeX expressions.
+
+This builder provides a fluent interface for constructing complex LaTeX
+expressions with proper brace balancing and formatting.
+"""
+
+from typing import List, Optional
+
+
+class LaTeXBuilder:
+    """
+    Fluent builder for constructing LaTeX expressions.
+
+    This builder provides method chaining for building complex LaTeX
+    expressions with automatic brace balancing and spacing optimization.
+
+    Examples:
+        Simple fraction:
+            >>> builder = LaTeXBuilder()
+            >>> result = builder.add_fraction("a", "b").build()
+            >>> result
+            '\\frac{a}{b}'
+
+        Superscript:
+            >>> builder = LaTeXBuilder()
+            >>> result = builder.add_superscript("x", "2").build()
+            >>> result
+            'x^{2}'
+
+        Complex expression:
+            >>> builder = LaTeXBuilder()
+            >>> result = (builder
+            ...     .add_command("sin", "x")
+            ...     .add_text(" + ")
+            ...     .add_fraction("1", "2")
+            ...     .build())
+            >>> result
+            '\\sin{x} + \\frac{1}{2}'
+
+        Nested fractions:
+            >>> builder = LaTeXBuilder()
+            >>> inner = LaTeXBuilder().add_fraction("a", "b").build()
+            >>> result = builder.add_fraction(inner, "c").build()
+            >>> result
+            '\\frac{\\frac{a}{b}}{c}'
+    """
+
+    def __init__(self):
+        """Initialize the LaTeX builder."""
+        self._parts: List[str] = []
+
+    def add_text(self, text: str) -> 'LaTeXBuilder':
+        """
+        Add raw text to the LaTeX expression.
+
+        Args:
+            text: The text to add (no processing)
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_text("x + y").build()
+            'x + y'
+        """
+        if text:
+            self._parts.append(text)
+        return self
+
+    def add_command(self, cmd: str, arg: str) -> 'LaTeXBuilder':
+        """
+        Add a LaTeX command with one argument: \\cmd{arg}
+
+        Args:
+            cmd: The command name (without backslash)
+            arg: The argument content
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_command("sin", "x").build()
+            '\\sin{x}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_command("text", "hello").build()
+            '\\text{hello}'
+        """
+        self._parts.append(f"\\{cmd}{{{arg}}}")
+        return self
+
+    def add_fraction(self, numerator: str, denominator: str) -> 'LaTeXBuilder':
+        """
+        Add a fraction: \\frac{numerator}{denominator}
+
+        Args:
+            numerator: The numerator expression
+            denominator: The denominator expression
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_fraction("a", "b").build()
+            '\\frac{a}{b}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_fraction("x + 1", "y - 2").build()
+            '\\frac{x + 1}{y - 2}'
+        """
+        self._parts.append(f"\\frac{{{numerator}}}{{{denominator}}}")
+        return self
+
+    def add_superscript(self, base: str, superscript: str) -> 'LaTeXBuilder':
+        """
+        Add a superscript: base^{superscript}
+
+        Args:
+            base: The base expression
+            superscript: The superscript expression
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_superscript("x", "2").build()
+            'x^{2}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_superscript("e", "i\\pi").build()
+            'e^{i\\pi}'
+        """
+        self._parts.append(f"{base}^{{{superscript}}}")
+        return self
+
+    def add_subscript(self, base: str, subscript: str) -> 'LaTeXBuilder':
+        """
+        Add a subscript: base_{subscript}
+
+        Args:
+            base: The base expression
+            subscript: The subscript expression
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_subscript("x", "1").build()
+            'x_{1}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_subscript("a", "i+j").build()
+            'a_{i+j}'
+        """
+        self._parts.append(f"{base}_{{{subscript}}}")
+        return self
+
+    def add_subscript_superscript(self, base: str, subscript: str, superscript: str) -> 'LaTeXBuilder':
+        """
+        Add both subscript and superscript: base_{subscript}^{superscript}
+
+        Args:
+            base: The base expression
+            subscript: The subscript expression
+            superscript: The superscript expression
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_subscript_superscript("x", "1", "2").build()
+            'x_{1}^{2}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_subscript_superscript("R", "i", "j").build()
+            'R_{i}^{j}'
+        """
+        self._parts.append(f"{base}_{{{subscript}}}^{{{superscript}}}")
+        return self
+
+    def add_sqrt(self, content: str, root: Optional[str] = None) -> 'LaTeXBuilder':
+        """
+        Add a square root or nth root.
+
+        Args:
+            content: The content under the root
+            root: Optional root index (None for square root)
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_sqrt("x").build()
+            '\\sqrt{x}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_sqrt("x", "3").build()
+            '\\sqrt[3]{x}'
+        """
+        if root:
+            self._parts.append(f"\\sqrt[{root}]{{{content}}}")
+        else:
+            self._parts.append(f"\\sqrt{{{content}}}")
+        return self
+
+    def add_environment(self, env: str, content: str) -> 'LaTeXBuilder':
+        """
+        Add a LaTeX environment: \\begin{env}content\\end{env}
+
+        Args:
+            env: The environment name
+            content: The environment content
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_environment("cases", "x & x > 0 \\\\\\\\ 0 & x \\\\leq 0").build()
+            '\\begin{cases}x & x > 0 \\\\\\\\ 0 & x \\\\leq 0\\end{cases}'
+        """
+        self._parts.append(f"\\begin{{{env}}}{content}\\end{{{env}}}")
+        return self
+
+    def add_delimiter_pair(self, left: str, content: str, right: str) -> 'LaTeXBuilder':
+        """
+        Add delimiter pair: \\left{left}content\\right{right}
+
+        Args:
+            left: The left delimiter
+            content: The content between delimiters
+            right: The right delimiter
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_delimiter_pair("(", "x + y", ")").build()
+            '\\left(x + y\\right)'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_delimiter_pair("\\\\{", "a, b, c", "\\\\}").build()
+            '\\left\\\\{a, b, c\\right\\\\}'
+        """
+        self._parts.append(f"\\left{left}{content}\\right{right}")
+        return self
+
+    def add_matrix(self, rows: List[List[str]], environment: str = "matrix") -> 'LaTeXBuilder':
+        """
+        Add a matrix environment.
+
+        Args:
+            rows: List of rows, each row is a list of cell contents
+            environment: The matrix environment (matrix, pmatrix, bmatrix, etc.)
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> rows = [["a", "b"], ["c", "d"]]
+            >>> builder.add_matrix(rows, "pmatrix").build()
+            '\\begin{pmatrix}a & b \\\\\\\\ c & d\\end{pmatrix}'
+        """
+        matrix_content = " \\\\ ".join(
+            " & ".join(cell for cell in row)
+            for row in rows
+        )
+        self._parts.append(f"\\begin{{{environment}}}{matrix_content}\\end{{{environment}}}")
+        return self
+
+    def clear(self) -> 'LaTeXBuilder':
+        """
+        Clear all parts (reset the builder).
+
+        Returns:
+            Self for method chaining
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_text("x").clear().add_text("y").build()
+            'y'
+        """
+        self._parts.clear()
+        return self
+
+    def build(self) -> str:
+        """
+        Build the final LaTeX string.
+
+        Returns:
+            The constructed LaTeX expression
+
+        Examples:
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_fraction("a", "b").build()
+            '\\frac{a}{b}'
+
+            >>> builder = LaTeXBuilder()
+            >>> builder.add_text("x").add_text(" + ").add_text("y").build()
+            'x + y'
+        """
+        return "".join(self._parts)
+
+    def __str__(self) -> str:
+        """String representation (same as build())."""
+        return self.build()
+
+    def __repr__(self) -> str:
+        """Debug representation."""
+        return f"LaTeXBuilder(parts={len(self._parts)})"
diff --git a/scripts/omml_mathml2latex/compat/__init__.py b/scripts/omml_mathml2latex/compat/__init__.py
new file mode 100644
index 0000000..66c97ad
--- /dev/null
+++ b/scripts/omml_mathml2latex/compat/__init__.py
@@ -0,0 +1,11 @@
+"""
+Compatibility layer for backward compatibility.
+
+This package provides adapters and compatibility shims for the original API.
+"""
+
+from .legacy_adapter import LegacyMathMLToTeXConverter
+
+__all__ = [
+    'LegacyMathMLToTeXConverter',
+]
diff --git a/scripts/omml_mathml2latex/compat/legacy_adapter.py b/scripts/omml_mathml2latex/compat/legacy_adapter.py
new file mode 100644
index 0000000..836ca07
--- /dev/null
+++ b/scripts/omml_mathml2latex/compat/legacy_adapter.py
@@ -0,0 +1,1055 @@
+"""
+Legacy adapter for backward compatibility.
+
+This module provides a drop-in replacement for the original MathMLToTeXConverter
+that internally uses the refactored architecture.
+
+Examples:
+    Legacy API usage:
+        >>> from omml2tex.compat import LegacyMathMLToTeXConverter
+        >>> converter = LegacyMathMLToTeXConverter(subject_mode='chemistry')
+        >>> latex = converter.convert('<math><mi>H</mi><mn>2</mn><mi>O</mi></math>')
+        >>> latex
+        '\\mathrm{H}_2\\mathrm{O}'
+"""
+
+from typing import Optional, List, Tuple
+from lxml import etree as ET
+
+from ..core.interfaces import Strategy
+from ..utils.debug import debug_print
+from ..strategies import (
+    MathStrategy,
+    ChemistryStrategy,
+    PhysicsStrategy,
+    StatisticsStrategy,
+    StrategyFactory,
+)
+from ..visitors import (
+    VisitorRegistry,
+    MiVisitor,
+    MoVisitor,
+    MnVisitor,
+    MfracVisitor,
+    MsupVisitor,
+    MsubVisitor,
+    MrowVisitor,
+    MsqrtVisitor,
+    MrootVisitor,
+    MsubsupVisitor,
+    MoverVisitor,
+    MunderVisitor,
+    MunderoverVisitor,
+    MfencedVisitor,
+    MtextVisitor,
+    MtableVisitor,
+    MtrVisitor,
+    MtdVisitor,
+    MspaceVisitor,
+    MstyleVisitor,
+    MerrorVisitor,
+    MencloseVisitor,
+    MmultiscriptsVisitor,
+    MpaddedVisitor,
+    MphantomVisitor,
+    MactionVisitor,
+    MsVisitor,
+    MglyphVisitor,
+    MlabeledtrVisitor,
+    MaligngroupVisitor,
+    MalignmarkVisitor,
+)
+
+
+class LegacyMathMLToTeXConverter:
+    """
+    Backward-compatible adapter for the original MathMLToTeXConverter.
+
+    This class maintains the same API as the original converter but internally
+    uses the refactored visitor/strategy architecture.
+
+    Args:
+        wrap_identifiers_in_mathrm: Whether to wrap multi-char identifiers in \\mathrm{}
+        prefer_xlongequal: Whether to use \\xlongequal for reaction arrows
+        subject_mode: Subject-specific formatting mode (auto, math, physics, chemistry, statistics)
+
+    Examples:
+        Basic usage:
+            >>> converter = LegacyMathMLToTeXConverter()
+            >>> latex = converter.convert('<math><mi>sin</mi><mi>x</mi></math>')
+            >>> latex
+            '\\sin x'
+
+        Chemistry mode:
+            >>> converter = LegacyMathMLToTeXConverter(subject_mode='chemistry')
+            >>> latex = converter.convert('<math><mi>Fe</mi></math>')
+            >>> latex
+            '\\mathrm{Fe}'
+    """
+
+    def __init__(
+        self,
+        wrap_identifiers_in_mathrm: bool = False,  # CRITICAL FIX: Default should be False like original
+        prefer_xlongequal: bool = True,
+        subject_mode: str = "auto",
+        universal_delimiter_scaling: bool = True,  # NEW: Add \left\right to ALL delimiters
+    ) -> None:
+        """Initialize the legacy converter with original API parameters."""
+        self.wrap_identifiers_in_mathrm = wrap_identifiers_in_mathrm
+        self.prefer_xlongequal = prefer_xlongequal
+        self.subject_mode = subject_mode
+        self.universal_delimiter_scaling = universal_delimiter_scaling
+
+        # Internal state (mimics original converter)
+        self._script_context_stack = []
+        self._symbol_contexts = {}
+        self._fraction_symbols = set()
+        self._set_theory_mode = False
+        self._equation_symbols = set()
+        self._equation_text = ""
+        self._uniform_equation_color = ""
+        self._suppress_leaf_colors = False
+        self._uniform_background_color = ""  # Background/highlight color from OMML
+
+        # Initialize strategy based on subject mode
+        self._strategy = self._create_strategy()
+
+        # Initialize visitor registry with all visitors
+        self._visitor_registry = self._create_visitor_registry()
+
+    def _create_strategy(self) -> Strategy:
+        """
+        Create conversion strategy based on subject mode.
+
+        Returns:
+            Strategy instance for the configured subject mode
+        """
+        if self.subject_mode == "auto":
+            # Auto-detection will be done per equation in convert()
+            return MathStrategy(wrap_identifiers_in_mathrm=self.wrap_identifiers_in_mathrm)  # Default fallback
+        elif self.subject_mode == "chemistry":
+            return ChemistryStrategy()
+        elif self.subject_mode == "physics":
+            return PhysicsStrategy()
+        elif self.subject_mode == "statistics":
+            return StatisticsStrategy()
+        elif self.subject_mode == "math":
+            return MathStrategy(wrap_identifiers_in_mathrm=self.wrap_identifiers_in_mathrm)
+        else:
+            # Unknown mode - default to math
+            return MathStrategy(wrap_identifiers_in_mathrm=self.wrap_identifiers_in_mathrm)
+
+    def _create_visitor_registry(self, context: 'ConversionContext' = None) -> VisitorRegistry:
+        """
+        Create and populate visitor registry with all known visitors.
+
+        Args:
+            context: Optional conversion context to pass to all visitors
+
+        Returns:
+            Configured VisitorRegistry instance
+        """
+        registry = VisitorRegistry(context)
+
+        # Register all MathML element visitors
+        # Namespace handling: strip namespace prefix if present
+        registry.register('mi', MiVisitor)
+        registry.register('mo', MoVisitor)
+        registry.register('mn', MnVisitor)
+        registry.register('mfrac', MfracVisitor)
+        registry.register('msup', MsupVisitor)
+        registry.register('msub', MsubVisitor)
+        registry.register('mrow', MrowVisitor)
+        registry.register('msqrt', MsqrtVisitor)
+        registry.register('mroot', MrootVisitor)
+        registry.register('msubsup', MsubsupVisitor)
+        registry.register('mover', MoverVisitor)
+        registry.register('munder', MunderVisitor)
+        registry.register('munderover', MunderoverVisitor)
+        registry.register('mfenced', MfencedVisitor)
+        registry.register('mtext', MtextVisitor)
+        registry.register('mtable', MtableVisitor)
+        registry.register('mtr', MtrVisitor)
+        registry.register('mtd', MtdVisitor)
+        registry.register('mspace', MspaceVisitor)
+        registry.register('mstyle', MstyleVisitor)
+        registry.register('merror', MerrorVisitor)
+        registry.register('menclose', MencloseVisitor)
+        registry.register('mmultiscripts', MmultiscriptsVisitor)
+        registry.register('mpadded', MpaddedVisitor)
+        registry.register('mphantom', MphantomVisitor)
+        registry.register('maction', MactionVisitor)
+        registry.register('ms', MsVisitor)
+        registry.register('mglyph', MglyphVisitor)
+        registry.register('mlabeledtr', MlabeledtrVisitor)
+        registry.register('maligngroup', MaligngroupVisitor)
+        registry.register('malignmark', MalignmarkVisitor)
+
+        # Use mrow as default visitor (handles container elements like <math>)
+        registry.set_default_visitor(MrowVisitor)
+
+        return registry
+
+    def convert(self, mathml_xml: str) -> str:
+        """
+        Convert MathML XML to LaTeX.
+
+        Args:
+            mathml_xml: MathML XML string
+
+        Returns:
+            LaTeX string
+
+        Raises:
+            ValueError: If MathML XML is invalid
+
+        Examples:
+            >>> converter = LegacyMathMLToTeXConverter()
+            >>> converter.convert('<math><mi>x</mi></math>')
+            'x'
+        """
+        # Store original equation text for context analysis
+        self._equation_text = mathml_xml
+
+        try:
+            # IMPORTANT: Preserve NBSP characters before XML parsing
+            # lxml normalizes U+00A0 (NBSP) to regular space during parsing
+            mathml_bytes = mathml_xml.encode("utf-8")
+            mathml_bytes = mathml_bytes.replace(b'\xc2\xa0', b'&#160;')
+            doc = ET.fromstring(mathml_bytes)
+        except ET.XMLSyntaxError as e:
+            raise ValueError(f"Invalid MathML XML: {e}") from e
+
+        # CRITICAL FIX: Word embeds "&" as column separators in equation arrays
+        # (e.g., <m:t>-x,  &amp;x&lt;0</m:t> for piecewise functions)
+        # The XSLT converts this to a single <mtd> containing <mo>&</mo> operators
+        # We need to split at these points to create separate table columns
+        self._fix_eqarr_column_separators(doc)
+
+        # Reset context tracking for new equation
+        self._symbol_contexts = {}
+        self._fraction_symbols = set()
+        self._set_theory_mode = False
+        self._equation_symbols = set()
+        self._uniform_equation_color = ""
+        self._suppress_leaf_colors = False
+        self._uniform_background_color = ""
+
+        # Detect background color from data-background attribute (set by styling_postprocessor)
+        background_attr = doc.get('data-background')
+        if background_attr:
+            self._uniform_background_color = background_attr
+
+        # Analyze equation context to detect set theory mode
+        self._analyze_equation_context(doc)
+
+        # Create conversion context for this equation
+        from ..core.context import ConversionContext
+        context = ConversionContext(
+            input_type='mathml',
+            subject_mode=self.subject_mode,
+            wrap_identifiers=self.wrap_identifiers_in_mathrm,
+            prefer_xlongequal=True
+        )
+
+        # Update visitor registry with new context
+        self._visitor_registry.context = context
+
+        # Step 0: Detect uniform color across entire equation (optimization)
+        from ..utils.color_helpers import detect_uniform_color
+        uniform_color = detect_uniform_color(doc)
+        if uniform_color:
+            # Entire equation uses same color - suppress individual leaf colors
+            # and wrap entire result at the end
+            self._uniform_equation_color = uniform_color
+            self._suppress_leaf_colors = True
+            # Also update context
+            context.uniform_equation_color = uniform_color
+            context.suppress_leaf_colors = True
+
+        # DISABLED: Auto-detect strategy (user wants full control via mathvariant only)
+        # Auto-detection was overriding user's explicit mathvariant settings
+        # if self.subject_mode == "auto":
+        #     self._strategy = StrategyFactory.auto_detect_strategy(mathml_xml)
+
+        # CRITICAL: Pass wrap_identifiers flag to strategy (especially for auto-detected strategies)
+        if hasattr(self._strategy, 'set_wrap_identifiers_flag'):
+            self._strategy.set_wrap_identifiers_flag(self.wrap_identifiers_in_mathrm)
+
+        # CRITICAL: Give strategy access to equation text for context detection
+        if hasattr(self._strategy, 'set_equation_text'):
+            self._strategy.set_equation_text(mathml_xml)
+
+        # CRITICAL: Give strategy access to root element for chemistry detection
+        if hasattr(self._strategy, 'set_root_element'):
+            self._strategy.set_root_element(doc)
+
+        # CRITICAL: Store converter context in strategy for color suppression
+        # This allows all visitors (including child visitors) to access the suppression flag
+        # since the strategy is shared across all visitors in the conversion tree
+        self._strategy._converter_context = self
+
+        # Handle <math> root element - process its children
+        # The <math> element is a container element, similar to <mrow>
+        if self._get_local_name(doc.tag) == 'math':
+            children = list(doc)
+
+            if not children:
+                # Empty <math> element
+                latex = ""
+            elif len(children) == 1:
+                # Single child - convert directly without adding spaces
+                latex = self._convert_node(children[0])
+            elif len(children) == 3 and self._is_prescript_pattern(children):
+                # Prescript pattern: <math><mrow>sub</mrow><mrow>sup</mrow><mrow>base</mrow></math>
+                # This comes from OMML <sPre> element which places scripts on LEFT side
+                # Result: _{sub}^{sup}base (no leading {} needed for MathJax)
+                left_sub = self._convert_node(children[0])
+                left_sup = self._convert_node(children[1])
+                base = self._convert_node(children[2])
+                latex = f"_{{{left_sub}}}^{{{left_sup}}}{base}"
+            else:
+                # Multiple children - process with intelligent spacing
+                # IMPORTANT: Check for fragmented functions BEFORE converting each child
+                # This handles cases like: <mi>c</mi><mi>o</mi><mi>s</mi> → \cos
+                parts = []
+                i = 0
+                while i < len(children):
+                    if not isinstance(children[i].tag, str):
+                        i += 1
+                        continue
+
+                    # Check for fragmented function starting at position i
+                    function_name, consumed = self._check_fragmented_function_at_level(children, i)
+
+                    if function_name:
+                        # Found fragmented function! Add it as \funcname
+                        parts.append(f"\\{function_name}")
+                        i += consumed  # Skip the consumed elements
+                    else:
+                        # Normal element - convert and add
+                        part = self._convert_node(children[i])
+                        # Skip LaTeX space commands (backslash-space) since we join with spaces anyway
+                        # This avoids double-spacing: `\sin ` + space + `\ ` = `\sin  \ `
+                        if part and part.strip() not in ['', '\\']:
+                            # Keep the part unless it's just whitespace or lone backslash
+                            parts.append(part)
+                        i += 1
+
+                # Determine separator based on content pattern
+                # Check if this looks like a chemical formula (no spaces)
+                # vs regular math expression (with spaces)
+                if self._is_chemical_formula_pattern(parts):
+                    # Chemical formula: H2O → no spaces
+                    latex = ''.join(parts)
+                else:
+                    # Regular math: sin x → with spaces
+                    latex = ' '.join(parts)
+        else:
+            # Non-math root (shouldn't happen, but handle it)
+            latex = self._convert_node(doc)
+
+        # Step 2.5: Wrap entire equation with uniform color if detected
+        # BUT: Skip wrapping if color is black (default color)
+        if self._uniform_equation_color:
+            from ..utils.color_helpers import wrap_with_uniform_color
+            latex = wrap_with_uniform_color(latex, self._uniform_equation_color)
+            # Reset suppression flag for next equation
+            self._suppress_leaf_colors = False
+            self._uniform_equation_color = ""
+
+        # Step 2.6: Wrap entire equation with background color if detected
+        # This uses \bbox[color,padding]{content} from amsmath
+        if self._uniform_background_color:
+            from ..utils.color_helpers import wrap_with_background_color
+            latex = wrap_with_background_color(latex, self._uniform_background_color)
+            # Reset for next equation
+            self._uniform_background_color = ""
+
+        # Step 3: Apply full 7-step post-processing pipeline
+        # Import chemical elements and units for post-processor
+        from ..data import CHEMICAL_ELEMENTS, COMMON_UNITS
+        from ..converters.post_processor import PostProcessor
+
+        post_processor = PostProcessor(
+            chemical_elements=CHEMICAL_ELEMENTS,
+            common_units=COMMON_UNITS,
+            subject_mode=self._strategy.name  # Pass actual strategy name (after auto-detection)
+        )
+        latex = post_processor.process(
+            latex,
+            set_theory_mode=self._set_theory_mode,
+            subject_mode=self.subject_mode,
+            skip_delimiter_processing=self.universal_delimiter_scaling  # Skip if using new processor
+        )
+
+        # Step 4: Apply universal delimiter scaling if enabled
+        # Phase 3 Fix: Use new delimiter_pairing_processor which respects __DELIM__ markers
+        if self.universal_delimiter_scaling:
+            from ..converters.delimiter_pairing_processor import add_universal_left_right
+            latex = add_universal_left_right(latex, debug=False)
+
+            # Step 4.1: Resolve brace markers (__LBRACE__/__RBRACE__)
+            # NEW: Context-aware brace marker resolution
+            # This converts source braces (from DOCX) to proper LaTeX delimiters
+            # while preserving generated braces in LaTeX commands (e.g., \mathrm{...})
+            from ..converters.brace_marker_resolver import BraceMarkerResolver
+            brace_resolver = BraceMarkerResolver(debug=False)
+            latex = brace_resolver.resolve(latex)
+
+            # Step 4.5: Fix double backslashes created by delimiter pairing
+            # The delimiter pairing processor can create \\left\{ when processing escaped braces
+            # This cleanup removes double backslashes before LaTeX commands, preserving only
+            # line break double backslashes (\\ followed by space)
+            # FIX BUG-007: Also match \\ before { or } (escaped braces)
+            import re
+            latex = re.sub(
+                r'\\\\(?=[a-zA-Z{])',  # Match \\ followed by a letter or { (lookahead)
+                r'\\',                  # Replace with single backslash
+                latex
+            )
+
+            # Step 4.6: [DEPRECATED - Replaced by brace_marker_resolver]
+            # Old regex-based brace handling - now handled by BraceMarkerResolver
+            # The new marker-based system properly distinguishes source braces from
+            # generated braces and handles pairing with context awareness
+            # escaped_delimiter_pairs = [
+            #     (r'(?<!\\left)\\\{', r'\\\}(?!\\right)', r'\\left\\{', r'\\right\\}'),  # Braces
+            # ]
+            # for open_pattern, close_pattern, left_cmd, right_cmd in escaped_delimiter_pairs:
+            #     pattern = f'{open_pattern}\\s*(.+?)\\s*{close_pattern}'
+            #     replacement = f'{left_cmd} \\1 {right_cmd}'
+            #     latex = re.sub(pattern, replacement, latex)
+
+            # Step 4.7: Fix mismatched vertical bar delimiters
+            # This handles cases like \mid 25,26| where plain text |...| gets confused
+            # The opening | becomes \mid (operator) but closing stays | (delimiter)
+            # Pattern: \mid content| → \left| content \right|
+            # IMPORTANT: Don't change \mid inside parentheses (conditional probability P(A \mid B))
+            # or inside set notation (\left\{ x \mid x>0 \right\})
+            # Strategy: Only fix if \mid is at start of equation (standalone absolute value)
+            if latex.startswith('\\mid ') and latex.endswith('|'):
+                # Standalone \mid...| expression → convert to \left|...\right|
+                latex = re.sub(
+                    r'^\\mid\s+(.+?)\|$',  # ^match start, content, end| (no space before |)
+                    r'\\left| \1 \\right|',
+                    latex
+                )
+
+            # Step 4.8: Universal delimiter scaling (Phase 3)
+            # Add \left\right to LaTeX delimiter commands that don't have them
+            # This catches remaining delimiters like \langle, \rangle, \|
+            # that weren't created with proper OMML delimiter structures
+
+            # Handle \langle...\rangle (angle brackets)
+            if r'\langle' in latex and r'\left\langle' not in latex:
+                latex = re.sub(
+                    r'\\langle\s*(.+?)\s*\\rangle',
+                    r'\\left\\langle \1 \\right\\rangle',
+                    latex
+                )
+
+            # Handle \|...\| (double vertical bars for norm notation)
+            if r'\|' in latex and r'\left\|' not in latex:
+                latex = re.sub(
+                    r'\\\|\s*(.+?)\s*\\\|',
+                    r'\\left\\| \1 \\right\\|',
+                    latex
+                )
+
+        # Clean up and return
+        # Replace all newlines with spaces (important for inline equations)
+        latex = latex.replace('\n', ' ')
+        return latex.strip()
+
+    def _post_process_consecutive_equals(self, latex: str) -> str:
+        """
+        Post-process the entire LaTeX output to fix consecutive equals patterns.
+
+        This handles cases where equals signs are split across multiple mtext elements,
+        like '+3C=' followed by '\\xlongequal{\\quad}', which should become
+        '+3C \\xlongequal{\\quad}' (remove the extra =).
+
+        Also ensures all xlongequal instances have proper [\quad] brackets.
+
+        Args:
+            latex: Input LaTeX string
+
+        Returns:
+            LaTeX string with consecutive equals fixed
+        """
+        import re
+
+        # Pattern to match: equals sign followed by \xlongequal
+        # This handles: "=" + space + "\xlongequal" or "=\xlongequal"
+        pattern = r'=\s*\\xlongequal\{([^}]*)\}'
+
+        # Replace with just the xlongequal (remove the leading =)
+        result = re.sub(pattern, r'\\xlongequal{\1}', latex)
+
+        # Safety net: Also catch raw consecutive equals in final output
+        # Pattern for 2+ consecutive equals signs (with optional spaces)
+        pattern2 = r'=\s*=\s*=+'
+        result = re.sub(pattern2, r'\\xlongequal[\\quad]{}', result)
+
+        # Fix xlongequal instances that don't have brackets (but preserve existing brackets)
+        # Only match \xlongequal{content} where there are NO brackets at all
+        pattern3 = r'\\xlongequal(?!\[)(\{[^}]*\})'
+        result = re.sub(pattern3, r'\\xlongequal[\\quad]\1', result)
+
+        # Fix xlongequal instances that have empty brackets
+        pattern4 = r'\\xlongequal\[\]\{([^}]*)\}'
+        result = re.sub(pattern4, r'\\xlongequal[\\quad]{\1}', result)
+
+        return result
+
+    def _process_delimiters(self, latex: str) -> str:
+        """
+        Post-process LaTeX to add \\left and \\right to delimiters for proper scaling.
+
+        This method processes __DELIM__ markers added during conversion and determines
+        which delimiters need \left/\right commands based on their content.
+
+        Based on original converter lines 5274-5509.
+        """
+        import re
+
+        # Find all marked delimiters
+        delim_pattern = r'__DELIM__([()[\]{}|])__DELIM__'
+        delimiters = []
+        for match in re.finditer(delim_pattern, latex):
+            delimiters.append({
+                'char': match.group(1),
+                'start': match.start(),
+                'end': match.end(),
+                'full_match': match.group(0)
+            })
+
+        if not delimiters:
+            return latex
+
+        # Dictionary of delimiter pairs
+        delimiter_pairs = {
+            '(': ')',
+            '[': ']',
+            '{': '}',
+            '|': '|'
+        }
+
+        # Define opening and closing delimiters
+        opening_delims = set(['(', '[', '{', '|'])
+        closing_delims = set([')', ']', '}', '|'])
+
+        # Stack to track opening delimiters
+        stack = []
+        pairs = []
+
+        # First pass: identify delimiter pairs
+        for delim in delimiters:
+            char = delim['char']
+
+            # Special handling for pipe - it pairs with itself
+            if char == '|':
+                pipe_in_stack = False
+                for i, stacked_delim in enumerate(stack):
+                    if stacked_delim['char'] == '|':
+                        opening_delim = stack.pop(i)
+                        pairs.append((opening_delim, delim))
+                        pipe_in_stack = True
+                        break
+                if not pipe_in_stack:
+                    stack.append(delim)
+            elif char in opening_delims:
+                stack.append(delim)
+            elif char in closing_delims:
+                if stack:
+                    opening_delim = stack.pop()
+                    pairs.append((opening_delim, delim))
+
+        # Build replacement list
+        result = latex
+        all_replacements = []
+
+        for opening, closing in pairs:
+            # Extract content between delimiters
+            start_pos = opening['end']
+            end_pos = closing['start']
+            content = latex[start_pos:end_pos]
+
+            # Check if content needs scaling
+            if opening['char'] == '|' or closing['char'] == '|':
+                needs_scaling = True
+            else:
+                needs_scaling = self._needs_delimiter_scaling(content)
+
+            if needs_scaling:
+                all_replacements.append((closing['start'], closing['end'], closing['char'], True))
+                all_replacements.append((opening['start'], opening['end'], opening['char'], True))
+            else:
+                all_replacements.append((closing['start'], closing['end'], closing['char'], False))
+                all_replacements.append((opening['start'], opening['end'], opening['char'], False))
+
+        # Sort by position (descending) to process from end to beginning
+        all_replacements.sort(key=lambda x: x[0], reverse=True)
+
+        # Apply replacements
+        for start, end, char, scale in all_replacements:
+            if scale:
+                if char in ['(', '[', '{']:
+                    latex_char = '\\{' if char == '{' else char
+                    replacement = f"\\left{latex_char}"
+                elif char == '|':
+                    # Determine if opening or closing by checking position
+                    is_opening = any(opening['start'] == start for opening, closing in pairs)
+                    replacement = "\\left|" if is_opening else "\\right|"
+                else:
+                    latex_char = '\\}' if char == '}' else char
+                    replacement = f"\\right{latex_char}"
+            else:
+                replacement = char
+
+            result = result[:start] + replacement + result[end:]
+
+        # Cleanup: Remove any remaining __DELIM__ markers
+        result = re.sub(r'__DELIM__(.+?)__DELIM__', r'\1', result)
+        result = re.sub(r'__DELIM__', '', result)
+
+        return result
+
+    def _needs_delimiter_scaling(self, content: str) -> bool:
+        """
+        Determine if content between delimiters needs scaling (\left and \right).
+
+        Based on original converter lines 6482-6507.
+        """
+        scaling_indicators = [
+            '\\frac', '\\dfrac', '\\tfrac',  # Fractions
+            '\\sum', '\\prod', '\\int',      # Large operators
+            '\\sqrt',                        # Square roots
+            '\\binom',                       # Binomial coefficients
+            '\\overset', '\\underset',       # Over/under sets
+            '\\limits',                      # Limits
+            '\\Big', '\\big',                # Already scaled content
+        ]
+
+        # Check for scaling indicators
+        if any(indicator in content for indicator in scaling_indicators):
+            return True
+
+        # Check for nested delimiters
+        nested_delims = content.count('(') + content.count('[') + content.count('{')
+        if nested_delims > 0:
+            return True
+
+        # Check for multiple script levels
+        script_levels = content.count('_') + content.count('^')
+        if script_levels > 1:
+            return True
+
+        # Long expressions often benefit from scaling
+        if len(content) > 20:
+            return True
+
+        return False
+
+    def _post_process_xlongequal_spacing(self, latex: str) -> str:
+        r"""
+        Remove extra spaces in xlongequal bracket and brace content.
+
+        Converts patterns like:
+        - \xlongequal[d e f g]{abc} → \xlongequal[defg]{abc}
+        - \xlongequal[a b c]{x y z} → \xlongequal[abc]{xyz}
+
+        Args:
+            latex: Input LaTeX string
+
+        Returns:
+            LaTeX string with spaces removed from xlongequal content
+        """
+        import re
+
+        def remove_spaces_in_xlongequal(match):
+            bracket_content = match.group(1)
+            brace_content = match.group(2)
+            # Remove all whitespace
+            bracket_clean = re.sub(r'\s+', '', bracket_content)
+            brace_clean = re.sub(r'\s+', '', brace_content)
+            return f'\\xlongequal[{bracket_clean}]{{{brace_clean}}}'
+
+        # Match \xlongequal[...]{...} and remove spaces
+        result = re.sub(r'\\xlongequal\[([^\]]*)\]\{([^}]*)\}', remove_spaces_in_xlongequal, latex)
+
+        return result
+
+    def _check_fragmented_function_at_level(self, children: List, start_idx: int) -> Tuple[str, int]:
+
+        """
+        Check if elements starting at start_idx form a fragmented function.
+
+        Detects patterns like:
+        - <mi>c</mi><mi>o</mi><mi>s</mi> → "cos", 3
+        - <mi>s</mi><mi>i</mi><mi>n</mi> → "sin", 3
+        - <mi>t</mi><mi>a</mi><mi>n</mi> → "tan", 3
+        - <mrow><mi>s</mi></mrow><mrow><mi>i</mi></mrow><mrow><mi>n</mi></mrow> → "sin", 3
+
+        Args:
+            children: List of child elements
+            start_idx: Index to start checking from
+
+        Returns:
+            Tuple of (function_name, elements_consumed) or ("", 0) if no function found
+        """
+        from ..utils import text_content as _text_content
+        from ..data import MATH_FUNCTIONS
+
+        if start_idx >= len(children):
+            return "", 0
+
+        letters = []
+        elements_checked = 0
+
+        for i in range(start_idx, len(children)):
+            child = children[i]
+            local_tag = self._get_local_name(child.tag)
+
+            # Case 1: Direct <mi> element with single letter
+            if local_tag == "mi":
+                content = _text_content(child).strip()
+                # Must be exactly one letter
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                    elements_checked += 1
+                else:
+                    # Not a single letter, stop checking
+                    break
+            # Case 2: <mrow> with single <mi> child (MathJax pattern)
+            elif (local_tag == "mrow" and
+                  len(list(child)) == 1 and
+                  self._get_local_name(list(child)[0].tag) == "mi"):
+                mi_element = list(child)[0]
+                content = _text_content(mi_element).strip()
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                    elements_checked += 1
+                else:
+                    # Not a single letter, stop checking
+                    break
+            else:
+                # Not an mi or mrow-mi element, stop checking
+                break
+
+        # Need at least 2 letters to form a function
+        if len(letters) < 2:
+            return "", 0
+
+        # Try different combinations, starting from the longest possible
+        for length in range(min(len(letters), 6), 1, -1):
+            potential_function = ''.join(letters[:length])
+            if potential_function in MATH_FUNCTIONS:
+                return potential_function, length
+
+        return "", 0
+
+    def _is_prescript_pattern(self, children: list) -> bool:
+        """
+        Detect if children match the prescript pattern from OMML <sPre> element.
+
+        Prescript pattern: exactly 3 consecutive <mrow> elements
+        - First <mrow>: left subscript
+        - Second <mrow>: left superscript
+        - Third <mrow>: base element
+
+        This pattern is generated by Microsoft's OMML→MathML transformation
+        for <sPre> (prescript) elements.
+
+        Args:
+            children: List of child elements
+
+        Returns:
+            True if this matches prescript pattern
+        """
+        if len(children) != 3:
+            return False
+
+        # All 3 children must be <mrow> elements
+        return all(
+            isinstance(child.tag, str) and self._get_local_name(child.tag) == 'mrow'
+            for child in children
+        )
+
+    def _is_chemical_formula_pattern(self, parts: List[str]) -> bool:
+        """
+        Detect if parts represent a chemical formula pattern.
+
+        Chemical formulas typically have:
+        - Element symbols wrapped in \\mathrm{}
+        - Numbers (stoichiometric coefficients)
+        - Superscripts for charges (ions)
+
+        Args:
+            parts: List of LaTeX parts from converted children
+
+        Returns:
+            True if pattern looks like a chemical formula
+        """
+        if not parts:
+            return False
+
+        # Heuristic: If most parts are \\mathrm{...} wrapped or plain numbers,
+        # it's likely a chemical formula
+        mathrm_count = sum(1 for p in parts if p.startswith('\\mathrm{'))
+        number_count = sum(1 for p in parts if p.isdigit())
+
+        # If more than half are chemical elements or numbers, treat as chemical formula
+        chemical_indicators = mathrm_count + number_count
+        return chemical_indicators > len(parts) / 2
+
+    def _get_local_name(self, tag: str) -> str:
+        """
+        Extract local element name from tag (strip namespace).
+
+        Args:
+            tag: Element tag (may include namespace)
+
+        Returns:
+            Local element name without namespace
+        """
+        if isinstance(tag, str) and '}' in tag:
+            return tag.split('}')[1]
+        return tag
+
+    def _convert_node(self, node: ET.Element) -> str:
+        """
+        Convert a MathML node to LaTeX using visitor pattern.
+
+        Args:
+            node: MathML element to convert
+
+        Returns:
+            LaTeX string
+        """
+        # Strip namespace from tag if present
+        # e.g., "{http://www.w3.org/1998/Math/MathML}mi" → "mi"
+        tag_name = self._get_local_name(node.tag)
+
+        # Get visitor for this element type
+        try:
+            visitor = self._visitor_registry.get_visitor(tag_name, self._strategy)
+        except ValueError as e:
+            # DEBUG: Log failed lookups for critical elements
+            if tag_name in ['mmultiscripts', 'munderover']:
+                debug_print(f"[DEBUG] Failed to get visitor for <{tag_name}>: {e}")
+                debug_print(f"[DEBUG] Registered visitors: {self._visitor_registry.get_registered_elements()}")
+            visitor = None
+
+        if visitor is not None:
+            # Pass converter instance to visitor for context access (color suppression, etc.)
+            # Visitors can check self._suppress_leaf_colors through the converter
+            if hasattr(visitor, 'set_converter_context'):
+                visitor.set_converter_context(self)
+            # Use visitor to convert (visitors handle their own recursion)
+            return visitor.visit(node)
+        else:
+            # Fallback: process children
+            # DEBUG: Log when falling back for critical elements
+            if tag_name in ['mmultiscripts', 'munderover']:
+                from ..utils import text_content
+                content = text_content(node)
+                debug_print(f"[DEBUG] Falling back for <{tag_name}> content={content[:60]}")
+
+            result = []
+            for child in node:
+                if isinstance(child.tag, str):  # Skip comments, processing instructions
+                    result.append(self._convert_node(child))
+            return ''.join(result)
+
+    def _has_set_brace_context(self, pipe_node: ET.Element) -> bool:
+        """
+        Check if a pipe symbol appears in a set brace context like {x | conditions}.
+
+        This method walks up the tree to find if there's an opening brace before the pipe.
+
+        Args:
+            pipe_node: The <mo>|</mo> element to check
+
+        Returns:
+            True if pipe appears after an opening brace, False otherwise
+        """
+        from ..utils import text_content as _text_content, local_name as _local
+
+        current = pipe_node
+        found_opening_brace = False
+
+        # Look for opening brace before the pipe
+        while current is not None:
+            parent = current.getparent()
+            if parent is None:
+                break
+
+            # Check all siblings before this node for opening brace
+            for sibling in parent:
+                if sibling == current:
+                    break
+                if _local(sibling.tag) == "mo" and _text_content(sibling).strip() == "{":
+                    found_opening_brace = True
+                    break
+
+            if found_opening_brace:
+                break
+
+            current = parent
+
+        return found_opening_brace
+
+    def _fix_eqarr_column_separators(self, doc: ET.Element) -> None:
+        """
+        Fix equation array column separators by splitting <mtd> cells at & operators.
+
+        Word embeds "&" as column separators in equation arrays. The XSLT converter
+        creates a single <mtd> containing <mo>&</mo> operators. This method splits
+        those cells into separate columns.
+
+        Args:
+            doc: The MathML document root element
+        """
+        from ..utils import local_name as _local
+
+        # Find all mtable elements
+        MATHML_NS = "http://www.w3.org/1998/Math/MathML"
+
+        # Try both with and without namespace
+        mtables = doc.findall(f".//{{{MATHML_NS}}}mtable")
+        if not mtables:
+            # Try without namespace prefix
+            mtables = [el for el in doc.iter() if _local(el.tag) == 'mtable']
+
+        for mtable in mtables:
+            # Process each row
+            mtrs = mtable.findall(f"{{{MATHML_NS}}}mtr")
+            # Try without namespace if not found
+            if not mtrs:
+                mtrs = [el for el in mtable if _local(el.tag) == 'mtr']
+
+            for mtr in mtrs:
+                mtds = mtr.findall(f"{{{MATHML_NS}}}mtd")
+                if not mtds:
+                    mtds = [el for el in mtr if _local(el.tag) == 'mtd']
+
+                # Check if any mtd contains & in text content
+                needs_splitting = False
+                for mtd in mtds:
+                    # Look for "&" in ANY child element's text
+                    for child in mtd:
+                        if child.text and '&' in child.text:
+                            needs_splitting = True
+                            break
+                    if needs_splitting:
+                        break
+
+                if needs_splitting:
+                    # Remove all existing mtd elements from the row
+                    for mtd in list(mtds):
+                        mtr.remove(mtd)
+
+                    # For each original mtd, split by & in text content
+                    for mtd in mtds:
+                        children = list(mtd)
+
+                        # Find the element containing &
+                        split_index = -1
+                        split_element = None
+                        for i, child in enumerate(children):
+                            if child.text and '&' in child.text:
+                                split_index = i
+                                split_element = child
+                                break
+
+                        if split_index >= 0:
+                            # Split the text at &
+                            text_before, text_after = split_element.text.split('&', 1)
+
+                            # IMPORTANT: Strip trailing/leading spaces around the & separator
+                            # LaTeX array environment handles spacing automatically, and Word's
+                            # spaces before & are just for visual alignment in the editor
+                            text_before = text_before.rstrip()
+                            text_after = text_after.lstrip()
+
+                            # Create first column: elements before split + text_before
+                            # Skip trailing space-only elements before the split
+                            col1 = ET.Element(f"{{{MATHML_NS}}}mtd")
+                            for child in children[:split_index]:
+                                # Skip space-only mo/mi/mtext elements before the &
+                                if (child.text and
+                                    child.text.strip() == '' and
+                                    _local(child.tag) in ('mo', 'mi', 'mtext')):
+                                    continue  # Skip this space element
+                                col1.append(child)
+                            if text_before:
+                                # Create element for text_before
+                                elem = ET.Element(split_element.tag)
+                                elem.text = text_before
+                                # Copy attributes
+                                for key, val in split_element.attrib.items():
+                                    elem.set(key, val)
+                                col1.append(elem)
+                            mtr.append(col1)
+
+                            # Create second column: text_after + elements after split
+                            col2 = ET.Element(f"{{{MATHML_NS}}}mtd")
+                            if text_after:
+                                # Create element for text_after
+                                elem = ET.Element(split_element.tag)
+                                elem.text = text_after
+                                # Copy attributes
+                                for key, val in split_element.attrib.items():
+                                    elem.set(key, val)
+                                col2.append(elem)
+                            for child in children[split_index + 1:]:
+                                col2.append(child)
+                            mtr.append(col2)
+                        else:
+                            # No & found, keep as single cell
+                            new_mtd = ET.Element(f"{{{MATHML_NS}}}mtd")
+                            for child in children:
+                                new_mtd.append(child)
+                            mtr.append(new_mtd)
+
+    def _analyze_equation_context(self, node: ET.Element) -> None:
+        """
+        Analyze the equation to detect set theory mode and other context.
+
+        This recursively walks the MathML tree to detect:
+        - Set theory operators (∈, ∉, ⊆, ⊇, etc.)
+        - Set builder notation patterns (pipe after opening brace)
+
+        Args:
+            node: MathML element to analyze
+        """
+        from ..utils import text_content as _text_content, local_name as _local
+
+        local_name_str = _local(node.tag)
+
+        # Check for set theory symbols in operators
+        if local_name_str == "mo":
+            op_text = _text_content(node)
+            set_theory_ops = ['∈', '∉', '⊆', '⊇', '⊂', '⊃', '∪', '∩', '∖', '∁', '∅']
+            if op_text in set_theory_ops:
+                self._set_theory_mode = True
+
+            # Also detect set builder notation patterns: look for { ... | ... } or { ... \mid ... }
+            if op_text == '|' and self._has_set_brace_context(node):
+                self._set_theory_mode = True
+
+        # Recursively analyze children
+        for child in node:
+            if isinstance(child.tag, str):  # Skip comments, processing instructions
+                self._analyze_equation_context(child)
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return (
+            f"LegacyMathMLToTeXConverter("
+            f"wrap_identifiers_in_mathrm={self.wrap_identifiers_in_mathrm}, "
+            f"prefer_xlongequal={self.prefer_xlongequal}, "
+            f"subject_mode={self.subject_mode!r})"
+        )
diff --git a/scripts/omml_mathml2latex/converters/brace_marker_resolver.py b/scripts/omml_mathml2latex/converters/brace_marker_resolver.py
new file mode 100644
index 0000000..ff8dd0e
--- /dev/null
+++ b/scripts/omml_mathml2latex/converters/brace_marker_resolver.py
@@ -0,0 +1,333 @@
+"""
+Brace marker resolver for context-aware delimiter pairing.
+
+This module converts __LBRACE__ and __RBRACE__ markers to proper LaTeX
+delimiters based on pairing context and existing \\left...\\right delimiters.
+
+The markers distinguish source braces (from DOCX) from generated braces
+(in LaTeX commands like \\mathrm{...}).
+
+Author: omml2tex project
+Date: 2026-01-14
+"""
+
+import re
+from typing import List, Dict, Optional
+from ..utils.debug import debug_print
+
+
+class BraceMarkerResolver:
+    """
+    Resolves __LBRACE__ and __RBRACE__ markers to LaTeX delimiters.
+
+    Pairing rules:
+    1. __LBRACE__...__RBRACE__ → \\left\\{...\\right\\}
+    2. __LBRACE__...\\right. → \\left\\{...\\right.
+    3. \\left....__RBRACE__ → \\left....\\right\\}
+    4. Standalone __LBRACE__ → \\{
+    5. Standalone __RBRACE__ → \\}
+    """
+
+    def __init__(self, debug: bool = False):
+        """
+        Initialize the brace marker resolver.
+
+        Args:
+            debug: Enable debug output to stderr
+        """
+        self.debug = debug
+
+    def resolve(self, latex: str) -> str:
+        """
+        Convert __LBRACE__ and __RBRACE__ markers to LaTeX delimiters.
+
+        Args:
+            latex: LaTeX string with markers
+
+        Returns:
+            LaTeX string with markers resolved to proper delimiters
+
+        Examples:
+            "__LBRACE__ x __RBRACE__" → "\\left\\{ x \\right\\}"
+            "__LBRACE__ x \\right." → "\\left\\{ x \\right."
+            "x __LBRACE__" → "x \\{"
+        """
+        if not latex or '__LBRACE__' not in latex and '__RBRACE__' not in latex:
+            return latex
+
+        if self.debug:
+            debug_print(f"[BRACE RESOLVE] Input: {latex[:100]}...")
+
+        # Step 1: Find all markers and existing \\left...\\right delimiters
+        markers = self._find_markers(latex)
+        existing_delims = self._find_existing_delimiters(latex)
+
+        if not markers:
+            if self.debug:
+                debug_print("[BRACE RESOLVE] No markers found")
+            return latex
+
+        if self.debug:
+            debug_print(f"[BRACE RESOLVE] Found {len(markers)} markers")
+
+        # Step 2: Pair markers using stack-based algorithm
+        pairs = self._pair_markers(markers, existing_delims, latex)
+
+        if self.debug:
+            debug_print(f"[BRACE RESOLVE] Created {len(pairs)} pairs")
+
+        # Step 3: Build replacements
+        replacements = self._build_replacements(pairs)
+
+        # Step 4: Apply replacements in reverse order
+        result = self._apply_replacements(latex, replacements)
+
+        if self.debug:
+            debug_print(f"[BRACE RESOLVE] Output: {result[:100]}...")
+
+        return result
+
+    def _find_markers(self, latex: str) -> List[Dict]:
+        """
+        Find all __LBRACE__ and __RBRACE__ markers.
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            List of marker dicts with 'text', 'pos', 'end' keys
+        """
+        markers = []
+
+        # Find __LBRACE__
+        for match in re.finditer(r'__LBRACE__', latex):
+            markers.append({
+                'kind': 'marker',
+                'text': '__LBRACE__',
+                'pos': match.start(),
+                'end': match.end(),
+            })
+
+        # Find __RBRACE__
+        for match in re.finditer(r'__RBRACE__', latex):
+            markers.append({
+                'kind': 'marker',
+                'text': '__RBRACE__',
+                'pos': match.start(),
+                'end': match.end(),
+            })
+
+        # Sort by position
+        markers.sort(key=lambda x: x['pos'])
+
+        return markers
+
+    def _find_existing_delimiters(self, latex: str) -> List[Dict]:
+        """
+        Find existing \\left and \\right delimiters.
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            List of delimiter dicts with 'text', 'pos', 'end', 'type' keys
+        """
+        delimiters = []
+
+        # Pattern for \\left followed by delimiter
+        # \\left(, \\left[, \\left\\{, \\left\\langle, \\left., etc.
+        left_pattern = r'\\left(?:\\{|\\langle|\\lfloor|\\lceil|\\||[(\[|.])'
+        for match in re.finditer(left_pattern, latex):
+            delimiters.append({
+                'kind': 'existing',
+                'text': match.group(),
+                'pos': match.start(),
+                'end': match.end(),
+                'type': 'left',
+            })
+
+        # Pattern for \\right followed by delimiter
+        right_pattern = r'\\right(?:\\}|\\rangle|\\rfloor|\\rceil|\\||[)\]|.])'
+        for match in re.finditer(right_pattern, latex):
+            delimiters.append({
+                'kind': 'existing',
+                'text': match.group(),
+                'pos': match.start(),
+                'end': match.end(),
+                'type': 'right',
+            })
+
+        return delimiters
+
+    def _pair_markers(self, markers: List[Dict], existing_delims: List[Dict], latex: str) -> List[Dict]:
+        """
+        Pair markers using stack-based algorithm.
+
+        Args:
+            markers: List of marker dicts
+            existing_delims: List of existing delimiter dicts
+            latex: Original LaTeX string (for context)
+
+        Returns:
+            List of pair dicts describing how to resolve each marker
+        """
+        stack = []
+        pairs = []
+
+        # Combine and sort by position
+        all_items = sorted(markers + existing_delims, key=lambda x: x['pos'])
+
+        for item in all_items:
+            if item['kind'] == 'marker' and item['text'] == '__LBRACE__':
+                # Push opening marker
+                stack.append({'type': 'marker_open', 'item': item})
+
+            elif item['kind'] == 'marker' and item['text'] == '__RBRACE__':
+                # Try to pair with stack top
+                if stack:
+                    top = stack[-1]
+                    if top['type'] == 'marker_open':
+                        # Pair: __LBRACE__...__RBRACE__
+                        opener = stack.pop()
+                        pairs.append({
+                            'type': 'symmetric',
+                            'left_pos': opener['item']['pos'],
+                            'left_end': opener['item']['end'],
+                            'right_pos': item['pos'],
+                            'right_end': item['end'],
+                        })
+                    elif top['type'] == 'existing_left':
+                        # Pair: \\left....__RBRACE__
+                        stack.pop()
+                        pairs.append({
+                            'type': 'right_with_existing_left',
+                            'right_pos': item['pos'],
+                            'right_end': item['end'],
+                        })
+                    else:
+                        # Standalone closing marker
+                        pairs.append({
+                            'type': 'standalone',
+                            'marker': '__RBRACE__',
+                            'pos': item['pos'],
+                            'end': item['end'],
+                        })
+                else:
+                    # Standalone closing marker
+                    pairs.append({
+                        'type': 'standalone',
+                        'marker': '__RBRACE__',
+                        'pos': item['pos'],
+                        'end': item['end'],
+                    })
+
+            elif item['kind'] == 'existing' and item['type'] == 'left':
+                # Push existing \\left delimiter
+                stack.append({'type': 'existing_left', 'item': item})
+
+            elif item['kind'] == 'existing' and item['type'] == 'right':
+                # Try to pair with marker on stack
+                if stack:
+                    top = stack[-1]
+                    if top['type'] == 'marker_open':
+                        # Pair: __LBRACE__...\\right
+                        opener = stack.pop()
+                        pairs.append({
+                            'type': 'left_with_existing_right',
+                            'left_pos': opener['item']['pos'],
+                            'left_end': opener['item']['end'],
+                        })
+                    elif top['type'] == 'existing_left':
+                        # Paired: \\left...\\right (no action needed)
+                        stack.pop()
+
+        # Handle remaining items on stack (standalone opening markers)
+        for item in stack:
+            if item['type'] == 'marker_open':
+                pairs.append({
+                    'type': 'standalone',
+                    'marker': '__LBRACE__',
+                    'pos': item['item']['pos'],
+                    'end': item['item']['end'],
+                })
+
+        return pairs
+
+    def _build_replacements(self, pairs: List[Dict]) -> List[Dict]:
+        """
+        Build replacement list from pairs.
+
+        Args:
+            pairs: List of pair dicts
+
+        Returns:
+            List of replacement dicts with 'pos', 'end', 'old', 'new' keys
+        """
+        replacements = []
+
+        for pair in pairs:
+            if pair['type'] == 'symmetric':
+                # __LBRACE__...__RBRACE__ → \\left\\{...\\right\\}
+                replacements.append({
+                    'pos': pair['left_pos'],
+                    'end': pair['left_end'],
+                    'old': '__LBRACE__',
+                    'new': '\\left\\{',
+                })
+                replacements.append({
+                    'pos': pair['right_pos'],
+                    'end': pair['right_end'],
+                    'old': '__RBRACE__',
+                    'new': '\\right\\}',
+                })
+
+            elif pair['type'] == 'left_with_existing_right':
+                # __LBRACE__...\\right → \\left\\{...\\right
+                replacements.append({
+                    'pos': pair['left_pos'],
+                    'end': pair['left_end'],
+                    'old': '__LBRACE__',
+                    'new': '\\left\\{',
+                })
+
+            elif pair['type'] == 'right_with_existing_left':
+                # \\left....__RBRACE__ → \\left....\\right\\}
+                replacements.append({
+                    'pos': pair['right_pos'],
+                    'end': pair['right_end'],
+                    'old': '__RBRACE__',
+                    'new': '\\right\\}',
+                })
+
+            elif pair['type'] == 'standalone':
+                # Standalone marker → escaped brace
+                replacements.append({
+                    'pos': pair['pos'],
+                    'end': pair['end'],
+                    'old': pair['marker'],
+                    'new': '\\{' if pair['marker'] == '__LBRACE__' else '\\}',
+                })
+
+        # Sort by position in reverse order for safe replacement
+        replacements.sort(key=lambda x: x['pos'], reverse=True)
+
+        return replacements
+
+    def _apply_replacements(self, latex: str, replacements: List[Dict]) -> str:
+        """
+        Apply replacements to LaTeX string.
+
+        Args:
+            latex: Original LaTeX string
+            replacements: List of replacement dicts (must be sorted by pos descending)
+
+        Returns:
+            LaTeX string with replacements applied
+        """
+        result = latex
+
+        for rep in replacements:
+            # Replace from back to front to preserve positions
+            result = result[:rep['pos']] + rep['new'] + result[rep['end']:]
+
+        return result
diff --git a/scripts/omml_mathml2latex/converters/delimiter_pairing_processor.py b/scripts/omml_mathml2latex/converters/delimiter_pairing_processor.py
new file mode 100644
index 0000000..4386c36
--- /dev/null
+++ b/scripts/omml_mathml2latex/converters/delimiter_pairing_processor.py
@@ -0,0 +1,846 @@
+"""
+Universal delimiter pairing post-processor.
+
+This module provides functionality to add \\left and \\right commands to ALL
+delimiter pairs in LaTeX output, ensuring uniform scaling regardless of content.
+
+The processor uses a smart stack-based pairing algorithm that:
+1. Handles symmetric pairs: (), [], {}, ||
+2. Handles mismatched pairs for interval notation: [), (], etc.
+3. Skips delimiters already in \\left...\\right or cases environment
+
+Author: omml2tex project
+Date: 2025-11-12
+"""
+
+import re
+import sys
+from typing import List, Tuple, Dict, Optional
+
+from ..utils.debug import debug_print
+
+
+class DelimiterPairingProcessor:
+    """
+    Post-processor that adds \\left and \\right to all delimiter pairs.
+
+    This ensures uniform scaling of all parentheses, brackets, and braces,
+    including interval notation with mismatched delimiters.
+
+    Rules:
+    1. Add \\left\\right to symmetric pairs: (), [], {}, ||, ⟨⟩
+    2. Add \\left\\right to mismatched pairs (intervals): [), (], etc.
+    3. Add \\left\\right to quantum mechanics notation: ⟨φ|, |ψ⟩, ⟨φ|ψ⟩
+    4. Skip delimiters in: \\left...\\right, \\begin{array}...\\end{array}
+    """
+
+    # Delimiter mappings
+    # BUG-010 FIX: Added '.' to OPENING_DELIMS for invisible left delimiter (\left.)
+    OPENING_DELIMS = {'(', '[', '{', '|', '\\langle', '\\{', '\\|', '\\lfloor', '\\lceil', '.'}
+    CLOSING_DELIMS = {')', ']', '}', '|', '\\rangle', '\\}', '\\|', '.', '\\rfloor', '\\rceil'}  # '.' for invisible delimiter
+    ALL_DELIMS = OPENING_DELIMS | CLOSING_DELIMS
+
+    # Compatible delimiter pairings (for interval notation and quantum mechanics)
+    # Any opening can pair with any closing
+    COMPATIBLE_PAIRS = {
+        '(': {')', ']', '}', '\\rangle', '\\}', '.'},  # ( can close with ), ], }, ⟩, or . (invisible)
+        '[': {')', ']', '}', '\\rangle', '\\}', '.'},  # [ can close with ), ], }, ⟩, or . (invisible)
+        '{': {')', ']', '}', '\\rangle', '\\}', '.'},  # { can close with ), ], }, ⟩, or . (invisible)
+        '\\{': {')', ']', '}', '\\rangle', '\\}', '.'},  # \{ can close with ), ], }, \}, or . (invisible)
+        '|': {'|', '\\rangle', '.'},            # | can pair with |, ⟩, or . (invisible)
+        '\\|': {'\\|', '.'},                    # \| pairs with \| or . (invisible)
+        '\\langle': {')', ']', '}', '\\rangle', '|', '\\}', '.'},  # ⟨ can pair with ⟩, |, or . (invisible)
+        '\\lfloor': {'\\rfloor', '.'},          # ⌊ pairs with ⌋ or . (invisible)
+        '\\lceil': {'\\rceil', '.'},            # ⌈ pairs with ⌉ or . (invisible)
+        # BUG-010 FIX: '.' (invisible delimiter) can pair with any closing delimiter
+        '.': {')', ']', '}', '\\rangle', '\\}', '\\|', '|', '\\rfloor', '\\rceil', '.'},
+    }
+
+    def __init__(self, debug: bool = False):
+        """
+        Initialize the delimiter pairing processor.
+
+        Args:
+            debug: Enable debug output to stderr
+        """
+        self.debug = debug
+
+    def process(self, latex: str) -> str:
+        """
+        Add \\left and \\right to all delimiter pairs in LaTeX.
+
+        This is a post-processing step that runs AFTER the visitor pattern,
+        ensuring ALL delimiters get scaled, including interval notation.
+
+        Args:
+            latex: LaTeX string from conversion
+
+        Returns:
+            LaTeX string with \\left...\\right added to all delimiter pairs
+
+        Examples:
+            "(x + y)" → "\\left(x + y\\right)"
+            "[a, b]" → "\\left[a, b\\right]"
+            "[0, 1)" → "\\left[0, 1\\right)"  (interval notation)
+            "(a, b]" → "\\left(a, b\\right]"  (interval notation)
+            "\\langle \\phi | \\psi \\rangle" → "\\left\\langle \\phi | \\psi \\right\\rangle"  (quantum mechanics)
+            "|\\psi\\rangle" → "\\left|\\psi\\right\\rangle"  (ket notation)
+            "\\left\\{ \\begin{array}...\\right." → unchanged (skip)
+        """
+        if not latex or not latex.strip():
+            return latex
+
+        # Step 1: Find all plain delimiters (skip those in protected contexts)
+        delimiters = self._find_plain_delimiters(latex)
+
+        if not delimiters:
+            if self.debug:
+                debug_print("[DELIM PAIR] No plain delimiters found")
+            return latex
+
+        if self.debug:
+            debug_print(f"[DELIM PAIR] Found {len(delimiters)} plain delimiters")
+
+        # Step 2: Pair delimiters using smart algorithm (handles intervals)
+        # Also identify pipes that should be \mid based on context
+        pairs, skip_indices = self._pair_delimiters(delimiters, latex)
+
+        if self.debug:
+            debug_print(f"[DELIM PAIR] Paired {len(pairs)} delimiter pairs")
+            for opening, closing in pairs:
+                debug_print(f"  - {opening['char']} at {opening['pos']} ... {closing['char']} at {closing['pos']}")
+            if skip_indices:
+                debug_print(f"[DELIM PAIR] Skipped {len(skip_indices)} pipes (will convert to \\mid)")
+
+        # Step 3: Build replacement list (includes both paired delimiters and skipped pipes)
+        replacements = self._build_replacements(pairs, delimiters, skip_indices)
+
+        # Step 4: Apply replacements in reverse order
+        result = self._apply_replacements(latex, replacements)
+
+        # Step 5: Cleanup - Remove any remaining __DELIM__ markers
+        # These are delimiters that couldn't be paired (unknown types, unmatched, etc.)
+        # This is a fail-safe to ensure no markers leak into the final output
+        if '__DELIM__' in result:
+            if self.debug:
+                debug_print("[DELIM PAIR] Cleaning up remaining __DELIM__ markers")
+            result = result.replace('__DELIM__', '')
+
+        return result
+
+    def _find_plain_delimiters(self, latex: str) -> List[Dict]:
+        """
+        Find all delimiters marked with __DELIM__ markers.
+
+        Phase 3 Fix: Only delimiters with __DELIM__ markers are paired.
+        This distinguishes fence delimiters (with fence="true" in MathML) from
+        plain operators that happen to use the same character (e.g., | in P(A|B)).
+
+        Args:
+            latex: LaTeX string with __DELIM__ markers
+
+        Returns:
+            List of delimiter dictionaries with 'char', 'pos', 'end', 'marker_start', 'marker_end' keys
+
+        Examples:
+            Input: "P __DELIM__(__DELIM__ A | B __DELIM__)__DELIM__"
+            Output: [
+                {'char': '(', 'pos': 11, 'end': 12, 'marker_start': 2, 'marker_end': 22},
+                {'char': ')', 'pos': 32, 'end': 33, 'marker_start': 23, 'marker_end': 43}
+            ]
+            Note: Plain '|' at position 17 is NOT in the list (no __DELIM__ markers)
+        """
+        delimiters = []
+        marker = '__DELIM__'
+        marker_len = len(marker)
+
+        # Scan for __DELIM__ markers
+        i = 0
+        while i < len(latex):
+            if latex[i:i+marker_len] == marker:
+                # Found opening marker
+                # FIX BUG-007: Check if there's a leading backslash before __DELIM__
+                # Pattern: \__DELIM__\{__DELIM__ should be treated as a unit
+                marker_start = i
+                if i > 0 and latex[i-1] == '\\':
+                    # Include the leading backslash in the marker range
+                    marker_start = i - 1
+                i += marker_len
+
+                # Extract delimiter character(s) between markers
+                delim_start = i
+
+                # Look for closing marker
+                closing_marker_pos = latex.find(marker, i)
+                if closing_marker_pos == -1:
+                    # No closing marker - skip this opening marker
+                    continue
+
+                # Extract delimiter between markers
+                delim_str = latex[delim_start:closing_marker_pos]
+
+                # Handle STRETCHY:: prefix (from MathStrategy)
+                if delim_str.startswith('STRETCHY::'):
+                    delim_str = delim_str[10:]  # Strip prefix
+
+                marker_end = closing_marker_pos + marker_len
+
+                # Skip empty delimiters
+                if not delim_str.strip():
+                    i = marker_end
+                    continue
+
+                # Add delimiter to list
+                delimiters.append({
+                    'char': delim_str,
+                    'pos': delim_start,
+                    'end': closing_marker_pos,
+                    'marker_start': marker_start,
+                    'marker_end': marker_end,
+                    'escaped': delim_str.startswith('\\'),
+                })
+
+                # Move past closing marker
+                i = marker_end
+            else:
+                i += 1
+
+        return delimiters
+
+    def _find_brace_argument_regions(self, latex: str) -> List[Tuple[int, int]]:
+        """
+        Find regions where braces are used as command arguments.
+
+        This includes:
+        - Command arguments: \\frac{num}{denom}, \\sqrt{x}, etc.
+        - Subscripts: x_{sub}
+        - Superscripts: x^{sup}
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            List of (start, end) tuples for brace regions
+        """
+        regions = []
+
+        # Simple approach: Find all {...} pairs
+        # These are almost always command arguments, not delimiters
+        stack = []
+        for i, char in enumerate(latex):
+            if char == '{' and (i == 0 or latex[i-1] != '\\'):
+                stack.append(i)
+            elif char == '}' and (i == 0 or latex[i-1] != '\\'):
+                if stack:
+                    start = stack.pop()
+                    regions.append((start, i+1))
+
+        return regions
+
+    def _find_protected_regions(self, latex: str) -> List[Tuple[int, int]]:
+        """
+        Find protected regions that should not have delimiters modified.
+
+        Protected regions:
+        1. \\left...\\right pairs
+        2. \\begin{array}...\\end{array} (cases environment)
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            List of (start, end) position tuples for protected regions
+        """
+        protected = []
+
+        # Pattern 1: Find \\left...\\right pairs
+        # Match \\left followed by delimiter, content, \\right followed by delimiter
+        # Include \langle and \rangle as possible delimiters
+        left_pattern = r'\\left(?:[(\[{\|]|\\langle)'
+        right_pattern = r'\\right(?:[)\]}\|.]|\\rangle)'
+
+        # Find all \\left positions
+        left_positions = []
+        for match in re.finditer(left_pattern, latex):
+            left_positions.append(match.start())
+
+        # Find all \\right positions
+        right_positions = []
+        for match in re.finditer(right_pattern, latex):
+            right_positions.append(match.end())
+
+        # Pair them (simple heuristic: match nearest \\right after each \\left)
+        for left_start in left_positions:
+            # Find the nearest \\right after this \\left
+            for right_end in right_positions:
+                if right_end > left_start:
+                    protected.append((left_start, right_end))
+                    break
+
+        # Pattern 2: Find \\begin{array}...\\end{array}
+        array_pattern = r'\\begin\{array\}.*?\\end\{array\}'
+        for match in re.finditer(array_pattern, latex, re.DOTALL):
+            protected.append((match.start(), match.end()))
+
+        return protected
+
+    def _is_in_protected_region(self, pos: int, protected_regions: List[Tuple[int, int]]) -> bool:
+        """Check if position is within any protected region."""
+        for start, end in protected_regions:
+            if start <= pos < end:
+                return True
+        return False
+
+    def _pair_delimiters(self, delimiters: List[Dict], latex: str) -> Tuple[List[Tuple[Dict, Dict]], set]:
+        r"""
+        Pair opening and closing delimiters using smart algorithm.
+
+        Algorithm supports:
+        1. Symmetric pairs: (), [], {}, ||, ⟨⟩
+        2. Mismatched pairs for intervals: [), (], etc.
+        3. Quantum mechanics: |ψ⟩ (ket), ⟨φ| (bra), ⟨φ|ψ⟩ (inner product)
+        4. Conditional probability: P(A|B) - pipe inside parentheses becomes \mid
+        5. Set notation: {x|x>0} - pipe inside braces becomes \mid
+
+        Key insight: For pipes, use proximity-based pairing (pair closest pipes first)
+        to correctly handle cases like {x | x + |x-2| < 0} where the inner pipes
+        should be paired before the outer pipe.
+
+        Args:
+            delimiters: List of delimiter dictionaries
+            latex: Full LaTeX string for context checking
+
+        Returns:
+            Tuple of (pairs, skip_indices) where:
+            - pairs: List of (opening, closing) delimiter pairs
+            - skip_indices: Set of indices for pipes that should become \mid
+        """
+        pairs = []
+
+        # Phase 1: Identify operator pipes (set separators, conditional probability) and pair remaining pipes
+        # Operator pipes should NOT be paired - they become \mid
+        # Examples:
+        #   - Set notation: {x | condition} - first pipe is separator
+        #   - Conditional probability: P(A|B) - pipe is operator
+        pipe_indices = [i for i, d in enumerate(delimiters) if d['char'] == '|']
+        operator_pipe_indices = set()  # Pipes that should become \mid
+        paired_pipe_indices = set()
+
+        if pipe_indices:
+            # First, identify pipes that are operators (not delimiters)
+            for pipe_idx in pipe_indices:
+                pipe_delim = delimiters[pipe_idx]
+                pipe_start = pipe_delim['marker_start']
+
+                # Look backwards in LaTeX string
+                search_start = max(0, pipe_start - 50)
+                latex_before = latex[search_start:pipe_start]
+
+                # Check 1: Set notation separator {x | ...}
+                # Pattern: brace shortly before pipe, no other pipes between them
+                # NOTE: Check for both raw braces and __LBRACE__ markers
+                if '{' in latex_before or '\\{' in latex_before or '__LBRACE__' in latex_before:
+                    last_brace_pos = max(
+                        latex_before.rfind('{'),
+                        latex_before.rfind('\\{'),
+                        latex_before.rfind('__LBRACE__')
+                    )
+                    content_between = latex_before[last_brace_pos:]
+                    if len(content_between) < 30:
+                        # Check no other pipes between brace and this pipe
+                        has_pipes_between = any(
+                            delimiters[other_idx]['marker_start'] > search_start + last_brace_pos and
+                            delimiters[other_idx]['marker_start'] < pipe_start
+                            for other_idx in pipe_indices if other_idx != pipe_idx
+                        )
+                        if not has_pipes_between:
+                            # Check if there's actual content between brace and pipe
+                            # Pattern: {x | condition} → content exists → separator
+                            # Pattern: {|x|} → no content → absolute value
+                            # Strip the brace marker itself to get content after it
+                            content_after_brace = content_between
+                            for marker in ('__LBRACE__', '\\{', '{'):
+                                if content_after_brace.startswith(marker):
+                                    content_after_brace = content_after_brace[len(marker):]
+                                    break
+                            content_after_brace = content_after_brace.strip()
+
+                            if content_after_brace:
+                                # Has content between brace and pipe → set notation separator
+                                operator_pipe_indices.add(pipe_idx)
+                                continue  # Skip other checks
+
+                # Check 2: Conditional probability operator P(A|B)
+                # Pattern: parenthesis shortly before pipe
+                if '(' in latex_before or '\\left(' in latex_before:
+                    last_paren_pos = max(
+                        latex_before.rfind('('),
+                        latex_before.rfind('\\left(')
+                    )
+                    content_between = latex_before[last_paren_pos:]
+                    if len(content_between) < 50:
+                        # Check no other pipes between parenthesis and this pipe
+                        has_pipes_between = any(
+                            delimiters[other_idx]['marker_start'] > search_start + last_paren_pos and
+                            delimiters[other_idx]['marker_start'] < pipe_start
+                            for other_idx in pipe_indices if other_idx != pipe_idx
+                        )
+                        if not has_pipes_between:
+                            # This is likely a conditional probability operator
+                            operator_pipe_indices.add(pipe_idx)
+                            continue  # Skip other checks
+
+            # Remove operator pipes from pairing consideration
+            pipe_indices_for_pairing = [idx for idx in pipe_indices if idx not in operator_pipe_indices]
+
+            # Now pair the remaining pipes using proximity-based algorithm
+            # This pairs absolute values like |x-2| correctly
+            while len(pipe_indices_for_pairing) >= 2:
+                # Find the pair of pipes with minimum distance
+                min_distance = float('inf')
+                best_pair = None
+
+                for i in range(len(pipe_indices_for_pairing)):
+                    for j in range(i + 1, len(pipe_indices_for_pairing)):
+                        idx1, idx2 = pipe_indices_for_pairing[i], pipe_indices_for_pairing[j]
+                        distance = idx2 - idx1
+                        if distance < min_distance:
+                            min_distance = distance
+                            best_pair = (i, j, idx1, idx2)
+
+                if best_pair:
+                    i, j, idx1, idx2 = best_pair
+                    # Pair these pipes
+                    pairs.append((delimiters[idx1], delimiters[idx2]))
+                    paired_pipe_indices.add(idx1)
+                    paired_pipe_indices.add(idx2)
+                    # Remove from consideration
+                    pipe_indices_for_pairing.pop(j)  # Remove j first (higher index)
+                    pipe_indices_for_pairing.pop(i)  # Then remove i
+                else:
+                    break
+
+        # Phase 2: Pair other delimiters using stack-based algorithm
+        stack = []
+        for idx, delim in enumerate(delimiters):
+            char = delim['char']
+
+            # Skip pipes that were already paired in Phase 1
+            if char == '|' and idx in paired_pipe_indices:
+                continue
+
+            # Skip pipes entirely - they'll be handled in Phase 3
+            if char == '|':
+                continue
+
+            # Special handling for ambiguous delimiters that can be both opening AND closing
+            # Examples: '.' (invisible delimiter), '|' (pipe)
+            # Strategy: If there's a compatible opening on the stack, treat as closing.
+            # Otherwise, treat as opening.
+            is_ambiguous = char in self.OPENING_DELIMS and char in self.CLOSING_DELIMS
+
+            if is_ambiguous:
+                # Check if there's a compatible opening on the stack
+                paired = False
+                if stack:
+                    for i in range(len(stack) - 1, -1, -1):
+                        opening = stack[i]
+                        opening_char = opening['char']
+
+                        # Check if this ambiguous delimiter can close this opening
+                        if char in self.COMPATIBLE_PAIRS.get(opening_char, set()):
+                            # Found a compatible match - treat as CLOSING
+                            paired_opening = stack.pop(i)
+                            pairs.append((paired_opening, delim))
+                            paired = True
+                            break
+
+                if not paired:
+                    # No compatible opening found - treat as OPENING
+                    stack.append(delim)
+
+            elif char in self.OPENING_DELIMS:
+                # Unambiguous opening delimiter - push to stack
+                stack.append(delim)
+
+            elif char in self.CLOSING_DELIMS:
+                # Unambiguous closing delimiter - find compatible opening
+                if stack:
+                    # Strategy: Find the MOST RECENT opening that's compatible
+                    # This handles both symmetric pairs and interval notation
+                    paired = False
+                    for i in range(len(stack) - 1, -1, -1):
+                        opening = stack[i]
+                        opening_char = opening['char']
+
+                        # Check if this opening is compatible with closing
+                        if char in self.COMPATIBLE_PAIRS.get(opening_char, set()):
+                            # Found a compatible match!
+                            paired_opening = stack.pop(i)
+                            pairs.append((paired_opening, delim))
+                            paired = True
+                            break
+
+                    if not paired and self.debug:
+                        debug_print(f"[DELIM PAIR] Warning: Unpaired closing delimiter '{char}' at {delim['pos']}")
+                else:
+                    # Stack is empty - unpaired closing delimiter
+                    if self.debug:
+                        debug_print(f"[DELIM PAIR] Warning: Unpaired closing delimiter '{char}' at {delim['pos']}")
+
+        # Phase 3: Post-process to identify UNPAIRED pipes that should be \mid operators
+        # Pattern 1: \langle ... | ... \rangle → quantum mechanics inner product (unpaired pipe)
+        # Pattern 2: ( ... | ... ) → conditional probability P(A|B) (unpaired pipe)
+        # Pattern 3: [ ... | ... ] → set builder notation [x|x>0] (unpaired pipe)
+        # Pattern 4: { ... | ... } → set notation {x|x>0} (unpaired pipe)
+        # We mark these UNPAIRED pipes to convert to \mid
+        skip_indices = set()
+        for i, delim in enumerate(delimiters):
+            if delim['char'] == '|' and i not in paired_pipe_indices:
+                # This pipe is unpaired - check if it's inside other delimiters
+                # Check if there's a \langle before and \rangle after this pipe
+                has_langle_before = False
+                has_rangle_after = False
+
+                # Check if there's a ( or [ before and ) or ] after this pipe
+                has_paren_or_bracket_before = False
+                has_paren_or_bracket_after = False
+
+                # Check if there's a { before and } after this pipe in the LaTeX string
+                # This handles set notation where braces might not have fence="true"
+                has_brace_before = False
+                has_brace_after = False
+
+                # Check in delimiters list first
+                for j in range(i-1, -1, -1):
+                    if delimiters[j]['char'] == '\\langle':
+                        has_langle_before = True
+                        break
+                    elif delimiters[j]['char'] in ('(', '['):
+                        has_paren_or_bracket_before = True
+                        break
+                    elif delimiters[j]['char'] in ('{', '\\{'):
+                        has_brace_before = True
+                        break
+                    elif delimiters[j]['char'] in (')', ']', '}', '\\}'):  # Other closing delims
+                        break  # Stop searching
+
+                for j in range(i+1, len(delimiters)):
+                    if delimiters[j]['char'] == '\\rangle':
+                        has_rangle_after = True
+                        break
+                    elif delimiters[j]['char'] in (')', ']'):
+                        has_paren_or_bracket_after = True
+                        break
+                    elif delimiters[j]['char'] in ('}', '\\}'):
+                        has_brace_after = True
+                        break
+                    elif delimiters[j]['char'] in ('(', '[', '{', '\\{', '\\langle'):  # Other opening delims
+                        break  # Stop searching
+
+                # Also check the LaTeX string for plain braces (not in delimiters list)
+                # Look backwards from the pipe position for a plain { or \{ or \left\{
+                if not has_brace_before:
+                    pipe_start = delim['marker_start']
+                    # Search backwards in LaTeX for { or \{ or \left\{
+                    for k in range(pipe_start - 1, max(0, pipe_start - 200), -1):
+                        # Check for \left\{
+                        if k >= 6 and latex[k-6:k+1] == '\\left\\{':
+                            has_brace_before = True
+                            break
+                        # Check for plain { (not \{)
+                        elif latex[k] == '{' and (k == 0 or latex[k-1] != '\\'):
+                            has_brace_before = True
+                            break
+                        # Check for \{ (escaped brace)
+                        elif k >= 1 and latex[k-1:k+1] == '\\{':
+                            has_brace_before = True
+                            break
+                        # Stop at other closing delimiters
+                        elif latex[k] in (')', ']') and (k == 0 or latex[k-1] != '\\'):
+                            break
+                        # Stop at \right) or \right]
+                        elif k >= 7 and latex[k-7:k+1] in ('\\right)', '\\right]'):
+                            break
+
+                # Look forwards from the pipe position for a plain } or \} or \right\}
+                if not has_brace_after:
+                    pipe_end = delim['marker_end']
+                    # Search forwards in LaTeX for } or \} or \right\}
+                    for k in range(pipe_end, min(len(latex), pipe_end + 200)):
+                        # Check for \right\}
+                        if k + 8 <= len(latex) and latex[k:k+8] == '\\right\\}':
+                            has_brace_after = True
+                            break
+                        # Check for plain } (not \})
+                        elif latex[k] == '}' and (k == 0 or latex[k-1] != '\\'):
+                            has_brace_after = True
+                            break
+                        # Check for \} (escaped brace)
+                        elif k + 2 <= len(latex) and latex[k:k+2] == '\\}':
+                            has_brace_after = True
+                            break
+                        # Stop at other opening delimiters
+                        elif latex[k] in ('(', '[') and (k == 0 or latex[k-1] != '\\'):
+                            break
+                        # Stop at \left( or \left[
+                        elif k + 6 <= len(latex) and latex[k:k+6] in ('\\left(', '\\left['):
+                            break
+
+                # If unpaired pipe is between \langle and \rangle, it's an inner product operator
+                if has_langle_before and has_rangle_after:
+                    skip_indices.add(i)
+
+                # If unpaired pipe is between ( and ) or [ and ], it's a conditional probability or set builder operator
+                # This handles P(A|B), P(A|B,C), [x|x>0], etc.
+                elif has_paren_or_bracket_before and has_paren_or_bracket_after:
+                    skip_indices.add(i)
+
+                # If unpaired pipe is between { and }, it's set notation {x|x>0}
+                elif has_brace_before and has_brace_after:
+                    skip_indices.add(i)
+                # Check if there's a \langle before and \rangle after this pipe
+                has_langle_before = False
+                has_rangle_after = False
+
+                # Check if there's a ( or [ before and ) or ] after this pipe
+                has_paren_or_bracket_before = False
+                has_paren_or_bracket_after = False
+
+                # NEW: Check if there's a { before and } after this pipe in the LaTeX string
+                # This handles set notation where braces might not have fence="true"
+                has_brace_before = False
+                has_brace_after = False
+
+                # Check in delimiters list first
+                for j in range(i-1, -1, -1):
+                    if delimiters[j]['char'] == '\\langle':
+                        has_langle_before = True
+                        break
+                    elif delimiters[j]['char'] in ('(', '['):
+                        has_paren_or_bracket_before = True
+                        break
+                    elif delimiters[j]['char'] in ('{', '\\{'):
+                        has_brace_before = True
+                        break
+                    elif delimiters[j]['char'] in (')', ']', '}', '\\}'):  # Other closing delims
+                        break  # Stop searching
+
+                for j in range(i+1, len(delimiters)):
+                    if delimiters[j]['char'] == '\\rangle':
+                        has_rangle_after = True
+                        break
+                    elif delimiters[j]['char'] in (')', ']'):
+                        has_paren_or_bracket_after = True
+                        break
+                    elif delimiters[j]['char'] in ('}', '\\}'):
+                        has_brace_after = True
+                        break
+                    elif delimiters[j]['char'] in ('(', '[', '{', '\\{', '\\langle'):  # Other opening delims
+                        break  # Stop searching
+
+                # NEW: Also check the LaTeX string for plain braces (not in delimiters list)
+                # Look backwards from the pipe position for a plain { or \{ or \left\{
+                if not has_brace_before:
+                    pipe_start = delim['marker_start']
+                    # Search backwards in LaTeX for { or \{ or \left\{
+                    for k in range(pipe_start - 1, max(0, pipe_start - 200), -1):
+                        # Check for \left\{
+                        if k >= 6 and latex[k-6:k+1] == '\\left\\{':
+                            has_brace_before = True
+                            break
+                        # Check for plain { (not \{)
+                        elif latex[k] == '{' and (k == 0 or latex[k-1] != '\\'):
+                            has_brace_before = True
+                            break
+                        # Check for \{ (escaped brace)
+                        elif k >= 1 and latex[k-1:k+1] == '\\{':
+                            has_brace_before = True
+                            break
+                        # Stop at other closing delimiters
+                        elif latex[k] in (')', ']') and (k == 0 or latex[k-1] != '\\'):
+                            break
+                        # Stop at \right) or \right]
+                        elif k >= 7 and latex[k-7:k+1] in ('\\right)', '\\right]'):
+                            break
+
+                # Look forwards from the pipe position for a plain } or \} or \right\}
+                if not has_brace_after:
+                    pipe_end = delim['marker_end']
+                    # Search forwards in LaTeX for } or \} or \right\}
+                    for k in range(pipe_end, min(len(latex), pipe_end + 200)):
+                        # Check for \right\}
+                        if k + 8 <= len(latex) and latex[k:k+8] == '\\right\\}':
+                            has_brace_after = True
+                            break
+                        # Check for plain } (not \})
+                        elif latex[k] == '}' and (k == 0 or latex[k-1] != '\\'):
+                            has_brace_after = True
+                            break
+                        # Check for \} (escaped brace)
+                        elif k + 2 <= len(latex) and latex[k:k+2] == '\\}':
+                            has_brace_after = True
+                            break
+                        # Stop at other opening delimiters
+                        elif latex[k] in ('(', '[') and (k == 0 or latex[k-1] != '\\'):
+                            break
+                        # Stop at \left( or \left[
+                        elif k + 6 <= len(latex) and latex[k:k+6] in ('\\left(', '\\left['):
+                            break
+
+                # If pipe is between \langle and \rangle, it's an inner product operator
+                if has_langle_before and has_rangle_after:
+                    skip_indices.add(i)
+
+                # If pipe is between ( and ) or [ and ], it's a conditional probability or set builder operator
+                # This handles P(A|B), P(A|B,C), [x|x>0], etc.
+                elif has_paren_or_bracket_before and has_paren_or_bracket_after:
+                    skip_indices.add(i)
+
+                # If unpaired pipe is between { and }, it's set notation {x|x>0}
+                elif has_brace_before and has_brace_after:
+                    skip_indices.add(i)
+
+        # Report unpaired opening delimiters
+        if stack and self.debug:
+            for unpaired in stack:
+                debug_print(f"[DELIM PAIR] Warning: Unpaired opening delimiter '{unpaired['char']}' at {unpaired['pos']}")
+
+        # Merge operator pipes into skip_indices so they get converted to \mid
+        skip_indices.update(operator_pipe_indices)
+
+        return pairs, skip_indices
+
+    def _build_replacements(self, pairs: List[Tuple[Dict, Dict]], delimiters: List[Dict], skip_indices: set) -> List[Tuple[int, int, str]]:
+        r"""
+        Build replacement list for paired delimiters and skipped pipes.
+
+        Phase 3 Fix: Replace __DELIM__char__DELIM__ with \left/\right commands.
+        Also converts skipped pipes (conditional probability) to \mid.
+
+        Args:
+            pairs: List of (opening, closing) delimiter pairs with marker positions
+            delimiters: List of all delimiter dictionaries
+            skip_indices: Set of indices for pipes that should become \mid
+
+        Returns:
+            List of (start_pos, end_pos, replacement_text) tuples
+
+        Examples:
+            Input pair: {'char': '(', 'marker_start': 2, 'marker_end': 22}
+            Output: (2, 22, '\\left(')  # Replace __DELIM__(__DELIM__ with \left(
+
+            Input skipped pipe: {'char': '|', 'marker_start': 10, 'marker_end': 30}
+            Output: (10, 30, ' \\mid ')  # Replace __DELIM__|__DELIM__ with \mid
+        """
+        replacements = []
+
+        # Handle paired delimiters
+        for opening, closing in pairs:
+            opening_char = opening['char']
+            closing_char = closing['char']
+
+            # Build \\left command for opening delimiter
+            left_cmd = self._get_left_command(opening_char)
+            right_cmd = self._get_right_command(closing_char)
+
+            if left_cmd and right_cmd:
+                # Replace entire marker range: __DELIM__char__DELIM__ → \left/\right command
+                replacements.append((opening['marker_start'], opening['marker_end'], left_cmd))
+                replacements.append((closing['marker_start'], closing['marker_end'], right_cmd))
+
+        # Handle skipped pipes (convert to \mid)
+        for idx in skip_indices:
+            delim = delimiters[idx]
+            # Replace __DELIM__|__DELIM__ with \mid (with spaces for proper LaTeX spacing)
+            replacements.append((delim['marker_start'], delim['marker_end'], ' \\mid '))
+
+        return replacements
+
+    def _get_left_command(self, char: str) -> Optional[str]:
+        """Get \\left command for opening delimiter."""
+        left_map = {
+            '(': '\\left(',
+            '[': '\\left[',
+            '{': '\\left\\{',
+            '\\{': '\\left\\{',  # Escaped brace → \left\{
+            '|': '\\left|',
+            '\\|': '\\left\\|',  # Double vertical line → \left\|
+            '\\langle': '\\left\\langle',
+            '\\lfloor': '\\left\\lfloor',  # Floor function
+            '\\lceil': '\\left\\lceil',    # Ceiling function
+            '.': '\\left.',  # BUG-010 FIX: Invisible left delimiter
+        }
+        return left_map.get(char)
+
+    def _get_right_command(self, char: str) -> Optional[str]:
+        """Get \\right command for closing delimiter."""
+        right_map = {
+            ')': '\\right)',
+            ']': '\\right]',
+            '}': '\\right\\}',
+            '\\}': '\\right\\}',  # Escaped brace → \right\}
+            '|': '\\right|',
+            '\\|': '\\right\\|',  # Double vertical line → \right\|
+            '\\rangle': '\\right\\rangle',
+            '.': '\\right.',  # Invisible delimiter → \right.
+            '\\rfloor': '\\right\\rfloor',  # Floor function
+            '\\rceil': '\\right\\rceil',    # Ceiling function
+        }
+        return right_map.get(char)
+
+    def _apply_replacements(self, latex: str, replacements: List[Tuple[int, int, str]]) -> str:
+        """
+        Apply replacements to LaTeX string.
+
+        Replacements are applied in reverse order to maintain position indices.
+
+        Args:
+            latex: Original LaTeX string
+            replacements: List of (start_pos, end_pos, replacement_text) tuples
+
+        Returns:
+            Modified LaTeX string
+        """
+        # Sort by position (reverse order) to maintain indices
+        replacements.sort(key=lambda x: x[0], reverse=True)
+
+        result = latex
+        for start, end, replacement in replacements:
+            result = result[:start] + replacement + result[end:]
+
+        return result
+
+
+# Convenience function for direct use
+def add_universal_left_right(latex: str, debug: bool = False) -> str:
+    """
+    Add \\left and \\right to all delimiter pairs in LaTeX.
+
+    Convenience function that creates a DelimiterPairingProcessor and
+    processes the LaTeX string.
+
+    This function handles:
+    - Symmetric pairs: (), [], {}, ||
+    - Interval notation: [), (], etc.
+    - Skips protected contexts (\\left...\\right, cases environment)
+
+    Args:
+        latex: LaTeX string from conversion
+        debug: Enable debug output to stderr
+
+    Returns:
+        LaTeX string with \\left...\\right added to all delimiter pairs
+
+    Examples:
+        >>> add_universal_left_right("(x + y)")
+        "\\\\left(x + y\\\\right)"
+
+        >>> add_universal_left_right("[0, 1)")
+        "\\\\left[0, 1\\\\right)"
+
+        >>> add_universal_left_right("\\\\left\\\\{ \\\\begin{array}...\\\\right.")
+        "\\\\left\\\\{ \\\\begin{array}...\\\\right."  (unchanged)
+    """
+    processor = DelimiterPairingProcessor(debug=debug)
+    return processor.process(latex)
diff --git a/scripts/omml_mathml2latex/converters/post_processor.py b/scripts/omml_mathml2latex/converters/post_processor.py
new file mode 100644
index 0000000..b92af68
--- /dev/null
+++ b/scripts/omml_mathml2latex/converters/post_processor.py
@@ -0,0 +1,2094 @@
+"""
+LaTeX post-processing pipeline for cleaning up and optimizing converted equations.
+
+This module implements a 7-step post-processing pipeline that:
+1. Fixes consecutive equals patterns (= → \\xlongequal)
+2. Processes delimiters (adds \\left/\\right for scaling)
+3. Handles unclosed set notation
+4. Adds intelligent spacing after LaTeX commands
+5. Performs final cleanup (various pattern fixes)
+6. Merges consecutive \\mathrm{} blocks (chemical formulas)
+7. Validates output quality
+
+Each step is independent and can be disabled if needed.
+"""
+
+import re
+import logging
+from typing import List, Dict, Any, Optional
+
+from ..utils.debug import debug_print
+from ..data import MATHJAX_UNSUPPORTED_TO_UNICODE , REGIONAL_SYMBOL_PREFERENCES
+
+
+class PostProcessor:
+    """
+    LaTeX post-processor that applies cleanup and optimization steps.
+
+    The pipeline is designed to fix common issues from MathML → LaTeX conversion:
+    - Fragmented chemical formulas: \\mathrm{C}\\mathrm{u} → \\mathrm{Cu}
+    - Missing delimiter scaling: (x) → \\left(x\\right)
+    - Spacing issues: \\sinx → \\sin x
+    - Consecutive equals: = \\xlongequal{} → \\xlongequal{}
+    - Pattern-specific fixes for cleaner output
+    """
+
+    def __init__(self, chemical_elements: set = None, common_units: set = None, subject_mode: str = 'auto'):
+        """
+        Initialize post-processor with optional configuration.
+
+        Args:
+            chemical_elements: Set of chemical element symbols (for cleanup rules)
+            common_units: Set of common unit abbreviations (for cleanup rules)
+            subject_mode: Subject mode ('auto', 'math', 'chemistry', etc.)
+        """
+        self.chemical_elements = chemical_elements or set()
+        self.common_units = common_units or set()
+        self.subject_mode = subject_mode
+
+        # ===== EXPLICIT COMMAND CATEGORIES FOR SPACING =====
+
+        # Mathematical functions that need spacing when followed by variables
+        # These should have: \sin x (with space) but NOT: \sin\cos (before another command)
+        self.math_functions = [
+            # Trigonometric
+            'sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+            'arcsin', 'arccos', 'arctan', 'arccot', 'arcsec', 'arccsc',
+            'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch',
+            # Arc-hyperbolic (inverse hyperbolic functions)
+            'arcsinh', 'arccosh', 'arctanh', 'arccoth', 'arcsech', 'arccsch',
+            # Also support alternative notation (asinh, etc.)
+            'asinh', 'acosh', 'atanh', 'acoth', 'asech', 'acsch',
+            # Logarithmic
+            'log', 'ln', 'lg', 'exp',
+            # Limits and extrema
+            'lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min',
+            # Linear algebra
+            'det', 'dim', 'ker', 'arg', 'deg', 'gcd', 'hom', 'Pr',
+        ]
+
+        # Large operators that need special handling
+        # These need space before variables: \int x, \sum x
+        # But NOT before modifiers: \int\limits, \sum\nolimits
+        self.large_operators = [
+            'int', 'iint', 'iiint', 'oint', 'oiint', 'oiiint',
+            'sum', 'prod', 'coprod',
+            'bigcup', 'bigcap', 'bigsqcup', 'bigvee', 'bigwedge',
+            'bigodot', 'bigoplus', 'bigotimes', 'biguplus',
+        ]
+
+        # Modifiers that should NEVER have space before them
+        # Example: \int\limits (no space), \sum\nolimits (no space)
+        self.modifiers_no_space_before = [
+            'limits', 'nolimits', 'displaylimits',
+        ]
+
+        # Style/size commands that should NEVER have space after them
+        # Example: \displaystyle\int (no space), \mathbf{x} (no space)
+        self.style_commands_no_space_after = [
+            # Display styles
+            'displaystyle', 'textstyle', 'scriptstyle', 'scriptscriptstyle',
+            # Font commands
+            'mathbf', 'mathit', 'mathrm', 'mathbb', 'mathcal', 'mathfrak',
+            'mathsf', 'mathtt', 'mathscr', 'mathbfup', 'mathbfit',
+            'boldsymbol', 'pmb',
+            # Text commands
+            'text', 'textbf', 'textit', 'textrm', 'textsf', 'texttt',
+            # Size commands
+            'big', 'Big', 'bigg', 'Bigg',
+            'bigl', 'Bigl', 'biggl', 'Biggl',
+            'bigr', 'Bigr', 'biggr', 'Biggr',
+            'bigm', 'Bigm', 'biggm', 'Biggm',
+        ]
+
+        # Delimiter commands that should NEVER have space after them
+        # Example: \left( (no space), \right) (no space)
+        self.delimiter_commands = [
+            'left', 'right', 'middle',
+            'langle', 'rangle', 'lfloor', 'rfloor', 'lceil', 'rceil',
+            'lvert', 'rvert', 'lVert', 'rVert',
+            'lgroup', 'rgroup', 'lmoustache', 'rmoustache',
+        ]
+
+        # Composite delimiter patterns (command + delimiter)
+        # These are multi-character patterns that should never have space in between
+        # Example: \left( (not \left (), \right| (not \right |)
+        self.composite_delimiters = [
+            # left delimiters
+            r'\left\(', r'\left\)', r'\left\[', r'\left\]',
+            r'\left\{', r'\left\}', r'\left\|', r'\left|',
+            r'\left\langle', r'\left\rangle',
+            r'\left\lfloor', r'\left\rfloor',
+            r'\left\lceil', r'\left\rceil',
+            r'\left\lvert', r'\left\rvert',
+            r'\left\lVert', r'\left\rVert',
+            r'\left.',  # \left. for unpaired delimiter
+            # right delimiters
+            r'\right\(', r'\right\)', r'\right\[', r'\right\]',
+            r'\right\{', r'\right\}', r'\right\|', r'\right|',
+            r'\right\langle', r'\right\rangle',
+            r'\right\lfloor', r'\right\rfloor',
+            r'\right\lceil', r'\right\rceil',
+            r'\right\lvert', r'\right\rvert',
+            r'\right\lVert', r'\right\rVert',
+            r'\right.',  # \right. for unpaired delimiter
+            # middle delimiters
+            r'\middle\|', r'\middle|',
+        ]
+
+        # Comparison and relation operators that need spacing
+        # These should have: \lt 5, \gt 10, \leq x
+        self.comparison_operators = [
+            # Must be sorted by length (longest first) to avoid partial matches
+            'leqslant', 'geqslant', 'nleqslant', 'ngeqslant',
+            'nless', 'ngtr', 'nleq', 'ngeq',
+            'leq', 'geq', 'neq',
+            'lll', 'ggg', 'll', 'gg',
+            'lt', 'gt', 'le', 'ge', 'ne',
+            'approx', 'equiv', 'sim', 'simeq', 'cong',
+        ]
+
+        # Other symbols that need spacing
+        self.symbols_need_spacing = [
+            # Geometric
+            'angle', 'parallel', 'perp', 'triangle',
+            # Set operations
+            'cap', 'cup', 'subset', 'supset', 'subseteq', 'supseteq',
+            'notin', 'owns',  # 'in' and 'ni' removed to avoid conflicts
+            # Logic
+            'forall', 'exists', 'nexists',
+            'neg', 'land', 'lor', 'implies', 'iff',
+            # Operators
+            'square', 'circ', 'cdot', 'times', 'div',
+            'pm', 'mp', 'ast', 'star', 'dagger', 'ddagger',
+            # Arrows (basic and extended)
+            'to', 'gets', 'mapsto', 'longmapsto',
+            'uparrow', 'downarrow', 'updownarrow',  # Single arrows
+            'Uparrow', 'Downarrow', 'Updownarrow',  # Double arrows
+            'leftarrow', 'rightarrow', 'leftrightarrow',  # Horizontal arrows
+            'Leftarrow', 'Rightarrow', 'Leftrightarrow',  # Double horizontal
+            'longleftarrow', 'longrightarrow', 'longleftrightarrow',  # Long arrows
+            'Longleftarrow', 'Longrightarrow', 'Longleftrightarrow',  # Long double
+            'nearrow', 'searrow', 'swarrow', 'nwarrow',  # Diagonal arrows
+            # Arrow plurals (double arrows stacked)
+            'leftrightarrows', 'rightleftarrows', 'leftleftarrows', 'rightrightarrows',
+            'upuparrows', 'downdownarrows', 'updownarrows', 'downuparrows',
+            # Harpoons
+            'leftharpoonup', 'leftharpoondown', 'rightharpoonup', 'rightharpoondown',
+            'leftrightharpoons', 'rightleftharpoons',
+            'upharpoonleft', 'upharpoonright', 'downharpoonleft', 'downharpoonright',
+            # Hooked arrows
+            'hookleftarrow', 'hookrightarrow',
+            # Curved arrows
+            'curvearrowleft', 'curvearrowright',
+            'circlearrowleft', 'circlearrowright',
+            # Twohead arrows
+            'twoheadleftarrow', 'twoheadrightarrow',
+        ]
+
+        # Common symbols that should NOT be split (for protection)
+        # These are added to prevent partial matches (e.g., \inf inside \infty, \cdot inside \cdots)
+        self.protected_symbols = [
+            # ===== SPECIAL COMMANDS THAT MUST NOT BE SPLIT =====
+            # Protect \genfrac from being split into \ge + nfrac
+            'genfrac',
+            # Protect array-related commands
+            'begin', 'end',
+            # ===== GREEK LETTERS =====
+            'infty', 'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
+            'eta', 'theta', 'iota', 'kappa', 'lambda', 'mu', 'nu', 'xi',
+            'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon', 'phi',
+            'chi', 'psi', 'omega',
+            'Gamma', 'Delta', 'Theta', 'Lambda', 'Xi', 'Pi', 'Sigma',
+            'Upsilon', 'Phi', 'Psi', 'Omega',
+            'varphi', 'varepsilon', 'vartheta', 'varrho', 'varsigma',
+
+            # ===== SPECIAL SYMBOLS =====
+            'partial', 'nabla', 'emptyset', 'varnothing',
+
+            # ===== BRACKET/DELIMITER SYMBOLS (ll/parallel are prefixes) =====
+            'llbracket', 'rrbracket', 'llparenthesis', 'rrparenthesis',
+            'parallelogram',  # parallel is prefix
+
+            # ===== ELLIPSIS (cdot is prefix of cdots) =====
+            'cdots', 'ldots', 'vdots', 'ddots', 'iddots',
+
+            # ===== TRIGONOMETRIC FUNCTIONS =====
+            # Hyperbolic functions (sin/cos/tan/cot/sec/csc are prefixes)
+            'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch',
+            # Arc functions (arcsin/arccos/etc are prefixes of arcsinh/arccosh/etc)
+            'arcsin', 'arccos', 'arctan', 'arccot', 'arcsec', 'arccsc',
+            # Arc-hyperbolic functions
+            'arcsinh', 'arccosh', 'arctanh', 'arccoth', 'arcsech', 'arccsch',
+
+            # ===== LIMITS AND EXTREMA (lim is prefix of limsup/liminf) =====
+            'limsup', 'liminf', 'limits',
+
+            # ===== INTEGRALS (int is prefix of iint/iiint/oint) =====
+            'iint', 'iiint', 'oint', 'oiint', 'oiiint',
+
+            # ===== COMPARISON OPERATORS =====
+            # leq/geq are prefixes of leqslant/geqslant
+            'leqslant', 'geqslant', 'nleqslant', 'ngeqslant',
+            # Other comparison variants
+            'leq', 'geq', 'neq',
+            'lll', 'ggg',  # ll/gg are prefixes
+            'simeq',  # sim is prefix
+
+            # ===== SET OPERATIONS (subset/supset are prefixes) =====
+            'subseteq', 'supseteq', 'subsetneq', 'supsetneq',
+
+            # ===== LOGIC (ne is prefix of neg/neq/nexists) =====
+            'neg', 'neq', 'nexists',
+
+            # ===== ARROWS =====
+            # Arrow plurals (leftarrow/rightarrow/etc are prefixes)
+            'leftrightarrows', 'rightleftarrows', 'leftleftarrows', 'rightrightarrows',
+            'upuparrows', 'downdownarrows', 'updownarrows', 'downuparrows',
+            # Arrow tails (leftarrow/rightarrow are prefixes)
+            'leftarrowtail', 'rightarrowtail',
+            # Harpoons
+            'upharpoonleft', 'upharpoonright', 'downharpoonleft', 'downharpoonright',
+            'leftrightharpoons', 'rightleftharpoons',
+            # Long arrows
+            'longleftrightarrow', 'longrightarrow', 'longleftarrow',
+            'Longleftrightarrow', 'Longrightarrow', 'Longleftarrow',
+            # Two-head arrows
+            'twoheadleftarrow', 'twoheadrightarrow',
+            # Hooked arrows
+            'hookleftarrow', 'hookrightarrow',
+            # Curved arrows
+            'curvearrowleft', 'curvearrowright', 'circlearrowleft', 'circlearrowright',
+
+            # ===== DELIMITERS =====
+            'langle', 'rangle', 'lfloor', 'rfloor', 'lceil', 'rceil',
+            'lvert', 'rvert', 'lVert', 'rVert',
+            'lgroup', 'rgroup', 'lmoustache', 'rmoustache',
+
+            # ===== OPERATORS =====
+            'bigcap', 'bigcup', 'bigvee', 'bigwedge', 'bigodot', 'bigoplus', 'bigotimes',
+            'bigsqcup', 'biguplus',
+
+            # ===== GEOMETRY =====
+            'triangle', 'angle', 'measuredangle', 'sphericalangle',
+            'triangleq', 'triangleleft', 'triangleright',
+
+            # ===== MISCELLANEOUS =====
+            'parallel', 'nparallel', 'perp',
+            'models', 'vdash', 'dashv',
+            'propto', 'varpropto',
+            'therefore', 'because',
+        ]
+
+    def process(self, latex: str, set_theory_mode: bool = False, subject_mode: Optional[str] = None, skip_delimiter_processing: bool = False) -> str:
+        # Store for use in validate_output()
+        self._skip_delimiter_processing = skip_delimiter_processing
+        """
+        Apply full 7-step post-processing pipeline.
+
+        Args:
+            latex: Raw LaTeX string from conversion
+            set_theory_mode: Whether to enable set theory notation fixes
+            subject_mode: Subject mode ('chemistry', 'math', 'physics', etc.)
+            skip_delimiter_processing: Skip delimiter processing (Phase 3: use new processor instead)
+
+        Returns:
+            Cleaned and optimized LaTeX string
+
+        Pipeline Steps:
+            1. Fix consecutive equals patterns
+            2. Process delimiters (\\left/\\right) - SKIPPED if skip_delimiter_processing=True
+            3. Handle unclosed set notation
+            4. Add intelligent spacing
+            5. Final cleanup
+            6. Merge consecutive \\mathrm{}
+            6.5. Merge fragmented chemistry elements
+            6.6. Format chemistry constants (K_sp, K_a, etc.)
+            7. Validate output
+        """
+        # Step 1: Fix consecutive equals patterns split across elements
+        latex = self.post_process_consecutive_equals(latex)
+
+        # Step 2: Add \\left and \\right to delimiters for proper scaling
+        # Phase 3 Fix: Skip this if using new delimiter_pairing_processor
+        if not skip_delimiter_processing:
+            latex = self.process_delimiters(latex)
+
+        # Step 3: Handle unclosed set notation
+        latex = self.post_process_unclosed_sets(latex, set_theory_mode)
+
+        # Step 4: Apply intelligent spacing enhancements
+        latex = self.add_intelligent_spacing(latex)
+
+        # Step 5: Final cleanup for specific patterns
+        latex = self.final_cleanup(latex)
+
+        # Step 5.5: Merge consecutive identical formatting commands (general)
+        # This handles cases like: \mathbf{F} \mathbf{e} → \mathbf{Fe}
+        latex = self.merge_consecutive_formatting(latex)
+
+        # Step 6: Merge consecutive \\mathrm{} blocks (chemical formulas)
+        latex = self.merge_consecutive_mathrm(latex)
+
+        # Step 6.3: Wrap ion charges in \\mathrm{} (chemistry mode only)
+        if self.subject_mode == 'chemistry':
+            latex = self.wrap_ion_charges_in_mathrm(latex)
+
+        # Step 6.5: Merge fragmented chemistry elements with charges (safety net)
+        latex = self.merge_fragmented_chemistry_elements(latex)
+
+        # Step 6.6: Format chemistry constants (K_{sp} → K_{\mathrm{sp}})
+        # This is intelligent: detects chemistry context and applies formatting automatically
+        latex = self.format_chemistry_constants(latex, subject_mode=subject_mode)
+
+        # Step 6.7: Apply Unicode fallback for MathJax-unsupported commands
+        latex = self.apply_mathjax_unicode_fallback(latex)
+
+        # Step 7: Validate output (detect and fix remaining issues)
+        latex = self.validate_output(latex)
+
+        return latex
+
+    def post_process_consecutive_equals(self, latex: str) -> str:
+        """
+        Post-process the entire LaTeX output to fix consecutive equals patterns.
+
+        This handles cases where equals signs are split across multiple mtext elements,
+        like '+3C=' followed by '\\xlongequal{\\quad}', which should become
+        '+3C \\xlongequal{\\quad}' (remove the extra =).
+
+        Args:
+            latex: LaTeX string with potential consecutive equals issues
+
+        Returns:
+            LaTeX with fixed equals patterns
+
+        Examples:
+            "= \\xlongequal{text}" → "\\xlongequal{text}"
+            "= = =" → "\\xlongequal[\\quad]{}"
+            "\\xlongequal{text}" → "\\xlongequal[\\quad]{text}"
+        """
+        # Pattern 1: equals sign followed by \\xlongequal (remove leading =)
+        latex = re.sub(r'=\s*\\xlongequal\{([^}]*)\}', r'\\xlongequal{\1}', latex)
+
+        # Pattern 2: Multiple consecutive equals signs → xlongequal
+        latex = re.sub(r'=\s*=\s*=+', r'\\xlongequal[\\quad]{}', latex)
+
+        # Pattern 3: xlongequal without brackets → add [\\quad]
+        latex = re.sub(r'\\xlongequal(?!\[)(\{[^}]*\})', r'\\xlongequal[\\quad]\1', latex)
+
+        # Pattern 4: xlongequal with empty brackets → add [\\quad]
+        latex = re.sub(r'\\xlongequal\[\]\{([^}]*)\}', r'\\xlongequal[\\quad]{\1}', latex)
+
+        return latex
+
+    def _handle_set_notation(self, latex: str) -> str:
+        """
+        Detect and handle set notation patterns before general delimiter processing.
+
+        Set notation pattern: {content|conditions}
+        In this pattern:
+        - The outer { and } are kept as delimiters (will become \\left\\{...\\right\\})
+        - The | becomes \\mid (set separator, not a delimiter)
+        - Inner delimiters are processed normally
+
+        Paired pipe pattern: |content|
+        In this pattern:
+        - Both | characters should be paired delimiters (will become \\left|...\\right|)
+        - These are absolute values or norms, NOT set notation
+
+        Args:
+            latex: LaTeX string with __DELIM__ markers
+
+        Returns:
+            LaTeX with set notation handled (| → \\mid only when in braces, preserved otherwise)
+
+        Examples:
+            Set notation: "__DELIM__{__DELIM__(x,y)__DELIM__|__DELIM__{...}__DELIM__}__DELIM__" →
+                         "__DELIM__{__DELIM__(x,y) \\mid {...}__DELIM__}__DELIM__"
+            Absolute value: "__DELIM__|__DELIM__x__DELIM__|__DELIM__" → unchanged (will be paired)
+        """
+        # Debug: Show BEFORE
+        if '__DELIM__|__DELIM__' in latex:
+            preview_before = latex[:200] if len(latex) > 200 else latex
+            debug_print(f"[DEBUG SET] BEFORE: {repr(preview_before)}")
+
+        # Strategy: Only convert | to \mid when it's clearly in set notation context
+        # Detect set notation: { ... | ... } pattern
+        # Do NOT convert paired absolute values: | ... | pattern
+
+        # Find all pipe positions
+        pipe_pattern = r'__DELIM__(?:STRETCHY::)?\|__DELIM__'
+        pipes = list(re.finditer(pipe_pattern, latex))
+
+        if not pipes:
+            return latex
+
+        # Find all brace positions (both marked and already-converted)
+        # Pattern 1: Marked braces __DELIM__{__DELIM__ or __DELIM__}__DELIM__ (with optional STRETCHY prefix)
+        # Pattern 2: Already-converted braces \left\{ or \right\}
+        brace_pattern = r'(__DELIM__(?:STRETCHY::)?([{}])__DELIM__|\\left\\{|\\right\\})'
+        braces = list(re.finditer(brace_pattern, latex))
+
+        # Build list of pipes to convert (those between matching braces)
+        pipes_to_convert = []
+
+        for pipe in pipes:
+            pipe_pos = pipe.start()
+
+            # Find the nearest enclosing brace pair
+            # Look for { before pipe and } after pipe
+            left_brace = None
+            right_brace = None
+
+            # Find nearest { before pipe (check both marked and converted forms)
+            for brace in reversed(braces):
+                brace_text = brace.group(1)
+                if brace.start() < pipe_pos:
+                    # Check if it's an opening brace
+                    # Group 2 captures the brace char if it's a marked delimiter
+                    if (brace.group(2) == '{') or brace_text == '\\left\\{':
+                        left_brace = brace
+                        break
+                    elif (brace.group(2) == '}') or brace_text == '\\right\\}':
+                        # Skip closing braces
+                        continue
+
+            # Find nearest } after pipe (check both marked and converted forms)
+            for brace in braces:
+                brace_text = brace.group(1)
+                if brace.start() > pipe_pos:
+                    # Check if it's a closing brace
+                    if (brace.group(2) == '}') or brace_text == '\\right\\}':
+                        right_brace = brace
+                        break
+                    elif (brace.group(2) == '{') or brace_text == '\\left\\{':
+                        # Skip opening braces
+                        continue
+
+            # If pipe is between { and }, it's set notation → convert to \mid
+            if left_brace and right_brace:
+                pipes_to_convert.append(pipe)
+                debug_print(f"[DEBUG SET] Pipe at {pipe_pos} is between braces → convert to \\mid")
+            else:
+                debug_print(f"[DEBUG SET] Pipe at {pipe_pos} is NOT between braces → keep as delimiter for pairing")
+
+        # Convert marked pipes to \mid (in reverse order to preserve positions)
+        result = latex
+        for pipe in reversed(pipes_to_convert):
+            result = result[:pipe.start()] + ' \\mid ' + result[pipe.end():]
+
+        # Debug: Check if pattern matched
+        if result != latex:
+            preview_after = result[:200] if len(result) > 200 else result
+            debug_print(f"[DEBUG SET] AFTER:  {repr(preview_after)}")
+            debug_print(f"[DEBUG SET] Converted {len(pipes_to_convert)} pipes to \\mid (out of {len(pipes)} total)")
+
+        return result
+
+    def process_delimiters(self, latex: str) -> str:
+        """
+        Post-process LaTeX to add \\left and \\right to delimiters for proper scaling.
+
+        Delimiters are marked with __DELIM__ during conversion to indicate they need
+        scaling. This method pairs them and adds \\left/\\right commands.
+
+        Args:
+            latex: LaTeX string with __DELIM__ markers
+
+        Returns:
+            LaTeX with \\left/\\right added to delimiter pairs
+
+        Examples:
+            "__DELIM__(x)__DELIM__" → "\\left(x\\right)"
+            "__DELIM__|x|__DELIM__" → "\\left|x\\right|"
+        """
+        # STEP 1: Detect and handle set notation BEFORE general delimiter processing
+        # Pattern: {content|conditions} → content \mid conditions
+        # The outer { is removed and | becomes \mid (not a delimiter)
+        latex = self._handle_set_notation(latex)
+
+        # Pattern to match marked delimiters (including Unicode angle brackets, ceil, floor, and LaTeX commands)
+        # Match either:
+        # 1. Single character delimiters: () [] {} | ⟨⟩ etc.
+        # 2. LaTeX command delimiters: \langle \rangle \lceil \rceil \lfloor \rfloor
+        # UPDATED: Support STRETCHY:: prefix and escaped braces
+        delim_pattern = r'__DELIM__(?:STRETCHY::)?(\\(?:langle|rangle|lceil|rceil|lfloor|rfloor|{|})|[()[\]{}|⟨⟩〈〉⌈⌉⌊⌋])__DELIM__'
+
+        # Find all delimiters and their positions
+        delimiters = []
+        for match in re.finditer(delim_pattern, latex):
+            delimiters.append({
+                'char': match.group(2),
+                'is_stretchy': bool(match.group(1)),
+                'start': match.start(),
+                'end': match.end(),
+                'full_match': match.group(0)
+            })
+
+        if not delimiters:
+            # No __DELIM__ markers found - either already processed or not needed
+            return latex
+
+        # Dictionary of delimiter pairs
+        delimiter_pairs = {
+            '(': ')',
+            '[': ']',
+            '{': '}',
+            '\\{': '\\}',  # Escaped braces
+            '|': '|',  # Pipe pairs with itself for absolute value/norms
+            '⟨': '⟩',  # Angle brackets (Unicode)
+            '〈': '〉',  # CJK angle brackets (Unicode)
+            '⌈': '⌉',  # Ceiling (Unicode)
+            '⌊': '⌋',  # Floor (Unicode)
+            '\\langle': '\\rangle',  # Angle brackets (LaTeX)
+            '\\lceil': '\\rceil',    # Ceiling (LaTeX)
+            '\\lfloor': '\\rfloor',  # Floor (LaTeX)
+        }
+
+        # Define opening and closing delimiters
+        opening_delims = set(['(', '[', '{', '\\{', '|', '⟨', '〈', '⌈', '⌊', '\\langle', '\\lceil', '\\lfloor'])
+        closing_delims = set([')', ']', '}', '\\}', '|', '⟩', '〉', '⌉', '⌋', '\\rangle', '\\rceil', '\\rfloor'])
+
+        # Check if this is set notation context (has \mid in the equation)
+        is_set_notation = '\\mid' in latex
+
+        # Stack to track opening delimiters
+        stack = []
+        pairs = []
+
+        # First pass: identify delimiter pairs
+        for delim in delimiters:
+            char = delim['char']
+
+            # Special handling for pipe - it pairs with itself OR closes angle brackets (bra-ket notation)
+            if char == '|':
+                # First, check if there's an angle bracket in the stack (bra notation: ⟨φ| or \langle\phi|)
+                # This takes priority over pipe-pipe pairing
+                langle_in_stack = False
+                for i, stacked_delim in enumerate(stack):
+                    if stacked_delim['char'] in ('⟨', '〈', '\\langle'):
+                        # Found angle bracket - pair with this pipe as closing delimiter
+                        opening_delim = stack.pop(i)
+                        pairs.append((opening_delim, delim))
+                        langle_in_stack = True
+                        break
+
+                if not langle_in_stack:
+                    # No angle bracket found, check if there's an unpaired pipe in the stack
+                    pipe_in_stack = False
+                    for i, stacked_delim in enumerate(stack):
+                        if stacked_delim['char'] == '|':
+                            # Found matching opening pipe - pair them
+                            opening_delim = stack.pop(i)
+                            pairs.append((opening_delim, delim))
+                            pipe_in_stack = True
+                            break
+
+                    if not pipe_in_stack:
+                        # No matching pipe found - this is an opening pipe
+                        stack.append(delim)
+            elif char in opening_delims:  # Opening delimiter
+                stack.append(delim)
+            elif char in closing_delims:  # Closing delimiter
+                if stack:
+                    # Special case: In set notation, don't pair a } with a { that precedes \begin{array}
+                    # This allows the array brace to remain unpaired (will use \right.)
+                    opening_delim = stack[-1]  # Peek at top of stack
+
+                    # Check if opening brace has array immediately after it
+                    skip_pairing = False
+                    if is_set_notation and opening_delim['char'] == '{' and char == '}':
+                        content_after_opening = latex[opening_delim['end']:opening_delim['end']+30]
+                        if '\\begin{array}' in content_after_opening:
+                            # This opening brace should stay unpaired - don't pop it
+                            # Check if there's another brace before it on the stack
+                            if len(stack) > 1:
+                                # Pop the array brace BUT PUT IT BACK after pairing the outer one
+                                array_brace = stack.pop()  # Remove temporarily
+                                opening_delim = stack.pop()  # Get the outer brace
+                                pairs.append((opening_delim, delim))
+                                stack.append(array_brace)  # Put array brace back as unpaired
+                            else:
+                                # Only the array brace on stack - leave it unpaired
+                                skip_pairing = True
+                        else:
+                            opening_delim = stack.pop()
+                            pairs.append((opening_delim, delim))
+                    else:
+                        opening_delim = stack.pop()
+                        pairs.append((opening_delim, delim))
+
+        # Handle unpaired opening delimiters (like single left brace for cases)
+        unpaired_replacements = []
+        array_right_dots = []  # Track where to insert \right. for array braces
+
+        for unpaired in stack:
+            if unpaired['char'] == '{':
+                # Check if this brace has \right. position marked (for array braces)
+                if unpaired.get('needs_right_dot'):
+                    # This is an array brace - add \left\{ and mark \right. position
+                    replacement = '\\left\\{'
+                    unpaired_replacements.append((unpaired['full_match'], replacement))
+                    array_right_dots.append(unpaired['right_dot_pos'])
+                else:
+                    # Single left brace → use \\left\\{ for regular unpaired braces
+                    replacement = '\\left\\{'
+                    unpaired_replacements.append((unpaired['full_match'], replacement))
+
+        # Second pass: replace delimiter pairs with \\left/\\right
+        # Process in reverse order to maintain position indices
+        result = latex
+
+        # DEBUG: Show pairing info
+        latex_preview = latex[:80] if len(latex) > 80 else latex
+        if pairs:
+            debug_print(f"[DEBUG DELIM] Found {len(pairs)} delimiter pairs in: {repr(latex_preview)}...")
+            for opening, closing in pairs:
+                debug_print(f"  - Pair: {opening['char']} ... {closing['char']}")
+        elif delimiters:
+            debug_print(f"[DEBUG DELIM] Found {len(delimiters)} delimiters but NO pairs in: {repr(latex_preview)}!")
+            for d in delimiters:
+                debug_print(f"  - {d['char']} at pos {d['start']}")
+
+        # DEBUG: Show unpaired delimiters
+        if stack:
+            debug_print(f"[DEBUG UNPAIRED] Found {len(stack)} unpaired delimiters:")
+            for unpaired in stack:
+                context = latex[unpaired['end']:unpaired['end']+40]
+                debug_print(f"  - {unpaired['char']} at {unpaired['start']}, after: {context!r}")
+
+        # Handle unpaired braces that precede arrays (they need \right. after the array)
+        for unpaired in stack:
+            if unpaired['char'] == '{':
+                content_after = latex[unpaired['end']:]
+                array_match = re.search(r'\\begin\{array\}.*?\\end\{array\}', content_after, re.DOTALL)
+                if array_match:
+                    # This is an array brace - add \right. after the array
+                    array_end_pos = unpaired['end'] + array_match.end()
+                    # Add to list for processing
+                    array_right_dots.append(array_end_pos)
+                    unpaired['needs_right_dot'] = True
+                    unpaired['right_dot_pos'] = array_end_pos
+                    debug_print(f"[DEBUG UNPAIRED] Array brace at {unpaired['start']} will get \\right. at {array_end_pos}")
+
+        # Build a list of ALL replacements BEFORE applying any
+        # This prevents position corruption
+        all_replacements = []
+
+        # Add paired delimiter replacements
+        for opening, closing in pairs:
+            # CRITICAL: Check if content between delimiters needs scaling
+            start_pos = opening['end']
+            end_pos = closing['start']
+            content = latex[start_pos:end_pos]
+
+            # ALWAYS scale in these cases:
+            # 1. Explicitly requested via stretchy attribute (STRETCHY:: prefix)
+            # 2. Pipes (absolute value/norms)
+            # 3. Angle brackets (⟨⟩ or \langle\rangle), ceil (⌈⌉ or \lceil\rceil), floor (⌊⌋ or \lfloor\rfloor)
+            # 4. Set notation context - all delimiters should be scaled for consistency
+            if opening.get('is_stretchy') or closing.get('is_stretchy'):
+                needs_scaling = True
+            elif opening['char'] == '|' or closing['char'] == '|':
+                needs_scaling = True
+            elif (opening['char'] in ('⟨', '〈', '⌈', '⌊', '\\langle', '\\lceil', '\\lfloor') or
+                  closing['char'] in ('⟩', '〉', '⌉', '⌋', '\\rangle', '\\rceil', '\\rfloor')):
+                # Angle brackets, ceil, and floor MUST use \left\langle/\right\rangle, etc.
+                # There's no plain LaTeX equivalent for these Unicode characters
+                needs_scaling = True
+            elif is_set_notation:
+                # In set notation, scale ALL delimiters for consistent appearance
+                needs_scaling = True
+            else:
+                needs_scaling = self._needs_delimiter_scaling(content)
+
+            # DEBUG
+            debug_print(f"[DEBUG SCALE] Delimiter pair {opening['char']}...{closing['char']}: content={repr(content[:50])}... needs_scaling={needs_scaling} (set_notation={is_set_notation})")
+
+            # Check if content already has leading/trailing spaces
+            has_leading_space = content.startswith(' ')
+            has_trailing_space = content.endswith(' ')
+
+            # Build \\left/\\right commands ONLY if scaling is needed
+            if needs_scaling:
+                # Add space after \left only if content doesn't already start with space
+                left_space = '' if has_leading_space else ' '
+                # Add space before \right only if content doesn't already end with space
+                right_space = '' if has_trailing_space else ' '
+
+                # CRITICAL: Escape braces in LaTeX (\\left{ → \\left\\{)
+                if opening['char'] == '{' or opening['char'] == '\\{':
+                    left_cmd = f"\\left\\{{{left_space}"
+                elif opening['char'] == '}' or opening['char'] == '\\}':
+                    left_cmd = f"\\left\\}}{left_space}"  # Shouldn't happen
+                elif opening['char'] == '|':
+                    left_cmd = f"\\left|{left_space}"
+                elif opening['char'] in ('⟨', '〈', '⌈', '⌊', '\\langle', '\\lceil', '\\lfloor'):
+                    # Map Unicode and LaTeX to LaTeX commands
+                    delim_map = {
+                        '⟨': '\\langle', '〈': '\\langle', '⌈': '\\lceil', '⌊': '\\lfloor',
+                        '\\langle': '\\langle', '\\lceil': '\\lceil', '\\lfloor': '\\lfloor'
+                    }
+                    left_cmd = f"\\left{delim_map[opening['char']]}{left_space}"
+                else:
+                    left_cmd = f"\\left{opening['char']}{left_space}"
+
+                if closing['char'] == '}' or closing['char'] == '\\}':
+                    right_cmd = f"{right_space}\\right\\}}"
+                elif closing['char'] == '{' or closing['char'] == '\\{':
+                    right_cmd = f"{right_space}\\right\\{{"  # Shouldn't happen
+                elif closing['char'] == '|':
+                    right_cmd = f"{right_space}\\right|"
+                elif closing['char'] in ('⟩', '〉', '⌉', '⌋', '\\rangle', '\\rceil', '\\rfloor'):
+                    # Map Unicode and LaTeX to LaTeX commands
+                    delim_map = {
+                        '⟩': '\\rangle', '〉': '\\rangle', '⌉': '\\rceil', '⌋': '\\rfloor',
+                        '\\rangle': '\\rangle', '\\rceil': '\\rceil', '\\rfloor': '\\rfloor'
+                    }
+                    right_cmd = f"{right_space}\\right{delim_map[closing['char']]}"
+                else:
+                    right_cmd = f"{right_space}\\right{closing['char']}"
+            else:
+                # No scaling needed - just use plain delimiters
+                left_cmd = opening['char']
+                right_cmd = closing['char']
+
+            # Add to replacements list (closing first, then opening)
+            all_replacements.append((closing['start'], closing['end'], right_cmd))
+            all_replacements.append((opening['start'], opening['end'], left_cmd))
+
+        # Add unpaired delimiter replacements
+        for unpaired in stack:
+            if unpaired['char'] == '{':
+                all_replacements.append((unpaired['start'], unpaired['end'], '\\left\\{'))
+
+        # Add array \right. insertions
+        if array_right_dots:
+            debug_print(f"[DEBUG ARRAY] Will insert \\right. at positions: {array_right_dots}")
+        for pos in array_right_dots:
+            all_replacements.append((pos, pos, ' \\right.'))  # Insertion at position
+
+        # Sort by position (reverse order) and apply ALL at once
+        all_replacements.sort(key=lambda x: x[0], reverse=True)
+
+        result = latex
+        for start, end, replacement in all_replacements:
+            result = result[:start] + replacement + result[end:]
+
+        return result
+
+    def _needs_delimiter_scaling(self, content: str) -> bool:
+        """
+        Determine if content between delimiters needs scaling with \\left and \\right.
+
+        Checks for indicators of tall content like fractions, large operators, etc.
+
+        Args:
+            content: LaTeX content between delimiters
+
+        Returns:
+            True if content needs scaling, False otherwise
+
+        Examples:
+            "x + y" → False (no scaling needed)
+            "\\dfrac{1}{2}" → True (fraction needs scaling)
+            "0 , \\dfrac{\\pi}{2}" → True (contains fraction)
+        """
+        # Check for indicators that suggest tall content
+        scaling_indicators = [
+            '\\frac', '\\dfrac', '\\tfrac',  # Fractions
+            '\\sum', '\\prod', '\\int',      # Large operators
+            '\\sqrt',                        # Square roots
+            '\\binom',                       # Binomial coefficients
+            '^{', '_{',                      # Scripts (especially nested)
+            '\\overset', '\\underset',       # Over/under sets
+            '\\limits',                      # Limits
+            '\\Big', '\\big',                # Already scaled content
+        ]
+
+        # Check for nested delimiters (benefit from scaling)
+        nested_delims = content.count('(') + content.count('[') + content.count('{')
+
+        # Check for multiple levels (subscripts/superscripts)
+        script_levels = content.count('_') + content.count('^')
+
+        # Determine if scaling is needed
+        needs_scaling = (any(indicator in content for indicator in scaling_indicators) or
+                        nested_delims > 0 or
+                        script_levels > 1 or
+                        len(content) > 20)  # Long expressions often benefit from scaling
+
+        return needs_scaling
+
+    def post_process_unclosed_sets(self, latex: str, set_theory_mode: bool) -> str:
+        r"""
+        Handle unclosed set notation like {(x,y) \\mid conditions} without closing brace.
+
+        This method adds outer braces ONLY if the set notation is implicit (no explicit braces in MathML).
+        If the MathML had explicit braces that were converted to inner \\left\\{...\\right\\}, don't add outer braces.
+
+        Args:
+            latex: LaTeX string
+            set_theory_mode: Whether set theory mode is active
+
+        Returns:
+            LaTeX with proper set notation formatting
+
+        Examples:
+            "(x,y) \\mid x ≠ 1" → "\\left\\{(x,y) \\mid x ≠ 1\\right." (implicit braces)
+            "(x,y) \\mid \\left\\{...\\right\\}" → unchanged (explicit braces already present)
+        """
+        if set_theory_mode:
+            has_mid = '\\mid' in latex
+            debug_print(f"[DEBUG SET] post_process_unclosed_sets called. mid={has_mid}, mode={set_theory_mode}")
+
+            # Check if using set theory mode (debug)
+            if set_theory_mode:
+                # Log usage but keep cleaner for production (logging module better)
+                pass
+
+            if '\\mid' not in latex:
+                return latex
+
+            # Find position of first \mid
+            mid_idx = latex.find('\\mid')
+
+            # Check nesting level at \mid position
+            # We need to count braces before the \mid to see if it's already inside a set
+            text_before = latex[:mid_idx]
+
+            # Count different types of opening braces
+            # 1. Standard/escaped braces
+            # \{ is a brace. { might be a brace or argument (but usually arguments are balanced)
+
+            # Simpler approach: Count all logical opening braces
+            # \left\{
+            count_left_cmd = text_before.count('\\left\\{')
+            # __DELIM__{
+            count_marker = text_before.count('__DELIM__{')
+            # \{ (escaped brace, not part of \left\{)
+            # We subtract count of \left\{ because \{ is inside it
+            count_escaped = text_before.count('\\{') - count_left_cmd
+
+            open_count = count_left_cmd + count_marker + count_escaped
+
+            # Count closing braces
+            # \right\}
+            count_right_cmd = text_before.count('\\right\\}')
+            # __DELIM__}
+            count_marker_close = text_before.count('__DELIM__}')
+            # \}
+            count_escaped_close = text_before.count('\\}') - count_right_cmd
+
+            close_count = count_right_cmd + count_marker_close + count_escaped_close
+
+            if open_count > close_count:
+                # \mid is nested in braces - skipping wrap
+                return latex
+
+            # Check if there are already explicit braces after \\mid (from MathML)
+            # Pattern: \\mid followed by content that includes \\left\\{
+            left_brace_idx = latex.find('\\left\\{', mid_idx)
+            if left_brace_idx > mid_idx and left_brace_idx != -1:
+                # Explicit braces present after \\mid - don't add outer braces
+                return latex
+
+            # Check if the expression already contains balanced braces (\{ and \})
+            # This indicates explicit set notation is already present (even if not yet \left\{...\right\})
+            # Example: "A = \{ x \mid ... \} , B = \{ x \mid ... \}"
+            # Should NOT be wrapped again
+            if '\\{' in latex and '\\}' in latex:
+                 # Re-check global balance just in case
+                total_open = latex.count('\\{')
+                total_close = latex.count('\\}')
+                if total_open > 0 and total_open == total_close:
+                    return latex
+
+            # No explicit braces found - add them for implicit set notation
+            # Split on \\mid but be careful about multiple occurrences
+            parts = latex.split('\\mid', 1)  # Split only on first \\mid
+            if len(parts) == 2:
+                content_before_mid = parts[0].strip()
+                content_after_mid = parts[1].strip()
+
+                # Check if this looks like an unclosed set (no \\left\\{ at start)
+                if not content_before_mid.startswith('\\left\\{'):
+                    # FIX BUG-007: Strip already-escaped braces from visitor output
+                    # When OMML text like {x|conditions} has spaces, visitors escape
+                    # the braces to \{x and \}, but we're about to add \left\{ and \right\}
+                    # So we need to strip these first to avoid double-escaping
+                    content_before_mid = re.sub(r'^\\{', '', content_before_mid)
+                    content_after_mid = re.sub(r'\\}$', '', content_after_mid)
+
+                    # Format as proper set notation with CORRECT f-string brace escaping
+                    # To output \left\{content\right\}:
+                    # - \\left\\{{ outputs \left\{ (backslash-left-backslash, then literal {)
+                    # - {content} for variable interpolation
+                    # - \\right\\}} outputs \right\} (backslash-right-backslash, then literal })
+                    # CRITICAL: Only TWO closing braces at end (one pair {{), not FOUR (}}}})
+                    return f"\\left\\{{{content_before_mid} \\mid {content_after_mid}\\right\\}}"
+
+        return latex
+
+    def add_intelligent_spacing(self, latex: str) -> str:
+        """
+        Add conservative intelligent spacing for better typographical quality.
+
+        This applies minimal spacing enhancements that don't conflict with expected outputs.
+        Based on analysis of test failures, the current dataset expects minimal spacing.
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            LaTeX with improved spacing
+        """
+        # Clean up multiple consecutive spaces
+        latex = re.sub(r' {3,}', '  ', latex)
+
+        # Fix spacing around specific LaTeX commands
+        latex = re.sub(r'\\left\s+\\{', r'\\left\\{', latex)
+        latex = re.sub(r'\\right\s+\\}', r'\\right\\}', latex)
+
+        # Remove spaces inside command names (common parsing error)
+        latex = re.sub(r'\\([a-zA-Z]+)\s+\{', r'\\\1{', latex)
+
+        # Fix spacing after LaTeX commands
+        latex = self.fix_latex_command_spacing(latex)
+
+        return latex
+
+    def fix_latex_command_spacing(self, latex: str) -> str:
+        """
+        Add proper spacing after LaTeX commands using explicit enumeration.
+
+        This new implementation avoids partial command matching by:
+        1. Sorting commands by length (longest first)
+        2. Using explicit word boundaries
+        3. Checking for complete command matches
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            LaTeX with proper command spacing
+
+        Examples:
+            "\\sinx" → "\\sin x"
+            "\\intx" → "\\int x"
+            "\\int\\limits" → "\\int\\limits" (no space before \\limits)
+            "\\limits" → "\\limits" (not broken into \\lim its)
+            "\\displaystyle\\int" → "\\displaystyle\\int" (no space after style commands)
+        """
+        # Step 1: Combine all commands that need spacing and sort by length (longest first)
+        # This prevents partial matches (e.g., matching \lim inside \limits)
+        commands_need_spacing = (
+            self.math_functions +
+            self.large_operators +
+            self.comparison_operators +
+            self.symbols_need_spacing
+        )
+
+        # Sort by length (longest first) to avoid partial matches
+        commands_need_spacing_sorted = sorted(set(commands_need_spacing), key=len, reverse=True)
+
+        # Step 2: Create exclusion set - commands that should NEVER have space after them
+        # Note: We exclude 'left', 'right', 'middle' from blanket no-space rule
+        # because they need special handling (see composite delimiter fixes)
+        delimiter_commands_no_space = [cmd for cmd in self.delimiter_commands
+                                       if cmd not in ('left', 'right', 'middle')]
+
+        no_space_after_commands = set(
+            self.style_commands_no_space_after +
+            self.modifiers_no_space_before  # These shouldn't have space before them
+        )
+
+        # Note: left/right/middle need special handling - see Step 7 for composite patterns
+
+        # Step 3: Build a set of all known longer commands for each command
+        # This helps us avoid matching prefixes (e.g., don't match \lim in \limits)
+        # IMPORTANT: Include ALL delimiter commands here for protection, even though
+        # some are not in no_space_after_commands (they need composite pattern handling)
+        all_known_commands = set(
+            commands_need_spacing_sorted +
+            list(no_space_after_commands) +
+            self.delimiter_commands +  # Include ALL delimiters for protection
+            self.protected_symbols
+        )
+
+        # Step 4: Process each command that needs spacing
+        # Use a careful approach: match complete commands only
+        for cmd in commands_need_spacing_sorted:
+            # Find any known longer commands that start with this command
+            # Example: for 'lim', find 'limits', 'limsup', 'liminf'
+            longer_commands = [
+                longer_cmd[len(cmd):]  # Get the suffix after our command
+                for longer_cmd in all_known_commands
+                if longer_cmd.startswith(cmd) and longer_cmd != cmd
+            ]
+
+            # Build negative lookahead pattern to exclude these longer commands
+            # Example: for 'lim', create (?!its|sup|inf) to avoid matching in \limits, \limsup, \liminf
+            if longer_commands:
+                # Sort by length (longest first) for correct regex matching
+                longer_commands_sorted = sorted(set(longer_commands), key=len, reverse=True)
+                negative_lookahead = '(?!' + '|'.join(re.escape(suffix) for suffix in longer_commands_sorted) + ')'
+            else:
+                negative_lookahead = ''
+
+            # Pattern: \\cmd not followed by known suffixes, but followed by alphanumeric/(
+            # Example: \\lim(?!its|sup|inf)(?=[a-zA-Z0-9(])
+            # For arrows/operators: also match when followed by +, -, =, etc.
+            pattern = f'\\\\{re.escape(cmd)}{negative_lookahead}(?=[a-zA-Z0-9(+\\-=])'
+
+            # Add space after command
+            latex = re.sub(pattern, f'\\\\{cmd} ', latex)
+
+        # Step 4: Remove spaces before LaTeX commands (backslash)
+        # This handles cases like: \sin \dfrac → \sin\dfrac
+        # Build pattern for all commands that need spacing
+        all_commands_pattern = '|'.join(re.escape(cmd) for cmd in commands_need_spacing_sorted)
+
+        # Remove space before any backslash command
+        pattern_remove = f'\\\\({all_commands_pattern}) (?=\\\\)'
+        latex = re.sub(pattern_remove, r'\\\1', latex)
+
+        # Step 5: Remove spaces before modifiers specifically
+        # Example: \int \limits → \int\limits
+        for modifier in self.modifiers_no_space_before:
+            # Remove any space before modifier
+            pattern = f' \\\\{modifier}(?![a-zA-Z])'
+            latex = re.sub(pattern, f'\\\\{modifier}', latex)
+
+        # Step 6: Remove spaces after style/delimiter commands
+        # Example: \displaystyle \int → \displaystyle\int
+        # Example: \left ( → \left(
+        for cmd in no_space_after_commands:
+            # Remove space after these commands
+            pattern = f'\\\\{re.escape(cmd)}(?![a-zA-Z]) '
+            latex = re.sub(pattern, f'\\\\{cmd}', latex)
+
+        # Step 7: Fix composite delimiter patterns (multi-character sequences)
+        # These are patterns like \left(, \right|, etc. that should never have spaces
+        # Example: \left ( → \left(, \right | → \right|
+        composite_fixes = [
+            # left delimiters with space
+            (r'\\left\s+\(', r'\\left('),
+            (r'\\left\s+\)', r'\\left)'),
+            (r'\\left\s+\[', r'\\left['),
+            (r'\\left\s+\]', r'\\left]'),
+            (r'\\left\s+\\{', r'\\left\\{'),
+            (r'\\left\s+\\}', r'\\left\\}'),
+            (r'\\left\s+\\?\|', r'\\left|'),
+            (r'\\left\s+\\\.', r'\\left.'),  # \left \.
+            (r'\\left\s+\.', r'\\left.'),     # \left . (plain dot)
+            # right delimiters with space
+            (r'\\right\s+\(', r'\\right('),
+            (r'\\right\s+\)', r'\\right)'),
+            (r'\\right\s+\[', r'\\right['),
+            (r'\\right\s+\]', r'\\right]'),
+            (r'\\right\s+\\{', r'\\right\\{'),
+            (r'\\right\s+\\}', r'\\right\\}'),
+            (r'\\right\s+\\?\|', r'\\right|'),
+            (r'\\right\s+\\\.', r'\\right.'),  # \right \.
+            (r'\\right\s+\.', r'\\right.'),     # \right . (plain dot)
+            # left with LaTeX delimiter commands
+            (r'\\left\s+\\langle', r'\\left\\langle'),
+            (r'\\left\s+\\rangle', r'\\left\\rangle'),
+            (r'\\left\s+\\lfloor', r'\\left\\lfloor'),
+            (r'\\left\s+\\rfloor', r'\\left\\rfloor'),
+            (r'\\left\s+\\lceil', r'\\left\\lceil'),
+            (r'\\left\s+\\rceil', r'\\left\\rceil'),
+            (r'\\left\s+\\lvert', r'\\left\\lvert'),
+            (r'\\left\s+\\rvert', r'\\left\\rvert'),
+            (r'\\left\s+\\lVert', r'\\left\\lVert'),
+            (r'\\left\s+\\rVert', r'\\left\\rVert'),
+            # right with LaTeX delimiter commands
+            (r'\\right\s+\\langle', r'\\right\\langle'),
+            (r'\\right\s+\\rangle', r'\\right\\rangle'),
+            (r'\\right\s+\\lfloor', r'\\right\\lfloor'),
+            (r'\\right\s+\\rfloor', r'\\right\\rfloor'),
+            (r'\\right\s+\\lceil', r'\\right\\rceil'),
+            (r'\\right\s+\\rceil', r'\\right\\rceil'),
+            (r'\\right\s+\\lvert', r'\\right\\lvert'),
+            (r'\\right\s+\\rvert', r'\\right\\rvert'),
+            (r'\\right\s+\\lVert', r'\\right\\lVert'),
+            (r'\\right\s+\\rVert', r'\\right\\rVert'),
+            # middle delimiters
+            (r'\\middle\s+\\?\|', r'\\middle|'),
+        ]
+
+        for pattern, replacement in composite_fixes:
+            latex = re.sub(pattern, replacement, latex)
+
+        # Step 8: Add spaces AFTER opening delimiters and BEFORE closing delimiters
+        # Example: \left(x\right) → \left( x \right)
+        # Example: \left[10\right] → \left[ 10 \right]
+
+        # Add space after opening delimiters (if not already present)
+        opening_delimiter_patterns = [
+            # === \left delimiters ===
+            # Basic delimiters
+            (r'\\left\((?! )', r'\\left( '),
+            (r'\\left\[(?! )', r'\\left[ '),
+            (r'\\left\\{(?! )', r'\\left\\{ '),
+            (r'\\left\|(?! )', r'\\left| '),           # Plain pipe
+            (r'\\left\\\|(?! )', r'\\left\\| '),       # Escaped pipe \left\|
+
+            # LaTeX delimiter commands - left versions
+            (r'\\left\\langle(?! )', r'\\left\\langle '),
+            (r'\\left\\lfloor(?! )', r'\\left\\lfloor '),
+            (r'\\left\\lceil(?! )', r'\\left\\lceil '),
+            (r'\\left\\lvert(?! )', r'\\left\\lvert '),
+            (r'\\left\\lVert(?! )', r'\\left\\lVert '),
+
+            # LaTeX delimiter commands - right versions (sometimes used as opening)
+            (r'\\left\\rangle(?! )', r'\\left\\rangle '),
+            (r'\\left\\rfloor(?! )', r'\\left\\rfloor '),
+            (r'\\left\\rceil(?! )', r'\\left\\rceil '),
+            (r'\\left\\rvert(?! )', r'\\left\\rvert '),
+            (r'\\left\\rVert(?! )', r'\\left\\rVert '),
+
+            # Other delimiters
+            (r'\\left\\uparrow(?! )', r'\\left\\uparrow '),
+            (r'\\left\\downarrow(?! )', r'\\left\\downarrow '),
+            (r'\\left\\updownarrow(?! )', r'\\left\\updownarrow '),
+            (r'\\left\\Uparrow(?! )', r'\\left\\Uparrow '),
+            (r'\\left\\Downarrow(?! )', r'\\left\\Downarrow '),
+            (r'\\left\\Updownarrow(?! )', r'\\left\\Updownarrow '),
+            (r'\\left/(?! )', r'\\left/ '),
+            (r'\\left\\backslash(?! )', r'\\left\\backslash '),
+
+            # === \bigl, \Bigl, \biggl, \Biggl (manual sizing - left) ===
+            (r'\\bigl\((?! )', r'\\bigl( '),
+            (r'\\bigl\[(?! )', r'\\bigl[ '),
+            (r'\\bigl\\{(?! )', r'\\bigl\\{ '),
+            (r'\\bigl\|(?! )', r'\\bigl| '),
+            (r'\\bigl\\langle(?! )', r'\\bigl\\langle '),
+            (r'\\bigl\\lfloor(?! )', r'\\bigl\\lfloor '),
+            (r'\\bigl\\lceil(?! )', r'\\bigl\\lceil '),
+
+            (r'\\Bigl\((?! )', r'\\Bigl( '),
+            (r'\\Bigl\[(?! )', r'\\Bigl[ '),
+            (r'\\Bigl\\{(?! )', r'\\Bigl\\{ '),
+            (r'\\Bigl\|(?! )', r'\\Bigl| '),
+            (r'\\Bigl\\langle(?! )', r'\\Bigl\\langle '),
+            (r'\\Bigl\\lfloor(?! )', r'\\Bigl\\lfloor '),
+            (r'\\Bigl\\lceil(?! )', r'\\Bigl\\lceil '),
+
+            (r'\\biggl\((?! )', r'\\biggl( '),
+            (r'\\biggl\[(?! )', r'\\biggl[ '),
+            (r'\\biggl\\{(?! )', r'\\biggl\\{ '),
+            (r'\\biggl\|(?! )', r'\\biggl| '),
+            (r'\\biggl\\langle(?! )', r'\\biggl\\langle '),
+            (r'\\biggl\\lfloor(?! )', r'\\biggl\\lfloor '),
+            (r'\\biggl\\lceil(?! )', r'\\biggl\\lceil '),
+
+            (r'\\Biggl\((?! )', r'\\Biggl( '),
+            (r'\\Biggl\[(?! )', r'\\Biggl[ '),
+            (r'\\Biggl\\{(?! )', r'\\Biggl\\{ '),
+            (r'\\Biggl\|(?! )', r'\\Biggl| '),
+            (r'\\Biggl\\langle(?! )', r'\\Biggl\\langle '),
+            (r'\\Biggl\\lfloor(?! )', r'\\Biggl\\lfloor '),
+            (r'\\Biggl\\lceil(?! )', r'\\Biggl\\lceil '),
+        ]
+
+        # Add space before closing delimiters (if not already present)
+        closing_delimiter_patterns = [
+            # === \right delimiters ===
+            # Basic delimiters
+            (r'(?<! )\\right\)', r' \\right)'),
+            (r'(?<! )\\right\]', r' \\right]'),
+            (r'(?<! )\\right\\}', r' \\right\\}'),
+            (r'(?<! )\\right\|', r' \\right|'),         # Plain pipe
+            (r'(?<! )\\right\\\|', r' \\right\\|'),     # Escaped pipe \right\|
+
+            # LaTeX delimiter commands - right versions
+            (r'(?<! )\\right\\rangle', r' \\right\\rangle'),
+            (r'(?<! )\\right\\rfloor', r' \\right\\rfloor'),
+            (r'(?<! )\\right\\rceil', r' \\right\\rceil'),
+            (r'(?<! )\\right\\rvert', r' \\right\\rvert'),
+            (r'(?<! )\\right\\rVert', r' \\right\\rVert'),
+
+            # LaTeX delimiter commands - left versions (sometimes used as closing)
+            (r'(?<! )\\right\\langle', r' \\right\\langle'),
+            (r'(?<! )\\right\\lfloor', r' \\right\\lfloor'),
+            (r'(?<! )\\right\\lceil', r' \\right\\lceil'),
+            (r'(?<! )\\right\\lvert', r' \\right\\lvert'),
+            (r'(?<! )\\right\\lVert', r' \\right\\lVert'),
+
+            # Other delimiters
+            (r'(?<! )\\right\\uparrow', r' \\right\\uparrow'),
+            (r'(?<! )\\right\\downarrow', r' \\right\\downarrow'),
+            (r'(?<! )\\right\\updownarrow', r' \\right\\updownarrow'),
+            (r'(?<! )\\right\\Uparrow', r' \\right\\Uparrow'),
+            (r'(?<! )\\right\\Downarrow', r' \\right\\Downarrow'),
+            (r'(?<! )\\right\\Updownarrow', r' \\right\\Updownarrow'),
+            (r'(?<! )\\right/', r' \\right/'),
+            (r'(?<! )\\right\\backslash', r' \\right\\backslash'),
+
+            # Unpaired delimiters
+            (r'(?<! )\\right\.', r' \\right.'),
+
+            # === \bigr, \Bigr, \biggr, \Biggr (manual sizing - right) ===
+            (r'(?<! )\\bigr\)', r' \\bigr)'),
+            (r'(?<! )\\bigr\]', r' \\bigr]'),
+            (r'(?<! )\\bigr\\}', r' \\bigr\\}'),
+            (r'(?<! )\\bigr\|', r' \\bigr|'),
+            (r'(?<! )\\bigr\\rangle', r' \\bigr\\rangle'),
+            (r'(?<! )\\bigr\\rfloor', r' \\bigr\\rfloor'),
+            (r'(?<! )\\bigr\\rceil', r' \\bigr\\rceil'),
+
+            (r'(?<! )\\Bigr\)', r' \\Bigr)'),
+            (r'(?<! )\\Bigr\]', r' \\Bigr]'),
+            (r'(?<! )\\Bigr\\}', r' \\Bigr\\}'),
+            (r'(?<! )\\Bigr\|', r' \\Bigr|'),
+            (r'(?<! )\\Bigr\\rangle', r' \\Bigr\\rangle'),
+            (r'(?<! )\\Bigr\\rfloor', r' \\Bigr\\rfloor'),
+            (r'(?<! )\\Bigr\\rceil', r' \\Bigr\\rceil'),
+
+            (r'(?<! )\\biggr\)', r' \\biggr)'),
+            (r'(?<! )\\biggr\]', r' \\biggr]'),
+            (r'(?<! )\\biggr\\}', r' \\biggr\\}'),
+            (r'(?<! )\\biggr\|', r' \\biggr|'),
+            (r'(?<! )\\biggr\\rangle', r' \\biggr\\rangle'),
+            (r'(?<! )\\biggr\\rfloor', r' \\biggr\\rfloor'),
+            (r'(?<! )\\biggr\\rceil', r' \\biggr\\rceil'),
+
+            (r'(?<! )\\Biggr\)', r' \\Biggr)'),
+            (r'(?<! )\\Biggr\]', r' \\Biggr]'),
+            (r'(?<! )\\Biggr\\}', r' \\Biggr\\}'),
+            (r'(?<! )\\Biggr\|', r' \\Biggr|'),
+            (r'(?<! )\\Biggr\\rangle', r' \\Biggr\\rangle'),
+            (r'(?<! )\\Biggr\\rfloor', r' \\Biggr\\rfloor'),
+            (r'(?<! )\\Biggr\\rceil', r' \\Biggr\\rceil'),
+
+            # === \bigm (middle delimiters with manual sizing) ===
+            (r'(?<! )\\bigm\|', r' \\bigm|'),
+            (r'(?<! )\\Bigm\|', r' \\Bigm|'),
+            (r'(?<! )\\biggm\|', r' \\biggm|'),
+            (r'(?<! )\\Biggm\|', r' \\Biggm|'),
+        ]
+
+        # Apply opening delimiter spacing
+        for pattern, replacement in opening_delimiter_patterns:
+            latex = re.sub(pattern, replacement, latex)
+
+        # Apply closing delimiter spacing
+        for pattern, replacement in closing_delimiter_patterns:
+            latex = re.sub(pattern, replacement, latex)
+
+        return latex
+
+    def final_cleanup(self, latex: str) -> str:
+        """
+        Final cleanup for specific patterns and spacing issues.
+
+        This step applies various pattern-specific fixes to match expected output formats.
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            Cleaned LaTeX string
+        """
+        # Replace \dfrac with \frac in superscripts and subscripts for proper sizing
+        # Pattern: ^{...\dfrac{...}{...}...} or _{...\dfrac{...}{...}...}
+        def replace_dfrac_in_script(match):
+            r"""Replace \dfrac with \frac inside a script (superscript or subscript)."""
+            script_marker = match.group(1)  # ^ or _
+            content = match.group(2)  # everything inside braces
+            # Replace all \dfrac with \frac in this content
+            content = content.replace(r'\dfrac', r'\frac')
+            return f'{script_marker}{{{content}}}'
+
+        # Apply to both superscripts and subscripts
+        # Use a simple pattern that matches ^{...} or _{...} and captures the content
+        # This handles nested braces correctly by matching the outermost braces
+        latex = re.sub(
+            r'([\^_])\{((?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*)\}',
+            replace_dfrac_in_script,
+            latex
+        )
+
+        # Fix assignment operator spacing: ∶ = → :=
+        latex = latex.replace("∶ =", ":=")
+        latex = latex.replace(": =", ":=")
+
+        # Fix Longleftrightarrow to iff
+        latex = latex.replace('\\Longleftrightarrow', '\\iff ')
+
+        # Replace \\lra with \\leftrightarrow (for compatibility)
+        latex = latex.replace('\\lra', '\\leftrightarrow')
+
+        # Remove \\mathrm{} from multi-letter text abbreviations
+        # Only remove mathrm from sequences of 3+ lowercase letters that are NOT known units
+        def should_remove_mathrm(match):
+            content = match.group(1)
+            # Don't remove if it's a known unit or chemical element
+            return content if content not in self.common_units and content not in self.chemical_elements else match.group(0)
+
+        latex = re.sub(r'\\mathrm\{([a-z]{3,})\}', should_remove_mathrm, latex)
+
+        # Remove spaces in expressions like "x + y + z" -> "x+y+z"
+        latex = re.sub(r'\\overset\{x \+ y \+ z\}', r'\\overset{x+y+z}', latex)
+
+        # Remove space in "n 个" -> "n个"
+        latex = latex.replace('n 个', 'n个')
+
+        # Fix spacing after \\cap and \\cup commands
+        latex = re.sub(r'\\cap(?![{])', r'\\cap ', latex)
+        latex = re.sub(r'\\cup(?![{])', r'\\cup ', latex)
+
+        # Convert \\overset{\\dot}{X} to \\dot{X} for simple variables
+        latex = re.sub(r'\\overset\{\\dot\}\{([a-zA-Z0-9])\}', r'\\dot{\1}', latex)
+        latex = re.sub(r'\\overset\{\.\}\{([a-zA-Z0-9])\}', r'\\dot{\1}', latex)
+
+        # Fix array column specification format
+        latex = re.sub(r'\\begin\{array\{([^}]+)\}\}', r'\\begin{array}{\1}', latex)
+
+        # Fix incorrect fraction format for reaction arrows
+        # Convert \\dfrac{\\underline{text}}{} → \\xlongequal[]{text}
+        latex = re.sub(r'\\dfrac\{\\underline\{([^}]+)\}\}\{\}', r'\\xlongequal[\\quad]{\1}', latex)
+
+        # Convert \\dfrac{\\underline{text1}}{text2} → \\xlongequal[text2]{text1}
+        def clean_dfrac_underline(match):
+            numerator = match.group(1)
+            denominator = match.group(2)
+            # Remove all spaces from both numerator and denominator
+            numerator_clean = re.sub(r'\s+', '', numerator)
+            denominator_clean = re.sub(r'\s+', '', denominator)
+            return f'\\xlongequal[{denominator_clean}]{{{numerator_clean}}}'
+
+        latex = re.sub(r'\\dfrac\{\\underline\{([^}]+)\}\}\{([^}]+)\}', clean_dfrac_underline, latex)
+
+        # Clean up xlongequal reaction arrows from OMML conversion
+        # Pattern: \xlongequal[\quad]{\overline{\overline{text}}} → \xlongequal[\quad]{text}
+        # The double \overline indicates reaction conditions that should go ABOVE arrow (in braces)
+        # Note: text (\1) already has \mathrm{} wrapper from earlier processing
+        latex = re.sub(
+            r'\\xlongequal\[\\quad\]\{\\overline\{\\overline\{([^}]+)\}\}\}',
+            r'\\xlongequal[\\quad]{\1}',
+            latex
+        )
+
+        # Also handle \underline{\underline{}} pattern (after XSLT fix for m:bar default behavior)
+        # Pattern: \xlongequal[\quad]{\underline{\underline{text}}} → \xlongequal[\quad]{text}
+        # The double \underline (from m:bar without pos attribute) also indicates reaction conditions
+        latex = re.sub(
+            r'\\xlongequal\[\\quad\]\{\\underline\{\\underline\{([^}]+)\}\}\}',
+            r'\\xlongequal[\\quad]{\1}',
+            latex
+        )
+
+        # Fix for nested array issues: Convert standalone \underline{\underline{text}} to \xlongequal[\quad]{text}
+        # This prevents the aggressive array matching pattern below from destroying table structures
+        # when the reaction arrow is inside an array cell.
+        # latex = re.sub(
+        #     r'\\underline\{\\underline\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}\}',
+        #     r'\\xlongequal[\\quad]{\1}',
+        #     latex
+        # )
+
+        # Convert array/matrix pattern with double underline/overline to reaction arrow
+        # Pattern semantics:
+        # - Double UNDERLINE on TOP row = reaction condition above arrow (convert)
+        # - Double OVERLINE on BOTTOM row = reaction condition below arrow (convert)
+        # - Double OVERLINE on TOP row = NOT reaction arrow, just decorated text (don't convert)
+        # Result format: \xlongequal[below]{above}
+        #
+        # Supports:
+        # - \begin{array}{c}, \begin{array}{l}, \begin{array}{r}, etc. (any alignment)
+        # - \begin{array} (no alignment parameter)
+        # - \begin{matrix} (matrix environment)
+
+        # Pattern 1: Double underline on TOP row (first position)
+        # \begin{array|matrix} + optional{alignment} + \underline{\underline{GROUP1}} + \\ + GROUP2 + \end{...}
+        # Convert to: \xlongequal[GROUP2]{GROUP1}
+        latex = re.sub(
+            r'\\begin\{(?:array|matrix)\}(?:\{[^}]+\})?\s*\\underline\{\\underline\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}\}\s*\\\\\s*((?:(?!\\begin\{(?:array|matrix)\}).)+?)\s*\\end\{(?:array|matrix)\}',
+            lambda m: '\\xlongequal[' + m.group(2).strip() + ']{' + m.group(1).strip() + '}',
+            latex,
+            flags=re.DOTALL
+        )
+
+        # Pattern 2: Double overline on BOTTOM row (second position only)
+        # \begin{array|matrix} + optional{alignment} + GROUP1 + \\ + \overline{\overline{GROUP2}} + \end{...}
+        # Convert to: \xlongequal[GROUP2]{GROUP1}
+        # Note: Overline on TOP row will NOT match this pattern and stays as array (correct behavior)
+        latex = re.sub(
+            r'\\begin\{(?:array|matrix)\}(?:\{[^}]+\})?\s*(.+?)\s*\\\\\s*\\overline\{\\overline\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}\}\s*\\end\{(?:array|matrix)\}',
+            lambda m: '\\xlongequal[' + m.group(2).strip() + ']{' + m.group(1).strip() + '}',
+            latex,
+            flags=re.DOTALL
+        )
+
+        # Fix fragmented mathematical functions (missing backslash)
+        # Pattern: "sin\ x", "cos\ x", "tan\ x" → "\sin x", "\cos x", "\tan x"
+        # These are functions that should have a backslash but don't
+        fragmented_functions = [
+            'sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+            'arcsin', 'arccos', 'arctan', 'arccot', 'arcsec', 'arccsc',
+            'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch',
+            'log', 'ln', 'lg', 'exp',
+            'lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min',
+            'det', 'dim', 'ker', 'arg', 'deg', 'gcd', 'hom',
+        ]
+
+        for func in fragmented_functions:
+            # Pattern: func followed by backslash-space (\ ) and then a character
+            # Example: "tan\ x" → "\tan x"
+            # IMPORTANT: Use negative lookbehind to avoid matching \sin\ inside \\sin\  x
+            pattern = rf'(?<!\\)\b{func}\\\s+'
+            replacement = f'\\\\{func} '
+            latex = re.sub(pattern, replacement, latex)
+
+        # Fix split function names in two forms:
+        # 1. "si n" → "\sin" (first letters together)
+        # 2. "s i n" → "\sin" (all letters separate)
+        # This handles cases where Word splits function names with superscripts
+        # Note: In re.sub() replacement strings, we need to escape backslashes: \\sin
+        split_functions = {
+            # Form 1: "si n" pattern (first part together)
+            r'\bsi\s+n\b': '\\\\sin',
+            r'\bco\s+s\b': '\\\\cos',
+            r'\bta\s+n\b': '\\\\tan',
+            r'\blo\s+g\b': '\\\\log',
+            r'\bl\s+n\b': '\\\\ln',
+            r'\be\s+xp\b': '\\\\exp',
+            r'\bco\s+t\b': '\\\\cot',
+            r'\bse\s+c\b': '\\\\sec',
+            r'\bcs\s+c\b': '\\\\csc',
+            # Form 2: "s i n" pattern (all letters separate)
+            r'\bs\s+i\s+n\b': '\\\\sin',
+            r'\bc\s+o\s+s\b': '\\\\cos',
+            r'\bt\s+a\s+n\b': '\\\\tan',
+            r'\bl\s+o\s+g\b': '\\\\log',
+            r'\bl\s+n\b': '\\\\ln',  # Already covered above
+            r'\be\s+x\s+p\b': '\\\\exp',
+            r'\bc\s+o\s+t\b': '\\\\cot',
+            r'\bs\s+e\s+c\b': '\\\\sec',
+            r'\bc\s+s\s+c\b': '\\\\csc',
+        }
+
+        for pattern, replacement in split_functions.items():
+            latex = re.sub(pattern, replacement, latex)
+
+        # Fix double-escaped LaTeX commands (e.g., "\\sin" → "\sin")
+        # This handles cases where backslashes were incorrectly doubled
+        double_escaped_functions = [
+            'sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+            'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh',
+            'log', 'ln', 'lg', 'exp',
+            'lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min',
+            'det', 'dim', 'ker', 'arg', 'deg', 'gcd',
+            'sum', 'prod', 'int', 'oint',
+            'frac', 'dfrac', 'sqrt', 'left', 'right',
+        ]
+
+        for func in double_escaped_functions:
+            # Pattern: \\func (two backslashes) → \func (one backslash)
+            # Be careful: we want \\ (4 chars in pattern string) to match actual \\
+            pattern = f'\\\\\\\\{func}'  # Four backslashes = match two literal backslashes
+            replacement = f'\\\\{func}'  # Two backslashes = one literal backslash
+            latex = latex.replace(pattern, replacement)
+
+        # Fix general double-backslash in LaTeX commands
+        # This handles cases like \\left\{, \\right\}, \\lceil, etc.
+        # Rule: Double backslash should ONLY appear in line breaks "\\ " (with space after)
+        # Pattern: \\<command> where command starts with a letter
+        # Examples: \\left\{ → \left\{, \\right\} → \right\}, \\lceil → \lceil
+        # But preserve: \\ followed by space (line break) or \\ at end of string
+        #
+        # Strategy: Match \\<letter> (double backslash followed by letter)
+        # Replace with \<letter> (single backslash followed by letter)
+        debug_print(f"[DEBUG CLEANUP] Before double-backslash fix: {latex[:100] if len(latex) <= 100 else latex[:100] + '...'}")
+        latex = re.sub(
+            r'\\\\(?=[a-zA-Z])',  # Match \\ followed by a letter (lookahead)
+            r'\\',                # Replace with single backslash
+            latex
+        )
+        debug_print(f"[DEBUG CLEANUP] After double-backslash fix: {latex[:100] if len(latex) <= 100 else latex[:100] + '...'}")
+
+        # Fix backslash-space (\ ) incorrectly separating LaTeX commands
+        # New approach: Convert all \ (backslash-space) to ~ first, then fix patterns where
+        # ~ incorrectly separates commands that should be together
+        # Examples: "\sum\ \limits" → "\sum~\limits" → "\sum\limits"
+        debug_print(f"[DEBUG CLEANUP] Before backslash-space to tilde conversion: {latex[:100] if len(latex) <= 100 else latex[:100] + '...'}")
+
+        # Step 1: Convert all backslash-space (\ ) to tilde (~)
+        # This normalizes spacing before we apply specific fixes
+        latex = latex.replace('\\ ', '~')
+
+        debug_print(f"[DEBUG CLEANUP] After converting \\ to ~: {latex[:100] if len(latex) <= 100 else latex[:100] + '...'}")
+
+        # Step 2: Fix patterns where ~ incorrectly separates LaTeX commands
+        # Define patterns to fix - order matters!
+        tilde_fix_patterns = [
+            # 1. Large operators + limits modifiers (sum, prod, int, lim, etc.)
+            # Pattern: \sum~\limits → \sum\limits
+            (r'(\\(?:sum|prod|int|iint|iiint|oint|lim|liminf|limsup|coprod|bigcup|bigcap|bigwedge|bigvee|bigodot|bigoplus|bigotimes|biguplus|bigsqcup))~+(\\(?:limits|nolimits|displaylimits))', r'\1\2'),
+
+            # 2. Any LaTeX command + underscore or caret (subscript/superscript)
+            # Pattern: \alpha~_ → \alpha_, \sum~^{2} → \sum^{2}
+            (r'(\\[a-zA-Z]+)~+([_^])', r'\1\2'),
+
+            # 3. Underscore/caret + tilde + command (for nested scripts)
+            # Pattern: _{x~\rightarrow} → _{x \rightarrow} (keep regular space)
+            (r'([_^]\{[^}]*?)~+(\\[a-zA-Z]+)', r'\1 \2'),
+
+            # 4. LaTeX command + tilde + opening brace
+            # Pattern: \sqrt~{2} → \sqrt{2}, \frac~{1} → \frac{1}
+            (r'(\\[a-zA-Z]+)~+(\{)', r'\1\2'),
+
+            # 5. LaTeX command + tilde + another command (keep regular space)
+            # Pattern: \mathrm~\alpha → \mathrm \alpha
+            # But for display: \sum~\alpha → \sum \alpha (should have regular space)
+            (r'(\\[a-zA-Z]+)~+(\\[a-zA-Z]+)', r'\1 \2'),
+
+            # 6. Remove tilde before punctuation (use regular space)
+            # Pattern: x~, → x ,
+            (r'~+([,;.])', r' \1'),
+
+            # 7. Tilde between numbers and commands (common in limits)
+            # Pattern: 1~\rightarrow → 1 \rightarrow
+            (r'(\d)~+(\\[a-zA-Z]+)', r'\1 \2'),
+
+            # 8. Tilde after closing brace and before underscore/caret
+            # Pattern: }~_ → }_
+            (r'\}~+([_^])', r'}\1'),
+
+            # 9. Tilde before differential notation (dx, dy, dt, etc.)
+            # Pattern: x~dx → x dx (use regular space for differential)
+            (r'~+(d[a-z])\b', r' \1'),
+
+            # 10. Tilde between variables and letters/numbers
+            # Pattern: x~y → x y (use regular space)
+            # Only apply to single lowercase letters followed by tilde and another letter/number
+            (r'([a-z])~+(?![\\])([a-z0-9])', r'\1 \2'),
+
+            # 11. Tilde between relation operators and variables in expressions
+            # Pattern: \leqslant i~\leqslant → \leqslant i \leqslant
+            (r'(\\(?:leqslant|geqslant|leq|geq|lt|gt|ne|equiv|approx|sim|cong)) ([a-z])~+(\\(?:leqslant|geqslant|leq|geq|lt|gt|ne|equiv|approx|sim|cong))', r'\1 \2 \3'),
+
+            # 12. Tilde after logical operators (convert to regular space)
+            # Pattern: \vee~x → \vee x, \wedge~y → \wedge y
+            (r'(\\(?:vee|wedge|land|lor|oplus|otimes|odot|cap|cup|sqcap|sqcup))~+', r'\1 '),
+
+            # 13. Command + space + tilde (remove extra tilde)
+            # Pattern: \vee ~x → \vee x (the tilde is redundant after a command with space)
+            (r'(\\[a-zA-Z]+) ~+', r'\1 '),
+
+            # 14. Variable + space + tilde (remove extra tilde for consistency)
+            # Pattern: a ~b → a b
+            (r'([a-z]) ~+', r'\1 '),
+        ]
+
+        for pattern, replacement in tilde_fix_patterns:
+            latex = re.sub(pattern, replacement, latex)
+
+        debug_print(f"[DEBUG CLEANUP] After fixing tilde patterns: {latex[:100] if len(latex) <= 100 else latex[:100] + '...'}")
+
+        return latex
+
+    def merge_consecutive_formatting(self, latex: str) -> str:
+        r"""
+        Merge consecutive identical formatting commands.
+
+        This handles fragmented text where the same formatting command is applied
+        to consecutive letters/words. Common with MathML conversion which may
+        apply formatting per-character.
+
+        Args:
+            latex: LaTeX string with potentially fragmented formatting
+
+        Returns:
+            LaTeX string with consecutive identical formatting merged
+
+        Examples:
+            "\\mathbf{F} \\mathbf{e}" → "\\mathbf{Fe}"
+            "\\mathrm{s} \\mathrm{i} \\mathrm{n}" → "\\mathrm{sin}"
+            "\\mathit{h} \\mathit{e} \\mathit{l} \\mathit{l} \\mathit{o}" → "\\mathit{hello}"
+
+        Note:
+            This runs before merge_consecutive_mathrm() which has more specialized
+            logic for chemical formulas (handles subscripts/superscripts).
+        """
+        # List of formatting commands to merge
+        format_commands = [
+            'mathbf', 'mathit', 'mathrm', 'mathbb', 'mathcal', 'mathfrak',
+            'mathsf', 'mathtt', 'mathscr', 'text', 'textbf', 'textit',
+            'textrm', 'textsf', 'texttt', 'boldsymbol'
+        ]
+
+        for cmd in format_commands:
+            # Pattern: \cmd{X} \cmd{Y} → \cmd{XY}
+            # Matches: \cmd{content1} (optional whitespace) \cmd{content2}
+            pattern = rf'\\{cmd}\{{([^}}]+)\}}\s+\\{cmd}\{{([^}}]+)\}}'
+
+            max_iterations = 100  # Safety limit
+            for _ in range(max_iterations):
+                match = re.search(pattern, latex)
+                if not match:
+                    break
+
+                content1 = match.group(1)
+                content2 = match.group(2)
+
+                # Merge: \cmd{content1 content2}
+                # Remove space between merged content (renders the same in LaTeX)
+                merged = f'\\{cmd}{{{content1}{content2}}}'
+
+                # Replace this occurrence
+                latex = latex[:match.start()] + merged + latex[match.end():]
+
+        return latex
+
+    def merge_consecutive_mathrm(self, latex: str) -> str:
+        r"""
+        Merge consecutive \\mathrm{} blocks with intervening subscripts/superscripts.
+
+        This is particularly useful for chemical formulas that are often fragmented.
+        Operators like +, -, =, etc. will prevent merging.
+
+        Args:
+            latex: LaTeX string with potentially fragmented \\mathrm{} blocks
+
+        Returns:
+            LaTeX string with consecutive \\mathrm{} blocks merged
+
+        Examples:
+            "\\mathrm{C} \\mathrm{u}_{2} \\mathrm{O}" → "\\mathrm{Cu_{2}O}"
+            "\\mathrm{H}^{2} \\mathrm{S}" → "\\mathrm{H^{2}S}"
+            "\\mathrm{Ca}^{2+}" → "\\mathrm{Ca^{2+}}"
+            "\\mathrm{2H_{\\mathrm{2}}}" → "\\mathrm{2H_{2}}" (remove nested)
+        """
+        # Step 0: Remove nested \\mathrm{} blocks
+        # Pattern: _{\\mathrm{X}} or ^{\\mathrm{X}} inside \\mathrm{...}
+        # This handles cases like \\mathrm{2H_{\\mathrm{2}}} → \\mathrm{2H_{2}}
+        # Strategy: Find _{\\mathrm{...}} or ^{\\mathrm{...}} INSIDE a \\mathrm{} block and unwrap
+        # CRITICAL: Only unwrap if it's nested inside another \\mathrm{}, not standalone subscripts
+
+        max_iterations = 100  # Safety limit
+        for _ in range(max_iterations):
+            # Pattern: \\mathrm{..._{\\mathrm{X}}...} or \\mathrm{...^{\\mathrm{X}}...}
+            # This matches subscripts/superscripts with \\mathrm{} INSIDE a \\mathrm{} block
+            # We need to find \\mathrm{ ... [_^]{\\mathrm{X}} ... }
+            nested_mathrm_pattern = r'\\mathrm\{([^{}]*?)([_^])\{\\mathrm\{([^}]+)\}\}([^{}]*?)\}'
+
+            match = re.search(nested_mathrm_pattern, latex)
+            if not match:
+                break
+
+            # Found \\mathrm{..._{\\mathrm{X}}...} or \\mathrm{...^{\\mathrm{X}}...}
+            before_script = match.group(1)  # Content before the script
+            script_char = match.group(2)  # _ or ^
+            inner_content = match.group(3)  # X
+            after_script = match.group(4)  # Content after the script
+
+            # Unwrap: \\mathrm{2H_{\\mathrm{2}}} → \\mathrm{2H_{2}}
+            unwrapped = f'\\mathrm{{{before_script}{script_char}{{{inner_content}}}{after_script}}}'
+            latex = latex[:match.start()] + unwrapped + latex[match.end():]
+
+        # Step 1: Merge adjacent \\mathrm{} blocks
+        # Pattern: \\mathrm{X} (optional whitespace/subscript/superscript) \\mathrm{Y}
+        pattern = r'\\mathrm\{([^}]+)\}((?:\s|_\{[^}]+\}|\^\{[^}]+\})*?)\\mathrm\{([^}]+)\}'
+
+        max_iterations = 100  # Safety limit
+        for _ in range(max_iterations):
+            match = re.search(pattern, latex)
+            if not match:
+                break
+
+            content1 = match.group(1)
+            middle = match.group(2)  # whitespace and/or scripts
+            content2 = match.group(3)
+
+            # CRITICAL FIX: Don't merge if BOTH blocks already have subscripts/superscripts
+            # This prevents merging geometry notation like \mathrm{F}_{2} \mathrm{F}_{1}
+            # into \mathrm{F_{2}F}_{1}, which would be incorrect.
+            #
+            # Pattern to check: If the middle contains a subscript (_{...}) AND
+            # there's a following \mathrm{} block, check if we're about to merge
+            # two independently subscripted items (like F₂ and F₁ for geometry points).
+            #
+            # Heuristic: If middle contains a subscript/superscript AND content2 is
+            # a single letter (or short identifier), this is likely geometry notation.
+            # Don't merge in this case.
+            has_script_in_middle = bool(re.search(r'[_^]\{', middle))
+            content2_is_short = len(content2.strip()) <= 3  # Single letter or short identifier
+
+            if has_script_in_middle and content2_is_short:
+                # This looks like geometry notation (F₂ F₁) or similar
+                # Check if content1 is also a single letter
+                content1_is_short = len(content1.strip()) <= 3
+
+                if content1_is_short:
+                    # Both sides are short identifiers with script in between
+                    # This is geometry notation like F₂ F₁ - DON'T merge
+                    # Move past this match to avoid infinite loop
+                    temp_marker = f'__NOMERGE__{match.group(0)}__NOMERGE__'
+                    latex = latex[:match.start()] + temp_marker + latex[match.end():]
+                    continue
+
+            # Merge into single \\mathrm{} block
+            merged_content = content1 + middle + content2
+
+            # Remove all spaces (they don't affect LaTeX rendering in \\mathrm{})
+            merged_content = merged_content.replace(' ', '')
+
+            merged = f'\\mathrm{{{merged_content}}}'
+
+            # Replace this occurrence
+            latex = latex[:match.start()] + merged + latex[match.end():]
+
+        # Remove temporary markers
+        latex = re.sub(r'__NOMERGE__', '', latex)
+
+        # Step 2: Pull trailing subscripts/superscripts into \\mathrm{} blocks
+        # Pattern: \\mathrm{content} followed immediately by subscript or superscript
+        # Example: \\mathrm{Ca}^{2+} -> \\mathrm{Ca^{2+}}
+        #
+        # CRITICAL: In chemistry mode, DON'T pull superscripts in - they should be
+        # wrapped separately for ion charges: \\mathrm{Cu}^{\\mathrm{2+}}
+        #
+        # CRITICAL: Don't pull superscripts into single-letter mathematical constants
+        # (e, i, d, etc.) as these are often used as bases for exponentiation.
+        # Example: \\mathrm{e}^{2x+3} should stay as-is, NOT become \\mathrm{e^{2x+3}}
+        if self.subject_mode != 'chemistry':
+            # Pattern allows one level of nested braces inside the script so that
+            # constructs like \mathrm{K}_{\mathrm{a}1} are parsed correctly.
+            trailing_pattern = r'\\mathrm\{([^{}]+)\}((?:[_^]\{(?:[^{}]|\{[^{}]*\})+\})+)'
+        
+            # Mathematical constants that should NOT have superscripts pulled in
+            # These are typically used as bases for exponentiation (e^x, i^2, etc.)
+            math_constants = {'e', 'i', 'j', 'd', 'D'}
+        
+            for _ in range(max_iterations):
+                match = re.search(trailing_pattern, latex)
+                if not match:
+                    break
+        
+                content = match.group(1)
+                trailing_scripts = match.group(2)
+        
+                # Don't merge if content is a single-letter mathematical constant
+                # with a superscript (e.g., e^x, i^2, d^n)
+                if content.strip() in math_constants and trailing_scripts.startswith('^'):
+                    # Skip this match to avoid merging
+                    # Move past it by inserting a temporary marker
+                    temp_marker = f'__NOMERGE_CONST__{match.group(0)}__NOMERGE_CONST__'
+                    latex = latex[:match.start()] + temp_marker + latex[match.end():]
+                    continue
+        
+                # Don't pull scripts into \mathrm{} if the scripts already contain
+                # \mathrm{} themselves. Pulling them in would create nested/duplicated
+                # \mathrm{} blocks (e.g., \mathrm{K_{\mathrm{a}1}} instead of
+                # \mathrm{K}_{\mathrm{a}1}).
+                if '\\mathrm{' in trailing_scripts:
+                    temp_marker = f'__NOMERGE_NESTED__{match.group(0)}__NOMERGE_NESTED__'
+                    latex = latex[:match.start()] + temp_marker + latex[match.end():]
+                    continue
+        
+                # Don't pull scripts into \mathrm{} if the scripts contain bare
+                # italic variables (letters not wrapped in formatting commands).
+                # Example: \mathrm{C}_{k - 1}^{n - 1} should stay as-is, NOT become
+                # \mathrm{C_{k - 1}^{n - 1}} because k and n are italic variables.
+                # Only pull in scripts that are entirely numeric/symbolic (chemical
+                # formulas like \mathrm{H}_{2} or \mathrm{Ca}^{2+}).
+                scripts_cleaned = re.sub(r'\\[a-zA-Z]+\{[^{}]*\}', '', trailing_scripts)
+                scripts_cleaned = re.sub(r'\\[a-zA-Z]+', '', scripts_cleaned)
+                if re.search(r'[a-zA-Z]', scripts_cleaned):
+                    temp_marker = f'__NOMERGE_BARE__{match.group(0)}__NOMERGE_BARE__'
+                    latex = latex[:match.start()] + temp_marker + latex[match.end():]
+                    continue
+        
+                # Merge trailing scripts into \mathrm{} block
+                merged = f'\\mathrm{{{content}{trailing_scripts}}}'
+        
+                # Replace this occurrence
+                latex = latex[:match.start()] + merged + latex[match.end():]
+        
+        # Remove temporary markers
+        latex = re.sub(r'__NOMERGE_CONST__|__NOMERGE_NESTED__|__NOMERGE_BARE__', '', latex)
+        
+        return latex
+
+    def wrap_ion_charges_in_mathrm(self, latex: str) -> str:
+        r"""
+        Wrap ion charge superscripts in \\mathrm{} for chemistry mode.
+
+        Patterns handled:
+        - ^{2 +} → ^{\\mathrm{2+}}
+        - ^{2 -} → ^{\\mathrm{2-}}
+        - ^{3 +} → ^{\\mathrm{3+}}
+        - Removes spaces between digit and +/-
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            LaTeX with ion charges wrapped in \\mathrm{}
+        """
+        # Pattern: ^{digit(s) space +/-}
+        # Match: ^{2 +}, ^{2 -}, ^{3 +}, etc.
+        pattern = r'\^\{(\d+)\s*([+\-])\}'
+
+        def replace_charge(match):
+            digit = match.group(1)
+            sign = match.group(2)
+            # Remove space and wrap in \mathrm{}
+            return f'^{{\\mathrm{{{digit}{sign}}}}}'
+
+        return re.sub(pattern, replace_charge, latex)
+
+    def merge_fragmented_chemistry_elements(self, latex: str) -> str:
+        r"""
+        Merge fragmented chemical elements followed by charge indicators (safety net).
+
+        This post-processing step catches cases where mrow_visitor couldn't merge
+        fragmented elements during conversion. It looks for patterns like:
+        - \mathrm{M}\mathrm{n}^{2+} → \mathrm{Mn}^{2+}
+        - \mathrm{C}\mathrm{u}^{2-} → \mathrm{Cu}^{2-}
+        - \mathrm{F}\mathrm{e} (followed by reaction) → \mathrm{Fe}
+
+        Only merges when:
+        1. Two consecutive \mathrm{} blocks with single letters
+        2. Combined text forms known multi-char element
+        3. Followed by charge superscript (^{digit+/-}) OR chemistry context
+
+        Args:
+            latex: LaTeX string with potentially fragmented chemical elements
+
+        Returns:
+            LaTeX with fragmented elements merged
+
+        Examples:
+            "\mathrm{M}\mathrm{n}^{2 +}" → "\mathrm{Mn}^{2 +}"
+            "\mathrm{C}\mathrm{u}^{2 -}" → "\mathrm{Cu}^{2 -}"
+            "\mathrm{F}\mathrm{e} + \mathrm{O}" → "\mathrm{Fe} + \mathrm{O}"
+        """
+        from ..data.chemistry_data import MULTI_CHAR_ELEMENTS
+
+        # Pattern: \mathrm{X}\mathrm{Y} where X and Y are single letters
+        # Look-ahead for charge superscript or chemistry context
+        pattern = r'\\mathrm\{([A-Z])\}\\mathrm\{([a-z])\}(?=\^{[0-9]+\s*[+-]\})'
+
+        def merge_if_element(match):
+            letter1 = match.group(1)  # First letter (capital)
+            letter2 = match.group(2)  # Second letter (lowercase)
+            combined = letter1 + letter2
+
+            # Only merge if combined forms known multi-char element
+            if combined in MULTI_CHAR_ELEMENTS:
+                return f'\\mathrm{{{combined}}}'
+            else:
+                # Not a known element, keep fragmented
+                return match.group(0)
+
+        # Merge fragmented elements followed by charges
+        latex = re.sub(pattern, merge_if_element, latex)
+
+        # Also handle case without charge but with clear chemistry context
+        # Pattern: \mathrm{X}\mathrm{Y} followed by chemistry indicators
+        # (reaction arrows, more elements, subscripts)
+        pattern_context = r'\\mathrm\{([A-Z])\}\\mathrm\{([a-z])\}(?=[\s]*(?:[\+\-\→\←\⇌]|\\mathrm\{|_\{))'
+
+        latex = re.sub(pattern_context, merge_if_element, latex)
+
+        return latex
+
+    def format_chemistry_constants(self, latex: str, subject_mode: Optional[str] = None) -> str:
+        r"""
+        Format chemistry equilibrium constants with upright subscripts.
+
+        INTELLIGENT MODE: Detects chemistry context from LaTeX patterns and applies
+        formatting only when chemistry probability is high enough.
+
+        Chemistry constants should have upright (roman) subscripts:
+        - K_{sp} → K_{\mathrm{sp}} (solubility product constant)
+        - K_{a} → K_{\mathrm{a}} (acid dissociation constant)
+        - K_{b} → K_{\mathrm{b}} (base dissociation constant)
+        - K_{w} → K_{\mathrm{w}} (water ionization constant)
+        - K_{c} → K_{\mathrm{c}} (concentration equilibrium constant)
+        - K_{p} → K_{\mathrm{p}} (pressure equilibrium constant)
+        - K_{eq} → K_{\mathrm{eq}} (equilibrium constant)
+        - K_{f} → K_{\mathrm{f}} (formation constant)
+        - K_{d} → K_{\mathrm{d}} (dissociation constant)
+
+        Args:
+            latex: LaTeX string with chemistry constants
+            subject_mode: Subject mode ('chemistry', 'auto', etc.)
+
+        Returns:
+            LaTeX with formatted chemistry constants
+
+        Examples:
+            "K_{sp}(CuS)" → "K_{\mathrm{sp}}(\mathrm{CuS})"  [chemistry detected]
+            "K_{a} + H^+" → "K_{\mathrm{a}} + \mathrm{H}^+"  [chemistry detected]
+            "K_{eq}" → "K_{\mathrm{eq}}"                      [chemistry mode only]
+        """
+        # Check if we should apply formatting based on chemistry context
+        should_format = False
+
+        if subject_mode == 'chemistry':
+            # Always format in chemistry mode
+            should_format = True
+        else:
+            # In auto mode, detect chemistry context from LaTeX patterns
+            chem_score = 0.0
+
+            # Chemistry indicators (same logic as calculate_chemistry_probability):
+            # 1. Ion charges: ^{digit+/-} (+1.0)
+            if re.search(r'\^\{[0-9]+\s*[+-]\s*\}', latex):
+                chem_score += 1.0
+
+            # 2. Chemical formulas in \mathrm{}: multi-char elements like Cu, Fe, Mn (+0.8)
+            from ..data.chemistry_data import MULTI_CHAR_ELEMENTS
+            for element in MULTI_CHAR_ELEMENTS:
+                if rf'\mathrm{{{element}' in latex:
+                    chem_score += 0.8
+                    break  # Only count once
+
+            # 3. Reaction arrows: \xlongequal, \rightarrow, \leftrightharpoons (+0.6)
+            if re.search(r'\\(xlongequal|rightarrow|leftrightharpoons|leftrightarrow)', latex):
+                chem_score += 0.6
+
+            # 4. Chemical subscripts: _{digit} like H_2, O_2 (+0.4)
+            if re.search(r'_\{[0-9]+\}', latex):
+                chem_score += 0.4
+
+            # 5. State symbols: \uparrow, \downarrow (gas/precipitate) (+0.3)
+            if r'\uparrow' in latex or r'\downarrow' in latex:
+                chem_score += 0.3
+
+            # 6. Chemistry equilibrium constants: K_{sp}, K_{a}, K_{b}, etc. (+1.0)
+            # These are definitive chemistry indicators
+            chemistry_k_pattern = r'\\?mathrm\{K\}_\{(sp|a|b|w|c|p|eq|f|d|h|i|m)\}|K_\{(sp|a|b|w|c|p|eq|f|d|h|i|m)\}'
+            if re.search(chemistry_k_pattern, latex):
+                chem_score += 1.0
+
+            # Decision threshold: ≥1.5 for auto mode (very strong chemistry indicators)
+            # This matches the threshold used in mrow_visitor for fragmented elements
+            if chem_score >= 1.5:
+                should_format = True
+
+        if not should_format:
+            return latex
+
+        # Chemistry constant subscripts that should be upright
+        # These are standard abbreviations, not variables
+        chemistry_subscripts = {
+            'sp',    # solubility product
+            'a',     # acid dissociation
+            'b',     # base dissociation
+            'w',     # water ionization
+            'c',     # concentration equilibrium
+            'p',     # pressure equilibrium
+            'eq',    # equilibrium
+            'f',     # formation
+            'd',     # dissociation
+            'h',     # hydrolysis
+            'i',     # ionization
+            'm',     # Michaelis constant (biochemistry)
+        }
+
+        # Pattern: K_{subscript} where subscript is one of the chemistry constants
+        # Use word boundary to avoid matching K_{alpha} or K_{x}
+        for subscript in chemistry_subscripts:
+            # Pattern 1: Plain K_{subscript} → K_{\mathrm{subscript}}
+            # Match K_{subscript} but not K_{\mathrm{subscript}} (already formatted)
+            pattern = rf'K_\{{{subscript}\}}'
+            replacement = rf'K_{{\\mathrm{{{subscript}}}}}'  # Need \\ for literal backslash
+            latex = latex.replace(pattern, replacement)
+
+            # Pattern 2: With spaces: K_{ sp } → K_{\mathrm{sp}}
+            pattern_spaces = rf'K_\{{\s*{subscript}\s*\}}'
+            latex = re.sub(pattern_spaces, replacement, latex)
+
+            # Pattern 3: Chemistry mode wraps K in \mathrm{}: \mathrm{K}_{subscript} → \mathrm{K}_{\mathrm{subscript}}
+            # This is critical for chemistry mode where K is detected as an element
+            pattern_mathrm_k = rf'\\mathrm\{{K\}}_\{{{subscript}\}}'
+            replacement_mathrm_k = rf'\\mathrm{{K}}_{{\\mathrm{{{subscript}}}}}'
+            latex = latex.replace(pattern_mathrm_k, replacement_mathrm_k)
+
+            # Pattern 4: With spaces in chemistry mode: \mathrm{K}_{ sp } → \mathrm{K}_{\mathrm{sp}}
+            pattern_mathrm_k_spaces = rf'\\mathrm\{{K\}}_\{{\s*{subscript}\s*\}}'
+            latex = re.sub(pattern_mathrm_k_spaces, replacement_mathrm_k, latex)
+
+        return latex
+
+    def apply_mathjax_unicode_fallback(self, latex: str) -> str:
+        r"""
+        Replace LaTeX commands not supported by MathJax with Unicode characters.
+        Also applies regional symbol preferences (e.g., emptyset → varnothing in Chinese).
+
+        This ensures symbols render correctly in MathJax by using Unicode fallback
+        for commands that MathJax doesn't support (e.g., \llbracket → 〚).
+
+        Args:
+            latex: LaTeX string potentially containing unsupported commands
+
+        Returns:
+            LaTeX string with unsupported commands replaced by Unicode
+
+        Examples:
+            "\\llbracket x \\rrbracket" → "〚x〛"
+            "\\parallelogram" → "▱"
+            "\\iddots" → "⋰"
+            "\\emptyset" → "\\varnothing" (regional preference)
+            "\\sin x" → "\\sin x" (supported, unchanged)
+        """
+        # Step 1: Apply regional symbol preferences (e.g., emptyset → varnothing)
+        for old_cmd, new_cmd in REGIONAL_SYMBOL_PREFERENCES.items():
+            # Replace \old_cmd with \new_cmd
+            pattern = f'\\\\{re.escape(old_cmd)}(?![a-zA-Z])'
+            replacement = f'\\\\{new_cmd}'  # Need double backslash for regex replacement
+            latex = re.sub(pattern, replacement, latex)
+
+        # Step 2: Replace MathJax-unsupported commands with Unicode characters
+        for command, unicode_char in MATHJAX_UNSUPPORTED_TO_UNICODE.items():
+            # Replace \command with Unicode character
+            # Use word boundary to avoid partial matches (e.g., \ll in \llbracket)
+            pattern = f'\\\\{re.escape(command)}(?![a-zA-Z])'
+            latex = re.sub(pattern, unicode_char, latex)
+
+        return latex
+
+    def validate_output(self, latex: str) -> str:
+        """
+        Validate output and fix any remaining delimiter markers or issues.
+
+        This is the final safety net to catch any processing issues.
+
+        Args:
+            latex: LaTeX string
+
+        Returns:
+            Validated and cleaned LaTeX string
+        """
+        # Phase 3 Fix: If skip_delimiter_processing=True, PRESERVE __DELIM__ markers
+        # They're intentionally left for the new delimiter_pairing_processor
+        if hasattr(self, '_skip_delimiter_processing') and self._skip_delimiter_processing:
+            return latex
+
+        # Check for surviving delimiter markers (indicates processing issue)
+        if '__DELIM' in latex or 'DELIM__' in latex or '_DELIM' in latex or 'LIM__' in latex or 'LIM_' in latex:
+            logging.warning(f"Delimiter markers survived cleanup. Applying emergency cleanup...")
+
+            # Emergency cleanup of marker remnants (most specific first)
+            latex = re.sub(r'__DELIM[_]*\([_]*', '(', latex)  # Opening paren
+            latex = re.sub(r'[_]*\)__DELIM[_]*', ')', latex)  # Closing paren
+            latex = re.sub(r'__DELIM[_]*\[[_]*', '[', latex)  # Opening bracket
+            latex = re.sub(r'[_]*\]__DELIM[_]*', ']', latex)  # Closing bracket
+            latex = re.sub(r'__DELIM[_]*\{[_]*', '{', latex)  # Opening brace
+            latex = re.sub(r'[_]*\}__DELIM[_]*', '}', latex)  # Closing brace
+            latex = re.sub(r'__DELIM[_]*\|[_]*', '|', latex)  # Pipe
+            latex = re.sub(r'__DELIM[_]*', '', latex)         # Prefix
+            latex = re.sub(r'[_]*DELIM__', '', latex)         # Suffix
+            latex = re.sub(r'[_]*DELIM[_]*', '', latex)       # Fragment
+            latex = re.sub(r'LIM__', '', latex)               # Specific fragment
+            latex = re.sub(r'LIM_', '', latex)                # Another variant
+
+        return latex
diff --git a/scripts/omml_mathml2latex/core/OMML2MML.xsl b/scripts/omml_mathml2latex/core/OMML2MML.xsl
new file mode 100644
index 0000000..9db269b
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/OMML2MML.xsl
@@ -0,0 +1,851 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
+    xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+    xmlns:mml="http://www.w3.org/1998/Math/MathML"
+    xmlns="http://www.w3.org/1998/Math/MathML"
+    exclude-result-prefixes="m w">
+
+    <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
+
+    <!-- Root template -->
+    <xsl:template match="/">
+        <xsl:apply-templates select="//m:oMath"/>
+    </xsl:template>
+
+    <!-- Main math element -->
+    <xsl:template match="m:oMath">
+        <math>
+            <xsl:apply-templates select="*"/>
+        </math>
+    </xsl:template>
+
+    <!-- Text run -->
+    <xsl:template match="m:r">
+        <xsl:apply-templates select="m:t"/>
+    </xsl:template>
+
+    <!-- Text content -->
+    <xsl:template match="m:t">
+        <!-- Get style from parent <m:r><m:rPr><m:sty> -->
+        <xsl:variable name="sty" select="../m:rPr/m:sty/@m:val"/>
+
+        <!-- Get Word run properties (w:rPr) - check for italic (w:i) -->
+        <!-- w:rPr is a sibling of m:t (both are children of m:r) -->
+        <!-- CRITICAL: w:i with @w:val="0" or "false" means NOT italic! -->
+        <!-- Only treat as italic if w:i exists AND val is not "0" or "false" -->
+        <xsl:variable name="has_word_italic" select="boolean(../w:rPr/w:i[not(@w:val = '0') and not(@w:val = 'false')])"/>
+
+        <!-- Get math "normal" style (m:nor) - text mode button -->
+        <xsl:variable name="has_math_normal" select="boolean(../m:rPr/m:nor)"/>
+
+        <xsl:choose>
+            <xsl:when test="normalize-space(.) = ''">
+                <!-- Skip empty text -->
+            </xsl:when>
+            <xsl:when test="number(.) = number(.)">
+                <mn><xsl:value-of select="normalize-space(.)"/></mn>
+            </xsl:when>
+            <!-- Fence delimiters: parentheses, brackets, pipes (with fence="true") -->
+            <xsl:when test=". = '(' or . = ')' or . = '[' or . = ']' or . = '|'">
+                <mo fence="true"><xsl:value-of select="normalize-space(.)"/></mo>
+            </xsl:when>
+            <!-- Plain operators (no fence attribute) -->
+            <!-- NOTE: { and } are converted to markers to distinguish source braces from generated LaTeX braces -->
+            <xsl:when test=". = '{' or . = '}' or . = '+' or . = '-' or . = '=' or . = '&lt;' or . = '&gt;' or . = '±' or . = '≠' or . = '≤' or . = '≥' or . = '×' or . = '÷' or . = '∞'">
+                <mo>
+                    <xsl:choose>
+                        <xsl:when test=". = '{'">__LBRACE__</xsl:when>
+                        <xsl:when test=". = '}'">__RBRACE__</xsl:when>
+                        <xsl:otherwise><xsl:value-of select="normalize-space(.)"/></xsl:otherwise>
+                    </xsl:choose>
+                </mo>
+            </xsl:when>
+            <!-- Mixed operators/delimiters (like ")+" or ")=" or "(A" or "={" or ",}") -->
+            <!-- Check if string contains multiple operator/delimiter characters -->
+            <xsl:when test="string-length(normalize-space(.)) &gt; 1 and (contains(., '(') or contains(., ')') or contains(., '[') or contains(., ']') or contains(., '{') or contains(., '}') or contains(., '+') or contains(., '-') or contains(., '=') or contains(., '&lt;') or contains(., '&gt;'))">
+                <!-- Split into individual characters and classify each one -->
+                <!-- Pass style info so letters get proper mathvariant (e.g., mathvariant="normal" for m:nor text mode) -->
+                <xsl:call-template name="split-operators">
+                    <xsl:with-param name="text" select="normalize-space(.)"/>
+                    <xsl:with-param name="math_variant">
+                        <xsl:choose>
+                            <xsl:when test="$has_word_italic">italic</xsl:when>
+                            <xsl:when test="$sty = 'b' or $sty = 'bi'">bold</xsl:when>
+                            <xsl:when test="$sty = 'p'">normal</xsl:when>
+                            <xsl:when test="$has_math_normal">normal</xsl:when>
+                            <xsl:otherwise></xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:with-param>
+                </xsl:call-template>
+            </xsl:when>
+            <xsl:when test="contains(., '|')">
+                <!-- Special handling for text containing | (like "x|x", "A|B", or "||") -->
+                <!-- Split by | and create separate elements with fence="true" for absolute values -->
+                <xsl:variable name="before" select="substring-before(., '|')"/>
+                <xsl:variable name="after" select="substring-after(., '|')"/>
+                <!-- Process before part (plain text) -->
+                <xsl:if test="$before != ''">
+                    <xsl:choose>
+                        <!-- If before part contains operators or is multi-char, use split-operators -->
+                        <xsl:when test="string-length($before) &gt; 1">
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$before"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- Single character - output as mi -->
+                        <xsl:otherwise>
+                            <mi><xsl:value-of select="$before"/></mi>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+                <!-- Output the | as fence for potential absolute value -->
+                <mo fence="true">|</mo>
+                <!-- Process after part recursively if it contains more | or operators -->
+                <xsl:if test="$after != ''">
+                    <xsl:choose>
+                        <!-- If after part is just |, output as fence -->
+                        <xsl:when test="$after = '|'">
+                            <mo fence="true">|</mo>
+                        </xsl:when>
+                        <!-- If after part contains more |, recursively process this m:t content -->
+                        <xsl:when test="contains($after, '|')">
+                            <xsl:call-template name="process-text-with-pipe">
+                                <xsl:with-param name="text" select="$after"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- If after part contains operators, use split-operators -->
+                        <xsl:when test="string-length($after) &gt; 1 and (contains($after, '+') or contains($after, '-') or contains($after, '='))">
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$after"/>
+                            </xsl:call-template>
+                        </xsl:when>
+                        <!-- Single character or simple text - output as mi -->
+                        <xsl:otherwise>
+                            <mi><xsl:value-of select="$after"/></mi>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:if>
+            </xsl:when>
+            <xsl:when test="string-length(normalize-space(.)) = 1 and not(contains('0123456789', .))">
+                <mi>
+                    <!-- Apply mathvariant based on style -->
+                    <!-- Note: m:sty='i' (italic) is NOT handled here as italic is the default for variables -->
+                    <!-- Priority: italic (w:i explicit) > bold > plain (m:sty='p') > normal (m:nor) -->
+                    <xsl:choose>
+                        <xsl:when test="$has_word_italic">
+                            <xsl:attribute name="mathvariant">italic</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'b' or $sty = 'bi'">
+                            <xsl:attribute name="mathvariant">bold</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'p'">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$has_math_normal">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                    </xsl:choose>
+                    <xsl:value-of select="normalize-space(.)"/>
+                </mi>
+            </xsl:when>
+            <xsl:otherwise>
+                <mi>
+                    <!-- Apply mathvariant for multi-character identifiers too -->
+                    <!-- Note: m:sty='i' (italic) is NOT handled here as italic is the default for variables -->
+                    <!-- Priority: italic (w:i explicit) > bold > plain (m:sty='p') > normal (m:nor) -->
+                    <xsl:choose>
+                        <xsl:when test="$has_word_italic">
+                            <xsl:attribute name="mathvariant">italic</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'b' or $sty = 'bi'">
+                            <xsl:attribute name="mathvariant">bold</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$sty = 'p'">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="$has_math_normal">
+                            <xsl:attribute name="mathvariant">normal</xsl:attribute>
+                        </xsl:when>
+                    </xsl:choose>
+                    <xsl:value-of select="normalize-space(.)"/>
+                </mi>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Superscript -->
+    <xsl:template match="m:sSup">
+        <msup>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sup"/>
+        </msup>
+    </xsl:template>
+
+    <!-- Subscript -->
+    <xsl:template match="m:sSub">
+        <msub>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sub"/>
+        </msub>
+    </xsl:template>
+
+    <!-- Sub-superscript -->
+    <xsl:template match="m:sSubSup">
+        <msubsup>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:sub"/>
+            <xsl:apply-templates select="m:sup"/>
+        </msubsup>
+    </xsl:template>
+
+    <!-- Pre-script (left-side subscript/superscript) -->
+    <!-- Used for nuclear notation like _{2}^{3}He -->
+    <xsl:template match="m:sPre">
+        <mmultiscripts>
+            <xsl:apply-templates select="m:e"/>
+            <mprescripts/>
+            <xsl:apply-templates select="m:sub"/>
+            <xsl:apply-templates select="m:sup"/>
+        </mmultiscripts>
+    </xsl:template>
+
+    <!-- Fraction -->
+    <!-- m:type values: bar (default), noBar, lin (linear), skw (skewed) -->
+    <xsl:template match="m:f">
+        <xsl:variable name="type" select="m:fPr/m:type/@m:val"/>
+        <mfrac>
+            <!-- Add linethickness="0" for noBar fractions (stacked without bar) -->
+            <xsl:if test="$type = 'noBar'">
+                <xsl:attribute name="linethickness">0</xsl:attribute>
+            </xsl:if>
+            <!-- Add bevelled="true" for linear fractions -->
+            <xsl:if test="$type = 'lin'">
+                <xsl:attribute name="bevelled">true</xsl:attribute>
+            </xsl:if>
+            <xsl:apply-templates select="m:num"/>
+            <xsl:apply-templates select="m:den"/>
+        </mfrac>
+    </xsl:template>
+
+    <!-- Radical -->
+    <xsl:template match="m:rad">
+        <xsl:choose>
+            <xsl:when test="m:deg">
+                <mroot>
+                    <xsl:apply-templates select="m:e"/>
+                    <xsl:apply-templates select="m:deg"/>
+                </mroot>
+            </xsl:when>
+            <xsl:otherwise>
+                <msqrt>
+                    <xsl:apply-templates select="m:e"/>
+                </msqrt>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Parentheses/delimiters -->
+    <xsl:template match="m:d">
+        <mrow>
+            <!-- Opening delimiter: skip if begChr has empty or whitespace-only val -->
+            <xsl:choose>
+                <xsl:when test="not(m:dPr/m:begChr)">
+                    <mo fence="true">(</mo>
+                </xsl:when>
+                <xsl:when test="normalize-space(m:dPr/m:begChr/@m:val) != ''">
+                    <mo fence="true">
+                        <xsl:value-of select="m:dPr/m:begChr/@m:val"/>
+                    </mo>
+                </xsl:when>
+                <!-- begChr with empty/whitespace val → no opening delimiter -->
+            </xsl:choose>
+            <!-- Handle multiple m:e elements with separators -->
+            <xsl:for-each select="m:e">
+                <xsl:apply-templates select="."/>
+                <!-- Insert separator | between elements (except after the last one) -->
+                <xsl:if test="position() != last()">
+                    <mo>|</mo>
+                </xsl:if>
+            </xsl:for-each>
+            <!-- Closing delimiter: skip if endChr has empty or whitespace-only val -->
+            <xsl:choose>
+                <xsl:when test="not(m:dPr/m:endChr)">
+                    <mo fence="true">)</mo>
+                </xsl:when>
+                <xsl:when test="normalize-space(m:dPr/m:endChr/@m:val) != ''">
+                    <mo fence="true">
+                        <xsl:value-of select="m:dPr/m:endChr/@m:val"/>
+                    </mo>
+                </xsl:when>
+                <!-- endChr with empty/whitespace val → no closing delimiter -->
+            </xsl:choose>
+        </mrow>
+    </xsl:template>
+
+    <!-- Function -->
+    <xsl:template match="m:func">
+        <mrow>
+            <xsl:apply-templates select="m:fName"/>
+            <xsl:apply-templates select="m:e"/>
+        </mrow>
+    </xsl:template>
+
+    <!-- Matrix -->
+    <xsl:template match="m:m">
+        <mtable>
+            <xsl:apply-templates select="m:mr"/>
+        </mtable>
+    </xsl:template>
+
+    <!-- Matrix row -->
+    <xsl:template match="m:mr">
+        <mtr>
+            <xsl:apply-templates select="m:e"/>
+        </mtr>
+    </xsl:template>
+
+    <!-- Equation array (for piecewise functions) -->
+    <xsl:template match="m:eqArr">
+        <mtable>
+            <!-- Each <m:e> child represents one row in the piecewise function -->
+            <xsl:for-each select="m:e">
+                <mtr>
+                    <mtd>
+                        <xsl:apply-templates select="node()"/>
+                    </mtd>
+                </mtr>
+            </xsl:for-each>
+        </mtable>
+    </xsl:template>
+
+    <!-- Bar (overbar/underbar) -->
+    <!-- OMML spec: no pos attribute = underline (default), pos="top" = overline, pos="bot" = underline -->
+    <xsl:template match="m:bar">
+        <xsl:choose>
+            <xsl:when test="m:barPr/m:pos/@m:val = 'top'">
+                <mover>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>‾</mo>
+                </mover>
+            </xsl:when>
+            <xsl:otherwise>
+                <!-- Default: no pos attribute or pos="bot" both mean underline -->
+                <munder>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>‾</mo>
+                </munder>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Limits -->
+    <!-- limLow: Lower limit position (content BELOW the base, like underscript) -->
+    <xsl:template match="m:limLow">
+        <munder>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim"/>
+        </munder>
+    </xsl:template>
+
+    <!-- limUpp: Upper limit position (content ABOVE the base, like overscript) -->
+    <xsl:template match="m:limUpp">
+        <mover>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim"/>
+        </mover>
+    </xsl:template>
+
+    <xsl:template match="m:limUppLow">
+        <munderover>
+            <xsl:apply-templates select="m:e"/>
+            <xsl:apply-templates select="m:lim[1]"/>
+            <xsl:apply-templates select="m:lim[2]"/>
+        </munderover>
+    </xsl:template>
+
+    <!-- N-ary operators (integrals, sums, products) -->
+    <xsl:template match="m:nary">
+        <xsl:variable name="chr" select="m:naryPr/m:chr/@m:val"/>
+        <xsl:variable name="limLoc" select="m:naryPr/m:limLoc/@m:val"/>
+        <xsl:variable name="subHide" select="m:naryPr/m:subHide/@m:val"/>
+        <xsl:variable name="supHide" select="m:naryPr/m:supHide/@m:val"/>
+
+        <xsl:choose>
+            <!-- Both limits hidden: just operator and integrand -->
+            <xsl:when test="$subHide = '1' and $supHide = '1'">
+                <mrow>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>∫</xsl:otherwise>
+                        </xsl:choose>
+                    </mo>
+                    <xsl:apply-templates select="m:e"/>
+                </mrow>
+            </xsl:when>
+
+            <!-- Limits as subscript/superscript (default for integrals) -->
+            <xsl:when test="not($limLoc) or $limLoc = 'subSup'">
+                <xsl:choose>
+                    <!-- Both sub and sup present -->
+                    <xsl:when test="m:sub and m:sup">
+                        <msubsup>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sub"/>
+                            <xsl:apply-templates select="m:sup"/>
+                        </msubsup>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- Only subscript -->
+                    <xsl:when test="m:sub">
+                        <msub>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sub"/>
+                        </msub>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- Only superscript -->
+                    <xsl:when test="m:sup">
+                        <msup>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:sup"/>
+                        </msup>
+                        <xsl:apply-templates select="m:e"/>
+                    </xsl:when>
+                    <!-- No limits -->
+                    <xsl:otherwise>
+                        <mrow>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="m:e"/>
+                        </mrow>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+
+            <!-- Limits as under/over (for sums, products) -->
+            <xsl:when test="$limLoc = 'undOvr'">
+                <mrow>
+                    <xsl:choose>
+                        <!-- Both under and over -->
+                        <xsl:when test="m:sub and m:sup and not($subHide = '1') and not($supHide = '1')">
+                            <munderover>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sub"/>
+                                <xsl:apply-templates select="m:sup"/>
+                            </munderover>
+                        </xsl:when>
+                        <!-- Only under -->
+                        <xsl:when test="m:sub and not($subHide = '1')">
+                            <munder>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sub"/>
+                            </munder>
+                        </xsl:when>
+                        <!-- Only over -->
+                        <xsl:when test="m:sup and not($supHide = '1')">
+                            <mover>
+                                <mo>
+                                    <xsl:choose>
+                                        <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                        <xsl:otherwise>∫</xsl:otherwise>
+                                    </xsl:choose>
+                                </mo>
+                                <xsl:apply-templates select="m:sup"/>
+                            </mover>
+                        </xsl:when>
+                        <!-- No visible limits -->
+                        <xsl:otherwise>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                                    <xsl:otherwise>∫</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                    <xsl:apply-templates select="m:e"/>
+                </mrow>
+            </xsl:when>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Accent (vector arrows, dots, etc.) -->
+    <xsl:template match="m:acc">
+        <xsl:variable name="chr" select="m:accPr/m:chr/@m:val"/>
+        <mover>
+            <!-- Add data attribute to distinguish default accents from explicit ones -->
+            <xsl:if test="not($chr)">
+                <xsl:attribute name="data-default-accent">true</xsl:attribute>
+            </xsl:if>
+            <xsl:apply-templates select="m:e"/>
+            <mo>
+                <xsl:choose>
+                    <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                    <xsl:otherwise>⃗</xsl:otherwise><!-- Default accent (should be hat in most cases) -->
+                </xsl:choose>
+            </mo>
+        </mover>
+    </xsl:template>
+
+    <!-- Group character (for over/under arrows with text) -->
+    <xsl:template match="m:groupChr">
+        <xsl:variable name="chr" select="m:groupChrPr/m:chr/@m:val"/>
+        <xsl:variable name="pos" select="m:groupChrPr/m:pos/@m:val"/>
+        <xsl:variable name="vertJc" select="m:groupChrPr/m:vertJc/@m:val"/>
+
+        <xsl:choose>
+            <!-- vertJc='bot': Character at bottom (base), content above → mover(char, content) -->
+            <!-- This is used for extensible arrows like \xrightarrow[]{text} or \overset{text}{arrow} -->
+            <xsl:when test="$vertJc = 'bot'">
+                <mover accent="false">
+                    <mo stretchy="true">
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>→</xsl:otherwise>
+                        </xsl:choose>
+                    </mo>
+                    <xsl:apply-templates select="m:e"/>
+                </mover>
+            </xsl:when>
+            <!-- pos='bot': Character position at bottom, content above → munder -->
+            <xsl:when test="$pos = 'bot'">
+                <munder>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>⏟</xsl:otherwise><!-- Default underbrace -->
+                        </xsl:choose>
+                    </mo>
+                </munder>
+            </xsl:when>
+            <!-- pos='top' (or default): Character above content → mover(content, char) -->
+            <xsl:otherwise>
+                <mover>
+                    <xsl:apply-templates select="m:e"/>
+                    <mo>
+                        <xsl:choose>
+                            <xsl:when test="$chr"><xsl:value-of select="$chr"/></xsl:when>
+                            <xsl:otherwise>⏞</xsl:otherwise><!-- Default overbrace -->
+                        </xsl:choose>
+                    </mo>
+                </mover>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Box (but detect if it contains groupChr for reaction arrows) -->
+    <xsl:template match="m:box">
+        <xsl:choose>
+            <!-- Skip boxes with opEmu="1" (operator emulation - should be transparent) -->
+            <!-- This means process all children in m:e transparently -->
+            <xsl:when test="m:boxPr/m:opEmu/@m:val='1'">
+                <xsl:apply-templates select="m:e/*"/>
+            </xsl:when>
+
+            <!-- If box contains ONLY a single direct groupChr, handle specially -->
+            <!-- This is for cases like reaction arrows: text above/below extensible arrow -->
+            <xsl:when test="count(m:e/*) = 1 and m:e/m:groupChr">
+                <xsl:variable name="groupChr" select="m:e/m:groupChr"/>
+                <xsl:variable name="arrow" select="$groupChr/m:groupChrPr/m:chr/@m:val"/>
+                <xsl:variable name="vertJc" select="$groupChr/m:groupChrPr/m:vertJc/@m:val"/>
+                <xsl:variable name="pos" select="$groupChr/m:groupChrPr/m:pos/@m:val"/>
+
+                <xsl:choose>
+                    <xsl:when test="$vertJc = 'bot'">
+                        <!-- Arrow at bottom with text above (like \xrightarrow[]{text}) -->
+                        <!-- For extensible arrows: mover with arrow base, text above -->
+                        <mover accent="false">
+                            <mo stretchy="true">
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                        </mover>
+                    </xsl:when>
+                    <xsl:when test="$pos = 'top'">
+                        <!-- Arrow at top: \overrightarrow pattern -->
+                        <!-- mover with content base, arrow above -->
+                        <mover>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </mover>
+                    </xsl:when>
+                    <xsl:otherwise>
+                        <!-- Default: Vector arrow over content -->
+                        <mover>
+                            <xsl:apply-templates select="$groupChr/m:e"/>
+                            <mo>
+                                <xsl:choose>
+                                    <xsl:when test="$arrow"><xsl:value-of select="$arrow"/></xsl:when>
+                                    <xsl:otherwise>→</xsl:otherwise>
+                                </xsl:choose>
+                            </mo>
+                        </mover>
+                    </xsl:otherwise>
+                </xsl:choose>
+            </xsl:when>
+
+            <!-- Skip phantom/layout boxes (argSz with negative value) -->
+            <!-- These are used for sizing/spacing control, not actual visible boxes -->
+            <xsl:when test="m:e/m:argPr/m:argSz/@m:val &lt; 0">
+                <xsl:apply-templates select="m:e"/>
+            </xsl:when>
+
+            <!-- Regular box -->
+            <xsl:otherwise>
+                <menclose notation="box">
+                    <xsl:apply-templates select="m:e"/>
+                </menclose>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:template>
+
+    <!-- Border box with strikethrough and border notation support -->
+    <xsl:template match="m:borderBox">
+        <xsl:variable name="props" select="m:borderBoxPr"/>
+
+        <!-- Check for strikethrough properties -->
+        <xsl:variable name="strikeBLTR" select="boolean($props/m:strikeBLTR)"/>
+        <xsl:variable name="strikeTLBR" select="boolean($props/m:strikeTLBR)"/>
+        <xsl:variable name="strikeH" select="boolean($props/m:strikeH)"/>
+        <xsl:variable name="strikeV" select="boolean($props/m:strikeV)"/>
+
+        <!-- Check for border hiding properties -->
+        <xsl:variable name="hideTop" select="boolean($props/m:hideTop)"/>
+        <xsl:variable name="hideBot" select="boolean($props/m:hideBot)"/>
+        <xsl:variable name="hideLeft" select="boolean($props/m:hideLeft)"/>
+        <xsl:variable name="hideRight" select="boolean($props/m:hideRight)"/>
+
+        <!-- Determine notation attribute -->
+        <xsl:variable name="notation">
+            <xsl:choose>
+                <!-- Combined diagonal strikes → xcancel -->
+                <xsl:when test="$strikeBLTR and $strikeTLBR">updiagonalstrike downdiagonalstrike</xsl:when>
+
+                <!-- Single diagonal strike BLTR → cancel (updiagonal) -->
+                <xsl:when test="$strikeBLTR">updiagonalstrike</xsl:when>
+
+                <!-- Single diagonal strike TLBR → bcancel (downdiagonal) -->
+                <xsl:when test="$strikeTLBR">downdiagonalstrike</xsl:when>
+
+                <!-- Combined horizontal and vertical → cancel -->
+                <xsl:when test="$strikeH and $strikeV">horizontalstrike verticalstrike</xsl:when>
+
+                <!-- Single horizontal strike → cancel -->
+                <xsl:when test="$strikeH">horizontalstrike</xsl:when>
+
+                <!-- Single vertical strike → bcancel -->
+                <xsl:when test="$strikeV">verticalstrike</xsl:when>
+
+                <!-- Single side visible -->
+                <xsl:when test="not($hideTop) and $hideBot and $hideLeft and $hideRight">top</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and $hideLeft and $hideRight">bottom</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and not($hideLeft) and $hideRight">left</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and $hideLeft and not($hideRight)">right</xsl:when>
+
+                <!-- Two sides visible -->
+                <xsl:when test="not($hideTop) and not($hideBot) and $hideLeft and $hideRight">top bottom</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and not($hideLeft) and $hideRight">top left</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and $hideLeft and not($hideRight)">top right</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and not($hideLeft) and $hideRight">bottom left</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and $hideLeft and not($hideRight)">bottom right</xsl:when>
+                <xsl:when test="$hideTop and $hideBot and not($hideLeft) and not($hideRight)">left right</xsl:when>
+
+                <!-- Three sides visible -->
+                <xsl:when test="not($hideTop) and not($hideBot) and not($hideLeft) and $hideRight">top bottom left</xsl:when>
+                <xsl:when test="not($hideTop) and not($hideBot) and $hideLeft and not($hideRight)">top bottom right</xsl:when>
+                <xsl:when test="not($hideTop) and $hideBot and not($hideLeft) and not($hideRight)">top left right</xsl:when>
+                <xsl:when test="$hideTop and not($hideBot) and not($hideLeft) and not($hideRight)">bottom left right</xsl:when>
+
+                <!-- All four sides visible (or none hidden) -->
+                <xsl:when test="not($hideTop or $hideBot or $hideLeft or $hideRight)">box</xsl:when>
+
+                <!-- Default: roundedbox -->
+                <xsl:otherwise>roundedbox</xsl:otherwise>
+            </xsl:choose>
+        </xsl:variable>
+
+        <menclose notation="{$notation}">
+            <xsl:apply-templates select="m:e"/>
+        </menclose>
+    </xsl:template>
+
+    <!-- Math element base -->
+    <xsl:template match="m:e | m:num | m:den | m:sup | m:sub | m:deg | m:fName | m:lim">
+        <mrow>
+            <xsl:apply-templates select="*"/>
+        </mrow>
+    </xsl:template>
+
+    <!-- Template to split mixed operator/delimiter strings character by character -->
+    <!-- Recursive template to process text containing | characters -->
+    <xsl:template name="process-text-with-pipe">
+        <xsl:param name="text"/>
+        <xsl:if test="string-length($text) &gt; 0">
+            <xsl:choose>
+                <!-- If text contains |, split and recurse -->
+                <xsl:when test="contains($text, '|')">
+                    <xsl:variable name="before" select="substring-before($text, '|')"/>
+                    <xsl:variable name="after" select="substring-after($text, '|')"/>
+                    <!-- Output before part if not empty -->
+                    <xsl:if test="$before != ''">
+                        <xsl:choose>
+                            <!-- If before is single char, output as mi or mn -->
+                            <xsl:when test="string-length($before) = 1">
+                                <xsl:choose>
+                                    <xsl:when test="contains('0123456789', $before)">
+                                        <mn><xsl:value-of select="$before"/></mn>
+                                    </xsl:when>
+                                    <xsl:otherwise>
+                                        <mi><xsl:value-of select="$before"/></mi>
+                                    </xsl:otherwise>
+                                </xsl:choose>
+                            </xsl:when>
+                            <!-- Multi-char - use split-operators -->
+                            <xsl:otherwise>
+                                <xsl:call-template name="split-operators">
+                                    <xsl:with-param name="text" select="$before"/>
+                                </xsl:call-template>
+                            </xsl:otherwise>
+                        </xsl:choose>
+                    </xsl:if>
+                    <!-- Output | as fence -->
+                    <mo fence="true">|</mo>
+                    <!-- Recurse on after part -->
+                    <xsl:if test="$after != ''">
+                        <xsl:call-template name="process-text-with-pipe">
+                            <xsl:with-param name="text" select="$after"/>
+                        </xsl:call-template>
+                    </xsl:if>
+                </xsl:when>
+                <!-- No more | in text - output as-is -->
+                <xsl:otherwise>
+                    <xsl:choose>
+                        <!-- Single char -->
+                        <xsl:when test="string-length($text) = 1">
+                            <xsl:choose>
+                                <xsl:when test="contains('0123456789', $text)">
+                                    <mn><xsl:value-of select="$text"/></mn>
+                                </xsl:when>
+                                <xsl:otherwise>
+                                    <mi><xsl:value-of select="$text"/></mi>
+                                </xsl:otherwise>
+                            </xsl:choose>
+                        </xsl:when>
+                        <!-- Multi-char - use split-operators for proper handling -->
+                        <xsl:otherwise>
+                            <xsl:call-template name="split-operators">
+                                <xsl:with-param name="text" select="$text"/>
+                            </xsl:call-template>
+                        </xsl:otherwise>
+                    </xsl:choose>
+                </xsl:otherwise>
+            </xsl:choose>
+        </xsl:if>
+    </xsl:template>
+
+    <xsl:template name="split-operators">
+        <xsl:param name="text"/>
+        <!-- Style variant to apply to identifier (letter) elements: 'normal', 'bold', 'italic', or empty -->
+        <xsl:param name="math_variant" select="''"/>
+        <xsl:if test="string-length($text) &gt; 0">
+            <!-- Process first character -->
+            <xsl:variable name="char" select="substring($text, 1, 1)"/>
+            <xsl:choose>
+                <!-- Fence delimiters with fence="true" -->
+                <xsl:when test="$char = '(' or $char = ')' or $char = '[' or $char = ']' or $char = '|'">
+                    <mo fence="true"><xsl:value-of select="$char"/></mo>
+                </xsl:when>
+                <!-- Plain operators (no fence attribute) -->
+                <!-- NOTE: { and } are converted to markers to distinguish source braces from generated LaTeX braces -->
+                <xsl:when test="$char = '+' or $char = '-' or $char = '=' or $char = '&lt;' or $char = '&gt;' or $char = '*' or $char = '/' or $char = '±' or $char = '≠' or $char = '≤' or $char = '≥' or $char = '×' or $char = '÷'">
+                    <mo><xsl:value-of select="$char"/></mo>
+                </xsl:when>
+                <!-- Source braces - use markers -->
+                <xsl:when test="$char = '{'">
+                    <mo>__LBRACE__</mo>
+                </xsl:when>
+                <xsl:when test="$char = '}'">
+                    <mo>__RBRACE__</mo>
+                </xsl:when>
+                <!-- Numbers -->
+                <xsl:when test="contains('0123456789', $char)">
+                    <mn><xsl:value-of select="$char"/></mn>
+                </xsl:when>
+                <!-- Identifiers (letters) -->
+                <xsl:otherwise>
+                    <mi>
+                        <!-- Apply mathvariant from parent run style if available -->
+                        <xsl:if test="$math_variant != ''">
+                            <xsl:attribute name="mathvariant"><xsl:value-of select="$math_variant"/></xsl:attribute>
+                        </xsl:if>
+                        <xsl:value-of select="$char"/>
+                    </mi>
+                </xsl:otherwise>
+            </xsl:choose>
+            <!-- Recursively process remaining characters -->
+            <xsl:if test="string-length($text) &gt; 1">
+                <xsl:call-template name="split-operators">
+                    <xsl:with-param name="text" select="substring($text, 2)"/>
+                    <xsl:with-param name="math_variant" select="$math_variant"/>
+                </xsl:call-template>
+            </xsl:if>
+        </xsl:if>
+    </xsl:template>
+
+    <!-- Properties elements - ignore -->
+    <xsl:template match="m:rPr | m:ctrlPr | m:dPr | m:fPr | m:funcPr | m:limLowPr | m:limUppPr | m:naryPr | m:phantPr | m:radPr | m:sPrePr | m:sSubPr | m:sSubSupPr | m:sSupPr | m:accPr | m:barPr | m:boxPr | m:borderBoxPr | m:dPr | m:eqArrPr | m:groupChrPr | m:mPr | w:rPr">
+        <!-- Ignore formatting properties -->
+    </xsl:template>
+
+    <!-- Control properties - ignore -->
+    <xsl:template match="m:ctrlPr">
+        <!-- Ignore control properties -->
+    </xsl:template>
+
+    <!-- Default template -->
+    <xsl:template match="*">
+        <xsl:apply-templates select="*"/>
+    </xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/scripts/omml_mathml2latex/core/__init__.py b/scripts/omml_mathml2latex/core/__init__.py
new file mode 100644
index 0000000..b754a05
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/__init__.py
@@ -0,0 +1,25 @@
+"""
+Core pipeline infrastructure.
+
+This package contains the foundational components of the refactored
+converter architecture: interfaces, context, and pipeline orchestrator.
+"""
+
+from .context import ConversionContext
+from .pipeline import ConversionPipeline
+from .interfaces import Stage, Visitor, Strategy, VisitorRegistry
+from .xslt_transformer import omml_to_mathml, _local, _text_content
+from .omml_parser_core import omml_to_mathml_fallback
+
+__all__ = [
+    'ConversionContext',
+    'ConversionPipeline',
+    'Stage',
+    'Visitor',
+    'Strategy',
+    'VisitorRegistry',
+    'omml_to_mathml',
+    'omml_to_mathml_fallback',
+    '_local',
+    '_text_content',
+]
diff --git a/scripts/omml_mathml2latex/core/cache.py b/scripts/omml_mathml2latex/core/cache.py
new file mode 100644
index 0000000..674123e
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/cache.py
@@ -0,0 +1,290 @@
+"""
+Caching utilities for performance optimization.
+
+Provides singleton pattern for expensive-to-create objects like
+XSL transformers, and LRU caching for frequently-used operations.
+"""
+
+import os
+import threading
+from typing import Dict, Optional
+from lxml import etree as ET
+from functools import lru_cache
+
+
+class XSLTransformerCache:
+    """
+    Thread-safe singleton cache for XSL transformers.
+
+    The OMML2MML.xsl file is expensive to parse (lxml XSLT compilation).
+    This cache ensures it's only parsed once and reused across all conversions.
+
+    Example:
+        >>> cache = XSLTransformerCache.get_instance()
+        >>> transformer = cache.get_transformer('path/to/OMML2MML.xsl')
+        >>> # Subsequent calls return cached transformer
+        >>> transformer2 = cache.get_transformer('path/to/OMML2MML.xsl')
+        >>> assert transformer is transformer2
+    """
+
+    _instance: Optional['XSLTransformerCache'] = None
+    _lock = threading.Lock()
+
+    def __init__(self):
+        """Initialize cache storage."""
+        self._transformers: Dict[str, ET.XSLT] = {}
+        self._cache_lock = threading.Lock()
+
+    @classmethod
+    def get_instance(cls) -> 'XSLTransformerCache':
+        """
+        Get singleton instance of the cache.
+
+        Thread-safe singleton pattern using double-checked locking.
+
+        Returns:
+            Singleton XSLTransformerCache instance
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def get_transformer(self, xsl_path: str) -> ET.XSLT:
+        """
+        Get cached XSL transformer or create and cache new one.
+
+        Args:
+            xsl_path: Path to XSL stylesheet file
+
+        Returns:
+            Compiled XSLT transformer
+
+        Raises:
+            FileNotFoundError: If XSL file doesn't exist
+            ET.XSLTParseError: If XSL file is malformed
+
+        Example:
+            >>> cache = XSLTransformerCache.get_instance()
+            >>> transformer = cache.get_transformer('OMML2MML.xsl')
+            >>> result = transformer(omml_doc)
+        """
+        # Normalize path for consistent caching
+        xsl_path = os.path.abspath(xsl_path)
+
+        # Check cache (read lock)
+        if xsl_path in self._transformers:
+            return self._transformers[xsl_path]
+
+        # Not in cache - create with write lock
+        with self._cache_lock:
+            # Double-check after acquiring lock
+            if xsl_path in self._transformers:
+                return self._transformers[xsl_path]
+
+            # Validate file exists
+            if not os.path.exists(xsl_path):
+                raise FileNotFoundError(f"XSL file not found: {xsl_path}")
+
+            # Parse and compile XSL
+            try:
+                xsl_doc = ET.parse(xsl_path)
+                transformer = ET.XSLT(xsl_doc)
+                self._transformers[xsl_path] = transformer
+                return transformer
+
+            except (ET.XSLTParseError, ET.XMLSyntaxError) as e:
+                raise ET.XSLTParseError(f"Failed to parse XSL file {xsl_path}: {e}") from e
+
+    def clear_cache(self) -> None:
+        """
+        Clear all cached transformers.
+
+        Useful for testing or when XSL files have been updated.
+
+        Example:
+            >>> cache = XSLTransformerCache.get_instance()
+            >>> cache.clear_cache()
+        """
+        with self._cache_lock:
+            self._transformers.clear()
+
+    def get_cache_size(self) -> int:
+        """
+        Get number of cached transformers.
+
+        Returns:
+            Number of cached XSL transformers
+
+        Example:
+            >>> cache = XSLTransformerCache.get_instance()
+            >>> size = cache.get_cache_size()
+            >>> print(f"Cached {size} transformers")
+        """
+        return len(self._transformers)
+
+
+class ConverterObjectPool:
+    """
+    Object pool for visitor registries and strategies.
+
+    Maintains a pool of pre-initialized conversion objects to avoid
+    recreation overhead for each equation.
+
+    Thread-safe implementation using locks.
+
+    Example:
+        >>> pool = ConverterObjectPool(pool_size=4)
+        >>> obj = pool.acquire_converter('math', wrap_identifiers=False)
+        >>> # Use converter...
+        >>> pool.release_converter(obj)
+    """
+
+    def __init__(self, pool_size: int = 4):
+        """
+        Initialize object pool.
+
+        Args:
+            pool_size: Maximum number of pooled objects
+        """
+        self.pool_size = pool_size
+        self._available = []
+        self._in_use = set()
+        self._lock = threading.Lock()
+
+    def acquire_converter(
+        self,
+        subject_mode: str = 'auto',
+        wrap_identifiers: bool = False,
+    ):
+        """
+        Acquire a converter from the pool.
+
+        If pool is exhausted, creates a new converter.
+
+        Args:
+            subject_mode: Subject formatting mode
+            wrap_identifiers: Wrap identifiers in \\mathrm{}
+
+        Returns:
+            Converter instance
+
+        Example:
+            >>> pool = ConverterObjectPool()
+            >>> converter = pool.acquire_converter('math')
+        """
+        with self._lock:
+            # Try to reuse from pool
+            for i, (cached_mode, cached_wrap, obj) in enumerate(self._available):
+                if cached_mode == subject_mode and cached_wrap == wrap_identifiers:
+                    self._available.pop(i)
+                    self._in_use.add(id(obj))
+                    return obj
+
+            # Pool miss - create new converter
+            from ..compat import LegacyMathMLToTeXConverter
+            converter = LegacyMathMLToTeXConverter(
+                wrap_identifiers_in_mathrm=wrap_identifiers,
+                subject_mode=subject_mode,
+            )
+            self._in_use.add(id(converter))
+            return converter
+
+    def release_converter(
+        self,
+        converter,
+        subject_mode: str = 'auto',
+        wrap_identifiers: bool = False,
+    ) -> None:
+        """
+        Release converter back to pool.
+
+        Args:
+            converter: Converter instance to release
+            subject_mode: Subject mode of the converter
+            wrap_identifiers: Wrap identifiers setting
+
+        Example:
+            >>> pool.release_converter(converter, 'math', False)
+        """
+        with self._lock:
+            obj_id = id(converter)
+            if obj_id in self._in_use:
+                self._in_use.remove(obj_id)
+
+                # Only pool if under limit
+                if len(self._available) < self.pool_size:
+                    self._available.append((subject_mode, wrap_identifiers, converter))
+
+    def clear_pool(self) -> None:
+        """Clear the object pool."""
+        with self._lock:
+            self._available.clear()
+            self._in_use.clear()
+
+
+# LRU cache for expensive pattern matching operations
+@lru_cache(maxsize=256)
+def cached_function_detection(text: str) -> Optional[str]:
+    """
+    Cached function name detection for fragmented functions.
+
+    Args:
+        text: Text to check for function names
+
+    Returns:
+        Function name if detected, None otherwise
+
+    Example:
+        >>> cached_function_detection('sin')
+        'sin'
+        >>> cached_function_detection('xyz')
+        None
+    """
+    from ..data import MATH_FUNCTIONS
+
+    text_lower = text.lower()
+    if text_lower in MATH_FUNCTIONS:
+        return text_lower
+    return None
+
+
+@lru_cache(maxsize=128)
+def cached_chemical_element_detection(symbol: str) -> bool:
+    """
+    Cached chemical element symbol detection.
+
+    Args:
+        symbol: Symbol to check
+
+    Returns:
+        True if symbol is a chemical element
+
+    Example:
+        >>> cached_chemical_element_detection('Fe')
+        True
+        >>> cached_chemical_element_detection('Xy')
+        False
+    """
+    from ..data import CHEMICAL_ELEMENTS
+
+    return symbol in CHEMICAL_ELEMENTS
+
+
+def clear_all_caches() -> None:
+    """
+    Clear all caches (XSL, LRU caches, object pools).
+
+    Useful for testing or when memory needs to be reclaimed.
+
+    Example:
+        >>> clear_all_caches()
+    """
+    # Clear XSL cache
+    cache = XSLTransformerCache.get_instance()
+    cache.clear_cache()
+
+    # Clear LRU caches
+    cached_function_detection.cache_clear()
+    cached_chemical_element_detection.cache_clear()
diff --git a/scripts/omml_mathml2latex/core/context.py b/scripts/omml_mathml2latex/core/context.py
new file mode 100644
index 0000000..faabbd6
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/context.py
@@ -0,0 +1,163 @@
+"""
+Conversion context data structure.
+
+This module defines the ConversionContext dataclass that holds all state
+and intermediate results throughout the conversion pipeline.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+
+
+@dataclass
+class ConversionContext:
+    """
+    Shared state for the conversion pipeline.
+
+    This context object flows through all pipeline stages, accumulating
+    intermediate results and maintaining conversion state.
+
+    Attributes:
+        input_type: Type of input ('docx', 'omml', 'mathml', 'stdin')
+        subject_mode: Subject area hint ('math', 'chemistry', 'physics', 'statistics', 'auto')
+        wrap_identifiers: Whether to wrap identifiers in \\mathrm{} (default: True)
+        prefer_xlongequal: Use \\xlongequal for overset equals (default: True)
+
+        # Intermediate results
+        omml: OMML XML string (if applicable)
+        mathml: MathML XML string
+        latex: Generated LaTeX string
+
+        # Validation state
+        validation_errors: List of validation error messages
+        validation_warnings: List of validation warning messages
+        is_valid: Whether MathML passed validation
+
+        # Color optimization state
+        uniform_equation_color: Hex color if entire equation uses same color, else empty
+        suppress_leaf_colors: Flag to suppress individual element colors when uniform color detected
+
+        # Metadata
+        equation_count: Number of equations processed
+        current_equation_index: Index of current equation being processed
+        context_hints: Additional context information
+
+        # Performance metrics
+        stage_timings: Dict mapping stage name to execution time (seconds)
+        total_time: Total processing time (seconds)
+    """
+
+    # Configuration
+    input_type: str
+    subject_mode: str = "math"
+    wrap_identifiers: bool = True
+    prefer_xlongequal: bool = True
+
+    # Intermediate results
+    omml: Optional[str] = None
+    mathml: Optional[str] = None
+    latex: Optional[str] = None
+
+    # Validation results
+    validation_errors: List[str] = field(default_factory=list)
+    validation_warnings: List[str] = field(default_factory=list)
+    is_valid: bool = True
+
+    # Color optimization state
+    uniform_equation_color: str = ""
+    suppress_leaf_colors: bool = False
+
+    # Script context tracking (for fraction sizing)
+    script_context_stack: List[str] = field(default_factory=list)
+    display_style_context: bool = False
+
+    # Set theory mode (for unclosed set notation)
+    set_theory_mode: bool = False
+
+    # Chemistry equation detection (cached)
+    is_chemistry_equation: Optional[bool] = None
+
+    # Metadata
+    equation_count: int = 0
+    current_equation_index: int = 0
+    context_hints: Dict[str, Any] = field(default_factory=dict)
+
+    # Performance metrics
+    stage_timings: Dict[str, float] = field(default_factory=dict)
+    total_time: float = 0.0
+
+    def add_error(self, error: str) -> None:
+        """Add a validation error."""
+        self.validation_errors.append(error)
+        self.is_valid = False
+
+    def add_warning(self, warning: str) -> None:
+        """Add a validation warning."""
+        self.validation_warnings.append(warning)
+
+    def record_stage_time(self, stage_name: str, time_seconds: float) -> None:
+        """Record execution time for a stage."""
+        self.stage_timings[stage_name] = time_seconds
+
+    def has_errors(self) -> bool:
+        """Check if any errors were recorded."""
+        return len(self.validation_errors) > 0
+
+    def has_warnings(self) -> bool:
+        """Check if any warnings were recorded."""
+        return len(self.validation_warnings) > 0
+
+    def clear_validation_state(self) -> None:
+        """Clear validation errors and warnings."""
+        self.validation_errors.clear()
+        self.validation_warnings.clear()
+        self.is_valid = True
+
+    def push_script_context(self, element_type: str) -> None:
+        """
+        Push a script context (msup/msub/msubsup) onto the stack.
+
+        Args:
+            element_type: The element type entering script context
+        """
+        self.script_context_stack.append(element_type)
+
+    def pop_script_context(self) -> Optional[str]:
+        """
+        Pop a script context from the stack.
+
+        Returns:
+            The popped element type, or None if stack was empty
+        """
+        return self.script_context_stack.pop() if self.script_context_stack else None
+
+    def in_script_context(self) -> bool:
+        """Check if currently inside a script context (superscript/subscript)."""
+        return len(self.script_context_stack) > 0
+
+    def __str__(self) -> str:
+        """String representation for debugging."""
+        status = "valid" if self.is_valid else "invalid"
+        return (
+            f"ConversionContext("
+            f"input_type={self.input_type}, "
+            f"subject_mode={self.subject_mode}, "
+            f"status={status}, "
+            f"equations={self.equation_count})"
+        )
+
+    def __repr__(self) -> str:
+        """Detailed representation for debugging."""
+        return (
+            f"ConversionContext(\n"
+            f"  input_type={self.input_type!r},\n"
+            f"  subject_mode={self.subject_mode!r},\n"
+            f"  wrap_identifiers={self.wrap_identifiers},\n"
+            f"  prefer_xlongequal={self.prefer_xlongequal},\n"
+            f"  is_valid={self.is_valid},\n"
+            f"  equation_count={self.equation_count},\n"
+            f"  errors={len(self.validation_errors)},\n"
+            f"  warnings={len(self.validation_warnings)},\n"
+            f"  total_time={self.total_time:.4f}s\n"
+            f")"
+        )
diff --git a/scripts/omml_mathml2latex/core/interfaces.py b/scripts/omml_mathml2latex/core/interfaces.py
new file mode 100644
index 0000000..917f0f6
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/interfaces.py
@@ -0,0 +1,298 @@
+"""
+Base interfaces for the refactored architecture.
+
+This module defines the abstract base classes (interfaces) that establish
+the contracts for all components in the refactored converter architecture.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, List
+from lxml import etree as ET
+
+
+class ConversionContext:
+    """
+    Shared context object that flows through the conversion pipeline.
+
+    This context holds all state and intermediate results during the conversion
+    process, allowing stages to communicate and share data.
+    """
+    pass  # Will be implemented as dataclass in context.py
+
+
+class Stage(ABC):
+    """
+    Abstract base class for pipeline stages.
+
+    Each stage represents a distinct step in the conversion pipeline
+    (e.g., input parsing, validation, transformation, conversion, output).
+    """
+
+    @abstractmethod
+    def process(self, context: ConversionContext) -> ConversionContext:
+        """
+        Process the conversion context and return updated context.
+
+        Args:
+            context: The current conversion context with all state
+
+        Returns:
+            Updated conversion context with stage results
+
+        Raises:
+            ValueError: If stage preconditions are not met
+            RuntimeError: If stage processing fails
+        """
+        pass
+
+    @abstractmethod
+    def validate_input(self, context: ConversionContext) -> bool:
+        """
+        Validate that stage preconditions are met.
+
+        Args:
+            context: The current conversion context
+
+        Returns:
+            True if preconditions are met, False otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the human-readable name of this stage."""
+        pass
+
+
+class Visitor(ABC):
+    """
+    Abstract base class for MathML element visitors.
+
+    Each visitor handles conversion of a specific MathML element type
+    (e.g., <mi>, <mo>, <mn>, <mfrac>) to LaTeX format.
+    """
+
+    def __init__(self, strategy: 'Strategy'):
+        """
+        Initialize visitor with a conversion strategy.
+
+        Args:
+            strategy: The subject-specific formatting strategy to use
+        """
+        self.strategy = strategy
+        self.context: Optional[ConversionContext] = None
+
+    @abstractmethod
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert MathML element to LaTeX string.
+
+        Args:
+            node: The MathML element to convert
+
+        Returns:
+            LaTeX string representation of the element
+
+        Raises:
+            ValueError: If node is not the expected element type
+        """
+        pass
+
+    @abstractmethod
+    def can_handle(self, node: ET.Element) -> bool:
+        """
+        Check if this visitor can handle the given node.
+
+        Args:
+            node: The MathML element to check
+
+        Returns:
+            True if this visitor can convert the node, False otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def element_name(self) -> str:
+        """Get the MathML element name this visitor handles (e.g., 'mi', 'mo')."""
+        pass
+
+
+class Strategy(ABC):
+    """
+    Abstract base class for subject-specific formatting strategies.
+
+    Strategies encapsulate the subject-specific logic for formatting
+    mathematical notation (e.g., math, chemistry, physics, statistics).
+    """
+
+    @abstractmethod
+    def format_identifier(self, text: str, node: ET.Element) -> str:
+        """
+        Format an identifier (<mi> element) according to subject conventions.
+
+        Args:
+            text: The identifier text content
+            node: The <mi> element node (for accessing attributes)
+
+        Returns:
+            Formatted LaTeX string for the identifier
+
+        Examples:
+            Math: "sin" → "\\sin" (function recognition)
+            Chemistry: "Fe" → "\\mathrm{Fe}" (element formatting)
+        """
+        pass
+
+    @abstractmethod
+    def format_operator(self, text: str, node: ET.Element) -> str:
+        """
+        Format an operator (<mo> element) according to subject conventions.
+
+        Args:
+            text: The operator text content
+            node: The <mo> element node
+
+        Returns:
+            Formatted LaTeX string for the operator
+
+        Examples:
+            Math: "+" → "+"
+            Chemistry: "→" → "\\rightarrow"
+        """
+        pass
+
+    @abstractmethod
+    def format_number(self, text: str, node: ET.Element) -> str:
+        """
+        Format a number (<mn> element) according to subject conventions.
+
+        Args:
+            text: The number text content
+            node: The <mn> element node
+
+        Returns:
+            Formatted LaTeX string for the number
+        """
+        pass
+
+    @abstractmethod
+    def detect_context(self, equation_text: str) -> bool:
+        """
+        Detect if an equation belongs to this subject area.
+
+        Args:
+            equation_text: The full equation text to analyze
+
+        Returns:
+            True if equation likely belongs to this subject, False otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the strategy name (e.g., 'math', 'chemistry', 'physics')."""
+        pass
+
+
+class VisitorRegistry(ABC):
+    """
+    Abstract base class for visitor registry/factory.
+
+    The registry maintains a mapping of MathML element names to their
+    corresponding visitor classes and provides visitor instances on demand.
+    """
+
+    @abstractmethod
+    def register(self, element_name: str, visitor_class: type) -> None:
+        """
+        Register a visitor class for a specific element type.
+
+        Args:
+            element_name: MathML element name (e.g., 'mi', 'mo')
+            visitor_class: The visitor class to handle this element
+        """
+        pass
+
+    @abstractmethod
+    def get_visitor(self, element_name: str, strategy: Strategy) -> Visitor:
+        """
+        Get a visitor instance for the given element type.
+
+        Args:
+            element_name: MathML element name
+            strategy: The conversion strategy to use
+
+        Returns:
+            Visitor instance configured with the strategy
+
+        Raises:
+            ValueError: If no visitor registered for element_name
+        """
+        pass
+
+    @abstractmethod
+    def has_visitor(self, element_name: str) -> bool:
+        """
+        Check if a visitor is registered for the element type.
+
+        Args:
+            element_name: MathML element name
+
+        Returns:
+            True if visitor is registered, False otherwise
+        """
+        pass
+
+
+class Parser(ABC):
+    """
+    Abstract base class for input parsers.
+
+    Parsers handle different input formats (DOCX, OMML, MathML) and convert
+    them to a unified format (MathML strings) for the conversion pipeline.
+    """
+
+    @abstractmethod
+    def parse(self, source: str) -> List[str]:
+        """
+        Parse input and return list of MathML strings.
+
+        Args:
+            source: Input source (file path, XML string, etc.)
+
+        Returns:
+            List of MathML equation strings
+
+        Raises:
+            ValueError: If input format is invalid
+            FileNotFoundError: If source file doesn't exist (for file-based parsers)
+            RuntimeError: If parsing fails
+        """
+        pass
+
+    @abstractmethod
+    def can_handle(self, source: str) -> bool:
+        """
+        Check if this parser can handle the given input source.
+
+        Args:
+            source: Input source to check
+
+        Returns:
+            True if this parser can handle the source, False otherwise
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def parser_type(self) -> str:
+        """
+        Get the parser type identifier.
+
+        Returns:
+            Parser type string (e.g., "docx", "omml", "mathml")
+        """
+        pass
diff --git a/scripts/omml_mathml2latex/core/omml_parser_core.py b/scripts/omml_mathml2latex/core/omml_parser_core.py
new file mode 100644
index 0000000..c155c18
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/omml_parser_core.py
@@ -0,0 +1,2353 @@
+"""
+Fallback OMML to MathML parser for edge cases.
+
+This module provides a Python-based OMML (Office Math Markup Language) to MathML converter
+that serves as a fallback when Microsoft's OMML2MML.XSL transformation fails or is unavailable.
+
+Supports:
+- Basic OMML elements: oMath, r/t, sSub, sSup, sSubSup
+- Equation arrays (eqArr) with summation and chemical reaction detection
+- Fractions (f), n-ary operators (nary), limits (lim), functions (func)
+- Accents (acc), delimiters (d), radicals (rad), matrices (m)
+- Formatting preservation: fonts, colors, bold, italic
+- Special patterns: \not negation, fragmented functions
+
+Key Features:
+- NBSP preservation (U+00A0 → &#160;)
+- Function merging (fragments like 's','i','n' → 'sin')
+- Chemical reaction detection (Chinese conditions, reaction arrows)
+- Summation notation (∑, ∏, ∫ with limits)
+- Color and font attribute preservation
+"""
+
+from typing import List, Dict, Optional, Tuple, Union
+from lxml import etree as ET
+from ..data.symbols import SUMMATION_SYMBOLS
+from ..data.functions import MATH_FUNCTIONS
+from ..data.patterns import MATH_SYMBOLS_SET, FONT_TO_LATEX
+from .xslt_transformer import _local, _text_content
+
+
+# Use the same import name as original code for consistency
+MATHEMATICAL_FUNCTIONS = MATH_FUNCTIONS
+
+MATHML_NS = "http://www.w3.org/1998/Math/MathML"
+OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math"
+
+
+def _mml(tag: str) -> ET._Element:
+    return ET.Element(f"{{{MATHML_NS}}}{tag}")
+
+
+def _append_all(parent: ET._Element, nodes: List[ET._Element]) -> None:
+    for n in nodes:
+        parent.append(n)
+
+
+def _is_chemical_reaction_arrow(eqArr_node: ET._Element) -> Optional[Dict]:
+    """Detect if an eqArr represents a chemical reaction arrow with conditions.
+
+    Args:
+        eqArr_node: OMML eqArr element
+
+    Returns:
+        Dictionary with chemical reaction info if detected, None otherwise
+        Structure: {
+            'above': str,    # Text above the arrow (e.g., '电解')
+            'below': str,    # Text below the arrow (e.g., '加热', can be empty)
+            'type': str      # 'chemical_reaction'
+        }
+    """
+    # Find all equation array elements
+    e_elements = eqArr_node.findall(f"{{{OMML_NS}}}e")
+
+    # Must have exactly 2 elements for chemical reaction conditions
+    if len(e_elements) != 2:
+        return None
+
+    # Extract text from first element (above the arrow)
+    above_text = ""
+    first_elem = e_elements[0]
+
+    # Extract text from all t elements in the first element, avoiding duplication
+    # Use a set to track unique text content
+    text_parts = set()
+    for t_elem in first_elem.findall(f".//{{{OMML_NS}}}t"):
+        if t_elem.text and t_elem.text.strip():
+            text_parts.add(t_elem.text.strip())
+
+    # Join unique text parts
+    above_text = "".join(sorted(text_parts))
+
+    # Extract text from second element (below the arrow)
+    below_text = ""
+    second_elem = e_elements[1]
+
+    # Extract text from all t elements in the second element, avoiding duplication
+    text_parts_below = set()
+    for t_elem in second_elem.findall(f".//{{{OMML_NS}}}t"):
+        if t_elem.text and t_elem.text.strip():
+            text_parts_below.add(t_elem.text.strip())
+
+    # Join unique text parts
+    below_text = "".join(sorted(text_parts_below))
+
+    # Validate that this looks like a chemical reaction pattern
+    if above_text.strip():
+        # Check if contains chemical condition patterns (Chinese text or typical reaction words)
+        if (_contains_chinese_characters(above_text) or
+            _is_typical_reaction_condition_text(above_text) or
+            _contains_chinese_characters(below_text) or
+            _is_typical_reaction_condition_text(below_text)):
+
+            return {
+                'above': above_text.strip(),
+                'below': below_text.strip(),
+                'type': 'chemical_reaction'
+            }
+
+    return None
+
+
+def _contains_chinese_characters(text: str) -> bool:
+    """Check if text contains Chinese characters."""
+    if not text:
+        return False
+    for char in text:
+        if '\u4e00' <= char <= '\u9fff':  # Chinese character range
+            return True
+    return False
+
+
+def _is_typical_reaction_condition_text(text: str) -> bool:
+    """Check if text looks like a typical chemical reaction condition."""
+    if not text:
+        return False
+
+    # Common chemical reaction conditions
+    typical_conditions = {
+        # Chinese conditions
+        "电解", "加热", "催化剂", "高温", "高压", "光照", "加压", "蒸馏", "熔融", "溶解", "酸化", "碱化",
+        "氧化", "还原", "分解", "合成", "中和", "干燥", "过滤", "沉淀", "结晶", "升华", "煅烧",
+        # English conditions
+        "heat", "catalyst", "pressure", "light", "oxidation", "reduction", "electrolysis",
+        "distillation", "crystallization", "precipitation", "filtration", "drying",
+        # Symbols and abbreviations
+        "Δ", "hv", "H+", "OH-", "cat", "pt", "ni", "pd"
+    }
+
+    text_lower = text.lower().strip()
+    return any(condition.lower() in text_lower for condition in typical_conditions)
+
+
+def _is_summation_notation(eqArr_node: ET._Element) -> Optional[Dict]:
+    """Detect if an eqArr represents summation/product/integral notation.
+
+    Args:
+        eqArr_node: OMML eqArr element
+
+    Returns:
+        Dictionary with summation info if detected, None otherwise
+        Structure: {
+            'operator': str,     # ∑, ∏, ∫, etc.
+            'upper_limit': str,  # e.g., 'n'
+            'lower_limit': str,  # e.g., 'i=1'
+            'type': str          # 'sum', 'prod', 'integral'
+        }
+    """
+    # Find all equation array elements
+    e_elements = eqArr_node.findall(f"{{{OMML_NS}}}e")
+
+    # Must have exactly 3 elements for summation notation
+    if len(e_elements) != 3:
+        return None
+
+    # Extract text content from each element
+    element_texts = []
+    for e_elem in e_elements:
+        text_parts = []
+        for r_elem in e_elem.findall(f".//{{{OMML_NS}}}t"):
+            if r_elem.text:
+                text_parts.append(r_elem.text.strip())
+        element_texts.append(''.join(text_parts))
+
+    # Check for summation operators in the middle element using centralized mapping
+    # Middle element should contain the operator
+    middle_text = element_texts[1]
+    operator_type = None
+    operator_symbol = None
+
+    for symbol, op_type in SUMMATION_SYMBOLS.items():
+        if symbol in middle_text:
+            operator_type = op_type
+            operator_symbol = symbol
+            break
+
+    if not operator_type:
+        return None
+
+    # First element is upper limit, third is lower limit
+    upper_limit = element_texts[0]
+    lower_limit = element_texts[2]
+
+    # Validate that we have meaningful limits
+    if not upper_limit or not lower_limit:
+        return None
+
+    return {
+        'operator': operator_symbol,
+        'upper_limit': upper_limit,
+        'lower_limit': lower_limit,
+        'type': operator_type
+    }
+
+
+def _create_summation_mathml(summation_info: dict) -> ET._Element:
+    """Create proper MathML for summation/product/integral notation.
+
+    Args:
+        summation_info: Dictionary from _is_summation_notation
+
+    Returns:
+        MathML element representing the summation
+    """
+    # Map operator types to MathML elements
+    if summation_info['type'] == 'sum':
+        base_elem = _mml("mo")
+        base_elem.text = "∑"
+    elif summation_info['type'] == 'prod':
+        base_elem = _mml("mo")
+        base_elem.text = "∏"
+    elif summation_info['type'] == 'integral':
+        base_elem = _mml("mo")
+        base_elem.text = "∫"
+    else:
+        # Fallback to generic operator
+        base_elem = _mml("mo")
+        base_elem.text = summation_info['operator']
+
+    # Create underover element for limits
+    munderover = _mml("munderover")
+    munderover.append(base_elem)
+
+    # Lower limit (under)
+    lower_mrow = _mml("mrow")
+    # Parse lower limit which might contain equations like "i=1"
+    lower_text = summation_info['lower_limit']
+    if '=' in lower_text:
+        parts = lower_text.split('=')
+        var_mi = _mml("mi")
+        var_mi.text = parts[0].strip()
+        eq_mo = _mml("mo")
+        eq_mo.text = "="
+        val_mn = _mml("mn")
+        val_mn.text = parts[1].strip()
+        lower_mrow.append(var_mi)
+        lower_mrow.append(eq_mo)
+        lower_mrow.append(val_mn)
+    else:
+        # Simple lower limit
+        lower_mi = _mml("mi")
+        lower_mi.text = lower_text
+        lower_mrow.append(lower_mi)
+
+    munderover.append(lower_mrow)
+
+    # Upper limit (over)
+    upper_mi = _mml("mi")
+    upper_mi.text = summation_info['upper_limit']
+    munderover.append(upper_mi)
+
+    return munderover
+
+
+def _create_chemical_reaction_mathml(chemical_info: dict) -> ET._Element:
+    """Create proper MathML for chemical reaction arrows with conditions.
+
+    Args:
+        chemical_info: Dictionary from _is_chemical_reaction_arrow
+
+    Returns:
+        MathML element representing the chemical reaction arrow
+    """
+    above_text = chemical_info['above']
+    below_text = chemical_info['below']
+
+    # Base element is equals sign (chemical reactions typically use equals for equilibrium)
+    base_elem = _mml("mo")
+    base_elem.text = "="
+
+    if below_text:
+        # Both above and below text: use munderover
+        munderover = _mml("munderover")
+        munderover.append(base_elem)
+
+        # Under element (below the arrow)
+        under_elem = _mml("mtext")
+        under_elem.text = below_text
+        munderover.append(under_elem)
+
+        # Over element (above the arrow)
+        over_elem = _mml("mtext")
+        over_elem.text = above_text
+        munderover.append(over_elem)
+
+        # Add special attribute to mark as chemical reaction
+        munderover.set("data-chemical-reaction", "true")
+
+        return munderover
+    else:
+        # Only above text: use mover
+        mover = _mml("mover")
+        mover.append(base_elem)
+
+        # Over element (above the arrow)
+        over_elem = _mml("mtext")
+        over_elem.text = above_text
+        mover.append(over_elem)
+
+        # Add special attribute to mark as chemical reaction
+        mover.set("data-chemical-reaction", "true")
+
+        return mover
+
+
+class MathMLSanitizer:
+    """Sanitizes malformed MathML XML for robust parsing.
+
+    Handles common issues from legacy XSL transformations:
+    - Missing or incorrect namespaces
+    - Unclosed tags and mismatched elements
+    - Character encoding issues
+    - Invalid nesting structures
+    - Missing required child elements
+    """
+
+    MATHML_NS = "http://www.w3.org/1998/Math/MathML"
+
+    def __init__(self):
+        self._errors = []
+        self._warnings = []
+
+    def sanitize(self, mathml_xml: str) -> str:
+        """Apply multi-tier sanitization strategy to malformed MathML.
+
+        Tier 1: Try direct XML parsing
+        Tier 2: Apply sanitization and retry
+        Tier 3: Use BeautifulSoup for recovery
+        Tier 4: Regex-based tag extraction as last resort
+        """
+        self._errors.clear()
+        self._warnings.clear()
+
+        # Tier 1: Try direct parsing
+        try:
+            ET.fromstring(mathml_xml.encode("utf-8"))
+            return mathml_xml  # Already valid
+        except ET.XMLSyntaxError as e:
+            self._errors.append(f"XML syntax error: {e}")
+
+        # Tier 2: Apply basic sanitization
+        try:
+            sanitized = self._apply_basic_sanitization(mathml_xml)
+            ET.fromstring(sanitized.encode("utf-8"))
+            self._warnings.append("Applied basic sanitization")
+            return sanitized
+        except ET.XMLSyntaxError as e:
+            self._errors.append(f"After basic sanitization: {e}")
+
+        # Tier 3: Use BeautifulSoup for recovery
+        try:
+            recovered = self._beautifulsoup_recovery(mathml_xml)
+            ET.fromstring(recovered.encode("utf-8"))
+            self._warnings.append("Applied BeautifulSoup recovery")
+            return recovered
+        except (ET.XMLSyntaxError, ImportError) as e:
+            self._errors.append(f"BeautifulSoup recovery failed: {e}")
+
+        # Tier 4: Regex-based extraction (last resort)
+        try:
+            extracted = self._regex_extraction(mathml_xml)
+            ET.fromstring(extracted.encode("utf-8"))
+            self._warnings.append("Applied regex extraction recovery")
+            return extracted
+        except ET.XMLSyntaxError as e:
+            self._errors.append(f"All recovery methods failed: {e}")
+            raise ValueError(f"Cannot sanitize MathML: {'; '.join(self._errors)}")
+
+    def _apply_basic_sanitization(self, xml: str) -> str:
+        """Apply basic fixes for common malformation issues."""
+        import re
+
+        # Fix namespace issues
+        xml = self._fix_namespaces(xml)
+
+        # Fix encoding issues
+        xml = self._fix_encoding(xml)
+
+        # Fix unclosed tags (basic patterns)
+        xml = self._fix_unclosed_tags(xml)
+
+        # Fix malformed attributes
+        xml = self._fix_attributes(xml)
+
+        return xml
+
+    def _fix_namespaces(self, xml: str) -> str:
+        """Fix missing or incorrect MathML namespaces."""
+        import re
+
+        # Check if we have a math root element
+        if '<math' not in xml.lower():
+            # Wrap in math element
+            xml = f'<math xmlns="{self.MATHML_NS}">{xml}</math>'
+        else:
+            # Ensure proper namespace is present
+            if 'xmlns=' not in xml:
+                xml = re.sub(r'<math\b', f'<math xmlns="{self.MATHML_NS}"', xml, flags=re.IGNORECASE)
+
+        return xml
+
+    def _fix_encoding(self, xml: str) -> str:
+        """Fix common encoding issues."""
+        import html
+
+        # Use html.unescape to handle all HTML entities properly
+        xml = html.unescape(xml)
+
+        # Additional specific fixes for common issues
+        replacements = [
+            ('&nbsp;', ' '),  # Non-breaking space (if not caught by html.unescape)
+        ]
+
+        for old, new in replacements:
+            xml = xml.replace(old, new)
+
+        return xml
+
+    def _fix_unclosed_tags(self, xml: str) -> str:
+        """Fix basic unclosed tag patterns."""
+        import re
+
+        # Common MathML elements that might be unclosed
+        mathml_elements = ['mi', 'mn', 'mo', 'mrow', 'msup', 'msub', 'mfrac', 'msqrt']
+
+        for elem in mathml_elements:
+            # Fix unclosed self-closing tags: <mi>content -> <mi>content</mi>
+            pattern = f'<{elem}([^>]*)>([^<]*?)(?!</{elem}>)'
+            replacement = rf'<{elem}\1>\2</{elem}>'
+            xml = re.sub(pattern, replacement, xml)
+
+        return xml
+
+    def _fix_attributes(self, xml: str) -> str:
+        """Fix malformed attributes."""
+        import re
+
+        # Fix unquoted attribute values
+        xml = re.sub(r'(\w+)=([^"\s>]+)', r'\1="\2"', xml)
+
+        # Remove invalid characters from attribute values
+        xml = re.sub(r'[^\x20-\x7E]', '', xml)
+
+        return xml
+
+    def _beautifulsoup_recovery(self, xml: str) -> str:
+        """Use BeautifulSoup for more aggressive recovery."""
+        try:
+            from bs4 import BeautifulSoup
+
+            # Use xml parser if available, fallback to html.parser
+            try:
+                soup = BeautifulSoup(xml, 'xml')
+            except:
+                soup = BeautifulSoup(xml, 'html.parser')
+
+            # Convert back to string
+            recovered = str(soup)
+
+            # Ensure we have proper MathML structure
+            if '<math' not in recovered.lower():
+                # Extract MathML-like content and wrap it
+                content = soup.get_text() if soup.get_text().strip() else xml
+                recovered = f'<math xmlns="{self.MATHML_NS}"><mrow>{content}</mrow></math>'
+
+            return recovered
+
+        except ImportError:
+            # BeautifulSoup not available
+            raise ImportError("BeautifulSoup4 required for advanced recovery")
+
+    def _regex_extraction(self, xml: str) -> str:
+        """Extract mathematical content using regex as last resort."""
+        import re
+
+        # Try to extract any mathematical expressions
+        math_patterns = [
+            r'([a-zA-Z0-9+\-*/=()<>\s]+)',  # Basic math expressions
+            r'(\$[^$]+\$)',                  # LaTeX-style delimited expressions
+        ]
+
+        content = ""
+        for pattern in math_patterns:
+            matches = re.findall(pattern, xml)
+            if matches:
+                content = " ".join(matches)
+                break
+
+        if not content.strip():
+            content = re.sub(r'<[^>]+>', '', xml)  # Strip all tags
+
+        # Wrap in basic MathML structure
+        return f'<math xmlns="{self.MATHML_NS}"><mrow><mi>{content.strip()}</mi></mrow></math>'
+
+    @property
+    def errors(self) -> list:
+        """Return list of errors encountered during sanitization."""
+        return self._errors.copy()
+
+    @property
+    def warnings(self) -> list:
+        """Return list of warnings from sanitization process."""
+        return self._warnings.copy()
+
+
+class ValidationResult:
+    """Result of MathML validation."""
+
+    def __init__(self, is_valid: bool, errors: list = None, warnings: list = None):
+        self.is_valid = is_valid
+        self.errors = errors or []
+        self.warnings = warnings or []
+
+    def __str__(self):
+        if self.is_valid:
+            return "Valid MathML"
+        return f"Invalid MathML: {len(self.errors)} error(s), {len(self.warnings)} warning(s)"
+
+
+class MathMLValidator:
+    """Validates MathML structure and reports detailed diagnostics."""
+
+    MATHML_NS = "http://www.w3.org/1998/Math/MathML"
+
+    # Core MathML elements and their required/optional children
+    ELEMENT_RULES = {
+        'math': {'required_children': [], 'valid_children': ['mrow', 'mi', 'mn', 'mo', 'mfrac', 'msup', 'msub', 'msubsup', 'msqrt', 'mroot', 'mtext', 'mover', 'munder', 'munderover']},
+        'mrow': {'required_children': [], 'valid_children': ['mi', 'mn', 'mo', 'mfrac', 'msup', 'msub', 'msubsup', 'msqrt', 'mroot', 'mtext', 'mrow']},
+        'mfrac': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'msup', 'msub', 'msubsup']},
+        'msup': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'msub': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'msubsup': {'required_children': 3, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'msqrt': {'required_children': 1, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'mroot': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'mi': {'required_children': 0, 'text_content': True},
+        'mn': {'required_children': 0, 'text_content': True},
+        'mo': {'required_children': 0, 'text_content': True},
+        'mtext': {'required_children': 0, 'text_content': True},
+        'mover': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'munder': {'required_children': 2, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+        'munderover': {'required_children': 3, 'valid_children': ['mi', 'mn', 'mo', 'mrow', 'mfrac']},
+    }
+
+    def __init__(self):
+        self.errors = []
+        self.warnings = []
+        self.line_numbers = {}
+
+    def validate(self, mathml_xml: str) -> ValidationResult:
+        """Validate MathML structure and return detailed results."""
+        self.errors.clear()
+        self.warnings.clear()
+
+        try:
+            # Parse with line number tracking
+            parser = ET.XMLParser()
+            doc = ET.fromstring(mathml_xml.encode("utf-8"), parser)
+            self._build_line_map(mathml_xml)
+
+        except ET.XMLSyntaxError as e:
+            # Extract line and column information
+            line_info = f"Line {e.lineno}, Column {e.offset}: " if hasattr(e, 'lineno') else ""
+            self.errors.append(f"{line_info}XML Syntax Error: {e.msg}")
+            return ValidationResult(False, self.errors.copy(), self.warnings.copy())
+
+        # Validate structure
+        self._validate_element(doc, "")
+
+        # Additional semantic validations
+        self._validate_semantics(doc)
+
+        is_valid = len(self.errors) == 0
+        return ValidationResult(is_valid, self.errors.copy(), self.warnings.copy())
+
+    def _build_line_map(self, xml: str):
+        """Build a mapping of element content to line numbers for error reporting."""
+        lines = xml.split('\n')
+        self.line_numbers = {}
+
+        for line_num, line in enumerate(lines, 1):
+            # Simple mapping - in production would use more sophisticated approach
+            if '<' in line:
+                # Extract tag names for mapping
+                import re
+                tags = re.findall(r'<(\w+)', line)
+                for tag in tags:
+                    if tag not in self.line_numbers:
+                        self.line_numbers[tag] = line_num
+
+    def _validate_element(self, element, path: str):
+        """Recursively validate an element and its children."""
+        local_name = _local(element.tag)
+        current_path = f"{path}/{local_name}" if path else local_name
+
+        # Check if element is known
+        if local_name not in self.ELEMENT_RULES:
+            line_info = self._get_line_info(local_name)
+            self.warnings.append(f"{line_info}Unknown MathML element: {local_name}")
+            return
+
+        rules = self.ELEMENT_RULES[local_name]
+
+        # Check required children count
+        child_count = len(list(element))
+        required_count = rules.get('required_children')
+
+        if isinstance(required_count, int) and child_count != required_count:
+            line_info = self._get_line_info(local_name)
+            self.errors.append(
+                f"{line_info}Element '{local_name}' requires exactly {required_count} children, got {child_count}"
+            )
+
+        # Check children types
+        valid_children = rules.get('valid_children', [])
+        if valid_children:
+            for child in element:
+                child_name = _local(child.tag)
+                if child_name not in valid_children:
+                    line_info = self._get_line_info(child_name)
+                    self.warnings.append(
+                        f"{line_info}'{child_name}' may not be valid child of '{local_name}'"
+                    )
+
+        # Check text content for leaf elements
+        if rules.get('text_content', False):
+            text = _text_content(element)
+            if not text.strip():
+                line_info = self._get_line_info(local_name)
+                self.warnings.append(f"{line_info}Element '{local_name}' should contain text content")
+
+        # Recursively validate children
+        for child in element:
+            self._validate_element(child, current_path)
+
+    def _validate_semantics(self, doc):
+        """Perform semantic validation checks."""
+        # Check for proper namespace
+        if doc.nsmap is None or self.MATHML_NS not in doc.nsmap.values():
+            self.warnings.append("Missing or incorrect MathML namespace declaration")
+
+        # Check for common semantic issues
+        self._check_empty_elements(doc)
+        self._check_nested_fractions(doc)
+        self._check_operator_usage(doc)
+
+    def _check_empty_elements(self, element):
+        """Check for empty elements that should have content."""
+        for elem in element.iter():
+            local_name = _local(elem.tag)
+
+            if local_name in ['mi', 'mn', 'mo', 'mtext']:
+                text = _text_content(elem)
+                if not text.strip() and len(list(elem)) == 0:
+                    line_info = self._get_line_info(local_name)
+                    self.warnings.append(f"{line_info}Empty {local_name} element")
+
+    def _check_nested_fractions(self, element):
+        """Check for deeply nested fractions that might cause rendering issues."""
+        def count_nested_fractions(elem, depth=0):
+            local_name = _local(elem.tag)
+            if local_name == 'mfrac':
+                depth += 1
+                if depth > 3:  # More than 3 nested fractions
+                    line_info = self._get_line_info(local_name)
+                    self.warnings.append(f"{line_info}Deeply nested fractions (depth {depth}) may cause rendering issues")
+
+            for child in elem:
+                count_nested_fractions(child, depth)
+
+        count_nested_fractions(element)
+
+    def _check_operator_usage(self, element):
+        """Check for proper operator usage and spacing."""
+        for elem in element.iter():
+            local_name = _local(elem.tag)
+
+            if local_name == 'mo':
+                text = _text_content(elem)
+                # Check for common operator issues
+                if text in ['(', ')', '[', ']', '{', '}']:
+                    # Check if delimiters are properly paired
+                    continue  # More complex pairing check would be needed
+
+                if text in ['+', '-', '*', '/', '=', '<', '>']:
+                    # Check spacing around operators
+                    continue  # Could check for proper spacing context
+
+    def _get_line_info(self, element_name: str) -> str:
+        """Get line information for error reporting."""
+        line_num = self.line_numbers.get(element_name)
+        return f"Line {line_num}: " if line_num else ""
+
+
+def omml_to_mathml_fallback(xml_input: str) -> str:
+    """Best-effort OMML → MathML converter for common elements.
+
+    Supports: oMath, r/t, sSub, sSup, sSubSup, eqArr(label via nested bar/t),
+    and ignores formatting/pr elements.
+    """
+    # IMPORTANT: Preserve NBSP characters before XML parsing
+    # lxml normalizes U+00A0 (NBSP) to regular space during parsing
+    # Replace NBSP with XML decimal entity before encoding
+    xml_bytes = xml_input.encode("utf-8")
+    xml_bytes = xml_bytes.replace(b'\xc2\xa0', b'&#160;')
+    root = ET.fromstring(xml_bytes)
+    # Find first oMath; if multiple, concatenate into one mrow
+    omath_nodes = root.findall(f".//{{{OMML_NS}}}oMath")
+    m_math = _mml("math")
+    m_row = _mml("mrow")
+    m_math.append(m_row)
+
+    if not omath_nodes:
+        # Treat the whole root as an oMath-like container
+        _append_all(m_row, _convert_omml_children(root))
+    else:
+        for om in omath_nodes:
+            _append_all(m_row, _convert_omml_children(om))
+
+    return ET.tostring(m_math, encoding="utf-8", pretty_print=True).decode("utf-8")
+
+
+def _get_text_content_from_omml(node: ET._Element) -> str:
+    """Extract all text content from an OMML element (recursively)."""
+    texts = []
+    for t in node.findall(f".//{{{OMML_NS}}}t"):
+        if t.text:
+            texts.append(t.text)
+    return "".join(texts).strip()
+
+
+def _convert_omml_children(node: ET._Element) -> List[ET._Element]:
+    out: list[ET._Element] = []
+
+    # First pass: detect \not pattern at OMML level before conversion
+    # This must happen before converting children to preserve the relationship
+    # between phant (zero-width phantom slash) and the following element
+    #
+    # IMPORTANT: In OMML, the \not command is represented as:
+    # <phant><phantPr><zeroWid val="1"/></phantPr><e><r><t>⧸</t></r></e></phant>
+    # followed by the element being negated (e.g., <r><t>x</t></r>)
+    #
+    # This pattern creates a zero-width phantom slash that overlays the next character.
+    # We detect this pattern and convert it to \not{...} in LaTeX.
+    children_to_process = []
+    i = 0
+    children_list = list(node)
+
+    while i < len(children_list):
+        child = children_list[i]
+
+        # Check if this is a phant element with zeroWid="1" containing negation slash
+        if _local(child.tag) == "phant":
+            phant_pr = child.find(f"{{{OMML_NS}}}phantPr")
+            is_zero_width = False
+
+            if phant_pr is not None:
+                zero_wid = phant_pr.find(f"{{{OMML_NS}}}zeroWid")
+                if zero_wid is not None:
+                    val = zero_wid.get(f"{{{OMML_NS}}}val")
+                    if val == "1" or val == "true":
+                        is_zero_width = True
+
+            # If zero-width phantom, check if it contains the negation slash
+            if is_zero_width:
+                phant_content = _get_text_content_from_omml(child)
+                # Check for various negation slash characters
+                if phant_content in ["⧸", "/", "∕"]:  # U+29F8 BIG SOLIDUS, regular slash, U+2215 DIVISION SLASH
+                    # This is a \not pattern - mark it specially and look for next element
+                    if i + 1 < len(children_list):
+                        # Create a special marker for \not that will be converted later
+                        # We'll create a temporary structure that signals \not{next_element}
+                        not_marker = ET.Element("__NOT_MARKER__")
+                        not_marker.set("__slash__", phant_content)
+                        children_to_process.append(not_marker)
+                        children_to_process.append(children_list[i + 1])
+                        i += 2  # Skip both phant and next element
+                        continue
+
+        children_to_process.append(child)
+        i += 1
+
+    # Second pass: convert OMML children to MathML
+    # Also handle \not markers by combining them with the following element
+    all_children = []
+    i = 0
+    while i < len(children_to_process):
+        child = children_to_process[i]
+
+        # Check if this is a \not marker
+        if hasattr(child, 'tag') and child.tag == "__NOT_MARKER__":
+            # The next element should be the negated element
+            if i + 1 < len(children_to_process):
+                # Convert the negated element
+                next_child = children_to_process[i + 1]
+                negated_elem_list = _convert_omml_node(next_child)
+
+                # Create mover element to represent \not
+                mover = _mml("mover")
+                mover.set("accent", "false")
+                mover.set("data-not-slash", "true")  # Special marker for LaTeX converter
+
+                # Add the negated element as the base
+                if isinstance(negated_elem_list, list):
+                    if len(negated_elem_list) == 1:
+                        mover.append(negated_elem_list[0])
+                    else:
+                        mrow = _mml("mrow")
+                        _append_all(mrow, negated_elem_list)
+                        mover.append(mrow)
+                else:
+                    mover.append(negated_elem_list)
+
+                # Add the slash as the overscript
+                mo_slash = _mml("mo")
+                mo_slash.text = "⧸"  # BIG SOLIDUS
+                mover.append(mo_slash)
+
+                all_children.append(mover)
+                i += 2  # Skip both marker and negated element
+                continue
+
+        # Regular element - convert normally
+        conv = _convert_omml_node(child)
+        if conv is None:
+            i += 1
+            continue
+        if isinstance(conv, list):
+            all_children.extend(conv)
+        else:
+            all_children.append(conv)
+        i += 1
+
+    # Third pass: detect and merge fragmented mathematical functions
+    i = 0
+    while i < len(all_children):
+        # Check if current element and next elements can form a mathematical function
+        merged_func = _detect_and_merge_fragmented_functions(all_children, i)
+        if merged_func:
+            func_element, skip_count = merged_func
+            out.append(func_element)
+            i += skip_count
+        else:
+            out.append(all_children[i])
+            i += 1
+
+    return out
+
+def _detect_and_merge_fragmented_functions(elements: List[ET._Element], start_idx: int) -> Optional[Tuple[ET._Element, int]]:
+    """
+    Detect if elements starting at start_idx form a fragmented mathematical function.
+    Returns (merged_function_element, skip_count) if found, None otherwise.
+    """
+    if start_idx >= len(elements):
+        return None
+
+    # Collect text from consecutive mi elements (mathematical identifiers)
+    text_parts = []
+    element_count = 0
+
+    for i in range(start_idx, min(start_idx + 15, len(elements))):  # Look ahead up to 15 elements
+        elem = elements[i]
+        if _local(elem.tag) == "mi" and elem.text:
+            text_parts.append(elem.text.strip())
+            element_count += 1
+        elif _local(elem.tag) in ["mspace", "mtext"] and elem.text and elem.text.isspace():
+            # Allow spaces between function parts
+            element_count += 1
+        elif _local(elem.tag) in ["msup", "msub", "msubsup"] and len(text_parts) > 0:
+            # Look inside superscript/subscript elements for function continuation
+            # Check if the first child (base) of the superscript contains function text
+            if len(elem) > 0:
+                base_elem = elem[0]
+                if _local(base_elem.tag) == "mi" and base_elem.text:
+                    text_parts.append(base_elem.text.strip())
+            element_count += 1
+        elif _local(elem.tag) in ["mo", "mn"] and len(text_parts) > 0:
+            # Allow operators or numbers between function parts
+            # but only if we've already found at least one text part
+            element_count += 1
+        else:
+            # Stop if we hit other elements or if no text parts found yet
+            break
+
+
+    if len(text_parts) < 2:
+        return None
+
+    # Combine text parts and check if they form a mathematical function
+    combined_text = "".join(text_parts)
+
+    for func in sorted(MATHEMATICAL_FUNCTIONS, key=len, reverse=True):
+        if combined_text.lower() == func.lower():
+
+            # Create a new mi element for the complete function
+            mi = _mml("mi")
+            mi.text = func
+
+            # Copy formatting from the first element if available
+            first_elem = elements[start_idx]
+            if hasattr(first_elem, 'attrib'):
+                for attr, value in first_elem.attrib.items():
+                    mi.set(attr, value)
+
+            return mi, element_count
+
+    return None
+
+
+def _convert_omml_node(node: ET._Element) -> Union[ET._Element, List[ET._Element], None]:
+    lname = _local(node.tag)
+
+    # Ignore property/styling nodes
+    if lname in {"sSubPr", "sSupPr", "eqArrPr", "rPr", "barPr", "ctrlPr", "sty", "phantPr"}:
+        return None
+
+    # Handle phant (phantom) element - if we reach here, it's not a \not pattern
+    if lname == "phant":
+        # Check if this is a zero-width phantom (already handled in parent)
+        # For other phantoms, convert to mphantom
+        phant_pr = node.find(f"{{{OMML_NS}}}phantPr")
+        if phant_pr is not None:
+            zero_wid = phant_pr.find(f"{{{OMML_NS}}}zeroWid")
+            if zero_wid is not None and (zero_wid.get(f"{{{OMML_NS}}}val") in ["1", "true"]):
+                # Zero-width phantom that wasn't caught as \not - just return content
+                e_el = node.find(f"{{{OMML_NS}}}e")
+                if e_el is not None:
+                    return _convert_omml_children(e_el)
+                return None
+
+        # Regular phantom - convert to mphantom
+        mphantom = _mml("mphantom")
+        e_el = node.find(f"{{{OMML_NS}}}e")
+        if e_el is not None:
+            children = _convert_omml_children(e_el)
+            if children:
+                if len(children) == 1:
+                    mphantom.append(children[0])
+                else:
+                    mrow = _mml("mrow")
+                    _append_all(mrow, children)
+                    mphantom.append(mrow)
+        return mphantom
+
+    if lname == "e" or lname in {"sub", "sup"}:
+        # Container wrappers: return converted children
+        return _convert_omml_children(node)
+
+    if lname == "r":
+        # Run: collect text tokens from m:t and extract formatting information
+        texts: list[str] = []
+        for t in node.findall(f".//{{{OMML_NS}}}t"):
+            if t.text:
+                texts.append(t.text)
+
+        # Extract formatting from OMML run properties (m:rPr)
+        formatting = {}
+
+        # Check for OMML style properties
+        mrpr = node.find(f"{{{OMML_NS}}}rPr")
+        if mrpr is not None:
+            # Check for script type (m:scr) - this indicates font variants like blackboard bold, script, fraktur, etc.
+            scr_elem = mrpr.find(f"{{{OMML_NS}}}scr")
+            if scr_elem is not None:
+                scr_val = scr_elem.get(f'{{{OMML_NS}}}val')
+                if scr_val is None:
+                    scr_val = scr_elem.get('val')
+
+                # Map OMML script values to formatting flags
+                if scr_val == 'double-struck':
+                    formatting['mathvariant'] = 'double-struck'
+                elif scr_val == 'script':
+                    formatting['mathvariant'] = 'script'
+                elif scr_val == 'fraktur':
+                    formatting['mathvariant'] = 'fraktur'
+                elif scr_val == 'sans-serif':
+                    formatting['mathvariant'] = 'sans-serif'
+                elif scr_val == 'monospace':
+                    formatting['mathvariant'] = 'monospace'
+
+            # Check for m:nor - indicates "text mode" in Word equation editor
+            # This makes text upright/roman (non-italic), triggered by user clicking "Text" button
+            nor_elem = mrpr.find(f"{{{OMML_NS}}}nor")
+            if nor_elem is not None:
+                # <m:nor/> indicates normal (upright/roman) text style
+                # Only set if not already set by m:scr
+                if 'mathvariant' not in formatting:
+                    formatting['mathvariant'] = 'normal'
+
+            sty_elem = mrpr.find(f"{{{OMML_NS}}}sty")
+            if sty_elem is not None:
+                sty_val = sty_elem.get(f'{{{OMML_NS}}}val')
+                if sty_val is None:
+                    sty_val = sty_elem.get('val')
+                if sty_val == 'p':  # Plain style means normal/roman (not italic)
+                    # m:sty="p" indicates upright/roman text, NOT blackboard bold
+                    # Only set if not already set by m:scr or m:nor
+                    if 'mathvariant' not in formatting:
+                        # Set to normal (roman/upright) style
+                        formatting['mathvariant'] = 'normal'
+                elif sty_val == 'b':  # Bold style
+                    # Only set bold if no mathvariant already set
+                    if 'mathvariant' not in formatting:
+                        formatting['bold'] = True
+
+        # Extract formatting from Word run properties (w:rPr)
+        W_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
+        wrpr = node.find(f".//{{{W_NS}}}rPr")
+        if wrpr is not None:
+            # Check for italic formatting
+            # IMPORTANT: <w:i/> (no val) means italic=true, but <w:i val="0"/> means italic=false
+            italic_elem = wrpr.find(f"{{{W_NS}}}i")
+            if italic_elem is not None:
+                # Check the val attribute - "0" or "false" means NOT italic
+                italic_val = italic_elem.get(f'{{{W_NS}}}val')
+                if italic_val is None:
+                    italic_val = italic_elem.get('val')  # Try without namespace
+                # Only set italic=True if val is not "0" or "false"
+                # Presence without val attribute means true
+                if italic_val not in ('0', 'false'):
+                    formatting['italic'] = True
+
+            # Extract font information
+            rfonts_elem = wrpr.find(f"{{{W_NS}}}rFonts")
+            if rfonts_elem is not None:
+                # Check for font attributes in rFonts element
+                font_ascii = rfonts_elem.get(f'{{{W_NS}}}ascii')
+                font_cs = rfonts_elem.get(f'{{{W_NS}}}cs')  # Complex script font
+                font_hAnsi = rfonts_elem.get(f'{{{W_NS}}}hAnsi')  # High ANSI font
+
+                # Use the most appropriate font, preferring ASCII font for math
+                font_name = font_ascii or font_hAnsi or font_cs
+                if font_name:
+                    formatting['font'] = font_name
+
+            # Extract color information from w:color element
+            color_elem = wrpr.find(f"{{{W_NS}}}color")
+            if color_elem is not None:
+                color_val = color_elem.get(f'{{{W_NS}}}val')
+                if color_val:
+                    # Store color as hex with # prefix for MathML mathcolor attribute
+                    formatting['color'] = f'#{color_val}'
+
+        return _tokens_to_mathml_nodes("".join(texts), formatting)
+
+    if lname == "t":
+        return _tokens_to_mathml_nodes(node.text or "", {})
+
+    if lname == "sSup":
+        m = _mml("msup")
+        base_children = _convert_omml_children(node.find(f"{{{OMML_NS}}}e")) if node.find(f"{{{OMML_NS}}}e") is not None else []
+        sup_children = _convert_omml_children(node.find(f"{{{OMML_NS}}}sup")) if node.find(f"{{{OMML_NS}}}sup") is not None else []
+        m.append(_collapse_to_single(base_children))
+        m.append(_collapse_to_single(sup_children))
+        return m
+
+    if lname == "sSub":
+        m = _mml("msub")
+        base_children = _convert_omml_children(node.find(f"{{{OMML_NS}}}e")) if node.find(f"{{{OMML_NS}}}e") is not None else []
+        sub_children = _convert_omml_children(node.find(f"{{{OMML_NS}}}sub")) if node.find(f"{{{OMML_NS}}}sub") is not None else []
+        m.append(_collapse_to_single(base_children))
+        m.append(_collapse_to_single(sub_children))
+        return m
+
+    if lname == "sSubSup":
+        base_el = node.find(f"{{{OMML_NS}}}e")
+        sub_el = node.find(f"{{{OMML_NS}}}sub")
+        sup_el = node.find(f"{{{OMML_NS}}}sup")
+
+        # Check if base element contains sPre (pre-script) - need unified mmultiscripts
+        if base_el is not None:
+            spre_el = base_el.find(f"{{{OMML_NS}}}sPre")
+            if spre_el is not None:
+                # Create unified mmultiscripts with both pre and post scripts
+                mmultiscripts = _mml("mmultiscripts")
+
+                # Extract complete base content: sPre/e content + any additional siblings
+                base_parts = []
+
+                # Get base content from sPre/e
+                pre_base_el = spre_el.find(f"{{{OMML_NS}}}e")
+                if pre_base_el is not None:
+                    base_parts.extend(_convert_omml_children(pre_base_el))
+
+                # Get any additional content from siblings of sPre (like additional r elements)
+                for child in base_el:
+                    if _local(child.tag) not in ("sPre",):  # Skip sPre itself, process other children
+                        base_parts.extend(_convert_omml_children(child))
+
+                if base_parts:
+                    mmultiscripts.append(_collapse_to_single(base_parts))
+                else:
+                    mmultiscripts.append(_mml("mi"))  # fallback empty base
+
+                # Add postscripts (from outer sSubSup)
+                if sub_el is not None:
+                    mmultiscripts.append(_collapse_to_single(_convert_omml_children(sub_el)))
+                else:
+                    mmultiscripts.append(_mml("none"))
+
+                if sup_el is not None:
+                    mmultiscripts.append(_collapse_to_single(_convert_omml_children(sup_el)))
+                else:
+                    mmultiscripts.append(_mml("none"))
+
+                # Add mprescripts marker
+                mprescripts = _mml("mprescripts")
+                mmultiscripts.append(mprescripts)
+
+                # Add prescripts (from sPre)
+                pre_sub_el = spre_el.find(f"{{{OMML_NS}}}sub")
+                pre_sup_el = spre_el.find(f"{{{OMML_NS}}}sup")
+
+                if pre_sub_el is not None:
+                    mmultiscripts.append(_collapse_to_single(_convert_omml_children(pre_sub_el)))
+                else:
+                    mmultiscripts.append(_mml("none"))
+
+                if pre_sup_el is not None:
+                    mmultiscripts.append(_collapse_to_single(_convert_omml_children(pre_sup_el)))
+                else:
+                    mmultiscripts.append(_mml("none"))
+
+                return mmultiscripts
+
+        # Regular sSubSup handling (no sPre in base)
+        m = _mml("msubsup")
+        base_children = _convert_omml_children(base_el) if base_el is not None else []
+        sub_children = _convert_omml_children(sub_el) if sub_el is not None else []
+        sup_children = _convert_omml_children(sup_el) if sup_el is not None else []
+        m.append(_collapse_to_single(base_children))
+        m.append(_collapse_to_single(sub_children))
+        m.append(_collapse_to_single(sup_children))
+        return m
+
+    if lname == "eqArr":
+        # Check if this is a summation/product/integral notation
+        summation_info = _is_summation_notation(node)
+        if summation_info:
+            return _create_summation_mathml(summation_info)
+
+        # Check if this is a chemical reaction arrow with conditions
+        chemical_info = _is_chemical_reaction_arrow(node)
+        if chemical_info:
+            return _create_chemical_reaction_mathml(chemical_info)
+
+        # Convert equation array to proper mtable structure
+        mtable = _mml("mtable")
+
+        # Find all equation array elements (e elements)
+        e_elements = node.findall(f"{{{OMML_NS}}}e")
+
+        for e_elem in e_elements:
+            mtr = _mml("mtr")
+
+            # Convert content of each array element
+            children = _convert_omml_children(e_elem)
+
+            # CRITICAL FIX: Word embeds "&" as column separators in equation arrays
+            # (e.g., <m:t>-x,  &amp;x&lt;0</m:t> for piecewise functions)
+            # After conversion, these appear as <mo>&</mo> operators
+            # We need to split at these points to create separate table columns
+            column_segments = []
+            current_segment = []
+
+            for child in children:
+                # Check if this is an & operator (column separator)
+                if (_local(child.tag) == "mo" and
+                    child.text is not None and
+                    child.text.strip() == "&"):
+                    # Found a column separator - save current segment and start new one
+                    if current_segment:
+                        column_segments.append(current_segment)
+                        current_segment = []
+                    # Skip the & operator itself (it becomes structural, not content)
+                else:
+                    # Add to current column segment
+                    current_segment.append(child)
+
+            # Add the last segment
+            if current_segment:
+                column_segments.append(current_segment)
+
+            # Create mtd cells for each column segment
+            if column_segments:
+                for segment in column_segments:
+                    mtd = _mml("mtd")
+                    if segment:
+                        if len(segment) == 1:
+                            mtd.append(segment[0])
+                        else:
+                            mrow = _mml("mrow")
+                            _append_all(mrow, segment)
+                            mtd.append(mrow)
+                    mtr.append(mtd)
+            else:
+                # No content - create empty cell
+                mtd = _mml("mtd")
+                mtr.append(mtd)
+
+            mtable.append(mtr)
+
+        return mtable
+
+    if lname == "f":
+        # Fraction: m:f with children m:num and m:den
+        # Check for noBar type (binomial coefficient)
+        fpr_el = node.find(f"{{{OMML_NS}}}fPr")
+        is_nobar = False
+        if fpr_el is not None:
+            type_el = fpr_el.find(f"{{{OMML_NS}}}type")
+            if type_el is not None:
+                type_val = type_el.get(f"{{{OMML_NS}}}val", "")
+                is_nobar = (type_val == "noBar")
+
+        num_el = node.find(f"{{{OMML_NS}}}num")
+        den_el = node.find(f"{{{OMML_NS}}}den")
+        num_children = _convert_omml_children(num_el) if num_el is not None else []
+        den_children = _convert_omml_children(den_el) if den_el is not None else []
+
+        if is_nobar:
+            # Create binomial coefficient structure using mtable
+            m = _mml("mtable")
+            # First row for numerator
+            mtr1 = _mml("mtr")
+            mtd1 = _mml("mtd")
+            mtd1.append(_collapse_to_single(num_children))
+            mtr1.append(mtd1)
+            m.append(mtr1)
+            # Second row for denominator
+            mtr2 = _mml("mtr")
+            mtd2 = _mml("mtd")
+            mtd2.append(_collapse_to_single(den_children))
+            mtr2.append(mtd2)
+            m.append(mtr2)
+            # Mark as binomial for LaTeX conversion
+            m.set("data-binomial", "true")
+        else:
+            # Regular fraction
+            m = _mml("mfrac")
+            m.append(_collapse_to_single(num_children))
+            m.append(_collapse_to_single(den_children))
+
+        return m
+
+    if lname == "nary":
+        # N-ary operators: sum, product, integral, etc.
+        return _convert_omml_nary(node)
+
+    if lname == "lim":
+        # Limit operators
+        return _convert_omml_limit(node)
+
+    if lname == "func":
+        # Function application
+        return _convert_omml_func(node)
+
+    if lname == "acc":
+        # Accent operators (hat, bar, tilde, etc.)
+        return _convert_omml_accent(node)
+
+    if lname == "d":
+        # Delimiter pairs
+        return _convert_omml_delimiter(node)
+
+    if lname == "sPre":
+        # Pre-subscripts/superscripts for isotopes
+        return _convert_omml_prescript(node)
+
+    if lname == "box":
+        # Boxed expressions
+        return _convert_omml_box(node)
+
+    if lname == "borderBox":
+        # Border boxed expressions (rounded box)
+        return _convert_omml_borderbox(node)
+
+    if lname == "bar":
+        # Bar (overbar/underbar): m:bar with child m:e (base expression)
+        return _convert_omml_bar(node)
+
+    if lname == "rad":
+        # Radical/root: m:rad with children m:deg (degree) and m:e (radicand)
+        return _convert_omml_radical(node)
+
+    if lname == "limLow":
+        # Lower limit (like subscript under function name)
+        return _convert_omml_limLow(node)
+
+    if lname == "limUpp":
+        # Upper limit with groupChr (like overbrace)
+        return _convert_omml_limUpp(node)
+
+    if lname == "groupChr":
+        # Group character (overbrace, underbrace, etc.)
+        return _convert_omml_groupChr(node)
+
+    if lname == "m":
+        # Matrix element - convert to mtable
+        return _convert_omml_matrix(node)
+
+    # Default: descend into children
+    return _convert_omml_children(node)
+
+
+def _collapse_to_single(nodes: List[ET._Element]) -> ET._Element:
+    if not nodes:
+        return _mml("mrow")
+    if len(nodes) == 1:
+        return nodes[0]
+    m = _mml("mrow")
+    _append_all(m, nodes)
+    return m
+
+
+# Comprehensive list of mathematical functions for fragmented function detection
+MATHEMATICAL_FUNCTIONS = {
+    # Trigonometric functions
+    "sin", "cos", "tan", "cot", "sec", "csc",
+    # Inverse trigonometric functions
+    "arcsin", "arccos", "arctan", "arccot", "arcsec", "arccsc",
+    "asin", "acos", "atan", "acot", "asec", "acsc",
+    # Hyperbolic functions
+    "sinh", "cosh", "tanh", "coth", "sech", "csch",
+    # Inverse hyperbolic functions
+    "arcsinh", "arccosh", "arctanh", "arccoth", "arcsech", "arccsch",
+    "asinh", "acosh", "atanh", "acoth", "asech", "acsch",
+    # Logarithmic and exponential functions
+    "log", "ln", "lg", "exp", "log10", "log2", "logb",
+    # Special mathematical functions
+    "min", "max", "sup", "inf", "limsup", "liminf", "lim",
+    "arg", "det", "dim", "ker", "deg", "gcd", "lcm",
+    # Calculus operators
+    "grad", "div", "curl", "laplacian",
+    # Probability and statistics
+    "Pr", "var", "cov", "corr", "Var", "Cov",
+    # Other common functions
+    "sgn", "sign", "abs", "floor", "ceil", "round", "frac", "mod"
+}
+
+def _detect_fragmented_function(text: str, start_pos: int) -> Optional[Tuple[str, int]]:
+    """
+    Detect if text starting at start_pos contains a fragmented mathematical function.
+    Returns (function_name, end_pos) if found, None otherwise.
+    """
+    # Look ahead to find potential function matches
+    max_func_len = max(len(func) for func in MATHEMATICAL_FUNCTIONS)
+    search_end = min(len(text), start_pos + max_func_len + 10)  # Add buffer for spaces
+
+    # Extract potential function text, ignoring spaces
+    potential_func = ""
+    char_positions = []
+
+    for i in range(start_pos, search_end):
+        if i >= len(text):
+            break
+        char = text[i]
+        if char.isalpha():
+            potential_func += char
+            char_positions.append(i)
+        elif char.isspace():
+            # Allow spaces within function names but track positions
+            char_positions.append(i)
+        else:
+            # Stop at non-alphabetic, non-space characters
+            break
+
+    # Check if the accumulated text matches any mathematical function
+    for func in sorted(MATHEMATICAL_FUNCTIONS, key=len, reverse=True):  # Check longer functions first
+        if potential_func.lower() == func.lower():
+            # Find the end position (last character of the function)
+            func_char_count = len(func)
+            if len(char_positions) >= func_char_count:
+                # Return the function name and position after the last function character
+                last_char_idx = None
+                alpha_count = 0
+                for pos in char_positions:
+                    if pos < len(text) and text[pos].isalpha():
+                        alpha_count += 1
+                        if alpha_count == func_char_count:
+                            last_char_idx = pos
+                            break
+
+                if last_char_idx is not None:
+                    return func, last_char_idx + 1
+
+    return None
+
+def _tokens_to_mathml_nodes(text: str, formatting: dict = None) -> List[ET._Element]:
+    nodes: list[ET._Element] = []
+    i = 0
+    buf = ""
+
+    def flush_buf_as(kind: str) -> None:
+        nonlocal buf
+        if not buf:
+            return
+        if kind == "num":
+            n = _mml("mn")
+            n.text = buf
+            # Apply color if available
+            if formatting and formatting.get('color'):
+                n.set('mathcolor', formatting['color'])
+            nodes.append(n)
+        elif kind == "id":
+            mi = _mml("mi")
+            mi.text = buf
+            # Apply formatting attributes if available
+            if formatting:
+                # PRECEDENCE RULE: Italic takes highest priority
+                # This handles conflicts where both <m:nor/> (→ mathvariant="normal")
+                # and <w:i/> (→ italic=True) are set. Italic should win because it's
+                # more specific and likely the most recent user action in Word.
+                #
+                # Example: User clicks "Text" button (sets m:nor), then clicks "Italic" (sets w:i)
+                # → Final intent is italic, so italic should override the normal style
+                if formatting.get('italic'):
+                    # Italic wins - most specific user intent
+                    mi.set('mathvariant', 'italic')
+                elif formatting.get('mathvariant'):
+                    # Check for direct mathvariant specification (from m:scr or m:nor in OMML)
+                    mi.set('mathvariant', formatting['mathvariant'])
+                elif formatting.get('blackboard'):
+                    # Set mathvariant to double-struck for blackboard bold sets
+                    mi.set('mathvariant', 'double-struck')
+                elif formatting.get('bold'):
+                    # Set mathvariant to bold for bold formatting
+                    mi.set('mathvariant', 'bold')
+                elif formatting.get('font'):
+                    # Handle font-specific formatting
+                    font_name = formatting.get('font')
+                    latex_cmd = FONT_TO_LATEX.get(font_name)
+                    if latex_cmd == 'mathrm':
+                        # Times New Roman should be upright/roman
+                        mi.set('mathvariant', 'normal')
+                        mi.set('font-family', font_name)  # Store original font for reference
+                    elif latex_cmd:
+                        # Other fonts (mathsf, mathtt) - store for LaTeX conversion
+                        mi.set('font-family', font_name)
+                        mi.set('latex-font-cmd', latex_cmd)
+                # Apply color if available (independent of other formatting)
+                if formatting.get('color'):
+                    mi.set('mathcolor', formatting['color'])
+            nodes.append(mi)
+        elif kind == "text":
+            tx = _mml("mtext")
+            tx.text = buf
+            # Apply color if available
+            if formatting and formatting.get('color'):
+                tx.set('mathcolor', formatting['color'])
+            nodes.append(tx)
+        buf = ""
+
+    current_kind: str | None = None
+
+    def classify(ch: str) -> str:
+        if ch.isdigit():
+            return "num"
+        if ch.isalpha():
+            return "id"
+        # Treat CJK and other non-mathematical symbols as text by default
+        if ord(ch) > 127 and ch not in MATH_SYMBOLS_SET:
+            return "text"
+        return "op"
+
+    while i < len(text):
+        ch = text[i]
+        kind = classify(ch)
+
+        # Check for fragmented mathematical functions when we encounter identifier characters
+        if kind == "id" and (current_kind != "id" or not buf):
+            # Check if a fragmented function starts at this position
+            fragmented_func = _detect_fragmented_function(text, i)
+            if fragmented_func:
+                func_name, end_pos = fragmented_func
+
+                # Flush any existing buffer
+                flush_buf_as(current_kind or "")
+                current_kind = None
+                buf = ""
+
+                # Create a mathematical identifier for the function
+                mi = _mml("mi")
+                mi.text = func_name
+                if formatting:
+                    # PRECEDENCE RULE: Italic takes highest priority (same as for regular identifiers)
+                    if formatting.get('italic'):
+                        mi.set('mathvariant', 'italic')
+                    elif formatting.get('mathvariant'):
+                        # Check for direct mathvariant specification (from m:scr or m:nor in OMML)
+                        mi.set('mathvariant', formatting['mathvariant'])
+                    elif formatting.get('blackboard'):
+                        mi.set('mathvariant', 'double-struck')
+                    elif formatting.get('bold'):
+                        mi.set('mathvariant', 'bold')
+                    elif formatting.get('font'):
+                        # Handle font-specific formatting
+                        font_name = formatting.get('font')
+                        latex_cmd = FONT_TO_LATEX.get(font_name)
+                        if latex_cmd == 'mathrm':
+                            # Times New Roman should be upright/roman
+                            mi.set('mathvariant', 'normal')
+                            mi.set('font-family', font_name)  # Store original font for reference
+                        elif latex_cmd:
+                            # Other fonts (mathsf, mathtt) - store for LaTeX conversion
+                            mi.set('font-family', font_name)
+                            mi.set('latex-font-cmd', latex_cmd)
+                    # Apply color if available (independent of other formatting)
+                    if formatting.get('color'):
+                        mi.set('mathcolor', formatting['color'])
+                nodes.append(mi)
+
+                # Skip to the end of the function
+                i = end_pos
+                continue
+
+        if kind in {"num", "id", "text"}:
+            if current_kind != kind:
+                flush_buf_as(current_kind or "")
+                current_kind = kind
+            buf += ch
+            i += 1
+            continue
+        # Operators
+        # Special handling for consecutive spaces - accumulate them
+        if ch in {' ', '\xa0'}:  # Regular space or NBSP
+            flush_buf_as(current_kind or "")
+            current_kind = None
+            # Collect all consecutive spaces (of same type)
+            space_text = ch
+            j = i + 1
+            while j < len(text) and text[j] == ch:  # Same space type
+                space_text += text[j]
+                j += 1
+            mo = _mml("mo")
+            mo.text = space_text
+            nodes.append(mo)
+            i = j  # Skip past all accumulated spaces
+        else:
+            # Other operators (non-space)
+            flush_buf_as(current_kind or "")
+            current_kind = None
+            mo = _mml("mo")
+            mo.text = ch
+            nodes.append(mo)
+            i += 1
+
+    flush_buf_as(current_kind or "")
+    return nodes
+
+
+def _convert_omml_nary(node: ET._Element) -> ET._Element:
+    """Convert OMML nary (n-ary operator) to MathML."""
+    # Extract the operator character
+    char_nodes = node.findall(f".//{{{OMML_NS}}}chr")
+    if char_nodes and hasattr(char_nodes[0], 'attrib'):
+        # Try both namespaced and non-namespaced attribute access
+        char_val = char_nodes[0].get(f'{{{OMML_NS}}}val')
+        if char_val is None:
+            char_val = char_nodes[0].get('val', '∫')
+    else:
+        char_val = '∫'  # Default to integral, not sum
+
+    # Map OMML nary characters to LaTeX
+    nary_map = {
+        '∑': 'sum',
+        '∏': 'prod',
+        '∐': 'coprod',
+        '∫': 'int',
+        '∬': 'iint',
+        '∭': 'iiint',
+        '∮': 'oint',
+        '⋃': 'bigcup',
+        '⋂': 'bigcap',
+        '⋁': 'bigvee',
+        '⋀': 'bigwedge',
+        '⨁': 'bigoplus',
+        '⨂': 'bigotimes',
+        '⨄': 'biguplus'
+    }
+
+    op_cmd = nary_map.get(char_val, 'sum')
+
+    # Check limLoc to determine if limits should be displayed
+    nary_pr = node.find(f"{{{OMML_NS}}}naryPr")
+    use_nolimits = False
+    if nary_pr is not None:
+        lim_loc = nary_pr.find(f"{{{OMML_NS}}}limLoc")
+        if lim_loc is not None:
+            lim_loc_val = lim_loc.get(f'{{{OMML_NS}}}val')
+            if lim_loc_val is None:
+                lim_loc_val = lim_loc.get('val', 'undOvr')
+            if lim_loc_val == 'subSup':
+                use_nolimits = True
+
+    # Find sub and sup elements
+    sub_el = node.find(f"{{{OMML_NS}}}sub")
+    sup_el = node.find(f"{{{OMML_NS}}}sup")
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Create the operator
+    mo = _mml("mo")
+    if use_nolimits:
+        mo.text = f"\\{op_cmd}\\nolimits"
+    else:
+        mo.text = f"\\{op_cmd}"
+
+    if sub_el is not None or sup_el is not None:
+        # Create msubsup, msub, or msup as needed
+        if sub_el is not None and sup_el is not None:
+            m = _mml("msubsup")
+            m.append(mo)
+            m.append(_collapse_to_single(_convert_omml_children(sub_el)))
+            m.append(_collapse_to_single(_convert_omml_children(sup_el)))
+        elif sub_el is not None:
+            m = _mml("msub")
+            m.append(mo)
+            m.append(_collapse_to_single(_convert_omml_children(sub_el)))
+        elif sup_el is not None:
+            m = _mml("msup")
+            m.append(mo)
+            m.append(_collapse_to_single(_convert_omml_children(sup_el)))
+        else:
+            m = mo
+
+        # Add the base if it exists
+        if base_el is not None:
+            return [m, _collapse_to_single(_convert_omml_children(base_el))]
+        else:
+            return m
+    else:
+        return mo
+
+
+def _convert_omml_limit(node: ET._Element) -> ET._Element:
+    """Convert OMML lim (limit) to MathML."""
+    # Find the limit base (what we're taking limit of)
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Create limit operator
+    lim_mo = _mml("mo")
+    lim_mo.text = "lim"
+
+    # Look for conditions in sub element
+    sub_el = node.find(f"{{{OMML_NS}}}sub")
+    if sub_el is not None:
+        msub = _mml("msub")
+        msub.append(lim_mo)
+        msub.append(_collapse_to_single(_convert_omml_children(sub_el)))
+
+        if base_el is not None:
+            return [msub, _collapse_to_single(_convert_omml_children(base_el))]
+        else:
+            return msub
+    else:
+        if base_el is not None:
+            return [lim_mo, _collapse_to_single(_convert_omml_children(base_el))]
+        else:
+            return lim_mo
+
+
+def _convert_omml_func(node: ET._Element) -> ET._Element:
+    """Convert OMML func (function) to MathML."""
+    # Find function name and argument
+    fname_el = node.find(f"{{{OMML_NS}}}fName")
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    if fname_el is not None:
+        # Check if the function name contains structured elements (like limLow)
+        structured_elements = fname_el.findall(f".//{{{OMML_NS}}}limLow")
+        if structured_elements:
+            # Process structured function name (e.g., max with subscript)
+            func_structure = _collapse_to_single(_convert_omml_children(fname_el))
+        else:
+            # Extract simple function name from text
+            fname_texts = []
+            for t in fname_el.findall(f".//{{{OMML_NS}}}t"):
+                if t.text:
+                    fname_texts.append(t.text)
+            fname = "".join(fname_texts).strip()
+
+            # Create function identifier
+            func_structure = _mml("mi")
+            func_structure.text = fname
+
+        if base_el is not None:
+            # Function application
+            mrow = _mml("mrow")
+            mrow.append(func_structure)
+            # Add invisible function application operator
+            mo = _mml("mo")
+            mo.text = "⁡"  # Invisible function application
+            mrow.append(mo)
+            mrow.append(_collapse_to_single(_convert_omml_children(base_el)))
+            return mrow
+        else:
+            return func_structure
+    else:
+        # No function name, just return the base
+        if base_el is not None:
+            return _collapse_to_single(_convert_omml_children(base_el))
+        else:
+            return _mml("mrow")
+
+
+def _convert_omml_accent(node: ET._Element) -> ET._Element:
+    """Convert OMML acc (accent) to MathML."""
+    # Find accent character
+    chr_nodes = node.findall(f".//{{{OMML_NS}}}chr")
+    accent_char = '̂'  # Default hat
+    if chr_nodes and hasattr(chr_nodes[0], 'attrib'):
+        accent_char = chr_nodes[0].get(f'{{{OMML_NS}}}val')
+        if accent_char is None:
+            accent_char = chr_nodes[0].get('val', '̂')
+
+    # Map accent characters to LaTeX commands or Unicode symbols
+    accent_map = {
+        '̂': 'hat',     # Circumflex
+        '̃': 'tilde',   # Tilde
+        '̄': 'bar',     # Overline
+        '̇': 'dot',     # Dot above
+        '̈': 'ddot',    # Double dot
+        '⃗': 'vec',     # U+20D7 Combining right arrow above (vector)
+        '˘': 'breve',   # U+02D8 Breve (spacing)
+        '̆': 'breve',   # U+0306 Combining breve
+        '̌': 'check',   # Caron/check
+        '́': 'acute',   # Acute accent
+        '̀': 'grave',   # Grave accent
+    }
+
+    # Arrow accent characters that should pass through as Unicode (not LaTeX commands)
+    arrow_accents = {
+        '⃖': '←',       # U+20D6 Combining left arrow above → left arrow
+        '↔': '↔',       # U+2194 Left right arrow (pass through)
+        '⃐': '⃐',       # U+20D0 Combining left harpoon above (pass through)
+        '⃑': '⃑',       # U+20D1 Combining right harpoon above (pass through)
+        '⇀': '⇀',       # U+21C0 Right harpoon over (pass through)
+        '↼': '↼',       # U+21BC Left harpoon over (pass through)
+        '⇁': '⇁',       # U+21C1 Right harpoon down (pass through)
+        '↽': '↽',       # U+21BD Left harpoon down (pass through)
+        '⏞': '⏞',       # U+23DE Overbrace (pass through)
+        '⏟': '⏟',       # U+23DF Underbrace (pass through)
+    }
+
+    # Line/bar characters used for overline notation - pass through as-is
+    # These should NOT be converted to LaTeX commands, so the MathML converter
+    # can recognize them as overline notation and convert to \overline{}
+    line_characters = {
+        "―",     # U+2014 em dash (most common in Word for overline)
+        "¯",     # U+00AF macron
+        "‾",     # U+203E overline character
+        "-",     # U+002D hyphen-minus
+        "−",     # U+2212 minus sign
+        "—",     # U+2014 em dash (duplicate for safety)
+        "–",     # U+2013 en dash
+        "﹣",    # U+FE63 small hyphen-minus
+        "⎯",     # U+23AF horizontal line extension
+    }
+
+    # Find base element
+    base_el = node.find(f"{{{OMML_NS}}}e")
+    if base_el is not None:
+        base_content = _collapse_to_single(_convert_omml_children(base_el))
+
+        # Create mover with accent
+        mover = _mml("mover")
+        mover.append(base_content)
+
+        # Create accent
+        mo = _mml("mo")
+
+        # Check if this is a line/bar character (for overline notation)
+        if accent_char in line_characters:
+            # Pass through as-is for \overline{} recognition
+            mo.text = accent_char
+        # Check if this is an arrow accent that should pass through as Unicode
+        elif accent_char in arrow_accents:
+            mo.text = arrow_accents[accent_char]
+        else:
+            # Use LaTeX command format for standard accents
+            accent_cmd = accent_map.get(accent_char, 'hat')
+            mo.text = f"\\{accent_cmd}"
+
+        mover.append(mo)
+
+        return mover
+    else:
+        # No base, just return empty
+        return _mml("mrow")
+
+
+def _convert_omml_delimiter(node: ET._Element) -> ET._Element:
+    """Convert OMML d (delimiter) to MathML mfenced."""
+    # Find delimiter properties
+    dpr_el = node.find(f"{{{OMML_NS}}}dPr")
+    begChr = "("
+    endChr = ")"
+
+    if dpr_el is not None:
+        beg_el = dpr_el.find(f"{{{OMML_NS}}}begChr")
+        end_el = dpr_el.find(f"{{{OMML_NS}}}endChr")
+        if beg_el is not None:
+            val = beg_el.get(f'{{{OMML_NS}}}val')
+            if val is not None:
+                begChr = val
+            else:
+                begChr = beg_el.get('val', "(")
+        if end_el is not None:
+            val = end_el.get(f'{{{OMML_NS}}}val')
+            if val is not None:
+                endChr = val  # This can be empty string!
+            else:
+                endChr = end_el.get('val', ")")
+    else:
+        # No delimiter properties found - check content for interval notation clues
+        base_el = node.find(f"{{{OMML_NS}}}e")
+        if base_el is not None:
+            content = ""
+            for t in base_el.findall(f".//{{{OMML_NS}}}t"):
+                if t.text:
+                    content += t.text
+            # Check for interval notation patterns
+            if "," in content and ("∞" in content or "+∞" in content or "-∞" in content):
+                begChr = "("
+                endChr = ")"
+
+    # Find content
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Handle special case where there's no closing delimiter (like array notation)
+    if not endChr or endChr.strip() == "":
+        # Check if this is a cases-like environment (left brace with equation array or matrix)
+        # NOTE: We NO LONGER use cases environment, instead use mfenced with \left\{ and \right.
+        if begChr == "{" and base_el is not None:
+            eqarr_el = base_el.find(f"{{{OMML_NS}}}eqArr")
+            if eqarr_el is not None:
+                # Convert to mfenced wrapping mtable for better compatibility
+                mtable = _mml("mtable")
+                # Add class attribute for styling (left-aligned like cases)
+                mtable.set("class", "tml-array")
+                mtable.set("columnalign", "left")
+
+                # Convert equation array elements to table rows
+                for e_el in eqarr_el.findall(f"{{{OMML_NS}}}e"):
+                    mtr = _mml("mtr")
+                    mtd = _mml("mtd")
+                    e_children = _convert_omml_children(e_el)
+                    _append_all(mtd, e_children)
+                    mtr.append(mtd)
+                    mtable.append(mtr)
+
+                # Wrap mtable in mfenced with left brace and no right delimiter
+                mfenced = _mml("mfenced")
+                mfenced.set("open", "{")
+                mfenced.set("close", "")
+                mfenced.append(mtable)
+                return mfenced
+
+            # Also check for matrix element (m) which can be used for piecewise functions
+            matrix_el = base_el.find(f"{{{OMML_NS}}}m")
+            if matrix_el is not None:
+                # Convert matrix to mfenced wrapping mtable for better compatibility
+                mtable = _mml("mtable")
+                # Add class attribute for styling (left-aligned like cases)
+                mtable.set("class", "tml-array")
+                mtable.set("columnalign", "left")
+
+                # Convert matrix rows to table rows
+                for mr_elem in matrix_el.findall(f"{{{OMML_NS}}}mr"):
+                    mtr = _mml("mtr")
+
+                    # Process all cells in the row
+                    for e_elem in mr_elem.findall(f"{{{OMML_NS}}}e"):
+                        mtd = _mml("mtd")
+                        e_children = _convert_omml_children(e_elem)
+                        _append_all(mtd, e_children)
+                        mtr.append(mtd)
+
+                    mtable.append(mtr)
+
+                # Wrap mtable in mfenced with left brace and no right delimiter
+                mfenced = _mml("mfenced")
+                mfenced.set("open", "{")
+                mfenced.set("close", "")
+                mfenced.append(mtable)
+                return mfenced
+
+        # Create mrow with opening delimiter and content, following XSLT pattern
+        mrow = _mml("mrow")
+
+        # Add opening delimiter if present
+        if begChr and begChr.strip():
+            open_mo = _mml("mo")
+            open_mo.text = begChr
+            mrow.append(open_mo)
+
+        # Add content
+        if base_el is not None:
+            children = _convert_omml_children(base_el)
+            _append_all(mrow, children)
+
+        # Add empty closing delimiter (following XSLT pattern)
+        close_mo = _mml("mo")
+        close_mo.text = ""
+        mrow.append(close_mo)
+
+        return mrow
+
+    # Create mfenced for paired delimiters
+    mfenced = _mml("mfenced")
+    mfenced.set("open", begChr)
+    mfenced.set("close", endChr)
+
+    # Process ALL e elements (for set notation like {(x,y) | |x+y|<2})
+    e_elements = node.findall(f"{{{OMML_NS}}}e")
+    for e_el in e_elements:
+        for child in _convert_omml_children(e_el):
+            mfenced.append(child)
+
+    return mfenced
+
+
+def _convert_omml_prescript(node: ET._Element) -> ET._Element:
+    """Convert OMML sPre (pre-subscript/superscript) to MathML mmultiscripts."""
+    # Find base element
+    base_el = node.find(f"{{{OMML_NS}}}e")
+    sub_el = node.find(f"{{{OMML_NS}}}sub")
+    sup_el = node.find(f"{{{OMML_NS}}}sup")
+
+    if base_el is not None:
+        mmultiscripts = _mml("mmultiscripts")
+        mmultiscripts.append(_collapse_to_single(_convert_omml_children(base_el)))
+
+        # Add mprescripts marker
+        mprescripts = _mml("mprescripts")
+        mmultiscripts.append(mprescripts)
+
+        # Add pre-subscript and pre-superscript
+        if sub_el is not None:
+            mmultiscripts.append(_collapse_to_single(_convert_omml_children(sub_el)))
+        else:
+            none_el = _mml("none")
+            mmultiscripts.append(none_el)
+
+        if sup_el is not None:
+            mmultiscripts.append(_collapse_to_single(_convert_omml_children(sup_el)))
+        else:
+            none_el = _mml("none")
+            mmultiscripts.append(none_el)
+
+        return mmultiscripts
+    else:
+        return _mml("mrow")
+
+
+def _convert_omml_box(node: ET._Element) -> ET._Element:
+    """Convert OMML box to MathML menclose."""
+    # Find content
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Special case: if the box contains only a groupChr (chemical reaction arrow),
+    # don't add the box notation - just return the content
+    if base_el is not None:
+        groupchr_nodes = base_el.findall(f".//{{{OMML_NS}}}groupChr")
+        if len(groupchr_nodes) == 1 and len(list(base_el)) == 1:
+            # Only contains a single groupChr, return it without boxing
+            return _collapse_to_single(_convert_omml_children(base_el))
+
+    menclose = _mml("menclose")
+    menclose.set("notation", "box")
+
+    if base_el is not None:
+        for child in _convert_omml_children(base_el):
+            menclose.append(child)
+
+    return menclose
+
+
+def _convert_omml_borderbox(node: ET._Element) -> ET._Element:
+    """Convert OMML borderBox to MathML menclose with selective border notation.
+
+    Reads OMML properties to determine notation type:
+    - Strikethrough properties: strikeBLTR, strikeTLBR, strikeH, strikeV
+    - Border visibility: hideTop, hideBot, hideLeft, hideRight
+
+    Generates MathML menclose with appropriate notation:
+    - Strikethrough notations: updiagonalstrike, downdiagonalstrike, horizontalstrike, verticalstrike
+    - Border notations: "top" | "bottom" | "left" | "right" | "box"
+    - 1 side: "top" | "bottom" | "left" | "right"
+    - 2-3 sides: space-separated like "top left"
+    - 4 sides: "box"
+    """
+    # Find content
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Special case: if the borderBox contains only a groupChr (chemical reaction arrow),
+    # don't add the box notation - just return the content
+    if base_el is not None:
+        groupchr_nodes = base_el.findall(f".//{{{OMML_NS}}}groupChr")
+        if len(groupchr_nodes) == 1 and len(list(base_el)) == 1:
+            # Only contains a single groupChr, return it without boxing
+            return _collapse_to_single(_convert_omml_children(base_el))
+
+    # Read properties
+    props = node.find(f"{{{OMML_NS}}}borderBoxPr")
+
+    # Check for strikethrough properties FIRST (they take precedence over borders)
+    strike_BLTR = False  # Bottom-Left to Top-Right diagonal
+    strike_TLBR = False  # Top-Left to Bottom-Right diagonal
+    strike_H = False     # Horizontal strike
+    strike_V = False     # Vertical strike
+
+    if props is not None:
+        # Check for strikethrough elements
+        strike_BLTR = props.find(f"{{{OMML_NS}}}strikeBLTR") is not None
+        strike_TLBR = props.find(f"{{{OMML_NS}}}strikeTLBR") is not None
+        strike_H = props.find(f"{{{OMML_NS}}}strikeH") is not None
+        strike_V = props.find(f"{{{OMML_NS}}}strikeV") is not None
+
+    # If any strikethrough is present, use strike notation instead of box
+    if strike_BLTR or strike_TLBR or strike_H or strike_V:
+        notations = []
+        if strike_BLTR:
+            # Bottom-Left to Top-Right creates a "/" line (updiagonalstrike)
+            notations.append("updiagonalstrike")
+        if strike_TLBR:
+            # Top-Left to Bottom-Right creates a "\" line (downdiagonalstrike)
+            notations.append("downdiagonalstrike")
+        if strike_H:
+            notations.append("horizontalstrike")
+        if strike_V:
+            notations.append("verticalstrike")
+
+        notation = " ".join(notations)
+    else:
+        # No strikethrough, check border visibility
+        # Determine which sides are hidden (default: all visible)
+        hide_top = False
+        hide_bot = False
+        hide_left = False
+        hide_right = False
+
+        if props is not None:
+            # Check for hide elements (presence means hide=true)
+            hide_top = props.find(f"{{{OMML_NS}}}hideTop") is not None
+            hide_bot = props.find(f"{{{OMML_NS}}}hideBot") is not None
+            hide_left = props.find(f"{{{OMML_NS}}}hideLeft") is not None
+            hide_right = props.find(f"{{{OMML_NS}}}hideRight") is not None
+
+        # Build list of visible sides (in standard order)
+        visible = []
+        if not hide_top:
+            visible.append("top")
+        if not hide_bot:
+            visible.append("bottom")
+        if not hide_left:
+            visible.append("left")
+        if not hide_right:
+            visible.append("right")
+
+        # Generate notation string
+        if len(visible) == 0:
+            # Edge case: no visible sides (shouldn't happen, fallback to box)
+            notation = "box"
+        elif len(visible) == 4:
+            # All sides visible: use standard box notation
+            notation = "box"
+        else:
+            # Partial visibility: space-separated list of visible sides
+            notation = " ".join(visible)
+
+    # Create menclose element
+    menclose = _mml("menclose")
+    menclose.set("notation", notation)
+
+    # Add content
+    if base_el is not None:
+        for child in _convert_omml_children(base_el):
+            menclose.append(child)
+
+    return menclose
+
+
+def _convert_omml_radical(node: ET._Element) -> ET._Element:
+    """Convert OMML rad (radical) to MathML msqrt or mroot."""
+    # Find the degree and radicand
+    deg_el = node.find(f"{{{OMML_NS}}}deg")
+    base_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Check if degree is hidden (square root)
+    rad_pr = node.find(f"{{{OMML_NS}}}radPr")
+    deg_hide = False
+    if rad_pr is not None:
+        deg_hide_el = rad_pr.find(f"{{{OMML_NS}}}degHide")
+        if deg_hide_el is not None:
+            deg_hide_val = deg_hide_el.get(f'{{{OMML_NS}}}val')
+            if deg_hide_val is None:
+                deg_hide_val = deg_hide_el.get('val', '0')
+            deg_hide = deg_hide_val == '1'
+
+    if deg_hide or deg_el is None or not _convert_omml_children(deg_el):
+        # Square root (degree is hidden or empty)
+        msqrt = _mml("msqrt")
+        if base_el is not None:
+            for child in _convert_omml_children(base_el):
+                msqrt.append(child)
+        return msqrt
+    else:
+        # Nth root (degree is specified)
+        mroot = _mml("mroot")
+        # First child is the radicand, second is the index
+        if base_el is not None:
+            mroot.append(_collapse_to_single(_convert_omml_children(base_el)))
+        if deg_el is not None:
+            mroot.append(_collapse_to_single(_convert_omml_children(deg_el)))
+        return mroot
+
+
+def _convert_omml_limLow(node: ET._Element) -> ET._Element:
+    """Convert OMML limLow (lower limit) to MathML munder."""
+    # Find the limit and the base expression
+    lim_el = node.find(f"{{{OMML_NS}}}lim")
+    e_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Create munder structure (base expression with subscript below)
+    munder = _mml("munder")
+
+    # Add the base expression (what's being under-ed)
+    if e_el is not None:
+        munder.append(_collapse_to_single(_convert_omml_children(e_el)))
+    else:
+        munder.append(_mml("mrow"))  # Empty base
+
+    # Add the limit (what goes below)
+    if lim_el is not None:
+        munder.append(_collapse_to_single(_convert_omml_children(lim_el)))
+    else:
+        munder.append(_mml("mrow"))  # Empty limit
+
+    return munder
+
+
+def _convert_omml_limUpp(node: ET._Element) -> ET._Element:
+    """Convert OMML limUpp (upper limit) to MathML mover."""
+    # Find the limit and the base expression
+    lim_el = node.find(f"{{{OMML_NS}}}lim")
+    e_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Create mover structure
+    mover = _mml("mover")
+
+    # Add the base expression (what's being over-ed)
+    if e_el is not None:
+        mover.append(_collapse_to_single(_convert_omml_children(e_el)))
+    else:
+        mover.append(_mml("mrow"))  # Empty base
+
+    # Add the limit (what goes on top)
+    if lim_el is not None:
+        mover.append(_collapse_to_single(_convert_omml_children(lim_el)))
+    else:
+        mover.append(_mml("mrow"))  # Empty limit
+
+    return mover
+
+
+def _convert_omml_groupChr(node: ET._Element) -> ET._Element:
+    """Convert OMML groupChr (group character like overbrace) to MathML mover."""
+    # Find the character used and the base expression
+    grp_pr = node.find(f"{{{OMML_NS}}}groupChrPr")
+    e_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Get the character (default to overbrace)
+    char = "⏞"  # Default overbrace character
+    if grp_pr is not None:
+        chr_el = grp_pr.find(f"{{{OMML_NS}}}chr")
+        if chr_el is not None:
+            char = chr_el.get(f'{{{OMML_NS}}}val')
+            if char is None:
+                char = chr_el.get('val', "⏞")
+
+    # Check position for arrow notation
+    pos_val = None
+    if grp_pr is not None:
+        pos_el = grp_pr.find(f"{{{OMML_NS}}}pos")
+        if pos_el is not None:
+            pos_val = pos_el.get(f'{{{OMML_NS}}}val')
+            if pos_val is None:
+                pos_val = pos_el.get('val')
+
+    # Check vertical justification (vertJc) attribute
+    # vertJc="bot" means character is at bottom (base), content above
+    # This is critical for proper overbrace handling when wrapped in limUpp
+    vert_jc = None
+    if grp_pr is not None:
+        vert_jc_el = grp_pr.find(f"{{{OMML_NS}}}vertJc")
+        if vert_jc_el is not None:
+            vert_jc = vert_jc_el.get(f'{{{OMML_NS}}}val')
+            if vert_jc is None:
+                vert_jc = vert_jc_el.get('val')
+
+    # Special case for arrows - distinguish between vector notation and chemical reactions
+    # pos="top" means arrow goes over content (vector notation: \overrightarrow{abc})
+    # No pos or other values mean content goes over arrow (chemical reaction: \overset{heat}{→})
+    if char in ["⇔", "⇒", "→"] and pos_val != "top":
+        # Chemical reaction: content over arrow
+        mover = _mml("mover")
+
+        # Base is the arrow character - map to appropriate LaTeX command
+        mo_base = _mml("mo")
+        if char == "⇒":
+            mo_base.text = "\\Longrightarrow"
+        elif char == "→":
+            mo_base.text = "\\longrightarrow"
+        else:  # ⇔
+            mo_base.text = "\\Longleftrightarrow"
+        mover.append(mo_base)
+
+        # Over is the text content
+        if e_el is not None:
+            mover.append(_collapse_to_single(_convert_omml_children(e_el)))
+        else:
+            mover.append(_mml("mrow"))
+
+        return mover
+
+    # Check for vertJc="bot": character at bottom, content above
+    # This creates: mover(char, content) instead of mover(content, char)
+    # Used when groupChr is wrapped in limUpp for overbrace with labels
+    if vert_jc == "bot":
+        mover = _mml("mover")
+        mover.set("accent", "false")
+
+        # Add the character as base (at bottom)
+        mo = _mml("mo")
+        mo.text = char
+        mo.set("stretchy", "true")
+        mover.append(mo)
+
+        # Add the content above the character
+        if e_el is not None:
+            mover.append(_collapse_to_single(_convert_omml_children(e_el)))
+        else:
+            mover.append(_mml("mrow"))
+
+        return mover
+
+    # Standard case - character goes over the base expression
+    mover = _mml("mover")
+
+    # Add the base expression
+    if e_el is not None:
+        mover.append(_collapse_to_single(_convert_omml_children(e_el)))
+    else:
+        mover.append(_mml("mrow"))
+
+    # Add the character as an operator
+    mo = _mml("mo")
+    mo.text = char
+    mover.append(mo)
+
+    return mover
+
+
+def _convert_omml_bar(node: ET._Element) -> ET._Element:
+    """Convert OMML bar (overbar/underbar) to MathML mover or munder."""
+    # Find the bar properties and the base expression
+    bar_pr = node.find(f"{{{OMML_NS}}}barPr")
+    e_el = node.find(f"{{{OMML_NS}}}e")
+
+    # Check if this should be an overbar or underbar
+    # Based on empirical analysis: pos="top" → overbar, missing pos → underbar, pos="bot" → underbar
+    # Default behavior when pos is missing: UNDERBAR (observed in real-world DOCX files)
+    is_underbar = True  # Default to underbar when pos not specified
+    if bar_pr is not None:
+        pos_el = bar_pr.find(f"{{{OMML_NS}}}pos")
+        if pos_el is not None:
+            pos_val = pos_el.get(f"{{{OMML_NS}}}val")
+            # Explicit pos="top" → overbar, pos="bot" → underbar
+            is_underbar = (pos_val != "top")
+
+    if is_underbar:
+        # Create munder for underbar
+        munder = _mml("munder")
+
+        # Add the base expression
+        if e_el is not None:
+            munder.append(_collapse_to_single(_convert_omml_children(e_el)))
+        else:
+            munder.append(_mml("mrow"))
+
+        # Add the underbar character
+        mo = _mml("mo")
+        mo.text = "‾"  # Unicode overline character used as underline
+        munder.append(mo)
+
+        return munder
+    else:
+        # Create mover for overbar
+        mover = _mml("mover")
+
+        # Add the base expression
+        if e_el is not None:
+            mover.append(_collapse_to_single(_convert_omml_children(e_el)))
+        else:
+            mover.append(_mml("mrow"))
+
+        # Add the overbar character
+        mo = _mml("mo")
+        mo.text = "‾"  # Unicode overline character
+        mover.append(mo)
+
+        return mover
+
+
+def _convert_omml_matrix(node: ET._Element) -> ET._Element:
+    """Convert OMML m (matrix) to MathML mtable."""
+    mtable = _mml("mtable")
+
+    # Find all matrix rows (mr elements)
+    mr_elements = node.findall(f"{{{OMML_NS}}}mr")
+
+    for mr_elem in mr_elements:
+        mtr = _mml("mtr")
+
+        # Find all cells in this row (e elements)
+        e_elements = mr_elem.findall(f"{{{OMML_NS}}}e")
+
+        for e_elem in e_elements:
+            mtd = _mml("mtd")
+            children = _convert_omml_children(e_elem)
+            if children:
+                if len(children) == 1:
+                    mtd.append(children[0])
+                else:
+                    mrow = _mml("mrow")
+                    _append_all(mrow, children)
+                    mtd.append(mrow)
+            mtr.append(mtd)
+
+        mtable.append(mtr)
+
+    return mtable
+
+
diff --git a/scripts/omml_mathml2latex/core/pipeline.py b/scripts/omml_mathml2latex/core/pipeline.py
new file mode 100644
index 0000000..7cf8b8f
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/pipeline.py
@@ -0,0 +1,171 @@
+"""
+Pipeline orchestrator for the conversion process.
+
+This module implements the pipeline pattern, coordinating the execution
+of multiple stages in sequence to convert inputs to LaTeX.
+"""
+
+import time
+import logging
+from typing import List, Optional
+from .interfaces import Stage, ConversionContext
+
+logger = logging.getLogger(__name__)
+
+
+class ConversionPipeline:
+    """
+    Orchestrates conversion through multiple stages.
+
+    The pipeline executes stages in sequence, passing the context from
+    one stage to the next. Each stage can read from and write to the
+    shared context object.
+
+    Example:
+        >>> pipeline = (ConversionPipeline()
+        ...     .add_stage(InputStage())
+        ...     .add_stage(ValidationStage())
+        ...     .add_stage(ConversionStage())
+        ...     .add_stage(OutputStage()))
+        >>> context = ConversionContext(input_type='mathml', mathml='<math>...</math>')
+        >>> result = pipeline.process(context)
+    """
+
+    def __init__(self, enable_validation: bool = True, enable_timing: bool = True):
+        """
+        Initialize the pipeline.
+
+        Args:
+            enable_validation: Whether to validate stage preconditions before execution
+            enable_timing: Whether to record stage execution times
+        """
+        self.stages: List[Stage] = []
+        self.enable_validation = enable_validation
+        self.enable_timing = enable_timing
+
+    def add_stage(self, stage: Stage) -> 'ConversionPipeline':
+        """
+        Add a stage to the pipeline (fluent interface).
+
+        Args:
+            stage: The stage to add to the pipeline
+
+        Returns:
+            Self for method chaining
+
+        Raises:
+            TypeError: If stage is not an instance of Stage
+        """
+        if not isinstance(stage, Stage):
+            raise TypeError(f"Stage must be instance of Stage, got {type(stage)}")
+
+        self.stages.append(stage)
+        logger.debug(f"Added stage: {stage.name}")
+        return self
+
+    def process(self, context: ConversionContext) -> ConversionContext:
+        """
+        Execute all stages in order.
+
+        Args:
+            context: The initial conversion context
+
+        Returns:
+            Updated conversion context after all stages
+
+        Raises:
+            ValueError: If any stage validation fails
+            RuntimeError: If any stage processing fails
+        """
+        if not self.stages:
+            raise RuntimeError("Pipeline has no stages configured")
+
+        logger.info(f"Starting pipeline with {len(self.stages)} stages")
+        pipeline_start_time = time.time()
+
+        try:
+            for stage in self.stages:
+                context = self._execute_stage(stage, context)
+
+            # Record total pipeline time
+            pipeline_end_time = time.time()
+            context.total_time = pipeline_end_time - pipeline_start_time
+
+            logger.info(
+                f"Pipeline completed successfully in {context.total_time:.4f}s "
+                f"({len(self.stages)} stages)"
+            )
+            return context
+
+        except Exception as e:
+            logger.error(f"Pipeline failed: {e}", exc_info=True)
+            raise
+
+    def _execute_stage(self, stage: Stage, context: ConversionContext) -> ConversionContext:
+        """
+        Execute a single stage with validation and timing.
+
+        Args:
+            stage: The stage to execute
+            context: The current context
+
+        Returns:
+            Updated context after stage execution
+
+        Raises:
+            ValueError: If stage validation fails
+            RuntimeError: If stage execution fails
+        """
+        logger.debug(f"Executing stage: {stage.name}")
+
+        # Validate preconditions if enabled
+        if self.enable_validation:
+            if not stage.validate_input(context):
+                error_msg = f"Stage '{stage.name}' validation failed"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+
+        # Execute stage with timing
+        if self.enable_timing:
+            stage_start_time = time.time()
+            context = stage.process(context)
+            stage_end_time = time.time()
+            stage_time = stage_end_time - stage_start_time
+            context.record_stage_time(stage.name, stage_time)
+            logger.debug(f"Stage '{stage.name}' completed in {stage_time:.4f}s")
+        else:
+            context = stage.process(context)
+
+        return context
+
+    def clear(self) -> 'ConversionPipeline':
+        """
+        Remove all stages from the pipeline.
+
+        Returns:
+            Self for method chaining
+        """
+        self.stages.clear()
+        logger.debug("Pipeline cleared")
+        return self
+
+    def get_stages(self) -> List[Stage]:
+        """Get a copy of the stages list."""
+        return self.stages.copy()
+
+    def get_stage_count(self) -> int:
+        """Get the number of stages in the pipeline."""
+        return len(self.stages)
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        stage_names = [stage.name for stage in self.stages]
+        return f"ConversionPipeline(stages={stage_names})"
+
+    def __str__(self) -> str:
+        """Human-readable representation."""
+        if not self.stages:
+            return "ConversionPipeline (empty)"
+
+        stage_list = "\n  ".join([f"{i+1}. {stage.name}" for i, stage in enumerate(self.stages)])
+        return f"ConversionPipeline ({len(self.stages)} stages):\n  {stage_list}"
diff --git a/scripts/omml_mathml2latex/core/xslt_transformer.py b/scripts/omml_mathml2latex/core/xslt_transformer.py
new file mode 100644
index 0000000..8a2df11
--- /dev/null
+++ b/scripts/omml_mathml2latex/core/xslt_transformer.py
@@ -0,0 +1,138 @@
+"""
+OMML to MathML transformation using Microsoft's OMML2MML.XSL.
+
+This module provides XSLT-based transformation of OMML (Office Math Markup Language)
+to MathML (Mathematical Markup Language) using Microsoft's official OMML2MML.XSL stylesheet.
+Includes fallback to Python-based parser for edge cases.
+"""
+
+import os
+from typing import List, Optional
+from lxml import etree as ET
+
+
+def omml_to_mathml(omml_xml: str, xsl_path: str, timer: Optional['PerformanceTimer'] = None) -> str:
+    """Transform OMML XML string to MathML XML string using OMML2MML.XSL.
+
+    Args:
+        omml_xml: OMML XML string (raw equation markup from Word)
+        xsl_path: Path to OMML2MML.XSL transformation stylesheet
+        timer: Optional performance timer for instrumentation
+
+    Returns:
+        MathML XML string
+
+    Raises:
+        ValueError: If OMML XML is invalid
+        FileNotFoundError: If XSL file not found
+
+    Example:
+        >>> omml = '<m:oMath xmlns:m="..."><m:r><m:t>x</m:t></m:r></m:oMath>'
+        >>> mathml = omml_to_mathml(omml, 'OMML2MML.xsl')
+        >>> '<math' in mathml
+        True
+
+    Note:
+        Falls back to omml_to_mathml_fallback() if XSLT transformation fails.
+        This ensures robust handling even when XSL file is missing or malformed.
+
+        Performance: Uses cached XSL transformer for significant speedup
+        (avoids reparsing XSL file for every equation).
+    """
+    # Timing context helper
+    def _time(name):
+        if timer:
+            return timer.measure(name)
+        else:
+            from contextlib import contextmanager
+            @contextmanager
+            def nullcontext(enter_result=None):
+                yield enter_result
+            return nullcontext()
+
+    # Ensure required namespaces exist for fragments without declarations
+    with _time("xslt_namespace_preparation"):
+        xml_input = omml_xml.strip()
+        if "xmlns:m=" not in xml_input:
+            xml_input = (
+                "<root xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" "
+                "xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"
+                f"{xml_input}"
+                "</root>"
+            )
+
+    try:
+        with _time("xslt_xml_parsing"):
+            omml_doc = ET.fromstring(xml_input.encode("utf-8"))
+    except ET.XMLSyntaxError as e:
+        raise ValueError(f"Invalid OMML XML: {e}") from e
+
+    try:
+        # PERFORMANCE OPTIMIZATION: Use cached XSL transformer
+        # This avoids reparsing the XSL file for every equation (major speedup)
+        from .cache import XSLTransformerCache
+
+        with _time("xslt_cache_lookup"):
+            cache = XSLTransformerCache.get_instance()
+            transform = cache.get_transformer(xsl_path)
+
+        with _time("xslt_transformation"):
+            result_tree = transform(omml_doc)
+            result_bytes = ET.tostring(result_tree, encoding="utf-8", pretty_print=True)
+            return result_bytes.decode("utf-8")
+    except (ET.XSLTParseError, ET.XSLTApplyError, ET.XMLSyntaxError, OSError, ValueError, FileNotFoundError):
+        # Fallback to a minimal Python-based OMML→MathML converter for common cases
+        # Import here to avoid circular dependency
+        with _time("xslt_fallback_parser"):
+            from .omml_parser_core import omml_to_mathml_fallback
+            return omml_to_mathml_fallback(xml_input)
+
+
+def _local(tag: str) -> str:
+    """Extract local tag name without namespace.
+
+    Args:
+        tag: XML tag name, possibly with namespace prefix
+
+    Returns:
+        Local tag name without namespace
+
+    Example:
+        >>> _local('{http://www.w3.org/1998/Math/MathML}mi')
+        'mi'
+        >>> _local('mi')
+        'mi'
+    """
+    if "}" in tag:
+        return tag.split("}", 1)[1]
+    return tag
+
+
+def _text_content(node: ET._Element) -> str:
+    """Flatten text under a node (best-effort).
+
+    NOTE: Does NOT strip() to preserve space-only content like NBSP and regular spaces.
+    Spaces are semantically meaningful in mathematical notation.
+
+    Args:
+        node: XML element node
+
+    Returns:
+        Combined text content from node and all children
+
+    Example:
+        >>> from lxml import etree as ET
+        >>> elem = ET.fromstring('<mi>x</mi>')
+        >>> _text_content(elem)
+        'x'
+    """
+    texts: List[str] = []
+    if node.text:
+        texts.append(node.text)
+    for child in node:
+        texts.append(_text_content(child))
+        if child.tail:
+            texts.append(child.tail)
+    # IMPORTANT: Do not strip() here - spaces are meaningful!
+    # Space handling is done in the converter (e.g., _convert_spaces_to_latex)
+    return "".join(texts)
diff --git a/scripts/omml_mathml2latex/data/__init__.py b/scripts/omml_mathml2latex/data/__init__.py
new file mode 100644
index 0000000..758c825
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/__init__.py
@@ -0,0 +1,73 @@
+"""
+Data module containing symbol mappings, function definitions, and pattern definitions.
+
+This module provides centralized data structures for:
+- Unicode to LaTeX symbol mappings
+- Mathematical function definitions
+- Chemical element definitions
+- Common unit definitions
+- Regex patterns for text processing
+- Operator and symbol set definitions
+"""
+
+from .symbols import (
+    UNICODE_TO_LATEX,
+    ADDITIONAL_SYMBOL_REPLACEMENTS,
+    LATEX_COMMAND_REPLACEMENTS,
+    MATHJAX_UNSUPPORTED_TO_UNICODE,
+    REGIONAL_SYMBOL_PREFERENCES,
+    UNICODE_PASSTHROUGH,
+)
+from .patterns import (
+    SPACING_CLEANUP_PATTERNS,
+    DELIMITER_CLEANUP_PATTERNS,
+    SIMPLE_STRUCTURE_FIX_PATTERNS,
+    ASSIGNMENT_OPERATOR_REPLACEMENTS,
+)
+from .functions import (
+    MATH_FUNCTIONS,
+    CHEMICAL_ELEMENTS,
+)
+from .units import COMMON_UNITS
+from .operators import (
+    MATH_SYMBOLS_SET,
+    SUMMATION_SYMBOLS,
+    FONT_TO_LATEX,
+    LARGE_OPERATORS,
+    LARGE_OPERATORS_UNICODE,
+)
+from .chemistry_data import (
+    MULTI_CHAR_ELEMENTS,
+    SINGLE_CHAR_ELEMENTS,
+    ALL_CHEMICAL_ELEMENTS,
+    CHEMICAL_GROUPS,
+    CHEMISTRY_VARIABLES,
+    CHINESE_CHEMICAL_TERMS,
+)
+
+__all__ = [
+    "UNICODE_TO_LATEX",
+    "ADDITIONAL_SYMBOL_REPLACEMENTS",
+    "LATEX_COMMAND_REPLACEMENTS",
+    "MATHJAX_UNSUPPORTED_TO_UNICODE",
+    "REGIONAL_SYMBOL_PREFERENCES",
+    "UNICODE_PASSTHROUGH",
+    "SPACING_CLEANUP_PATTERNS",
+    "DELIMITER_CLEANUP_PATTERNS",
+    "SIMPLE_STRUCTURE_FIX_PATTERNS",
+    "ASSIGNMENT_OPERATOR_REPLACEMENTS",
+    "MATH_FUNCTIONS",
+    "CHEMICAL_ELEMENTS",
+    "COMMON_UNITS",
+    "MATH_SYMBOLS_SET",
+    "SUMMATION_SYMBOLS",
+    "FONT_TO_LATEX",
+    "LARGE_OPERATORS",
+    "LARGE_OPERATORS_UNICODE",
+    "MULTI_CHAR_ELEMENTS",
+    "SINGLE_CHAR_ELEMENTS",
+    "ALL_CHEMICAL_ELEMENTS",
+    "CHEMICAL_GROUPS",
+    "CHEMISTRY_VARIABLES",
+    "CHINESE_CHEMICAL_TERMS",
+]
diff --git a/scripts/omml_mathml2latex/data/chemistry_data.py b/scripts/omml_mathml2latex/data/chemistry_data.py
new file mode 100644
index 0000000..4e22fb8
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/chemistry_data.py
@@ -0,0 +1,95 @@
+"""
+Chemistry-related data for equation formatting.
+
+This module contains chemical elements, groups, and variables used for
+detecting and formatting chemistry equations.
+"""
+
+# Multi-character chemical elements (2 chars)
+# These are STRONG indicators - their presence alone triggers chemistry detection
+MULTI_CHAR_ELEMENTS = {
+    # Period 2
+    'He', 'Li', 'Be', 'Ne',
+    # Period 3
+    'Na', 'Mg', 'Al', 'Si', 'Cl', 'Ar',
+    # Period 4
+    'Ca', 'Sc', 'Ti', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn',
+    'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr',
+    # Period 5
+    'Rb', 'Sr', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd',
+    'In', 'Sn', 'Sb', 'Te', 'Xe',
+    # Period 6
+    'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd', 'Pm', 'Sm', 'Eu', 'Gd', 'Tb', 'Dy',
+    'Ho', 'Er', 'Tm', 'Yb', 'Lu', 'Hf', 'Ta', 'Re', 'Os', 'Ir', 'Pt',
+    'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Po', 'At', 'Rn',
+    # Period 7
+    'Fr', 'Ra', 'Ac', 'Th', 'Pa', 'Np', 'Pu', 'Am', 'Cm', 'Bk', 'Cf',
+    'Es', 'Fm', 'Md', 'No', 'Lr', 'Rf', 'Db', 'Sg', 'Bh', 'Hs', 'Mt', 'Ds',
+    'Rg', 'Cn', 'Nh', 'Fl', 'Mc', 'Lv', 'Ts', 'Og'
+}
+
+# Single-character chemical elements (1 char)
+# These need CONTEXT - only formatted as chemistry when chemistry equation is detected
+SINGLE_CHAR_ELEMENTS = {
+    'H',   # Hydrogen
+    'B',   # Boron
+    'C',   # Carbon
+    'N',   # Nitrogen
+    'O',   # Oxygen
+    'F',   # Fluorine
+    'P',   # Phosphorus
+    'S',   # Sulfur
+    'K',   # Potassium (but also common variable)
+    'V',   # Vanadium (but also common variable for volume)
+    'Y',   # Yttrium
+    'I',   # Iodine
+    'W',   # Tungsten
+    'U',   # Uranium
+}
+
+# All chemical elements (for formatting once chemistry is detected)
+ALL_CHEMICAL_ELEMENTS = MULTI_CHAR_ELEMENTS | SINGLE_CHAR_ELEMENTS
+
+# Chemical groups and radicals (strong indicators)
+CHEMICAL_GROUPS = {
+    'OH',   # Hydroxide
+    'SO',   # Sulfite/Sulfate (partial)
+    'NO',   # Nitrite/Nitrate (partial)
+    'CO',   # Carbonyl/Carbonate (partial)
+    'NH',   # Amine/Ammonium (partial)
+    'CH',   # Methine/Hydrocarbon (partial)
+    'PO',   # Phosphate (partial)
+    'ClO',  # Chlorate (partial)
+}
+
+# Common chemistry variables (should stay italic even in chemistry equations)
+# These are NOT chemical elements, they're variables used in chemistry
+# NOTE: Keep this list minimal to avoid conflicts with fragmented elements
+CHEMISTRY_VARIABLES = {
+    'c',   # Concentration
+    # NOTE: 'n' removed - conflicts with fragmented Mn (Manganese)
+    # NOTE: 'M' removed - conflicts with fragmented Mn, Mg (Magnesium)
+    'p',   # Pressure (but P is Phosphorus!)
+    'T',   # Temperature
+    'm',   # Mass
+    'R',   # Gas constant
+    'E',   # Energy (but E is also used in chemistry)
+    # NOTE: 'V' removed - conflicts with V (Vanadium)
+    # NOTE: 'K' removed - conflicts with K (Potassium)
+    # Generic math variables
+    'x', 'y', 'z',
+    'a', 'b', 'd', 'q',
+}
+
+# Chinese chemical conditions/terms
+CHINESE_CHEMICAL_TERMS = {
+    '高温',    # High temperature
+    '加热',    # Heating
+    '催化剂',  # Catalyst
+    '点燃',    # Ignition
+    '电解',    # Electrolysis
+    '控温',    # Temperature control
+    '加压',    # Pressurization
+    '光照',    # Light
+    '通电',    # Electrify
+}
diff --git a/scripts/omml_mathml2latex/data/functions.py b/scripts/omml_mathml2latex/data/functions.py
new file mode 100644
index 0000000..71a7e10
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/functions.py
@@ -0,0 +1,71 @@
+"""
+Mathematical functions and chemical elements definitions.
+
+Contains:
+- MATH_FUNCTIONS: Set of 60+ recognized mathematical functions
+- CHEMICAL_ELEMENTS: Set of 118 chemical elements
+"""
+
+# Comprehensive function database
+MATH_FUNCTIONS = {
+    # Trigonometric functions
+    'sin', 'cos', 'tan', 'sec', 'csc', 'cot',
+    'sinh', 'cosh', 'tanh', 'sech', 'csch', 'coth',
+    'arcsin', 'arccos', 'arctan', 'arcsec', 'arccsc', 'arccot',
+    'asin', 'acos', 'atan', 'asec', 'acsc', 'acot',
+    'arcsinh', 'arccosh', 'arctanh', 'arcsech', 'arccsch', 'arccoth',
+    'asinh', 'acosh', 'atanh', 'asech', 'acsch', 'acoth',
+
+    # Logarithmic and exponential
+    'log', 'ln', 'lg', 'exp', 'log2', 'log10',
+
+    # Limits and supremum/infimum
+    'lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min',
+
+    # Linear algebra
+    'det', 'dim', 'ker', 'rank', 'trace', 'tr', 'span', 'null',
+    'col', 'row', 'diag', 'adj',
+
+    # Number theory
+    'gcd', 'lcm', 'mod', 'rem',
+
+    # Probability and statistics
+    'Pr', 'Var', 'Cov', 'Corr', 'Std', 'Med',
+
+    # Calculus and analysis
+    'grad', 'div', 'curl', 'rot', 'arg', 'Im', 'Re',
+    'sgn', 'sign', 'abs', 'floor', 'ceil', 'round',
+
+    # Special functions
+    'erf', 'erfc', 'gamma', 'Gamma', 'zeta', 'beta', 'Beta',
+    'sinc', 'jinc',
+
+    # Hyperbolic and inverse hyperbolic
+    'arsinh', 'arcosh', 'artanh', 'arsech', 'arcsch', 'arcoth',
+
+    # Other common functions
+    'deg', 'rad', 'hom', 'end', 'aut', 'id',
+}
+
+# Chemical elements for special handling
+CHEMICAL_ELEMENTS = {
+    'H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne',
+    'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar', 'K', 'Ca',
+    'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn',
+    'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr', 'Rb', 'Sr', 'Y', 'Zr',
+    'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn',
+    'Sb', 'Te', 'I', 'Xe', 'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd',
+    'Pm', 'Sm', 'Eu', 'Gd', 'Tb', 'Dy', 'Ho', 'Er', 'Tm', 'Yb',
+    'Lu', 'Hf', 'Ta', 'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg',
+    'Tl', 'Pb', 'Bi', 'Po', 'At', 'Rn', 'Fr', 'Ra', 'Ac', 'Th',
+    'Pa', 'U', 'Np', 'Pu', 'Am', 'Cm', 'Bk', 'Cf', 'Es', 'Fm',
+    'Md', 'No', 'Lr', 'Rf', 'Db', 'Sg', 'Bh', 'Hs', 'Mt', 'Ds',
+    'Rg', 'Cn', 'Nh', 'Fl', 'Mc', 'Lv', 'Ts', 'Og'
+}
+
+# Mathematical set notation symbols that should be wrapped in \mathrm{}
+MATHEMATICAL_SETS = {
+    'N', 'Z', 'Q', 'R', 'C',  # Number sets (Natural, Integer, Rational, Real, Complex)
+    'A', 'B', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'O', 'P', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',  # Generic sets
+}
diff --git a/scripts/omml_mathml2latex/data/operators.py b/scripts/omml_mathml2latex/data/operators.py
new file mode 100644
index 0000000..1ac1ec0
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/operators.py
@@ -0,0 +1,65 @@
+"""
+Operator and symbol set definitions for MathML to LaTeX conversion.
+
+This module provides:
+- Mathematical symbol sets for symbol detection
+- Summation symbol mappings
+- Font to LaTeX command mappings
+- Large operator definitions (Unicode versions)
+"""
+
+# Mathematical symbol set for symbol detection
+MATH_SYMBOLS_SET = {
+    "↑", "↓", "→", "←", "↔", "×", "⋅", "·", "÷", "∕", "−",  # Added U+2212 MINUS SIGN
+    "∩", "∪", "⊂", "⊃", "⊆", "⊇", "∈", "∉", "∋", "∌",
+    "≤", "≥", "≠", "≈", "≅", "≡", "≢", "∼", "≃", "≄",
+    "≜", "≝", "≞", "≟", "≦", "≧", "≨", "≩", "≲", "≳", "≴", "≵", "≶", "≷", "≸", "≹",
+    "≺", "≻", "⪯", "⪰", "∝", "⊥",
+    "∥", "∦", "±", "∓", "∗", "∘", "∙", "√", "∞",
+    "∂", "∇", "∆", "∫", "∬", "∭", "∮", "∯", "∰",
+    "∑", "∏", "∐", "⋃", "⋂", "⋁", "⋀", "⨁", "⨂", "⨄",
+    "∀", "∃", "∄", "⊢", "⊣", "⊤", "⊥", "¬", "∧", "∨",
+    "⟨", "⟩", "⌊", "⌋", "⌈", "⌉", "⏞", "⏟", "∠", "∁"
+}
+
+# Summation symbols for specific processing
+SUMMATION_SYMBOLS = {
+    '∑': 'sum',
+    '∏': 'prod',
+    '∫': 'integral',
+    'Σ': 'sum',
+    'Π': 'prod'
+}
+
+# Font family to LaTeX command mapping
+FONT_TO_LATEX = {
+    'Times New Roman': 'mathrm',   # Roman/upright text
+    'Times': 'mathrm',             # Times font variant
+    'Cambria Math': None,          # Default math font (no special formatting)
+    'Cambria': None,               # Cambria variant
+    'Arial': 'mathsf',             # Sans-serif
+    'Helvetica': 'mathsf',         # Helvetica sans-serif
+    'Courier New': 'mathtt',       # Typewriter/monospace
+    'Courier': 'mathtt',           # Courier variant
+    'Computer Modern': None,       # LaTeX default math font
+    'Latin Modern Math': None,     # Modern LaTeX math font
+}
+
+# Large operators that should use \limits in display mode (LaTeX commands)
+LARGE_OPERATORS = [
+    "\\sum", "\\prod", "\\int", "\\iint", "\\iiint", "\\oint",
+    "\\bigcup", "\\bigcap", "\\bigvee", "\\bigwedge",
+    "\\bigoplus", "\\bigotimes", "\\biguplus", "\\coprod",
+    "\\lim", "\\limsup", "\\liminf", "\\sup", "\\inf",
+    "\\max", "\\min"
+]
+
+# Unicode large operators for detection
+LARGE_OPERATORS_UNICODE = [
+    "∑", "Σ",        # Summation
+    "∏", "Π",        # Product
+    "∫",             # Integral
+    "⋃", "⋂",        # Union, Intersection
+    "⋁", "⋀",        # Logical OR, AND
+    "⨁", "⨂", "⨄",  # Direct sum, tensor product, union
+]
diff --git a/scripts/omml_mathml2latex/data/patterns.py b/scripts/omml_mathml2latex/data/patterns.py
new file mode 100644
index 0000000..c7cb157
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/patterns.py
@@ -0,0 +1,168 @@
+"""
+Pattern-based replacements and regex patterns for LaTeX processing.
+
+This module provides regex patterns for:
+- Spacing cleanup and normalization
+- Delimiter marker cleanup
+- LaTeX structure fixes
+- Assignment operator normalization
+"""
+
+# Assignment operator normalization (line 5529-5530)
+ASSIGNMENT_OPERATOR_REPLACEMENTS = [
+    ('∶ =', ':='),   # U+2236 RATIO with space and equals
+    (': =', ':='),    # Colon with space and equals
+]
+
+# ========================================================================
+# Pattern-Based Replacements (Regex Patterns)
+# ========================================================================
+
+# Spacing cleanup patterns (consolidated from lines 1289, 1292-1293, 1296, 5566-5567)
+SPACING_CLEANUP_PATTERNS = [
+    # Reduce excessive spaces (line 1289)
+    (r' {3,}', '  ', 'Reduce 3+ spaces to double space'),
+
+    # Remove spaces before delimiters (lines 1292-1293)
+    (r'\\left\s+\\{', r'\\left\\{', 'Remove space before left brace'),
+    (r'\\right\s+\\}', r'\\right\\}', 'Remove space before right brace'),
+
+    # Remove space between command and braces (line 1296)
+    (r'\\([a-zA-Z]+)\s+\{', r'\\\1{', 'Remove space between command and opening brace'),
+
+    # Add space after set operations when not followed by braces (lines 5566-5567)
+    (r'\\cap(?![{])', r'\\cap ', 'Add space after \\cap'),
+    (r'\\cup(?![{])', r'\\cup ', 'Add space after \\cup'),
+]
+
+# Delimiter marker cleanup patterns (consolidated from lines 1491-1502, 5433-5447)
+# These clean up __DELIM__ markers left from OMML processing
+DELIMITER_CLEANUP_PATTERNS = [
+    # Paired delimiters with content (line 5433)
+    (r'__DELIM__(.+?)__DELIM__', r'\1', 'Remove paired __DELIM__ markers'),
+
+    # Corrupted paired delimiters (lines 5436-5438)
+    (r'__DELIM_(.+?)__DELIM_', r'\1', 'Remove corrupted paired markers (single underscore)'),
+    (r'__DELIM__(.+?)__DELIM_', r'\1', 'Remove mixed paired markers (full+corrupted)'),
+    (r'__DELIM_(.+?)__DELIM__', r'\1', 'Remove mixed paired markers (corrupted+full)'),
+
+    # Orphaned markers with single character (lines 5441-5444)
+    (r'__DELIM__(.)', r'\1', 'Remove orphaned opening marker with character'),
+    (r'(.)__DELIM__', r'\1', 'Remove orphaned closing marker with character'),
+    (r'__DELIM_(.)', r'\1', 'Remove corrupted opening marker with character'),
+    (r'(.)__DELIM_', r'\1', 'Remove corrupted closing marker with character'),
+
+    # Standalone markers (lines 5445-5447)
+    (r'__DELIM__', '', 'Remove any remaining full markers'),
+    (r'__DELIM_', '', 'Remove any remaining corrupted markers'),
+    (r'_DELIM__', '', 'Remove reverse corrupted markers'),
+
+    # Specific delimiter characters (lines 1491-1497)
+    (r'__DELIM[_]*\([_]*', '(', 'Clean opening paren markers'),
+    (r'[_]*\)__DELIM[_]*', ')', 'Clean closing paren markers'),
+    (r'__DELIM[_]*\[[_]*', '[', 'Clean opening bracket markers'),
+    (r'[_]*\]__DELIM[_]*', ']', 'Clean closing bracket markers'),
+    (r'__DELIM[_]*\{[_]*', '{', 'Clean opening brace markers'),
+    (r'[_]*\}__DELIM[_]*', '}', 'Clean closing brace markers'),
+    (r'__DELIM[_]*\|[_]*', '|', 'Clean pipe markers (absolute value)'),
+
+    # Fragments (lines 1500-1502)
+    (r'LIM__', '', 'Remove LIM__ fragment'),
+    (r'LIM_', '', 'Remove LIM_ fragment'),
+]
+
+# Simple structure fix patterns (these don't need complex logic)
+SIMPLE_STRUCTURE_FIX_PATTERNS = [
+    # Convert \overset{\dot}{X} to \dot{X} (lines 5570-5571)
+    (r'\\overset\{\\dot\}\{([a-zA-Z0-9])\}', r'\\dot{\1}', 'Simplify dot overset to \\dot command'),
+    (r'\\overset\{\.\}\{([a-zA-Z0-9])\}', r'\\dot{\1}', 'Simplify literal dot overset to \\dot command'),
+
+    # Fix array column specification (line 5574)
+    (r'\\begin\{array\{([^}]+)\}\}', r'\\begin{array}{\1}', 'Fix array column specification braces'),
+
+    # Convert incorrect fraction to reaction arrow (line 5579)
+    (r'\\dfrac\{\\underline\{([^}]+)\}\}\{\}', r'\\xlongequal[\\quad]{\1}', 'Convert underline fraction to reaction arrow'),
+
+    # Fix nested underset with underbrace (lines 5744-5747)
+    (r'\\underset\{([^{}]+)\}\{\\underset\{\\underbrace\}\{([^{}]+)\}\}', r'\\underbrace{\2}_{\1}', 'Fix nested underset underbrace pattern'),
+
+    # Fix overset with \hat over numbers to \overline (lines 5753-5756)
+    (r'\\overset\{\\hat\}\{(\\mathrm\{)?(\d+)\}?\}', r'\\overline{\2}', 'Convert hat overset to overline for numbers'),
+
+    # Fix underset with textemdash patterns (lines 5802-5823)
+    (r'\\underset\{\\textemdash\}\{\\underset\{\\textemdash\}\{([^{}]+)\}\}', r'\\underline{\\underline{\1}}', 'Convert nested textemdash underset to double underline'),
+    (r'\\underset\{\\textemdash\}\{\\underline\{([^{}]+)\}\}', r'\\underline{\\underline{\1}}', 'Convert textemdash underset with underline to double underline'),
+    (r'\\underset\{\\textemdash\}\{([^{}]+)\}', r'\\underline{\1}', 'Convert textemdash underset to underline'),
+]
+
+# ========================================================================
+# Additional Symbol Classification Data
+# ========================================================================
+
+# Mathematical symbols for classification
+MATH_SYMBOLS_SET = {
+    "↑", "↓", "→", "←", "↔", "×", "⋅", "·", "÷", "∕", "−",  # Added U+2212 MINUS SIGN
+    "∩", "∪", "⊂", "⊃", "⊆", "⊇", "∈", "∉", "∋", "∌",
+    "≤", "≥", "≠", "≈", "≅", "≡", "≢", "∼", "≃", "≄",
+    "≜", "≝", "≞", "≟", "≦", "≧", "≨", "≩", "≲", "≳", "≴", "≵", "≶", "≷", "≸", "≹",
+    "≺", "≻", "⪯", "⪰", "∝", "⊥",
+    "∥", "∦", "±", "∓", "∗", "∘", "∙", "√", "∞",
+    "∂", "∇", "∆", "∫", "∬", "∭", "∮", "∯", "∰",
+    "∑", "∏", "∐", "⋃", "⋂", "⋁", "⋀", "⨁", "⨂", "⨄",
+    "∀", "∃", "∄", "⊢", "⊣", "⊤", "⊥", "¬", "∧", "∨",
+    "⟨", "⟩", "⌊", "⌋", "⌈", "⌉", "⏞", "⏟", "∠", "∁"
+}
+
+# Summation symbols for specific processing
+SUMMATION_SYMBOLS = {
+    '∑': 'sum',
+    '∏': 'prod',
+    '∫': 'integral',
+    'Σ': 'sum',
+    'Π': 'prod'
+}
+
+# Font family to LaTeX command mapping
+FONT_TO_LATEX = {
+    'Times New Roman': 'mathrm',   # Roman/upright text
+    'Times': 'mathrm',             # Times font variant
+    'Cambria Math': None,          # Default math font (no special formatting)
+    'Cambria': None,               # Cambria variant
+    'Arial': 'mathsf',             # Sans-serif
+    'Helvetica': 'mathsf',         # Helvetica sans-serif
+    'Courier New': 'mathtt',       # Typewriter/monospace
+    'Courier': 'mathtt',           # Courier variant
+    'Computer Modern': None,       # LaTeX default math font
+    'Latin Modern Math': None,     # Modern LaTeX math font
+}
+
+# Large operators that should use \limits in display mode
+LARGE_OPERATORS = [
+    "\\sum", "\\prod", "\\int", "\\iint", "\\iiint", "\\oint",
+    "\\bigcup", "\\bigcap", "\\bigvee", "\\bigwedge",
+    "\\bigoplus", "\\bigotimes", "\\biguplus", "\\coprod",
+    "\\lim", "\\limsup", "\\liminf", "\\sup", "\\inf",
+    "\\max", "\\min"
+]
+
+# Unicode large operators for detection
+LARGE_OPERATORS_UNICODE = [
+    "∑", "Σ",        # Summation
+    "∏", "Π",        # Product
+    "∫",             # Integral
+    "∮",             # Contour integral
+    "∬",             # Double integral
+    "∭",             # Triple integral
+    "⋂",             # Intersection
+    "⋃",             # Union
+    "⋁",             # Logical OR
+    "⋀",             # Logical AND
+    "⊕",             # Direct sum
+    "⊗",             # Tensor product
+    "⊎",             # Multiset sum
+    "⨁",             # Large direct sum
+    "⨂",             # Large tensor product
+    "⨃",             # Large union with plus
+    "⨆",             # Large square union
+    "⨄",             # Large union with plus
+]
diff --git a/scripts/omml_mathml2latex/data/symbols.py b/scripts/omml_mathml2latex/data/symbols.py
new file mode 100644
index 0000000..a366457
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/symbols.py
@@ -0,0 +1,689 @@
+"""
+Unicode to LaTeX symbol mappings for OMML/MathML to LaTeX conversion.
+
+This module provides comprehensive Unicode symbol to LaTeX command mappings
+for mathematical notation, chemical symbols, and special characters.
+
+Architecture
+============
+
+This module defines three primary dictionaries that work together to handle
+symbol conversion with MathJax compatibility:
+
+1. UNICODE_TO_LATEX (dict[str, str])
+   - Maps Unicode symbols → LaTeX commands
+   - Used for symbols that SHOULD be converted to LaTeX
+   - Contains ~430 symbol mappings organized by category:
+     * Greek letters (lowercase and uppercase)
+     * Mathematical operators and relations
+     * Arrows and directional symbols
+     * Set theory and logic symbols
+     * Calculus and analysis symbols (basic integrals)
+     * Chemistry symbols and arrows
+     * Geometric shapes and special characters
+
+2. UNICODE_PASSTHROUGH (set[str])
+   - Unicode symbols that should NEVER be converted to LaTeX
+   - These symbols are kept as-is for MathJax compatibility
+   - Contains ~64 advanced mathematical symbols whose LaTeX commands
+     are not supported or render poorly in MathJax
+   - Examples: advanced integrals (∯, ∰), special operators (⊛, ⊚)
+   - IMPORTANT: Symbols in this set are NOT in UNICODE_TO_LATEX
+
+3. MATHJAX_UNSUPPORTED_TO_UNICODE (dict[str, str])
+   - Inverse of UNICODE_PASSTHROUGH: LaTeX command → Unicode
+   - Used in post-processing to convert unsupported LaTeX back to Unicode
+   - Should be exact inverse of symbols in UNICODE_PASSTHROUGH
+
+Conversion Flow
+===============
+
+Input Unicode Symbol
+    ↓
+Is it in UNICODE_PASSTHROUGH?
+    ├─ YES → Keep as Unicode (don't convert)
+    └─ NO  → Look up in UNICODE_TO_LATEX
+         ↓
+         Convert to LaTeX command
+         ↓
+         Post-process: If command in MATHJAX_UNSUPPORTED_TO_UNICODE
+         ↓
+         Convert back to Unicode for MathJax rendering
+
+Design Principles
+=================
+
+1. **No Overlap**: Symbols should be in EITHER UNICODE_TO_LATEX OR
+   UNICODE_PASSTHROUGH, never both.
+
+2. **Consistency**: MATHJAX_UNSUPPORTED_TO_UNICODE values must exactly
+   match UNICODE_PASSTHROUGH contents (they are inverses).
+
+3. **Inverse Mapping**: For any symbol in UNICODE_PASSTHROUGH, if there
+   exists a LaTeX command in MATHJAX_UNSUPPORTED_TO_UNICODE, the command
+   names must be consistent.
+
+4. **Special Patterns**:
+   - Empty braces ({}) only for radical symbols (√, ∛, ∜)
+   - Placeholders (__DDOT__, __DDDOT__) only for accent detection
+   - Regional preferences handled separately (see REGIONAL_SYMBOL_PREFERENCES)
+
+Testing
+=======
+
+Symbol dictionary integrity is validated by:
+- tests/test_symbol_dictionaries.py
+
+This test suite ensures:
+- No duplicate keys in any dictionary
+- No overlap between UNICODE_TO_LATEX and UNICODE_PASSTHROUGH
+- Consistency between MATHJAX_UNSUPPORTED and UNICODE_PASSTHROUGH
+- Valid mappings and inverse consistency
+"""
+
+# Centralized symbol mappings to eliminate duplication
+UNICODE_TO_LATEX = {
+    # Greek letters (lowercase)
+    "α": "\\alpha", "β": "\\beta", "γ": "\\gamma", "δ": "\\delta",
+    "ε": "\\varepsilon", "ζ": "\\zeta", "η": "\\eta", "θ": "\\theta",
+    "ι": "\\iota", "κ": "\\kappa", "λ": "\\lambda", "μ": "\\mu",
+    "ν": "\\nu", "ξ": "\\xi", "ο": "\\omicron", "π": "\\pi",
+    "ρ": "\\rho", "σ": "\\sigma", "τ": "\\tau", "υ": "\\upsilon",
+    "φ": "\\varphi", "χ": "\\chi", "ψ": "\\psi", "ω": "\\omega",
+    "ϵ": "\\epsilon", "ϑ": "\\vartheta", "ϕ": "\\phi", "ϱ": "\\varrho",
+    "ϖ": "\\varpi", "ς": "\\varsigma", "ϰ": "\\varkappa",
+
+    # Greek letters (uppercase)
+    "Α": "A", "Β": "B", "Γ": "\\Gamma", "Δ": "\\Delta",
+    "Ε": "E", "Ζ": "Z", "Η": "H", "Θ": "\\Theta",
+    "Ι": "I", "Κ": "K", "Λ": "\\Lambda", "Μ": "M",
+    "Ν": "N", "Ξ": "\\Xi", "Ο": "O", "Π": "\\Pi",
+    "Ρ": "P", "Σ": "\\Sigma", "Τ": "T", "Υ": "\\Upsilon",
+    "Φ": "\\Phi", "Χ": "X", "Ψ": "\\Psi", "Ω": "\\Omega",
+
+    # Mathematical constants and special symbols
+    "∞": "\\infty", "∅": "\\emptyset", "∇": "\\nabla", "∂": "\\partial",
+    "ℏ": "\\hbar", "ℓ": "\\ell", "∠": "\\angle", "∁": "\\complement",
+    "℘": "\\wp", "ℵ": "\\aleph", "℧": "\\mho",
+
+    # Geometric symbols
+    "△": "\\triangle", "▲": "\\blacktriangle", "▽": "\\triangledown",
+    "◁": "\\triangleleft", "▷": "\\triangleright", "◀": "\\blacktriangleleft",
+    "▶": "\\blacktriangleright",
+
+    # Square symbols (comprehensive coverage)
+    "□": "\\square",           # U+25A1 WHITE SQUARE
+    "■": "\\blacksquare",      # U+25A0 BLACK SQUARE
+    "▪": "\\blacksquare",      # U+25AA BLACK SMALL SQUARE
+    "▫": "\\square",           # U+25AB WHITE SMALL SQUARE
+    "◻": "\\square",           # U+25FB WHITE MEDIUM SQUARE
+    "◼": "\\blacksquare",      # U+25FC BLACK MEDIUM SQUARE
+    "◽": "\\square",           # U+25FD WHITE MEDIUM SMALL SQUARE
+    "◾": "\\blacksquare",      # U+25FE BLACK MEDIUM SMALL SQUARE
+
+    # Other geometric shapes
+    # NOTE: ▱ (parallelogram) is in UNICODE_PASSTHROUGH
+    "◇": "\\diamond", "◆": "\\blacklozenge", "○": "\\circ", "●": "\\bullet",
+    "☆": "\\star", "★": "\\bigstar", "◯": "\\bigcirc",
+
+    # Temperature symbols
+    "℃": "^\\circ\\mathrm{C}", "℉": "^\\circ\\mathrm{F}",
+
+    # Basic operators and punctuation
+    "∶": ":",  # U+2236 RATIO to colon for assignment operators
+    "§": "\\S", "†": "\\dagger", "‵": "\\backprime",
+    "`": "\\backprime",  # U+0060 GRAVE ACCENT (backtick) used as backprime in equations
+    "―": "\\textemdash",  # U+2015 horizontal bar
+
+    # Multiplication and division
+    "×": "\\times", "⋅": "\\cdot", "·": "\\cdot", "÷": "\\div", "∕": "/", "⁄": "/",
+    "//": "/ /",  # Double slash with spacing
+    "⧸": "/",  # U+29F8 BIG SOLIDUS (used in \not patterns but also standalone)
+
+    # Mathematical script letters
+    "ℑ": "\\Im",  # Imaginary part (Fraktur I)
+    "ℜ": "\\Re",  # Real part (Fraktur R)
+
+    # Arrows (basic)
+    "→": "\\rightarrow", "←": "\\leftarrow", "↔": "\\leftrightarrow",
+    "⇒": "\\Longrightarrow", "⇐": "\\Longleftarrow", "⇔": "\\Longleftrightarrow",
+    "⟹": "\\Longrightarrow", "⟸": "\\Longleftarrow", "⟺": "\\Longleftrightarrow",
+    "⟷": "\\longleftrightarrow",
+    "↑": "\\uparrow", "↓": "\\downarrow", "⇑": "\\Uparrow", "⇓": "\\Downarrow",
+    "↕": "\\updownarrow", "⇕": "\\Updownarrow",
+
+    # Arrows (diagonal)
+    "↗": "\\nearrow", "↘": "\\searrow", "↙": "\\swarrow", "↖": "\\nwarrow",
+    "⤴": "\\nwarrow", "⤵": "\\searrow", "⤡": "\\swarrow", "⤢": "\\nearrow",
+
+    # Arrows (special forms)
+    # NOTE: Some special arrows (↤ mapsfrom, ⟻ longmapsfrom, ⇜ leftsquigarrow, ⇝ rightsquigarrow) are in UNICODE_PASSTHROUGH
+    "↦": "\\mapsto",
+    "⟼": "\\longmapsto",
+    "↪": "\\hookrightarrow", "↩": "\\hookleftarrow",
+    "⤷": "\\hookrightarrow", "⤶": "\\hookleftarrow",
+    "↬": "\\looparrowright", "↫": "\\looparrowleft",
+    "⇀": "\\rightharpoonup", "↼": "\\leftharpoonup",
+    "↢": "\\leftarrowtail", "↣": "\\rightarrowtail",
+    "↰": "\\Lsh", "↱": "\\Rsh",
+
+    # Arrows (negated)
+    "↛": "\\nrightarrow", "↚": "\\nleftarrow", "⇏": "\\nRightarrow", "⇍": "\\nLeftarrow",
+    "↮": "\\nleftrightarrow", "⇎": "\\nLeftrightarrow",
+
+    # Set theory and logic
+    # Set membership
+    "∈": "\\in", "∉": "\\notin", "∋": "\\ni", "∌": "\\notni",
+    "⋲": "\\in", "⋳": "\\ni", "⋴": "\\in", "⋵": "\\ni",
+    "⋶": "\\in", "⋷": "\\ni", "⋸": "\\pitchfork", "⋹": "\\ltimes",
+
+    # Subset and superset relations (basic)
+    "⊂": "\\subset", "⊃": "\\supset",
+    "⊆": "\\subseteq", "⊇": "\\supseteq",
+    "⊄": "\\not\\subset", "⊅": "\\not\\supset",
+    "⊈": "\\nsubseteq", "⊉": "\\nsupseteq",
+    "⊊": "\\subsetneq", "⊋": "\\supsetneq",
+
+    # Subset and superset relations (extended with double lines)
+    "⫅": "\\subseteqq", "⫆": "\\supseteqq",  # U+2AC5, U+2AC6 subset/supset with double equals
+    "⫋": "\\subsetneqq", "⫌": "\\supsetneqq",  # U+2ACB, U+2ACC not equal variant with double
+    "⫏": "\\sqsubset", "⫐": "\\sqsupset",  # U+2ACF, U+2AD0 square subset/supset
+    "⫑": "\\sqsubseteq", "⫒": "\\sqsupseteq",  # U+2AD1, U+2AD2 square subset/supset equal
+    "⊏": "\\sqsubset", "⊐": "\\sqsupset",  # U+228F, U+2290 square variants
+    "⊑": "\\sqsubseteq", "⊒": "\\sqsupseteq",  # U+2291, U+2292 square equal variants
+
+    # Set operations
+    # NOTE: Some symbols like ⊌ (dotcup), ⊍ (cupdot) are in UNICODE_PASSTHROUGH
+    "∪": "\\cup", "∩": "\\cap", "∖": "\\setminus",
+    "⊎": "\\uplus", "⊔": "\\sqcup", "⊓": "\\sqcap",
+    "⨃": "\\Cup", "⨄": "\\biguplus", "⨅": "\\bigsqcap", "⨆": "\\bigsqcup",
+    "⩁": "\\Cup", "⩂": "\\Cap", "⩃": "\\cupdot",
+
+    # Logical operators
+    "∧": "\\wedge", "∨": "\\vee", "¬": "\\neg", "⊕": "\\oplus",
+    "⊗": "\\otimes", "⊙": "\\odot", "⊖": "\\ominus", "⊘": "\\oslash",
+    "∀": "\\forall", "∃": "\\exists", "∄": "\\nexists",
+    "⊤": "\\top", "⊥": "\\perp", "⊢": "\\vdash", "⊣": "\\dashv",
+    "⊨": "\\models", "⊭": "\\not\\models",
+    "∴": "\\therefore", "∵": "\\because",
+    "⋏": "\\curlywedge", "⋎": "\\curlyvee",
+
+    # Additional logical symbols
+    "⊩": "\\Vdash", "⊪": "\\Vvdash", "⊫": "\\VDash", "⊬": "\\nvdash",
+    "⊯": "\\nVdash", "⊮": "\\nVDash", "∎": "\\qed", "◊": "\\lozenge",
+    "≐": "\\doteq", "≑": "\\doteqdot", "≒": "\\fallingdotseq", "≓": "\\risingdotseq",
+
+    # Relations
+    # Equality and equivalence
+    "≈": "\\approx", "≅": "\\cong", "≡": "\\equiv", "≢": "\\not\\equiv",
+    "≠": "\\neq", "≁": "\\not\\sim", "≄": "\\nsim", "≇": "\\ncong",
+    "~": "\\sim",  # ASCII tilde (U+007E) - similarity operator
+    "∼": "\\sim", "≃": "\\simeq", "≂": "\\eqsim", "≊": "\\approxeq",
+
+    # Inequality relations (basic)
+    # NOTE: Triple relations ⋘ (lll), ⋙ (ggg) are in UNICODE_PASSTHROUGH
+    "≤": "\\leqslant", "≥": "\\geqslant", "≮": "\\nless", "≯": "\\ngtr",
+    "≰": "\\nleq", "≱": "\\ngeq", "≪": "\\ll", "≫": "\\gg",
+
+    # Inequality relations (extended)
+    "≦": "\\leqq", "≧": "\\geqq", "≨": "\\lneqq", "≩": "\\gneqq",
+    "⩽": "\\leqslant", "⩾": "\\geqslant", "⩿": "\\gneq",
+    "≶": "\\lessgtr", "≷": "\\gtrless", "≸": "\\not\\lessgtr", "≹": "\\not\\gtrless",
+    # NOTE: Advanced comparison symbols (⪋ lesseqgtr, ⪌ gtreqless, ⪅ lessapprox, etc.) are in UNICODE_PASSTHROUGH
+    "⪇": "\\lneq", "⪈": "\\gneq",
+
+    # Precedence and succession
+    # NOTE: Advanced precedence symbols (⋞ curlyeqprec, ⋟ curlyeqsucc, ⪷ precapprox, ⪸ succapprox) are in UNICODE_PASSTHROUGH
+    "≺": "\\prec", "≻": "\\succ", "⪯": "\\preceq", "⪰": "\\succeq",
+    "⪳": "\\preceqq", "⪴": "\\succeqq",
+    "⪵": "\\precneqq", "⪶": "\\succneqq",
+
+    # Similarity and comparison
+    "≲": "\\lesssim", "≳": "\\gtrsim", "≴": "\\not\\lesssim", "≵": "\\not\\gtrsim",
+    "∝": "\\propto", "∥": "\\parallel", "∦": "\\nparallel",
+    "≍": "\\asymp", "≎": "\\Bumpeq", "≏": "\\bumpeq",
+    "∽": "\\backsim", "⋍": "\\backsimeq",  # U+22CD REVERSED TILDE EQUALS
+    "≌": "\\cong",  # U+224C ALL EQUAL TO (commonly used for congruence)
+    "⊲": "\\lhd", "⊳": "\\rhd",
+    "⌢": "\\frown", "⌣": "\\smile",
+
+    # Special equality symbols
+    # NOTE: Some special equality symbols (≔ coloneqq, ≕ eqqcolon, ≘ arceq, ≙ wedgeq, ≚ veeeq) are in UNICODE_PASSTHROUGH
+    "≜": "\\triangleq", "≝": "\\overset{\\mathrm{def}}{=}", "≞": "\\overset{\\mathrm{m}}{=}",
+    "≟": "\\overset{?}{=}", "≗": "\\circeq", "≖": "\\eqcirc",
+
+    # Calculus and analysis
+    # Integrals
+    # NOTE: Many advanced integral symbols (∯, ∰, ∱, etc.) are in UNICODE_PASSTHROUGH
+    # for direct MathJax rendering, so they are NOT listed here
+    "∫": "\\int", "∬": "\\iint", "∭": "\\iiint", "⨌": "\\iiiint",
+    "∮": "\\oint",
+
+    # Differentials and operators
+    "∆": "\\Delta", "∂": "\\partial", "∇": "\\nabla",
+    "∝": "\\propto", "∞": "\\infty",
+
+    # Cardinality symbols
+    # NOTE: Hebrew letters ℶ (beth), ℷ (gimel), ℸ (daleth) are in UNICODE_PASSTHROUGH
+    "ℵ": "\\aleph",
+
+    # Number sets (use \mathbb for blackboard bold notation)
+    "ℕ": "\\mathbb{N}", "ℤ": "\\mathbb{Z}", "ℚ": "\\mathbb{Q}",
+    "ℝ": "\\mathbb{R}", "ℂ": "\\mathbb{C}", "ℍ": "\\mathbb{H}",
+    "ℙ": "\\mathbb{P}", "𝔽": "\\mathbb{F}", "𝔾": "\\mathbb{G}",
+
+    # Special operators
+    # Basic arithmetic operators
+    "±": "\\pm", "∓": "\\mp", "−": "-", "∔": "\\dotplus",
+
+    # Binary operators (algebraic)
+    "⋆": "\\star", "∗": "\\ast", "∘": "\\circ", "∙": "\\bullet",
+    "⋄": "\\diamond", "⋅": "\\cdot", "•": "\\bullet",
+
+    # Binary operators (lattice and semilattice)
+    # NOTE: ⊌ (dotcup), ⊍ (cupdot) are in UNICODE_PASSTHROUGH
+    "⊔": "\\sqcup", "⊓": "\\sqcap", "⊎": "\\uplus",
+
+    # Binary operators (group theory)
+    # NOTE: Some group theory operators (⋋ leftthreetimes, ⋌ rightthreetimes, ⋇ divideontimes) are in UNICODE_PASSTHROUGH
+    "⋉": "\\ltimes", "⋊": "\\rtimes",
+    "⨿": "\\amalg", "⋈": "\\bowtie",
+
+    # Binary operators (wreath and semidirect products)
+    "≀": "\\wr", "⊺": "\\intercal", "⊻": "\\veebar",
+
+    # Binary operators (extended)
+    # NOTE: Advanced box operators (⧄ boxbox, ⧅ boxast, ⧆ boxcirc, ⧇ boxbslash, ⧈ boxslash) are in UNICODE_PASSTHROUGH
+    "⊝": "\\ominus", "⊞": "\\boxplus", "⊟": "\\boxminus", "⊠": "\\boxtimes",
+    "⊡": "\\boxdot",
+
+    # Big operators
+    "∑": "\\sum", "∏": "\\prod", "∐": "\\coprod", "⋃": "\\bigcup",
+    "⋂": "\\bigcap", "⋁": "\\bigvee", "⋀": "\\bigwedge", "⨁": "\\bigoplus",
+    "⨂": "\\bigotimes", "⨄": "\\biguplus", "⨅": "\\bigsqcap", "⨆": "\\bigsqcup",
+
+    # Delimiters and brackets
+    # Angle brackets
+    "⟨": "\\langle", "⟩": "\\rangle", "⟪": "\\langle\\langle", "⟫": "\\rangle\\rangle",
+    "〈": "\\langle", "〉": "\\rangle",  # CJK angle brackets
+
+    # Floor and ceiling
+    "⌊": "\\lfloor", "⌋": "\\rfloor", "⌈": "\\lceil", "⌉": "\\rceil",
+
+    # Special brackets
+    # NOTE: Some special brackets (⦅ llparenthesis, ⦆ rrparenthesis, 〚 llbracket, 〛 rrbracket, ⦉ Langle, ⦊ Rangle) are in UNICODE_PASSTHROUGH
+    "⦃": "\\{", "⦄": "\\}",
+    "⟦": "[\\![", "⟧": "]\\!]", "⟬": "\\llbracket", "⟭": "\\rrbracket",
+    "⦇": "\\llparenthesis", "⦈": "\\rrparenthesis",
+
+    # Absolute value and norm
+    "|": "|", "‖": "\\|", "∥": "\\parallel",  # ‖ (U+2016) is double vertical line for norms → \|
+
+    # Miscellaneous symbols
+    # NOTE: Radical symbols must include {} braces for valid LaTeX
+    # Users may type these directly as text (malformed input), so we ensure valid output
+    "√": "\\sqrt{}", "∛": "\\sqrt[3]{}", "∜": "\\sqrt[4]{}",
+    "∡": "\\measuredangle", "∢": "\\sphericalangle", "°": "^\\circ",
+    # Prime notation - both Unicode primes and ASCII apostrophe (commonly used in Word)
+    "'": "\\prime",  # ASCII apostrophe (U+0027) - commonly typed instead of Unicode prime
+    "′": "\\prime", "″": "\\prime\\prime", "‴": "\\prime\\prime\\prime", "⁗": "\\prime\\prime\\prime\\prime",
+    "℮": "e", "ℯ": "e", "ⅈ": "i", "ⅉ": "j",
+    # NOTE: ⋰ (iddots) is in UNICODE_PASSTHROUGH
+    "…": "\\ldots", "⋯": "\\cdots", "⋮": "\\vdots", "⋱": "\\ddots",
+    "♭": "\\flat", "♮": "\\natural", "♯": "\\sharp",
+
+    # Fullwidth punctuation (CJK)
+    "，": ", ",  # U+FF0C fullwidth comma (Chinese comma) → regular comma with space
+
+    # Accent marks (for detection in mover elements)
+    "¨": "__DDOT__",  # U+00A8 diaeresis (standalone) - placeholder for ddot detection
+    "⃛": "__DDDOT__",  # U+20DB combining three dots above - placeholder for dddot detection
+    "̈": "__DDOT__",  # U+0308 combining diaeresis - placeholder for ddot detection
+    "⃛": "__DDDOT__",  # U+20DB combining triple dot above - placeholder for dddot detection
+
+    # Chemistry arrows and symbols (harpoons)
+    "⇌": "\\rightleftharpoons",  # U+21CC rightleftharpoons (equilibrium)
+    "⇋": "\\leftrightharpoons",   # U+21CB leftrightharpoons (equilibrium reversed)
+    "⇀": "\\rightharpoonup",      # U+21C0 rightharpoonup
+    "⇁": "\\rightharpoondown",    # U+21C1 rightharpoondown
+    "↼": "\\leftharpoonup",       # U+21BC leftharpoonup
+    "↽": "\\leftharpoondown",     # U+21BD leftharpoondown
+    "⥂": "\\rightleftharpoons",   # U+2942 alternate form
+    "⥃": "\\leftrightharpoons",   # U+2943 alternate form
+    "⥄": "\\rightleftarrows",     # U+2944 right over left arrows
+    "⥅": "\\leftrightarrows",     # U+2945 left over right arrows
+    "⥆": "\\rightleftarrows",     # U+2946 right over left arrows
+    "⥇": "\\leftrightarrows",     # U+2947 left over right arrows
+    "⇄": "\\rightleftarrows",     # U+21C4 right over left (already in extended arrows)
+    "⇆": "\\leftrightarrows",     # U+21C6 left over right (already in extended arrows)
+    "⇉": "\\rightrightarrows",    # U+21C9 double right (already in extended arrows)
+    "⇇": "\\leftleftarrows",      # U+21C7 double left (already in extended arrows)
+
+    # Overbrace and underbrace characters
+    "⏞": "\\overbrace", "⏟": "\\underbrace",
+
+    # Extended mathematical operators (remaining unique ones)
+    # NOTE: ⊚ (ocirc), ⊛ (oast) are in UNICODE_PASSTHROUGH
+
+    # Extended relation symbols (remaining unique ones)
+    # NOTE: Several special equality symbols (≔ coloneqq, ≕ eqqcolon, ≘ arceq, ≙ wedgeq, ≚ veeeq) are in UNICODE_PASSTHROUGH
+    "≆": "\\approxeq", "≛": "\\triangleq",
+
+    # Extended arrows (remaining unique ones)
+    "⇈": "\\upuparrows", "⇊": "\\downdownarrows",
+    "⇅": "\\updownarrows", "⇵": "\\downuparrows", "↶": "\\curvearrowleft",
+    "↷": "\\curvearrowright", "↺": "\\circlearrowleft", "↻": "\\circlearrowright",
+
+    # Extended logical symbols
+    # NOTE: ⟀ (lozengeminus) is in UNICODE_PASSTHROUGH
+    "⟁": "\\lozengepls", "⟂": "\\perp", "⟃": "\\between",
+    "⟄": "\\pitchfork", "⟅": "\\varpropto", "⟆": "\\backprime", "⟇": "\\caretinsert",
+
+    # Extended geometric symbols
+    "⟐": "\\angle", "⟑": "\\measuredangle", "⟒": "\\sphericalangle", "⟓": "\\rightangle",
+    "⟔": "\\angle", "⟕": "\\measuredangle", "⟖": "\\sphericalangle", "⟗": "\\rightangle",
+
+    # Extended miscellaneous symbols
+    "⟘": "\\perp", "⟙": "\\diamondsuit", "⟚": "\\heartsuit", "⟛": "\\clubsuit",
+    "⟜": "\\spadesuit", "⟝": "\\varnothing", "⟞": "\\diameter", "⟟": "\\house",
+}
+
+# Additional Symbol Replacements (Consolidated from scattered code)
+# ========================================================================
+
+# These symbols are used in specific contexts (e.g., function subscripts)
+# and should be applied consistently across the codebase
+ADDITIONAL_SYMBOL_REPLACEMENTS = {
+    # Arrows used in function subscripts (line 1828)
+    '→': '\\to ',
+
+    # These are handled in UNICODE_TO_LATEX but kept for reference in subscript context
+    # '∞': '\\infty',  # Already in UNICODE_TO_LATEX
+    # '≤': '\\leqslant ',  # Already in UNICODE_TO_LATEX
+    # '≥': '\\geqslant ',  # Already in UNICODE_TO_LATEX
+    # '≠': '\\ne ',  # Already in UNICODE_TO_LATEX as \\neq
+    # '±': '\\pm ',  # Already in UNICODE_TO_LATEX
+}
+
+# LaTeX command normalization (converting between command variants)
+LATEX_COMMAND_REPLACEMENTS = {
+    # Logical equivalence (line 5545)
+    '\\Longleftrightarrow': '\\iff ',
+
+    # Arrow shorthand (line 5548)
+    '\\lra': '\\leftrightarrow',
+
+}
+
+# Summation symbols for OMML fallback parser
+SUMMATION_SYMBOLS = {
+    '∑': 'sum',
+    '∏': 'prod',
+    '∫': 'integral',
+    'Σ': 'sum',
+    'Π': 'prod'
+}
+
+# LaTeX commands not supported by MathJax - use Unicode fallback
+# Maps LaTeX command (without backslash) to Unicode character
+# This comprehensive list ensures proper rendering in MathJax environments
+MATHJAX_UNSUPPORTED_TO_UNICODE = {
+    # =========================================================================
+    # INTEGRAL OPERATORS - Many not in standard MathJax
+    # =========================================================================
+    # Surface and volume integrals
+    'oiint': '∯',              # U+222F SURFACE INTEGRAL
+    'oiiint': '∰',             # U+2230 VOLUME INTEGRAL
+    # Clockwise/counterclockwise integrals - NOT in MathJax
+    'intclockwise': '∱',       # U+2231 CLOCKWISE INTEGRAL
+    'varointclockwise': '∲',   # U+2232 CLOCKWISE CONTOUR INTEGRAL
+    'varointctrclockwise': '∳',  # U+2233 ANTICLOCKWISE CONTOUR INTEGRAL
+    # Extended integrals - limited MathJax support
+    'fint': '⨍',               # U+2A0D FINITE PART INTEGRAL
+    'pointint': '⨎',           # U+2A0E PATH INTEGRAL (line integral)
+    'sqint': '⨏',              # U+2A0F INTEGRAL WITH SQUARED OPERATOR
+    'intlarhk': '⨐',           # U+2A10 CIRCULATION FUNCTION
+    'intbar': '⨑',             # U+2A11 INTEGRAL WITH OVERBAR
+    'intBar': '⨒',             # U+2A12 INTEGRAL WITH DOUBLE OVERBAR
+    'fintbar': '⨓',            # U+2A13 FINITE PART INTEGRAL WITH OVERBAR
+    'ointbar': '⨔',            # U+2A14 CONTOUR INTEGRAL WITH OVERBAR
+    'ointBar': '⨕',            # U+2A15 CONTOUR INTEGRAL WITH DOUBLE OVERBAR
+    'oiintbar': '⨖',           # U+2A16 SURFACE INTEGRAL WITH OVERBAR
+    'oiintBar': '⨗',           # U+2A17 SURFACE INTEGRAL WITH DOUBLE OVERBAR
+
+    # =========================================================================
+    # BINARY OPERATORS - Non-standard or limited support
+    # =========================================================================
+    # Division operator
+    'divideontimes': '⋇',      # U+22C7 DIVISION TIMES
+    # Circle operators - non-standard names
+    'oast': '⊛',               # U+229B CIRCLED ASTERISK OPERATOR
+    'ocirc': '⊚',              # U+229A CIRCLED RING OPERATOR
+    # Box operators - extended (standard ones like boxplus ARE supported)
+    'boxbox': '⧄',             # U+29C4 SQUARED SQUARE
+    'boxast': '⧅',             # U+29C5 SQUARED ASTERISK
+    'boxcirc': '⧆',            # U+29C6 SQUARED SMALL CIRCLE
+    'boxbslash': '⧇',          # U+29C7 SQUARED BACKSLASH
+    'boxslash': '⧈',           # U+29C8 SQUARED SLASH
+    # Semidirect products
+    'leftthreetimes': '⋋',     # U+22CB LEFT SEMIDIRECT PRODUCT
+    'rightthreetimes': '⋌',    # U+22CC RIGHT SEMIDIRECT PRODUCT
+    # Set operations with dot
+    'dotcup': '⊌',             # U+228C MULTISET
+    'cupdot': '⊍',             # U+228D MULTISET MULTIPLICATION
+
+    # =========================================================================
+    # ARROWS - Extended arrows with limited MathJax support
+    # =========================================================================
+    'mapsfrom': '↤',           # U+21A4 LEFTWARDS ARROW FROM BAR
+    'longmapsfrom': '⟻',       # U+27FB LONG LEFTWARDS ARROW FROM BAR
+    'leftsquigarrow': '⇜',     # U+21DC LEFTWARDS SQUIGGLE ARROW
+    'rightsquigarrow': '⇝',    # U+21DD RIGHTWARDS SQUIGGLE ARROW
+    # 'looparrowleft': '↫',      # U+21AB LEFTWARDS ARROW WITH LOOP
+    # 'looparrowright': '↬',     # U+21AC RIGHTWARDS ARROW WITH LOOP
+    # 'leftarrowtail': '↢',      # U+21A2 LEFTWARDS ARROW WITH TAIL
+    # 'rightarrowtail': '↣',     # U+21A3 RIGHTWARDS ARROW WITH TAIL
+    # 'Lsh': '↰',                # U+21B0 UPWARDS ARROW WITH TIP LEFTWARDS
+    # 'Rsh': '↱',                # U+21B1 UPWARDS ARROW WITH TIP RIGHTWARDS
+    # 'curvearrowleft': '↶',     # U+21B6 ANTICLOCKWISE TOP SEMICIRCLE ARROW
+    # 'curvearrowright': '↷',    # U+21B7 CLOCKWISE TOP SEMICIRCLE ARROW
+    # 'circlearrowleft': '↺',    # U+21BA ANTICLOCKWISE OPEN CIRCLE ARROW
+    # 'circlearrowright': '↻',   # U+21BB CLOCKWISE OPEN CIRCLE ARROW
+    # 'upuparrows': '⇈',         # U+21C8 UPWARDS PAIRED ARROWS
+    # 'downdownarrows': '⇊',     # U+21CA DOWNWARDS PAIRED ARROWS
+    # 'updownarrows': '⇅',       # U+21C5 UPWARDS ARROW LEFTWARDS OF DOWNWARDS
+    # 'downuparrows': '⇵',       # U+21F5 DOWNWARDS ARROW LEFTWARDS OF UPWARDS
+
+    # =========================================================================
+    # RELATION SYMBOLS - Extended relations
+    # =========================================================================
+    # Triple comparisons
+    'lll': '⋘',                # U+22D8 VERY MUCH LESS-THAN
+    'ggg': '⋙',                # U+22D9 VERY MUCH GREATER-THAN
+    # Combined relations
+    'lesseqgtr': '⪋',          # U+2A8B LESS-THAN EQUAL TO OR GREATER-THAN
+    'gtreqless': '⪌',          # U+2A8C GREATER-THAN EQUAL TO OR LESS-THAN
+    'lessapprox': '⪅',         # U+2A85 LESS-THAN OR APPROXIMATE
+    'gtrapprox': '⪆',          # U+2A86 GREATER-THAN OR APPROXIMATE
+    'lnapprox': '⪉',           # U+2A89 LESS-THAN AND NOT APPROXIMATE
+    'gnapprox': '⪊',           # U+2A8A GREATER-THAN AND NOT APPROXIMATE
+    # Precedence relations
+    'precapprox': '⪷',         # U+2AB7 PRECEDES ABOVE ALMOST EQUAL TO
+    'succapprox': '⪸',         # U+2AB8 SUCCEEDS ABOVE ALMOST EQUAL TO
+    'curlyeqprec': '⋞',        # U+22DE EQUAL TO OR PRECEDES
+    'curlyeqsucc': '⋟',        # U+22DF EQUAL TO OR SUCCEEDS
+    # Similarity relations
+    # 'backsim': '∽',            # U+223D REVERSED TILDE
+    # 'backsimeq': '⋍',          # U+22CD REVERSED TILDE EQUALS
+    # Special equality symbols
+    'wedgeq': '≙',             # U+2259 ESTIMATES (wedge equals)
+    'veeeq': '≚',              # U+225A EQUIANGULAR TO
+    'arceq': '≘',              # U+2258 CORRESPONDS TO
+    'coloneqq': '≔',           # U+2254 COLON EQUALS
+    'eqqcolon': '≕',           # U+2255 EQUALS COLON
+    'Coloneqq': '⩴',           # U+2A74 DOUBLE COLON EQUAL
+    'eqcolon': '∹',            # U+2239 EXCESS (-:)
+
+    # =========================================================================
+    # BRACKET/DELIMITER SYMBOLS
+    # =========================================================================
+    'llbracket': '〚',          # U+301A LEFT WHITE SQUARE BRACKET
+    'rrbracket': '〛',          # U+301B RIGHT WHITE SQUARE BRACKET
+    'llparenthesis': '⦅',      # U+2985 LEFT WHITE PARENTHESIS
+    'rrparenthesis': '⦆',      # U+2986 RIGHT WHITE PARENTHESIS
+    'Langle': '⦉',             # U+2989 Z NOTATION LEFT BINDING BRACKET
+    'Rangle': '⦊',             # U+298A Z NOTATION RIGHT BINDING BRACKET
+
+    # =========================================================================
+    # GEOMETRIC AND MISCELLANEOUS SYMBOLS
+    # =========================================================================
+    'parallelogram': '▱',      # U+25B1 WHITE PARALLELOGRAM
+    'iddots': '⋰',             # U+22F0 UP RIGHT DIAGONAL ELLIPSIS
+    # 'mho': '℧',                # U+2127 INVERTED OHM SIGN
+    # 'complement': '∁',         # U+2201 COMPLEMENT
+    # Hebrew letters (beyond aleph)
+    'beth': 'ℶ',               # U+2136 BET SYMBOL
+    'gimel': 'ℷ',              # U+2137 GIMEL SYMBOL
+    'daleth': 'ℸ',             # U+2138 DALET SYMBOL
+
+    # =========================================================================
+    # LOGICAL AND SET OPERATORS
+    # =========================================================================
+    # Extended subset/superset relations
+    # 'subseteqq': '⫅',          # U+2AC5 SUBSET OF ABOVE EQUALS SIGN
+    # 'supseteqq': '⫆',          # U+2AC6 SUPERSET OF ABOVE EQUALS SIGN
+    # 'subsetneqq': '⫋',         # U+2ACB SUBSET OF ABOVE NOT EQUAL TO
+    # 'supsetneqq': '⫌',         # U+2ACC SUPERSET OF ABOVE NOT EQUAL TO
+    # Logic symbols
+    'lozengeminus': '⟀',       # U+27C0 THREE DIMENSIONAL ANGLE
+    'between': '≬',            # U+226C BETWEEN
+}
+
+# Regional symbol preferences (e.g., Chinese region prefers varnothing over emptyset)
+# Maps standard LaTeX command to regional alternative
+REGIONAL_SYMBOL_PREFERENCES = {
+    # Chinese region: prefer varnothing (⌀) over emptyset (∅)
+    # varnothing has a diagonal line which is clearer in Chinese typography
+    'emptyset': 'varnothing',  # ∅ → ⌀
+}
+
+# Unicode symbols that should be kept as-is (NOT converted to LaTeX)
+# These are symbols whose LaTeX commands are not supported or render poorly in MathJax.
+# By keeping them as Unicode, they render correctly using system fonts.
+# This set is the "inverse" of MATHJAX_UNSUPPORTED_TO_UNICODE - same symbols, different direction.
+UNICODE_PASSTHROUGH = {
+    # =========================================================================
+    # INTEGRAL OPERATORS - Keep as Unicode for MathJax compatibility
+    # =========================================================================
+    '∯',    # U+222F SURFACE INTEGRAL (oiint)
+    '∰',    # U+2230 VOLUME INTEGRAL (oiiint)
+    '∱',    # U+2231 CLOCKWISE INTEGRAL (intclockwise)
+    '∲',    # U+2232 CLOCKWISE CONTOUR INTEGRAL (varointclockwise)
+    '∳',    # U+2233 ANTICLOCKWISE CONTOUR INTEGRAL (varointctrclockwise)
+    '⨍',    # U+2A0D FINITE PART INTEGRAL (fint)
+    '⨎',    # U+2A0E PATH INTEGRAL (pointint)
+    '⨏',    # U+2A0F INTEGRAL WITH SQUARED OPERATOR (sqint)
+    '⨐',    # U+2A10 CIRCULATION FUNCTION (intlarhk)
+    '⨑',    # U+2A11 INTEGRAL WITH OVERBAR (intbar)
+    '⨒',    # U+2A12 INTEGRAL WITH DOUBLE OVERBAR (intBar)
+    '⨓',    # U+2A13 FINITE PART INTEGRAL WITH OVERBAR (fintbar)
+    '⨔',    # U+2A14 CONTOUR INTEGRAL WITH OVERBAR (ointbar)
+    '⨕',    # U+2A15 CONTOUR INTEGRAL WITH DOUBLE OVERBAR (ointBar)
+    '⨖',    # U+2A16 SURFACE INTEGRAL WITH OVERBAR (oiintbar)
+    '⨗',    # U+2A17 SURFACE INTEGRAL WITH DOUBLE OVERBAR (oiintBar)
+
+    # =========================================================================
+    # BINARY OPERATORS - Keep as Unicode
+    # =========================================================================
+    '⋇',    # U+22C7 DIVISION TIMES (divideontimes)
+    '⊛',    # U+229B CIRCLED ASTERISK OPERATOR (oast)
+    '⊚',    # U+229A CIRCLED RING OPERATOR (ocirc)
+    '⧄',    # U+29C4 SQUARED SQUARE (boxbox)
+    '⧅',    # U+29C5 SQUARED ASTERISK (boxast)
+    '⧆',    # U+29C6 SQUARED SMALL CIRCLE (boxcirc)
+    '⧇',    # U+29C7 SQUARED BACKSLASH (boxbslash)
+    '⧈',    # U+29C8 SQUARED SLASH (boxslash)
+    '⋋',    # U+22CB LEFT SEMIDIRECT PRODUCT (leftthreetimes)
+    '⋌',    # U+22CC RIGHT SEMIDIRECT PRODUCT (rightthreetimes)
+    '⊌',    # U+228C MULTISET (dotcup)
+    '⊍',    # U+228D MULTISET MULTIPLICATION (cupdot)
+
+    # =========================================================================
+    # ARROWS - Keep as Unicode for consistency
+    # =========================================================================
+    '↤',    # U+21A4 LEFTWARDS ARROW FROM BAR (mapsfrom)
+    '⟻',    # U+27FB LONG LEFTWARDS ARROW FROM BAR (longmapsfrom)
+    '⇜',    # U+21DC LEFTWARDS SQUIGGLE ARROW (leftsquigarrow)
+    '⇝',    # U+21DD RIGHTWARDS SQUIGGLE ARROW (rightsquigarrow)
+    # '↫',    # U+21AB LEFTWARDS ARROW WITH LOOP (looparrowleft)
+    # '↬',    # U+21AC RIGHTWARDS ARROW WITH LOOP (looparrowright)
+    # '↢',    # U+21A2 LEFTWARDS ARROW WITH TAIL (leftarrowtail)
+    # '↣',    # U+21A3 RIGHTWARDS ARROW WITH TAIL (rightarrowtail)
+    # '↰',    # U+21B0 UPWARDS ARROW WITH TIP LEFTWARDS (Lsh)
+    # '↱',    # U+21B1 UPWARDS ARROW WITH TIP RIGHTWARDS (Rsh)
+    # '↶',    # U+21B6 ANTICLOCKWISE TOP SEMICIRCLE ARROW (curvearrowleft)
+    # '↷',    # U+21B7 CLOCKWISE TOP SEMICIRCLE ARROW (curvearrowright)
+    # '↺',    # U+21BA ANTICLOCKWISE OPEN CIRCLE ARROW (circlearrowleft)
+    # '↻',    # U+21BB CLOCKWISE OPEN CIRCLE ARROW (circlearrowright)
+    # '⇈',    # U+21C8 UPWARDS PAIRED ARROWS (upuparrows)
+    # '⇊',    # U+21CA DOWNWARDS PAIRED ARROWS (downdownarrows)
+    # '⇅',    # U+21C5 UPWARDS ARROW LEFTWARDS OF DOWNWARDS (updownarrows)
+    # '⇵',    # U+21F5 DOWNWARDS ARROW LEFTWARDS OF UPWARDS (downuparrows)
+
+    # =========================================================================
+    # RELATION SYMBOLS - Keep as Unicode
+    # =========================================================================
+    '⋘',    # U+22D8 VERY MUCH LESS-THAN (lll)
+    '⋙',    # U+22D9 VERY MUCH GREATER-THAN (ggg)
+    '⪋',    # U+2A8B LESS-THAN EQUAL TO OR GREATER-THAN (lesseqgtr)
+    '⪌',    # U+2A8C GREATER-THAN EQUAL TO OR LESS-THAN (gtreqless)
+    '⪅',    # U+2A85 LESS-THAN OR APPROXIMATE (lessapprox)
+    '⪆',    # U+2A86 GREATER-THAN OR APPROXIMATE (gtrapprox)
+    '⪉',    # U+2A89 LESS-THAN AND NOT APPROXIMATE (lnapprox)
+    '⪊',    # U+2A8A GREATER-THAN AND NOT APPROXIMATE (gnapprox)
+    '⪷',    # U+2AB7 PRECEDES ABOVE ALMOST EQUAL TO (precapprox)
+    '⪸',    # U+2AB8 SUCCEEDS ABOVE ALMOST EQUAL TO (succapprox)
+    '⋞',    # U+22DE EQUAL TO OR PRECEDES (curlyeqprec)
+    '⋟',    # U+22DF EQUAL TO OR SUCCEEDS (curlyeqsucc)
+    # '∽',    # U+223D REVERSED TILDE (backsim)
+    # '⋍',    # U+22CD REVERSED TILDE EQUALS (backsimeq)
+    '≙',    # U+2259 ESTIMATES (wedgeq)
+    '≚',    # U+225A EQUIANGULAR TO (veeeq)
+    '≘',    # U+2258 CORRESPONDS TO (arceq)
+    '≔',    # U+2254 COLON EQUALS (coloneqq)
+    '≕',    # U+2255 EQUALS COLON (eqqcolon)
+    '⩴',    # U+2A74 DOUBLE COLON EQUAL (Coloneqq)
+    '∹',    # U+2239 EXCESS (eqcolon)
+    '≬',    # U+226C BETWEEN (between)
+
+    # =========================================================================
+    # BRACKET/DELIMITER SYMBOLS - Keep as Unicode
+    # =========================================================================
+    '〚',    # U+301A LEFT WHITE SQUARE BRACKET (llbracket)
+    '〛',    # U+301B RIGHT WHITE SQUARE BRACKET (rrbracket)
+    '⦅',    # U+2985 LEFT WHITE PARENTHESIS (llparenthesis)
+    '⦆',    # U+2986 RIGHT WHITE PARENTHESIS (rrparenthesis)
+    '⦉',    # U+2989 Z NOTATION LEFT BINDING BRACKET (Langle)
+    '⦊',    # U+298A Z NOTATION RIGHT BINDING BRACKET (Rangle)
+
+    # =========================================================================
+    # GEOMETRIC AND MISCELLANEOUS SYMBOLS - Keep as Unicode
+    # =========================================================================
+    '▱',    # U+25B1 WHITE PARALLELOGRAM (parallelogram)
+    '⋰',    # U+22F0 UP RIGHT DIAGONAL ELLIPSIS (iddots)
+    # '℧',    # U+2127 INVERTED OHM SIGN (mho)
+    # '∁',    # U+2201 COMPLEMENT (complement)
+    'ℶ',    # U+2136 BET SYMBOL (beth)
+    'ℷ',    # U+2137 GIMEL SYMBOL (gimel)
+    'ℸ',    # U+2138 DALET SYMBOL (daleth)
+    '⟀',    # U+27C0 THREE DIMENSIONAL ANGLE (lozengeminus)
+
+    # =========================================================================
+    # LOGICAL AND SET OPERATORS - Keep as Unicode
+    # =========================================================================
+    # '⫅',    # U+2AC5 SUBSET OF ABOVE EQUALS SIGN (subseteqq)
+    # '⫆',    # U+2AC6 SUPERSET OF ABOVE EQUALS SIGN (supseteqq)
+    # '⫋',    # U+2ACB SUBSET OF ABOVE NOT EQUAL TO (subsetneqq)
+    # '⫌',    # U+2ACC SUPERSET OF ABOVE NOT EQUAL TO (supsetneqq)
+}
+
diff --git a/scripts/omml_mathml2latex/data/units.py b/scripts/omml_mathml2latex/data/units.py
new file mode 100644
index 0000000..1d2d489
--- /dev/null
+++ b/scripts/omml_mathml2latex/data/units.py
@@ -0,0 +1,63 @@
+"""
+Common unit definitions for chemistry, physics, and mathematics.
+
+Contains:
+- COMMON_UNITS: Set of common units that should be formatted as \\mathrm{unit}
+  Includes: chemistry units, SI base units, SI derived units, non-SI units,
+  angular units, time units, concentration units, biological units
+"""
+
+# Common units that should be formatted as ~\mathrm{unit}~ (with preceding and trailing space)
+COMMON_UNITS = {
+    # Chemistry units
+    'mol', 'M', 'mM', 'µM', 'nM', 'pM', 'pH', 'pOH', 'atm', 'bar', 'Torr', 'eq',
+    'aq', 'sol', 'ppm', 'ppb', 'vol', 'wt',
+
+    # SI base units
+    'kg', 'g', 'mg', 'µg', 'ng', 'pg', 'ton', 'tonne',
+    'm', 'km', 'cm', 'mm', 'µm', 'nm', 'pm', 'Å',
+    's', 'ms', 'µs', 'ns', 'ps', 'min', 'h', 'hr', 'day',
+    'A', 'mA', 'µA', 'nA', 'pA',
+    'K', 'mK', 'µK', 'nK',
+    'cd', 'lm', 'lx',
+
+    # SI derived units
+    'Hz', 'kHz', 'MHz', 'GHz', 'THz',
+    'N', 'kN', 'MN', 'µN', 'nN', 'pN',
+    'Pa', 'kPa', 'MPa', 'GPa', 'hPa', 'mbar',
+    'J', 'kJ', 'MJ', 'µJ', 'nJ', 'pJ', 'mJ',
+    'W', 'kW', 'MW', 'GW', 'mW', 'µW', 'nW', 'pW',
+    'C', 'mC', 'µC', 'nC', 'pC',
+    'V', 'kV', 'MV', 'mV', 'µV', 'nV',
+    'F', 'mF', 'µF', 'nF', 'pF',
+    'Ω', 'kΩ', 'MΩ', 'GΩ', 'mΩ', 'µΩ',
+    'S', 'mS', 'µS', 'nS',
+    'Wb', 'mWb', 'µWb', 'nWb',
+    'T', 'mT', 'µT', 'nT', 'pT',
+    'H', 'mH', 'µH', 'nH', 'pH',
+
+    # Common non-SI units
+    'L', 'mL', 'µL', 'nL', 'pL', 'dL', 'cL',
+    '°C', '°F', '°K', 'celsius', 'fahrenheit', 'kelvin',
+    'eV', 'keV', 'MeV', 'GeV', 'TeV', 'meV', 'µeV',
+    'cal', 'kcal', 'Cal',
+    'Bq', 'kBq', 'MBq', 'GBq', 'mBq',
+    'Gy', 'mGy', 'µGy', 'kGy',
+    'Sv', 'mSv', 'µSv', 'kSv',
+
+    # Angular units
+    'rad', 'mrad', 'µrad', 'sr',
+    'deg', 'arcmin', 'arcsec',
+
+    # Time units
+    'ms', 'µs', 'ns', 'ps', 'fs', 'as',
+    'year', 'yr', 'month', 'week', 'day', 'hr', 'min',
+
+    # Concentration and biological units
+    'IU', 'U', 'unit', 'units', 'Da', 'kDa', 'MDa',
+    'bp', 'kbp', 'Mbp', 'kb', 'Mb', 'Gb',
+    'rpm', 'rps', 'Hz', 'cps',
+
+    # Physics constants (when used as units)
+    'c', 'h', 'ħ', 'kB', 'NA', 'R', 'σ', 'ε₀', 'μ₀',
+}
diff --git a/scripts/omml_mathml2latex/omml_mathml.json b/scripts/omml_mathml2latex/omml_mathml.json
new file mode 100644
index 0000000..016ae83
--- /dev/null
+++ b/scripts/omml_mathml2latex/omml_mathml.json
@@ -0,0 +1,15 @@
+{
+  "x1": "<m:oMath xmlns:cppr=\"http://schemas.microsoft.com/office/2006/coverPageProps\" xmlns:dgm1611=\"http://schemas.microsoft.com/office/drawing/2016/11/diagram\" xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wp15=\"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" xmlns:a1611=\"http://schemas.microsoft.com/office/drawing/2016/11/main\" xmlns:a16svg=\"http://schemas.microsoft.com/office/drawing/2016/SVG/main\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:pvml=\"urn:schemas-microsoft-com:office:powerpoint\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:dgm1612=\"http://schemas.microsoft.com/office/drawing/2016/12/diagram\" xmlns:comp=\"http://schemas.openxmlformats.org/drawingml/2006/compatibility\" xmlns:xvml=\"urn:schemas-microsoft-com:office:excel\" xmlns:c173=\"http://schemas.microsoft.com/office/drawing/2017/03/chart\" xmlns:anam3d=\"http://schemas.microsoft.com/office/drawing/2018/animation/model3d\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:adec=\"http://schemas.microsoft.com/office/drawing/2017/decorative\" xmlns:oda=\"http://opendope.org/answers\" xmlns:a18hc=\"http://schemas.microsoft.com/office/drawing/2018/hyperlinkcolor\" xmlns:odc=\"http://opendope.org/conditions\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:cdr=\"http://schemas.openxmlformats.org/drawingml/2006/chartDrawing\" xmlns:odi=\"http://opendope.org/components\" xmlns:msink=\"http://schemas.microsoft.com/ink/2010/main\" xmlns:cdr14=\"http://schemas.microsoft.com/office/drawing/2010/chartDrawing\" xmlns:iact=\"http://schemas.microsoft.com/office/powerpoint/2014/inkAction\" xmlns:an18=\"http://schemas.microsoft.com/office/drawing/2018/animation\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:odq=\"http://opendope.org/questions\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:dsp=\"http://schemas.microsoft.com/office/drawing/2008/diagram\" xmlns:odx=\"http://opendope.org/xpaths\" xmlns:a15=\"http://schemas.microsoft.com/office/drawing/2012/main\" xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" xmlns:c15=\"http://schemas.microsoft.com/office/drawing/2012/chart\" xmlns:a13cmd=\"http://schemas.microsoft.com/office/drawing/2013/main/command\" xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\" xmlns:a16=\"http://schemas.microsoft.com/office/drawing/2014/main\" xmlns:odgm=\"http://opendope.org/SmartArt/DataHierarchy\" xmlns:c16=\"http://schemas.microsoft.com/office/drawing/2014/chart\" xmlns:dgm=\"http://schemas.openxmlformats.org/drawingml/2006/diagram\" xmlns:thm15=\"http://schemas.microsoft.com/office/thememl/2012/main\" xmlns:we=\"http://schemas.microsoft.com/office/webextensions/webextension/2010/11\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:ns39=\"http://www.w3.org/2003/InkML\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:sl=\"http://schemas.openxmlformats.org/schemaLibrary/2006/main\" xmlns:ns38=\"http://www.w3.org/1998/Math/MathML\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:dgm14=\"http://schemas.microsoft.com/office/drawing/2010/diagram\" xmlns:c16ac=\"http://schemas.microsoft.com/office/drawing/2014/chart/ac\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:cs=\"http://schemas.microsoft.com/office/drawing/2012/chartStyle\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:pic14=\"http://schemas.microsoft.com/office/drawing/2010/picture\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:lc=\"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas\" xmlns:wetp=\"http://schemas.microsoft.com/office/webextensions/taskpanes/2010/11\"><m:rad><m:radPr><m:degHide m:val=\"1\"/><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr></m:ctrlPr></m:radPr><m:deg><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr></m:ctrlPr></m:deg><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>−</m:t></m:r><m:d><m:dPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr></m:ctrlPr></m:dPr><m:e><m:r><m:rPr/><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>7</m:t></m:r><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>−</m:t></m:r><m:r><m:rPr/><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>3x</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr></m:ctrlPr></m:e></m:d><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr></m:ctrlPr></m:e></m:rad></m:oMath>",
+  "x2": "<m:oMath xmlns:cppr=\"http://schemas.microsoft.com/office/2006/coverPageProps\" xmlns:dgm1611=\"http://schemas.microsoft.com/office/drawing/2016/11/diagram\" xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wp15=\"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" xmlns:a1611=\"http://schemas.microsoft.com/office/drawing/2016/11/main\" xmlns:a16svg=\"http://schemas.microsoft.com/office/drawing/2016/SVG/main\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:pvml=\"urn:schemas-microsoft-com:office:powerpoint\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:dgm1612=\"http://schemas.microsoft.com/office/drawing/2016/12/diagram\" xmlns:comp=\"http://schemas.openxmlformats.org/drawingml/2006/compatibility\" xmlns:xvml=\"urn:schemas-microsoft-com:office:excel\" xmlns:c173=\"http://schemas.microsoft.com/office/drawing/2017/03/chart\" xmlns:anam3d=\"http://schemas.microsoft.com/office/drawing/2018/animation/model3d\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:adec=\"http://schemas.microsoft.com/office/drawing/2017/decorative\" xmlns:oda=\"http://opendope.org/answers\" xmlns:a18hc=\"http://schemas.microsoft.com/office/drawing/2018/hyperlinkcolor\" xmlns:odc=\"http://opendope.org/conditions\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:cdr=\"http://schemas.openxmlformats.org/drawingml/2006/chartDrawing\" xmlns:odi=\"http://opendope.org/components\" xmlns:msink=\"http://schemas.microsoft.com/ink/2010/main\" xmlns:cdr14=\"http://schemas.microsoft.com/office/drawing/2010/chartDrawing\" xmlns:iact=\"http://schemas.microsoft.com/office/powerpoint/2014/inkAction\" xmlns:an18=\"http://schemas.microsoft.com/office/drawing/2018/animation\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:odq=\"http://opendope.org/questions\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:dsp=\"http://schemas.microsoft.com/office/drawing/2008/diagram\" xmlns:odx=\"http://opendope.org/xpaths\" xmlns:a15=\"http://schemas.microsoft.com/office/drawing/2012/main\" xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" xmlns:c15=\"http://schemas.microsoft.com/office/drawing/2012/chart\" xmlns:a13cmd=\"http://schemas.microsoft.com/office/drawing/2013/main/command\" xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\" xmlns:a16=\"http://schemas.microsoft.com/office/drawing/2014/main\" xmlns:odgm=\"http://opendope.org/SmartArt/DataHierarchy\" xmlns:c16=\"http://schemas.microsoft.com/office/drawing/2014/chart\" xmlns:dgm=\"http://schemas.openxmlformats.org/drawingml/2006/diagram\" xmlns:thm15=\"http://schemas.microsoft.com/office/thememl/2012/main\" xmlns:we=\"http://schemas.microsoft.com/office/webextensions/webextension/2010/11\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:ns39=\"http://www.w3.org/2003/InkML\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:sl=\"http://schemas.openxmlformats.org/schemaLibrary/2006/main\" xmlns:ns38=\"http://www.w3.org/1998/Math/MathML\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:dgm14=\"http://schemas.microsoft.com/office/drawing/2010/diagram\" xmlns:c16ac=\"http://schemas.microsoft.com/office/drawing/2014/chart/ac\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:cs=\"http://schemas.microsoft.com/office/drawing/2012/chartStyle\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:pic14=\"http://schemas.microsoft.com/office/drawing/2010/picture\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:lc=\"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas\" xmlns:wetp=\"http://schemas.microsoft.com/office/webextensions/taskpanes/2010/11\"><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>0.0016 m</m:t></m:r><m:r><m:rPr><m:nor/><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:b w:val=\"false\"/><w:i w:val=\"false\"/><w:iCs/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>ol</m:t></m:r></m:oMath>",
+  "x3": "<m:oMath xmlns:cppr=\"http://schemas.microsoft.com/office/2006/coverPageProps\" xmlns:dgm1611=\"http://schemas.microsoft.com/office/drawing/2016/11/diagram\" xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wp15=\"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" xmlns:a1611=\"http://schemas.microsoft.com/office/drawing/2016/11/main\" xmlns:a16svg=\"http://schemas.microsoft.com/office/drawing/2016/SVG/main\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:pvml=\"urn:schemas-microsoft-com:office:powerpoint\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:dgm1612=\"http://schemas.microsoft.com/office/drawing/2016/12/diagram\" xmlns:comp=\"http://schemas.openxmlformats.org/drawingml/2006/compatibility\" xmlns:xvml=\"urn:schemas-microsoft-com:office:excel\" xmlns:c173=\"http://schemas.microsoft.com/office/drawing/2017/03/chart\" xmlns:anam3d=\"http://schemas.microsoft.com/office/drawing/2018/animation/model3d\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:adec=\"http://schemas.microsoft.com/office/drawing/2017/decorative\" xmlns:oda=\"http://opendope.org/answers\" xmlns:a18hc=\"http://schemas.microsoft.com/office/drawing/2018/hyperlinkcolor\" xmlns:odc=\"http://opendope.org/conditions\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:cdr=\"http://schemas.openxmlformats.org/drawingml/2006/chartDrawing\" xmlns:odi=\"http://opendope.org/components\" xmlns:msink=\"http://schemas.microsoft.com/ink/2010/main\" xmlns:cdr14=\"http://schemas.microsoft.com/office/drawing/2010/chartDrawing\" xmlns:iact=\"http://schemas.microsoft.com/office/powerpoint/2014/inkAction\" xmlns:an18=\"http://schemas.microsoft.com/office/drawing/2018/animation\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:odq=\"http://opendope.org/questions\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:dsp=\"http://schemas.microsoft.com/office/drawing/2008/diagram\" xmlns:odx=\"http://opendope.org/xpaths\" xmlns:a15=\"http://schemas.microsoft.com/office/drawing/2012/main\" xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" xmlns:c15=\"http://schemas.microsoft.com/office/drawing/2012/chart\" xmlns:a13cmd=\"http://schemas.microsoft.com/office/drawing/2013/main/command\" xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\" xmlns:a16=\"http://schemas.microsoft.com/office/drawing/2014/main\" xmlns:odgm=\"http://opendope.org/SmartArt/DataHierarchy\" xmlns:c16=\"http://schemas.microsoft.com/office/drawing/2014/chart\" xmlns:dgm=\"http://schemas.openxmlformats.org/drawingml/2006/diagram\" xmlns:thm15=\"http://schemas.microsoft.com/office/thememl/2012/main\" xmlns:we=\"http://schemas.microsoft.com/office/webextensions/webextension/2010/11\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:ns39=\"http://www.w3.org/2003/InkML\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:sl=\"http://schemas.openxmlformats.org/schemaLibrary/2006/main\" xmlns:ns38=\"http://www.w3.org/1998/Math/MathML\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:dgm14=\"http://schemas.microsoft.com/office/drawing/2010/diagram\" xmlns:c16ac=\"http://schemas.microsoft.com/office/drawing/2014/chart/ac\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:cs=\"http://schemas.microsoft.com/office/drawing/2012/chartStyle\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:pic14=\"http://schemas.microsoft.com/office/drawing/2010/picture\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:lc=\"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas\" xmlns:wetp=\"http://schemas.microsoft.com/office/webextensions/taskpanes/2010/11\"><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>0.0017         m</m:t></m:r><m:r><m:rPr><m:nor/><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:b w:val=\"false\"/><w:i w:val=\"false\"/><w:iCs/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/></w:rPr><m:t>ol</m:t></m:r></m:oMath>",
+  "x4": "<m:oMath xmlns:cppr=\"http://schemas.microsoft.com/office/2006/coverPageProps\" xmlns:dgm1611=\"http://schemas.microsoft.com/office/drawing/2016/11/diagram\" xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wp15=\"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" xmlns:a1611=\"http://schemas.microsoft.com/office/drawing/2016/11/main\" xmlns:a16svg=\"http://schemas.microsoft.com/office/drawing/2016/SVG/main\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:pvml=\"urn:schemas-microsoft-com:office:powerpoint\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:dgm1612=\"http://schemas.microsoft.com/office/drawing/2016/12/diagram\" xmlns:comp=\"http://schemas.openxmlformats.org/drawingml/2006/compatibility\" xmlns:xvml=\"urn:schemas-microsoft-com:office:excel\" xmlns:c173=\"http://schemas.microsoft.com/office/drawing/2017/03/chart\" xmlns:anam3d=\"http://schemas.microsoft.com/office/drawing/2018/animation/model3d\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:adec=\"http://schemas.microsoft.com/office/drawing/2017/decorative\" xmlns:oda=\"http://opendope.org/answers\" xmlns:a18hc=\"http://schemas.microsoft.com/office/drawing/2018/hyperlinkcolor\" xmlns:odc=\"http://opendope.org/conditions\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:cdr=\"http://schemas.openxmlformats.org/drawingml/2006/chartDrawing\" xmlns:odi=\"http://opendope.org/components\" xmlns:msink=\"http://schemas.microsoft.com/ink/2010/main\" xmlns:cdr14=\"http://schemas.microsoft.com/office/drawing/2010/chartDrawing\" xmlns:iact=\"http://schemas.microsoft.com/office/powerpoint/2014/inkAction\" xmlns:an18=\"http://schemas.microsoft.com/office/drawing/2018/animation\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:odq=\"http://opendope.org/questions\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:dsp=\"http://schemas.microsoft.com/office/drawing/2008/diagram\" xmlns:odx=\"http://opendope.org/xpaths\" xmlns:a15=\"http://schemas.microsoft.com/office/drawing/2012/main\" xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" xmlns:c15=\"http://schemas.microsoft.com/office/drawing/2012/chart\" xmlns:a13cmd=\"http://schemas.microsoft.com/office/drawing/2013/main/command\" xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\" xmlns:a16=\"http://schemas.microsoft.com/office/drawing/2014/main\" xmlns:odgm=\"http://opendope.org/SmartArt/DataHierarchy\" xmlns:c16=\"http://schemas.microsoft.com/office/drawing/2014/chart\" xmlns:dgm=\"http://schemas.openxmlformats.org/drawingml/2006/diagram\" xmlns:thm15=\"http://schemas.microsoft.com/office/thememl/2012/main\" xmlns:we=\"http://schemas.microsoft.com/office/webextensions/webextension/2010/11\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:ns39=\"http://www.w3.org/2003/InkML\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:sl=\"http://schemas.openxmlformats.org/schemaLibrary/2006/main\" xmlns:ns38=\"http://www.w3.org/1998/Math/MathML\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:dgm14=\"http://schemas.microsoft.com/office/drawing/2010/diagram\" xmlns:c16ac=\"http://schemas.microsoft.com/office/drawing/2014/chart/ac\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:cs=\"http://schemas.microsoft.com/office/drawing/2012/chartStyle\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:pic14=\"http://schemas.microsoft.com/office/drawing/2010/picture\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:lc=\"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas\" xmlns:wetp=\"http://schemas.microsoft.com/office/webextensions/taskpanes/2010/11\"><m:sSubSup><m:sSubSupPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sSubSupPr><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>C</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:e><m:sub><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sub><m:sup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>3</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sup></m:sSubSup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>(</m:t></m:r><m:f><m:fPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:fPr><m:num><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>3</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:num><m:den><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:den></m:f><m:sSup><m:sSupPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sSupPr><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>)</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:e><m:sup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>3</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sup></m:sSup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>(</m:t></m:r><m:f><m:fPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:fPr><m:num><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>1</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:num><m:den><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:den></m:f><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>)+</m:t></m:r><m:sSubSup><m:sSubSupPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sSubSupPr><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>C</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:e><m:sub><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sub><m:sup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sup></m:sSubSup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>(</m:t></m:r><m:f><m:fPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:fPr><m:num><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>3</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:num><m:den><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:den></m:f><m:sSup><m:sSupPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sSupPr><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>)</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:e><m:sup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>4</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:sup></m:sSup><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>=</m:t></m:r><m:f><m:fPr><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:fPr><m:num><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>189</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:num><m:den><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr><m:t>256</m:t></m:r><m:ctrlPr><w:rPr><w:rFonts w:hint=\"eastAsia\" w:ascii=\"DejaVu Math TeX Gyre\" w:hAnsi=\"DejaVu Math TeX Gyre\" w:eastAsia=\"微软雅黑\" w:cs=\"微软雅黑\"/><w:kern w:val=\"2\"/><w:sz w:val=\"18\"/><w:szCs w:val=\"18\"/><w:lang w:val=\"en-US\" w:eastAsia=\"zh-CN\" w:bidi=\"ar-SA\"/></w:rPr></m:ctrlPr></m:den></m:f></m:oMath>",
+  "x5" : "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:cx1=\"http://schemas.microsoft.com/office/drawing/2015/9/8/chartex\" xmlns:cx2=\"http://schemas.microsoft.com/office/drawing/2015/10/21/chartex\" xmlns:cx3=\"http://schemas.microsoft.com/office/drawing/2016/5/9/chartex\" xmlns:cx4=\"http://schemas.microsoft.com/office/drawing/2016/5/10/chartex\" xmlns:cx5=\"http://schemas.microsoft.com/office/drawing/2016/5/11/chartex\" xmlns:cx6=\"http://schemas.microsoft.com/office/drawing/2016/5/12/chartex\" xmlns:cx7=\"http://schemas.microsoft.com/office/drawing/2016/5/13/chartex\" xmlns:cx8=\"http://schemas.microsoft.com/office/drawing/2016/5/14/chartex\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:aink=\"http://schemas.microsoft.com/office/drawing/2016/ink\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:oel=\"http://schemas.microsoft.com/office/2019/extlst\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w16cex=\"http://schemas.microsoft.com/office/word/2018/wordml/cex\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:w16=\"http://schemas.microsoft.com/office/word/2018/wordml\" xmlns:w16du=\"http://schemas.microsoft.com/office/word/2023/wordml/word16du\" xmlns:w16sdtdh=\"http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash\" xmlns:w16sdtfl=\"http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\"><m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>∀</m:t></m:r><m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\" w:hint=\"eastAsia\"/></w:rPr><m:t>x</m:t></m:r><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\" w:hint=\"eastAsia\"/></w:rPr><m:t>∈</m:t></m:r><m:r><m:rPr><m:sty m:val=\"b\"/></m:rPr><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>Z</m:t></m:r></m:oMath>",
+  "x6" : "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:cx1=\"http://schemas.microsoft.com/office/drawing/2015/9/8/chartex\" xmlns:cx2=\"http://schemas.microsoft.com/office/drawing/2015/10/21/chartex\" xmlns:cx3=\"http://schemas.microsoft.com/office/drawing/2016/5/9/chartex\" xmlns:cx4=\"http://schemas.microsoft.com/office/drawing/2016/5/10/chartex\" xmlns:cx5=\"http://schemas.microsoft.com/office/drawing/2016/5/11/chartex\" xmlns:cx6=\"http://schemas.microsoft.com/office/drawing/2016/5/12/chartex\" xmlns:cx7=\"http://schemas.microsoft.com/office/drawing/2016/5/13/chartex\" xmlns:cx8=\"http://schemas.microsoft.com/office/drawing/2016/5/14/chartex\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:aink=\"http://schemas.microsoft.com/office/drawing/2016/ink\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:oel=\"http://schemas.microsoft.com/office/2019/extlst\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w16cex=\"http://schemas.microsoft.com/office/word/2018/wordml/cex\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:w16=\"http://schemas.microsoft.com/office/word/2018/wordml\" xmlns:w16du=\"http://schemas.microsoft.com/office/word/2023/wordml/word16du\" xmlns:w16sdtdh=\"http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash\" xmlns:w16sdtfl=\"http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\"><m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>∄x∈</m:t></m:r><m:r><m:rPr><m:sty m:val=\"b\"/></m:rPr><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>R</m:t></m:r></m:oMath>",
+  "x7" : "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:cx1=\"http://schemas.microsoft.com/office/drawing/2015/9/8/chartex\" xmlns:cx2=\"http://schemas.microsoft.com/office/drawing/2015/10/21/chartex\" xmlns:cx3=\"http://schemas.microsoft.com/office/drawing/2016/5/9/chartex\" xmlns:cx4=\"http://schemas.microsoft.com/office/drawing/2016/5/10/chartex\" xmlns:cx5=\"http://schemas.microsoft.com/office/drawing/2016/5/11/chartex\" xmlns:cx6=\"http://schemas.microsoft.com/office/drawing/2016/5/12/chartex\" xmlns:cx7=\"http://schemas.microsoft.com/office/drawing/2016/5/13/chartex\" xmlns:cx8=\"http://schemas.microsoft.com/office/drawing/2016/5/14/chartex\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:aink=\"http://schemas.microsoft.com/office/drawing/2016/ink\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:oel=\"http://schemas.microsoft.com/office/2019/extlst\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w16cex=\"http://schemas.microsoft.com/office/word/2018/wordml/cex\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:w16=\"http://schemas.microsoft.com/office/word/2018/wordml\" xmlns:w16du=\"http://schemas.microsoft.com/office/word/2023/wordml/word16du\" xmlns:w16sdtdh=\"http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash\" xmlns:w16sdtfl=\"http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\"><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>∃</m:t></m:r><m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>x</m:t></m:r><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>∉</m:t></m:r><m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\" w:hAnsi=\"Cambria Math\"/></w:rPr><m:t>R</m:t></m:r></m:oMath>",
+  "x8" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><mi>P</mi><mo>(</mo><mi>X</mi><mo>=</mo><mn>1</mn><mo>)</mo><mo>=</mo><msubsup><mrow><mi mathvariant=\"normal\">C</mi></mrow><mrow><mn>4</mn></mrow><mrow><mn>1</mn></mrow></msubsup><mo>(</mo><mfrac><mrow><mn>1</mn></mrow><mrow><mn>4</mn></mrow></mfrac><msup><mrow><mo>)</mo></mrow><mrow><mn>1</mn></mrow></msup><mo>(</mo><mfrac><mrow><mn>3</mn></mrow><mrow><mn>4</mn></mrow></mfrac><msup><mrow><mo>)</mo></mrow><mrow><mn>3</mn></mrow></msup><mo>=</mo><mfrac><mrow><mn>27</mn></mrow><mrow><mn>64</mn></mrow></mfrac></math>",
+  "x9" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><msup><mrow><mi mathvariant=\"normal\">e</mi></mrow><mrow><mi>x</mi></mrow></msup><mo>+</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mn>1</mn></mrow><mrow><mi>y</mi></mrow></mfrac><mo>+</mo><mi mathvariant=\"normal\">l</mi><mi mathvariant=\"normal\">n</mi><mfrac><mrow><mn>1</mn></mrow><mrow><mi>y</mi></mrow></mfrac><mo>=</mo><mi mathvariant=\"normal\">l</mi><mi mathvariant=\"normal\">n</mi><mfrac><mrow><mn>1</mn></mrow><mrow><mi>y</mi></mrow></mfrac><mo>+</mo><msup><mrow><mi mathvariant=\"normal\">e</mi></mrow><mrow><mi mathvariant=\"normal\">l</mi><mi mathvariant=\"normal\">n</mi><mfrac><mrow><mn>1</mn></mrow><mrow><mi>y</mi></mrow></mfrac></mrow></msup></math>",
+  "x10" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><msub><mrow><mi>T</mi></mrow><mrow><mi>r</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><msubsup><mrow><mi mathvariant=\"normal\">C</mi></mrow><mrow><mn>6</mn></mrow><mrow><mi>r</mi></mrow></msubsup><msup><mrow><mn>2</mn></mrow><mrow><mn>6</mn><mo>-</mo><mi>r</mi></mrow></msup><msup><mrow><mi>x</mi></mrow><mrow><mn>6</mn><mo>-</mo><mfrac><mrow><mn>3</mn><mi>r</mi></mrow><mrow><mn>2</mn></mrow></mfrac></mrow></msup></math>",
+  "x11" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><mi>P</mi><mo>(</mo><mover accent=\"false\"><mrow><mi>B</mi></mrow><mo>¯</mo></mover><mo>|</mo><mi>A</mi><mo>)</mo><mo>=</mo><mfrac><mrow><mi>P</mi><mo>(</mo><mover accent=\"false\"><mrow><mi>B</mi></mrow><mo>¯</mo></mover><mo>)</mo><mi>P</mi><mo>(</mo><mi>A</mi><mo>)</mo></mrow><mrow><mi>P</mi><mo>(</mo><mi>A</mi><mo>)</mo></mrow></mfrac><mo>=</mo><mi>P</mi><mo>(</mo><mover accent=\"false\"><mrow><mi>B</mi></mrow><mo>¯</mo></mover><mo>)</mo><mo>=</mo><mfrac><mrow><mn>3</mn></mrow><mrow><mn>4</mn></mrow></mfrac></math>",
+  "x12" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><msub><mrow><mi>T</mi></mrow><mrow><mi>r</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><msubsup><mrow><mi mathvariant=\"normal\">C</mi></mrow><mrow><mn>8</mn></mrow><mrow><mi>r</mi></mrow></msubsup><mo>(</mo><mn>2</mn><mi>x</mi><msup><mrow><mo>)</mo></mrow><mrow><mn>8</mn><mo>-</mo><mi>r</mi></mrow></msup><mo>(</mo><mo>-</mo><mfrac><mrow><mi>a</mi></mrow><mrow><mi>x</mi></mrow></mfrac><msup><mrow><mo>)</mo></mrow><mrow><mi>r</mi></mrow></msup><mo>=</mo><mo>(</mo><mo>-</mo><mi>a</mi><msup><mrow><mo>)</mo></mrow><mrow><mi>r</mi></mrow></msup><msup><mrow><mn>2</mn></mrow><mrow><mn>8</mn><mo>-</mo><mi>r</mi></mrow></msup><msubsup><mrow><mi mathvariant=\"normal\">C</mi></mrow><mrow><mn>8</mn></mrow><mrow><mi>r</mi></mrow></msubsup><msup><mrow><mi>x</mi></mrow><mrow><mn>8</mn><mo>-</mo><mn>2</mn><mi>r</mi></mrow></msup></math>",
+  "x13" : "<math display=\"inline\" xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><msubsup><mrow><mi mathvariant=\"normal\">C</mi></mrow><mrow><mn>3</mn></mrow><mrow><mn>2</mn></mrow></msubsup><mo>×</mo><mo>(</mo><mn>1</mn><mo>-</mo><mfrac><mrow><mn>2</mn></mrow><mrow><mn>3</mn></mrow></mfrac><mo>)</mo><mo>×</mo><mo>(</mo><mfrac><mrow><mn>2</mn></mrow><mrow><mn>3</mn></mrow></mfrac><msup><mrow><mo>)</mo></mrow><mrow><mn>2</mn></mrow></msup><mo>×</mo><mo>[</mo><mn>1</mn><mo>-</mo><mo>(</mo><mfrac><mrow><mn>3</mn></mrow><mrow><mn>4</mn></mrow></mfrac><msup><mrow><mo>)</mo></mrow><mrow><mn>2</mn></mrow></msup><mo>]</mo><mo>=</mo><mfrac><mrow><mn>7</mn></mrow><mrow><mn>36</mn></mrow></mfrac></math>"
+}
\ No newline at end of file
diff --git a/scripts/omml_mathml2latex/omml_mathml2latex.py b/scripts/omml_mathml2latex/omml_mathml2latex.py
new file mode 100644
index 0000000..0050efb
--- /dev/null
+++ b/scripts/omml_mathml2latex/omml_mathml2latex.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Standalone CLI runner for omml2tex converter.
+execute: python /path/omml_mathml2latex.py --json input.json
+"""
+
+import sys
+import os
+
+# 添加项目根目录到系统路径（上两级目录）
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+# 直接导入主模块，避免通过 __init__.py 的相对导入
+from omml_mathml2latex.__main__ import main
+
+if __name__ == '__main__':
+    default_args = [
+        '--output-format', 'json',
+        '--parallel',
+        '--quiet'
+    ]
+    sys.argv.extend(default_args)
+    sys.exit(main())
diff --git a/scripts/omml_mathml2latex/parallel/__init__.py b/scripts/omml_mathml2latex/parallel/__init__.py
new file mode 100644
index 0000000..1644089
--- /dev/null
+++ b/scripts/omml_mathml2latex/parallel/__init__.py
@@ -0,0 +1,13 @@
+"""
+Parallel processing module for omml2tex.
+
+Provides multiprocessing and multithreading capabilities for efficient
+batch conversion of equations.
+"""
+
+from .batch_processor import ParallelConverter, BatchProcessor
+
+__all__ = [
+    'ParallelConverter',
+    'BatchProcessor',
+]
diff --git a/scripts/omml_mathml2latex/parallel/batch_processor.py b/scripts/omml_mathml2latex/parallel/batch_processor.py
new file mode 100644
index 0000000..6e72af0
--- /dev/null
+++ b/scripts/omml_mathml2latex/parallel/batch_processor.py
@@ -0,0 +1,449 @@
+"""
+Batch processor with multiprocessing and multithreading support.
+
+This module provides parallel processing capabilities for converting
+large batches of equations efficiently.
+"""
+
+import os
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from typing import List, Dict, Any, Optional, Callable
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ParallelConverter:
+    """
+    Parallel equation converter using multiprocessing.
+
+    This class handles CPU-bound equation conversion across multiple processes
+    to bypass Python's GIL and maximize CPU utilization.
+
+    Example:
+        >>> converter = ParallelConverter(workers=4)
+        >>> results = converter.convert_batch(mathml_equations, subject_mode='math')
+        >>> successful = [r for r in results if r['success']]
+    """
+
+    def __init__(
+        self,
+        workers: Optional[int] = None,
+        subject_mode: str = "auto",
+        wrap_identifiers: bool = False,
+        prefer_xlongequal: bool = True,
+        universal_delimiter_scaling: bool = True,
+        show_progress: bool = True,
+    ):
+        """
+        Initialize parallel converter.
+
+        Args:
+            workers: Number of worker processes (default: CPU count)
+            subject_mode: Subject-specific formatting mode
+            wrap_identifiers: Whether to wrap identifiers in \\mathrm{}
+            prefer_xlongequal: Whether to use \\xlongequal for arrows
+            universal_delimiter_scaling: Whether to add \\left\\right to all delimiters
+            show_progress: Whether to show progress bar
+        """
+        self.workers = workers or min(mp.cpu_count(), 8)  # Cap at 8 to avoid overhead
+        self.subject_mode = subject_mode
+        self.wrap_identifiers = wrap_identifiers
+        self.prefer_xlongequal = prefer_xlongequal
+        self.universal_delimiter_scaling = universal_delimiter_scaling
+        self.show_progress = show_progress
+
+    def convert_batch(
+        self,
+        mathml_equations: List[str],
+        quiet: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """
+        Convert a batch of MathML equations to LaTeX in parallel.
+
+        Args:
+            mathml_equations: List of MathML equation strings
+            quiet: Suppress progress output
+
+        Returns:
+            List of result dictionaries with keys:
+            - 'index': Original equation index
+            - 'latex': Converted LaTeX (if successful)
+            - 'success': Boolean success flag
+            - 'error': Error message (if failed)
+
+        Example:
+            >>> equations = ['<math><mi>x</mi></math>', '<math><mi>y</mi></math>']
+            >>> results = converter.convert_batch(equations)
+            >>> all(r['success'] for r in results)
+            True
+        """
+        if not mathml_equations:
+            return []
+
+        # For small batches, sequential processing is faster due to overhead
+        if len(mathml_equations) < 5:
+            return self._convert_sequential(mathml_equations, quiet)
+
+        # Prepare conversion tasks
+        tasks = [
+            {
+                'index': i,
+                'mathml': eq,
+                'subject_mode': self.subject_mode,
+                'wrap_identifiers': self.wrap_identifiers,
+                'prefer_xlongequal': self.prefer_xlongequal,
+                'universal_delimiter_scaling': self.universal_delimiter_scaling,
+            }
+            for i, eq in enumerate(mathml_equations)
+        ]
+
+        results = []
+
+        try:
+            with ProcessPoolExecutor(max_workers=self.workers) as executor:
+                # Submit all tasks
+                future_to_task = {
+                    executor.submit(_convert_single_equation, task): task
+                    for task in tasks
+                }
+
+                # Collect results as they complete
+                completed = 0
+                total = len(tasks)
+
+                for future in as_completed(future_to_task):
+                    task = future_to_task[future]
+                    completed += 1
+
+                    try:
+                        result = future.result()
+                        results.append(result)
+
+                        if not quiet and self.show_progress:
+                            print(f"\rProgress: {completed}/{total} equations processed", end='', flush=True)
+
+                    except Exception as e:
+                        logger.error(f"Failed to convert equation {task['index']}: {e}")
+                        results.append({
+                            'index': task['index'],
+                            'success': False,
+                            'error': str(e),
+                        })
+
+                if not quiet and self.show_progress:
+                    print()  # New line after progress
+
+        except Exception as e:
+            logger.error(f"Parallel processing failed: {e}. Falling back to sequential.")
+            return self._convert_sequential(mathml_equations, quiet)
+
+        # Sort results by original index to maintain order
+        results.sort(key=lambda r: r['index'])
+        return results
+
+    def _convert_sequential(
+        self,
+        mathml_equations: List[str],
+        quiet: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """
+        Fallback sequential conversion (single-threaded).
+
+        Args:
+            mathml_equations: List of MathML equations
+            quiet: Suppress output
+
+        Returns:
+            List of conversion results
+        """
+        # Import here to avoid circular dependencies
+        from ..compat import LegacyMathMLToTeXConverter
+
+        converter = LegacyMathMLToTeXConverter(
+            wrap_identifiers_in_mathrm=self.wrap_identifiers,
+            prefer_xlongequal=self.prefer_xlongequal,
+            subject_mode=self.subject_mode,
+            universal_delimiter_scaling=self.universal_delimiter_scaling,
+        )
+
+        results = []
+        for i, mathml in enumerate(mathml_equations):
+            try:
+                latex = converter.convert(mathml)
+                results.append({
+                    'index': i,
+                    'latex': latex,
+                    'success': True,
+                })
+            except Exception as e:
+                results.append({
+                    'index': i,
+                    'success': False,
+                    'error': str(e),
+                })
+
+            if not quiet and self.show_progress:
+                print(f"\rProgress: {i+1}/{len(mathml_equations)} equations processed", end='', flush=True)
+
+        if not quiet and self.show_progress:
+            print()  # New line
+
+        return results
+
+
+class BatchProcessor:
+    """
+    Batch file processor with parallel file and equation processing.
+
+    Processes multiple DOCX files in parallel, with parallel equation
+    conversion within each file.
+
+    Example:
+        >>> processor = BatchProcessor(file_workers=2, equation_workers=4)
+        >>> results = processor.process_files(['doc1.docx', 'doc2.docx'])
+    """
+
+    def __init__(
+        self,
+        file_workers: Optional[int] = None,
+        equation_workers: Optional[int] = None,
+        subject_mode: str = "auto",
+        wrap_identifiers: bool = False,
+        prefer_xlongequal: bool = True,
+    ):
+        """
+        Initialize batch processor.
+
+        Args:
+            file_workers: Workers for parallel file I/O (default: 2)
+            equation_workers: Workers for parallel equation conversion (default: CPU count)
+            subject_mode: Subject formatting mode
+            wrap_identifiers: Wrap identifiers in \\mathrm{}
+            prefer_xlongequal: Use \\xlongequal for arrows
+        """
+        self.file_workers = file_workers or 2
+        self.equation_workers = equation_workers
+        self.subject_mode = subject_mode
+        self.wrap_identifiers = wrap_identifiers
+        self.prefer_xlongequal = prefer_xlongequal
+
+    def process_files(
+        self,
+        docx_paths: List[str],
+        output_dir: Optional[str] = None,
+        quiet: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Process multiple DOCX files in parallel.
+
+        Args:
+            docx_paths: List of DOCX file paths
+            output_dir: Optional output directory for results
+            quiet: Suppress progress output
+
+        Returns:
+            Dictionary with processing statistics and results
+
+        Example:
+            >>> files = ['test1.docx', 'test2.docx']
+            >>> results = processor.process_files(files, output_dir='output/')
+            >>> print(f"Processed {results['total_equations']} equations")
+        """
+        if not docx_paths:
+            return {'files_processed': 0, 'total_equations': 0, 'results': []}
+
+        # For small file counts, sequential is fine
+        if len(docx_paths) <= 2:
+            return self._process_files_sequential(docx_paths, output_dir, quiet)
+
+        results = []
+        total_equations = 0
+
+        try:
+            with ThreadPoolExecutor(max_workers=self.file_workers) as executor:
+                # Submit file processing tasks
+                future_to_path = {
+                    executor.submit(
+                        self._process_single_file,
+                        path,
+                        output_dir,
+                        quiet,
+                    ): path
+                    for path in docx_paths
+                }
+
+                # Collect results
+                for future in as_completed(future_to_path):
+                    path = future_to_path[future]
+                    try:
+                        result = future.result()
+                        results.append(result)
+                        total_equations += result['equation_count']
+
+                        if not quiet:
+                            print(f"✓ Processed {path}: {result['equation_count']} equations")
+
+                    except Exception as e:
+                        logger.error(f"Failed to process {path}: {e}")
+                        results.append({
+                            'file': path,
+                            'success': False,
+                            'error': str(e),
+                        })
+
+        except Exception as e:
+            logger.error(f"Batch file processing failed: {e}")
+            return self._process_files_sequential(docx_paths, output_dir, quiet)
+
+        return {
+            'files_processed': len([r for r in results if r.get('success', False)]),
+            'total_files': len(docx_paths),
+            'total_equations': total_equations,
+            'results': results,
+        }
+
+    def _process_single_file(
+        self,
+        docx_path: str,
+        output_dir: Optional[str],
+        quiet: bool,
+    ) -> Dict[str, Any]:
+        """
+        Process a single DOCX file.
+
+        Args:
+            docx_path: Path to DOCX file
+            output_dir: Output directory
+            quiet: Suppress output
+
+        Returns:
+            Processing result dictionary
+        """
+        from ..parsers import InputParserFactory
+
+        try:
+            # Parse DOCX to get MathML equations
+            parser = InputParserFactory.create_parser(docx_path, parser_type='docx')
+            mathml_equations = parser.parse(docx_path)
+
+            # Convert equations in parallel
+            converter = ParallelConverter(
+                workers=self.equation_workers,
+                subject_mode=self.subject_mode,
+                wrap_identifiers=self.wrap_identifiers,
+                prefer_xlongequal=self.prefer_xlongequal,
+                show_progress=not quiet,
+            )
+
+            conversion_results = converter.convert_batch(mathml_equations, quiet=quiet)
+
+            # Optionally write output
+            if output_dir:
+                self._write_output(docx_path, conversion_results, output_dir)
+
+            return {
+                'file': docx_path,
+                'success': True,
+                'equation_count': len(mathml_equations),
+                'successful_conversions': sum(1 for r in conversion_results if r['success']),
+                'results': conversion_results,
+            }
+
+        except Exception as e:
+            logger.error(f"Error processing {docx_path}: {e}")
+            return {
+                'file': docx_path,
+                'success': False,
+                'error': str(e),
+            }
+
+    def _process_files_sequential(
+        self,
+        docx_paths: List[str],
+        output_dir: Optional[str],
+        quiet: bool,
+    ) -> Dict[str, Any]:
+        """Sequential fallback for file processing."""
+        results = []
+        total_equations = 0
+
+        for path in docx_paths:
+            result = self._process_single_file(path, output_dir, quiet)
+            results.append(result)
+            if result.get('success'):
+                total_equations += result['equation_count']
+
+        return {
+            'files_processed': len([r for r in results if r.get('success', False)]),
+            'total_files': len(docx_paths),
+            'total_equations': total_equations,
+            'results': results,
+        }
+
+    def _write_output(
+        self,
+        docx_path: str,
+        results: List[Dict[str, Any]],
+        output_dir: str,
+    ) -> None:
+        """Write conversion results to output file."""
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        # Generate output filename
+        input_name = Path(docx_path).stem
+        output_file = output_path / f"{input_name}_converted.tex"
+
+        # Write LaTeX equations
+        with open(output_file, 'w', encoding='utf-8') as f:
+            for i, result in enumerate(results, 1):
+                if result['success']:
+                    f.write(f"% Equation {i}\n")
+                    f.write(f"${result['latex']}$\n\n")
+                else:
+                    f.write(f"% Equation {i} - Error: {result.get('error', 'Unknown')}\n\n")
+
+
+def _convert_single_equation(task: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Worker function for parallel equation conversion.
+
+    This function is called in separate processes by ProcessPoolExecutor.
+    Must be defined at module level for pickling.
+
+    Args:
+        task: Dictionary with conversion parameters
+
+    Returns:
+        Result dictionary with conversion outcome
+    """
+    # Import here (in worker process) to avoid pickling issues
+    from ..compat import LegacyMathMLToTeXConverter
+
+    try:
+        # Create converter instance in worker process
+        converter = LegacyMathMLToTeXConverter(
+            wrap_identifiers_in_mathrm=task['wrap_identifiers'],
+            prefer_xlongequal=task['prefer_xlongequal'],
+            subject_mode=task['subject_mode'],
+            universal_delimiter_scaling=task['universal_delimiter_scaling'],
+        )
+
+        # Convert equation
+        latex = converter.convert(task['mathml'])
+
+        return {
+            'index': task['index'],
+            'latex': latex,
+            'success': True,
+        }
+
+    except Exception as e:
+        return {
+            'index': task['index'],
+            'success': False,
+            'error': str(e),
+        }
diff --git a/scripts/omml_mathml2latex/parsers/__init__.py b/scripts/omml_mathml2latex/parsers/__init__.py
new file mode 100644
index 0000000..f43f0c0
--- /dev/null
+++ b/scripts/omml_mathml2latex/parsers/__init__.py
@@ -0,0 +1,18 @@
+"""
+Input parser classes for handling different input formats.
+
+This package contains parser implementations for DOCX, OMML, and MathML
+input formats, along with a factory for auto-detection and creation.
+"""
+
+from .factory import InputParserFactory
+from .docx_parser import DocxParser
+from .omml_parser import OmmlParser
+from .mathml_parser import MathMLParser
+
+__all__ = [
+    'InputParserFactory',
+    'DocxParser',
+    'OmmlParser',
+    'MathMLParser',
+]
diff --git a/scripts/omml_mathml2latex/parsers/docx_parser.py b/scripts/omml_mathml2latex/parsers/docx_parser.py
new file mode 100644
index 0000000..b0568c2
--- /dev/null
+++ b/scripts/omml_mathml2latex/parsers/docx_parser.py
@@ -0,0 +1,143 @@
+"""
+DOCX parser for Microsoft Word documents.
+
+This parser handles .docx files, extracting OMML equations and converting
+them to MathML format using the existing DOCX processing pipeline.
+"""
+
+import os
+from typing import List
+from ..core.interfaces import Parser
+
+
+class DocxParser(Parser):
+    """
+    Parser for Microsoft Word .docx files.
+
+    This parser handles .docx files by extracting OMML equations and
+    converting them to MathML using the existing DOCX processing pipeline.
+
+    Examples:
+        Parse DOCX file:
+            >>> parser = DocxParser()
+            >>> results = parser.parse("equations.docx")
+            >>> isinstance(results, list)
+            True
+    """
+
+    def __init__(self):
+        """Initialize the DOCX parser."""
+        pass
+
+    def parse(self, source: str) -> List[str]:
+        """
+        Parse DOCX file and return list of MathML equation strings.
+
+        Args:
+            source: Path to .docx file
+
+        Returns:
+            List of MathML equation strings (extracted from DOCX)
+
+        Raises:
+            FileNotFoundError: If DOCX file doesn't exist
+            ValueError: If file is not a valid .docx file
+            RuntimeError: If DOCX processing fails
+
+        Examples:
+            >>> parser = DocxParser()
+            >>> # Assuming test.docx exists with equations
+            >>> results = parser.parse("test.docx")
+            >>> all(isinstance(eq, str) for eq in results)
+            True
+        """
+        # Validate file exists
+        if not os.path.exists(source):
+            raise FileNotFoundError(f"DOCX file not found: {source}")
+
+        # Validate file extension
+        if not source.lower().endswith('.docx'):
+            raise ValueError(f"File must have .docx extension: {source}")
+
+        # Import here to avoid circular dependencies
+        from ..processing import OMMLExtractor
+        from ..core import omml_to_mathml
+        from ..utils.styling_postprocessor import apply_styling_to_mathml_from_omml
+
+        # Get XSL path (in core module)
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        core_dir = os.path.join(os.path.dirname(current_dir), 'core')
+        xsl_path = os.path.join(core_dir, 'OMML2MML.xsl')
+
+        try:
+            # Extract OMML from DOCX using OMMLExtractor
+            extractor = OMMLExtractor()
+            equation_dicts = extractor.extract_from_docx(source)
+
+            if not equation_dicts:
+                # No equations found
+                return []
+
+            # Convert each OMML to MathML
+            results = []
+            for eq_dict in equation_dicts:
+                try:
+                    # Extract the cleaned OMML string from the dictionary
+                    omml_str = eq_dict.get('cleaned_omml', eq_dict.get('omml', ''))
+                    if not omml_str:
+                        continue
+
+                    # Step 1: XSLT transformation
+                    mathml_str = omml_to_mathml(omml_str, xsl_path)
+
+                    # Step 2: Post-process to fix table structure and add styling
+                    # CRITICAL: This fixes the OMML2MML.xsl bug where <mtr><mrow> should be <mtr><mtd>
+                    mathml_str = apply_styling_to_mathml_from_omml(omml_str, mathml_str)
+
+                    if mathml_str and mathml_str.strip():
+                        results.append(mathml_str)
+                except Exception as e:
+                    # Log error but continue with other equations
+                    print(f"Warning: Failed to convert OMML equation: {e}")
+                    continue
+
+            return results
+
+        except Exception as e:
+            raise RuntimeError(f"DOCX processing failed: {e}")
+
+    def can_handle(self, source: str) -> bool:
+        """
+        Check if this parser can handle the given input source.
+
+        Args:
+            source: Input source to check
+
+        Returns:
+            True if source is a .docx file, False otherwise
+
+        Examples:
+            >>> parser = DocxParser()
+            >>> parser.can_handle("equations.docx")
+            True
+            >>> parser.can_handle("<math><mi>x</mi></math>")
+            False
+        """
+        # Check file extension
+        if source.lower().endswith('.docx'):
+            return True
+
+        # Check if it's an existing file with .docx extension
+        if os.path.exists(source) and source.lower().endswith('.docx'):
+            return True
+
+        return False
+
+    @property
+    def parser_type(self) -> str:
+        """Get the parser type identifier."""
+        return "docx"
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return "DocxParser()"
diff --git a/scripts/omml_mathml2latex/parsers/factory.py b/scripts/omml_mathml2latex/parsers/factory.py
new file mode 100644
index 0000000..3643bea
--- /dev/null
+++ b/scripts/omml_mathml2latex/parsers/factory.py
@@ -0,0 +1,144 @@
+"""
+Input parser factory for auto-detecting and creating appropriate parsers.
+
+This module provides centralized parser creation with auto-detection
+support for determining the most appropriate parser based on input source.
+"""
+
+import os
+from typing import Union, List
+from ..core.interfaces import Parser
+
+
+class InputParserFactory:
+    """
+    Factory for creating input parsers based on source content.
+
+    This factory provides centralized parser creation with support for:
+    - Auto-detection based on file extension or content
+    - Explicit parser selection by type
+    - Clear error messages for unsupported formats
+    """
+
+    @staticmethod
+    def create_parser(source: str, parser_type: Union[str, None] = None) -> Parser:
+        """
+        Create an appropriate parser for the input source.
+
+        Args:
+            source: Input source (file path or content string)
+            parser_type: Optional explicit parser type
+                        ("docx", "omml", "mathml", or None for auto-detection)
+
+        Returns:
+            Parser instance appropriate for the source
+
+        Raises:
+            ValueError: If input format cannot be determined or is unsupported
+
+        Examples:
+            >>> factory = InputParserFactory()
+            >>> parser = factory.create_parser("equations.docx")
+            >>> isinstance(parser, DocxParser)
+            True
+
+            >>> parser = factory.create_parser("<math><mi>x</mi></math>")
+            >>> isinstance(parser, MathMLParser)
+            True
+
+            >>> parser = factory.create_parser(xml_content, parser_type="omml")
+            >>> isinstance(parser, OmmlParser)
+            True
+        """
+        # Import here to avoid circular dependencies
+        from .docx_parser import DocxParser
+        from .omml_parser import OmmlParser
+        from .mathml_parser import MathMLParser
+
+        # Explicit parser type specified
+        if parser_type:
+            parser_type = parser_type.lower()
+            if parser_type == "docx":
+                return DocxParser()
+            elif parser_type == "omml":
+                return OmmlParser()
+            elif parser_type == "mathml":
+                return MathMLParser()
+            else:
+                raise ValueError(f"Unknown parser type: {parser_type}")
+
+        # Auto-detection based on source
+        # Check file extension first (most common case)
+        if source.endswith('.docx') or (os.path.exists(source) and source.lower().endswith('.docx')):
+            return DocxParser()
+
+        # Check content for XML markers
+        # Strip whitespace for reliable detection
+        content_start = source.strip()[:200]  # Check first 200 chars
+
+        # Check for OMML namespace
+        if '<m:oMath' in content_start or '<m:oMathPara' in content_start:
+            return OmmlParser()
+
+        # Check for MathML namespace
+        if '<math' in content_start or '<mml:math' in content_start:
+            return MathMLParser()
+
+        # If it's a file path but not .docx, check file content
+        if os.path.exists(source):
+            try:
+                with open(source, 'r', encoding='utf-8') as f:
+                    file_content = f.read(500)  # Read first 500 chars
+                    if '<m:oMath' in file_content:
+                        return OmmlParser()
+                    elif '<math' in file_content or '<mml:math' in file_content:
+                        return MathMLParser()
+            except (UnicodeDecodeError, IOError):
+                # Binary file or read error - not a supported format
+                pass
+
+        # Unable to determine format
+        preview = source if len(source) <= 100 else source[:100] + "..."
+        raise ValueError(
+            f"Unable to determine input format for source: '{preview}'. "
+            f"Supported formats: .docx files, OMML XML (<m:oMath), MathML XML (<math)"
+        )
+
+    @staticmethod
+    def detect_parser_type(source: str) -> str:
+        """
+        Detect the parser type needed for the input source.
+
+        Args:
+            source: Input source (file path or content string)
+
+        Returns:
+            Parser type string ("docx", "omml", or "mathml")
+
+        Raises:
+            ValueError: If input format cannot be determined
+
+        Examples:
+            >>> factory = InputParserFactory()
+            >>> factory.detect_parser_type("equations.docx")
+            'docx'
+
+            >>> factory.detect_parser_type("<math><mi>x</mi></math>")
+            'mathml'
+        """
+        parser = InputParserFactory.create_parser(source)
+        return parser.parser_type
+
+    @staticmethod
+    def get_supported_formats() -> List[str]:
+        """
+        Get list of supported input formats.
+
+        Returns:
+            List of format identifiers that can be parsed
+        """
+        return ["docx", "omml", "mathml"]
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return "InputParserFactory(docx, omml, mathml)"
diff --git a/scripts/omml_mathml2latex/parsers/mathml_parser.py b/scripts/omml_mathml2latex/parsers/mathml_parser.py
new file mode 100644
index 0000000..9911fd0
--- /dev/null
+++ b/scripts/omml_mathml2latex/parsers/mathml_parser.py
@@ -0,0 +1,168 @@
+"""
+MathML parser for direct MathML input.
+
+This parser handles MathML XML input, performing validation and extraction
+of individual math equations.
+"""
+
+import sys
+from typing import List
+from pathlib import Path
+from lxml import etree as ET
+from ..core.interfaces import Parser
+
+# Import utilities from omml_to_tex package for HTML entity decoding and equation extraction
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+from ..utils import decode_html_entities, extract_math_equations
+
+
+class MathMLParser(Parser):
+    """
+    Parser for MathML XML input.
+
+    This parser handles direct MathML XML input, performing basic validation
+    and extracting individual <math> elements.
+
+    Examples:
+        Single equation:
+            >>> parser = MathMLParser()
+            >>> mathml = "<math><mi>x</mi></math>"
+            >>> results = parser.parse(mathml)
+            >>> len(results)
+            1
+
+        Multiple equations:
+            >>> parser = MathMLParser()
+            >>> mathml = "<root><math><mi>x</mi></math><math><mi>y</mi></math></root>"
+            >>> results = parser.parse(mathml)
+            >>> len(results)
+            2
+    """
+
+    def __init__(self):
+        """Initialize the MathML parser."""
+        pass
+
+    def parse(self, source: str) -> List[str]:
+        """
+        Parse MathML input and return list of MathML equation strings.
+
+        Args:
+            source: MathML XML string or file path
+
+        Returns:
+            List of MathML equation strings (one per <math> element)
+
+        Raises:
+            ValueError: If input is not valid MathML XML
+            RuntimeError: If parsing fails
+
+        Examples:
+            >>> parser = MathMLParser()
+            >>> mathml = "<math><mi>x</mi><mo>+</mo><mi>y</mi></math>"
+            >>> results = parser.parse(mathml)
+            >>> len(results)
+            1
+            >>> '<mi>x</mi>' in results[0]
+            True
+        """
+        import os
+
+        # Check if source is a file path
+        if os.path.exists(source):
+            try:
+                with open(source, 'r', encoding='utf-8') as f:
+                    source = f.read()
+            except (IOError, UnicodeDecodeError) as e:
+                raise ValueError(f"Failed to read MathML file: {e}")
+
+        # STRATEGY 1: Try regex-based extraction first (handles multi-equation files + HTML entities)
+        # This is the same approach as the original omml_to_tex.py
+        try:
+            equations = extract_math_equations(source)
+            if equations:
+                return equations
+        except Exception:
+            # If regex extraction fails, fall through to XML parsing
+            pass
+
+        # STRATEGY 2: Try XML parsing as fallback (single well-formed document)
+        try:
+            root = ET.fromstring(source.encode('utf-8'))
+        except ET.XMLSyntaxError as e:
+            raise ValueError(f"Invalid XML syntax: {e}")
+
+        # Find all <math> elements
+        math_elements = []
+
+        # Check if root itself is a <math> element
+        if self._is_math_element(root):
+            math_elements.append(root)
+        else:
+            # Search for <math> elements (with or without namespace)
+            math_elements.extend(root.findall('.//{http://www.w3.org/1998/Math/MathML}math'))
+            math_elements.extend(root.findall('.//math'))
+
+        if not math_elements:
+            # No <math> elements found - treat entire document as one equation if it looks like MathML
+            if self._looks_like_mathml(root):
+                math_elements.append(root)
+            else:
+                raise ValueError("No <math> elements found in MathML input")
+
+        # Convert each <math> element to string
+        results = []
+        for math_elem in math_elements:
+            mathml_str = ET.tostring(math_elem, encoding='unicode')
+            results.append(mathml_str)
+
+        return results
+
+    def can_handle(self, source: str) -> bool:
+        """
+        Check if this parser can handle the given input source.
+
+        Args:
+            source: Input source to check
+
+        Returns:
+            True if source appears to be MathML, False otherwise
+
+        Examples:
+            >>> parser = MathMLParser()
+            >>> parser.can_handle("<math><mi>x</mi></math>")
+            True
+            >>> parser.can_handle("<m:oMath>...</m:oMath>")
+            False
+        """
+        # Check for MathML markers
+        content_start = source.strip()[:200]
+        return '<math' in content_start or '<mml:math' in content_start
+
+    @property
+    def parser_type(self) -> str:
+        """Get the parser type identifier."""
+        return "mathml"
+
+    def _is_math_element(self, element: ET.Element) -> bool:
+        """Check if element is a <math> element."""
+        local_name = element.tag.split('}')[-1] if '}' in element.tag else element.tag
+        return local_name == 'math'
+
+    def _looks_like_mathml(self, element: ET.Element) -> bool:
+        """Check if element tree looks like MathML content."""
+        # Check for common MathML element tags
+        mathml_tags = {'mi', 'mo', 'mn', 'mrow', 'mfrac', 'msup', 'msub', 'mtext'}
+
+        # Get all element tags in tree
+        all_tags = set()
+        for elem in element.iter():
+            local_name = elem.tag.split('}')[-1] if '}' in elem.tag else elem.tag
+            all_tags.add(local_name)
+
+        # If at least 2 MathML tags present, consider it MathML
+        return len(all_tags & mathml_tags) >= 2
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return "MathMLParser()"
diff --git a/scripts/omml_mathml2latex/parsers/omml_parser.py b/scripts/omml_mathml2latex/parsers/omml_parser.py
new file mode 100644
index 0000000..4e8ee37
--- /dev/null
+++ b/scripts/omml_mathml2latex/parsers/omml_parser.py
@@ -0,0 +1,183 @@
+"""
+OMML parser for Office Math Markup Language input.
+
+This parser handles OMML XML input from Microsoft Office, converting it
+to MathML format using the existing OMML processing pipeline.
+"""
+
+from typing import List
+from lxml import etree as ET
+from ..core.interfaces import Parser
+
+
+class OmmlParser(Parser):
+    """
+    Parser for OMML (Office Math Markup Language) XML input.
+
+    This parser handles OMML XML from Microsoft Office documents, converting
+    it to MathML using the existing OMML transformation pipeline.
+
+    Examples:
+        Single OMML equation:
+            >>> parser = OmmlParser()
+            >>> omml = '<m:oMath xmlns:m="http://..."><m:r><m:t>x</m:t></m:r></m:oMath>'
+            >>> results = parser.parse(omml)
+            >>> len(results) >= 1
+            True
+    """
+
+    def __init__(self):
+        """Initialize the OMML parser."""
+        pass
+
+    def parse(self, source: str) -> List[str]:
+        """
+        Parse OMML input and return list of MathML equation strings.
+
+        Args:
+            source: OMML XML string or file path
+
+        Returns:
+            List of MathML equation strings (converted from OMML)
+
+        Raises:
+            ValueError: If input is not valid OMML XML
+            RuntimeError: If OMML to MathML conversion fails
+
+        Examples:
+            >>> parser = OmmlParser()
+            >>> omml = '<m:oMath xmlns:m="http://...">...</m:oMath>'
+            >>> results = parser.parse(omml)
+            >>> isinstance(results, list)
+            True
+        """
+        import os
+
+        # Check if source is a file path
+        if os.path.exists(source):
+            try:
+                with open(source, 'r', encoding='utf-8') as f:
+                    source = f.read()
+            except (IOError, UnicodeDecodeError) as e:
+                raise ValueError(f"Failed to read OMML file: {e}")
+
+        # Parse XML
+        try:
+            root = ET.fromstring(source.encode('utf-8'))
+        except ET.XMLSyntaxError as e:
+            raise ValueError(f"Invalid XML syntax: {e}")
+
+        # Find all OMML math elements
+        # OMML uses <m:oMath> or <m:oMathPara> elements
+        omml_ns = {'m': 'http://schemas.openxmlformats.org/officeDocument/2006/math'}
+
+        # Find oMath elements (with or without namespace)
+        omath_elements = []
+        omath_elements.extend(root.findall('.//m:oMath', omml_ns))
+        omath_elements.extend(root.findall('.//m:oMathPara', omml_ns))
+
+        # Try without namespace (in case it's not declared)
+        if not omath_elements:
+            for elem in root.iter():
+                local_name = elem.tag.split('}')[-1] if '}' in elem.tag else elem.tag
+                if local_name in ('oMath', 'oMathPara'):
+                    omath_elements.append(elem)
+
+        if not omath_elements:
+            # Check if root itself is an OMML element
+            root_local = root.tag.split('}')[-1] if '}' in root.tag else root.tag
+            if root_local in ('oMath', 'oMathPara'):
+                omath_elements.append(root)
+            else:
+                raise ValueError("No OMML math elements (<m:oMath> or <m:oMathPara>) found in input")
+
+        # Convert each OMML element to MathML
+        results = []
+        for omml_elem in omath_elements:
+            try:
+                mathml_str = self._omml_to_mathml(omml_elem)
+                if mathml_str and mathml_str.strip():
+                    results.append(mathml_str)
+            except Exception as e:
+                # Log error but continue with other equations
+                print(f"Warning: Failed to convert OMML element: {e}")
+                continue
+
+        if not results:
+            raise RuntimeError("Failed to convert any OMML elements to MathML")
+
+        return results
+
+    def can_handle(self, source: str) -> bool:
+        """
+        Check if this parser can handle the given input source.
+
+        Args:
+            source: Input source to check
+
+        Returns:
+            True if source appears to be OMML, False otherwise
+
+        Examples:
+            >>> parser = OmmlParser()
+            >>> parser.can_handle("<m:oMath>...</m:oMath>")
+            True
+            >>> parser.can_handle("<math><mi>x</mi></math>")
+            False
+        """
+        # Check for OMML markers
+        content_start = source.strip()[:200]
+        return '<m:oMath' in content_start or '<m:oMathPara' in content_start
+
+    @property
+    def parser_type(self) -> str:
+        """Get the parser type identifier."""
+        return "omml"
+
+    def _omml_to_mathml(self, omml_element: ET.Element) -> str:
+        """
+        Convert OMML element to MathML string with styling preservation.
+
+        This wraps the existing OMML to MathML conversion from the core module,
+        and adds post-processing to preserve styling (bold, fonts, colors) that
+        the XSLT stylesheet doesn't preserve.
+
+        Args:
+            omml_element: OMML XML element
+
+        Returns:
+            MathML string with styling attributes
+
+        Raises:
+            RuntimeError: If conversion fails
+        """
+        # Import here to avoid circular dependencies
+        import os
+        from ..core import omml_to_mathml
+        from ..utils.styling_postprocessor import apply_styling_to_mathml_from_omml
+
+        try:
+            # Convert OMML element to string
+            omml_str = ET.tostring(omml_element, encoding='unicode')
+
+            # Get XSL path (in core module)
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            core_dir = os.path.join(os.path.dirname(current_dir), 'core')
+            xsl_path = os.path.join(core_dir, 'OMML2MML.xsl')
+
+            # Step 1: Use XSLT to convert OMML to MathML
+            mathml_str = omml_to_mathml(omml_str, xsl_path)
+
+            # Step 2: Post-process to add styling (bold, fonts, colors)
+            # The XSLT doesn't preserve m:sty, m:scr, w:color, etc.
+            # This step extracts styling from OMML and applies to MathML
+            mathml_str = apply_styling_to_mathml_from_omml(omml_str, mathml_str)
+
+            return mathml_str
+
+        except Exception as e:
+            raise RuntimeError(f"OMML to MathML conversion failed: {e}")
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return "OmmlParser()"
diff --git a/scripts/omml_mathml2latex/processing/__init__.py b/scripts/omml_mathml2latex/processing/__init__.py
new file mode 100644
index 0000000..9303652
--- /dev/null
+++ b/scripts/omml_mathml2latex/processing/__init__.py
@@ -0,0 +1,27 @@
+"""
+Input/output processing module for OMML and DOCX files.
+
+This module handles:
+- DOCX file processing and equation extraction
+- OMML extraction from Word documents
+- LaTeX output formatting (inline, display, various delimiters)
+- Result data structures
+"""
+
+from .result import ConversionResult
+from .omml_extractor import OMMLExtractor
+from .docx_processor import DocxProcessor
+from .output_formatter import (
+    format_latex,
+    save_results,
+    generate_html_preview,
+)
+
+__all__ = [
+    "ConversionResult",
+    "OMMLExtractor",
+    "DocxProcessor",
+    "format_latex",
+    "save_results",
+    "generate_html_preview",
+]
diff --git a/scripts/omml_mathml2latex/processing/docx_processor.py b/scripts/omml_mathml2latex/processing/docx_processor.py
new file mode 100644
index 0000000..8aeab57
--- /dev/null
+++ b/scripts/omml_mathml2latex/processing/docx_processor.py
@@ -0,0 +1,156 @@
+"""
+DOCX file processing and end-to-end conversion.
+
+This module provides the DocxProcessor class which orchestrates the complete
+conversion pipeline from DOCX to LaTeX, including OMML extraction, MathML
+transformation, and LaTeX conversion.
+"""
+
+import logging
+import time
+from typing import List
+from .result import ConversionResult
+from .omml_extractor import OMMLExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class DocxProcessor:
+    """Process DOCX files and convert all OMML equations to LaTeX.
+
+    This class coordinates:
+    - OMML extraction from DOCX (via OMMLExtractor)
+    - OMML → MathML transformation (via omml_to_mathml function)
+    - MathML → LaTeX conversion (via MathMLToTeXConverter)
+
+    Example:
+        >>> from omml2tex.compat import LegacyMathMLToTeXConverter
+        >>> processor = DocxProcessor(
+        ...     xsl_path='OMML2MML.xsl',
+        ...     converter=MathMLToTeXConverter()
+        ... )
+        >>> results = processor.process_docx('document.docx')
+        >>> for result in results:
+        ...     if result.success:
+        ...         print(result.latex)
+    """
+
+    def __init__(self, xsl_path: str, converter, subject_mode: str = "auto"):
+        """Initialize DOCX processor.
+
+        Args:
+            xsl_path: Path to OMML2MML.xsl transformation file
+            converter: MathMLToTeXConverter instance
+            subject_mode: Subject mode for conversion ('auto', 'math', 'chemistry', 'physics')
+        """
+        self.extractor = OMMLExtractor()
+        self.xsl_path = xsl_path
+        self.converter = converter
+        self.subject_mode = subject_mode
+
+    def process_docx(self, docx_path: str, omml_to_mathml_func=None) -> List[ConversionResult]:
+        """Process a DOCX file and convert all equations.
+
+        Args:
+            docx_path: Path to DOCX file
+            omml_to_mathml_func: Function to convert OMML to MathML (for dependency injection)
+
+        Returns:
+            List of ConversionResult objects
+
+        Example:
+            >>> results = processor.process_docx('test.docx')
+            >>> successful = [r for r in results if r.success]
+            >>> print(f"{len(successful)}/{len(results)} equations converted")
+        """
+        results = []
+
+        try:
+            # Extract OMML equations
+            equations = self.extractor.extract_from_docx(docx_path)
+            logger.info(f"Found {len(equations)} equations in {docx_path}")
+
+            for eq_data in equations:
+                result = ConversionResult()
+                result.omml = eq_data['cleaned_omml']
+                result.context = eq_data['context']
+                result.position = eq_data['position']
+                result.source_file = eq_data['source_file']
+                result.display_mode = eq_data.get('display_mode', False)
+
+                try:
+                    start_time = time.time()
+
+                    # Convert OMML to MathML
+                    if omml_to_mathml_func is None:
+                        # Import here to avoid circular dependency
+                        from ..core.xslt_transformer import omml_to_mathml
+                        omml_to_mathml_func = omml_to_mathml
+
+                    mathml_xml = omml_to_mathml_func(eq_data['cleaned_omml'], self.xsl_path)
+                    result.mathml = mathml_xml
+
+                    # Convert MathML to LaTeX
+                    latex = self.converter.convert(mathml_xml)
+                    result.latex = latex
+
+                    result.processing_time = time.time() - start_time
+                    result.success = True
+
+                except Exception as e:
+                    result.error = str(e)
+                    result.success = False
+                    logger.error(f"Failed to convert equation {result.position}: {e}")
+
+                results.append(result)
+
+        except Exception as e:
+            logger.error(f"Failed to process DOCX file: {e}")
+            # Return empty results with error
+            result = ConversionResult()
+            result.error = f"DOCX processing failed: {e}"
+            results.append(result)
+
+        return results
+
+    def detect_subject_mode(self, results: List[ConversionResult]) -> str:
+        """Auto-detect subject mode based on content.
+
+        Analyzes context text from equations to determine if document
+        is primarily chemistry, physics, or general math.
+
+        Args:
+            results: List of conversion results with context
+
+        Returns:
+            Detected subject mode: 'chemistry', 'physics', or 'math'
+
+        Example:
+            >>> results = processor.process_docx('chem_doc.docx')
+            >>> mode = processor.detect_subject_mode(results)
+            >>> print(f"Detected mode: {mode}")
+        """
+        chemistry_indicators = 0
+        physics_indicators = 0
+        total_context = ""
+
+        for result in results:
+            if result.success and result.context:
+                total_context += " " + result.context.lower()
+
+        # Simple heuristic detection
+        chemistry_words = ['reaction', 'equation', 'chemical', 'compound', 'element', 'molecule', 'ion', 'acid', 'base']
+        physics_words = ['force', 'energy', 'velocity', 'acceleration', 'wave', 'field', 'quantum', 'particle']
+
+        for word in chemistry_words:
+            chemistry_indicators += total_context.count(word)
+
+        for word in physics_words:
+            physics_indicators += total_context.count(word)
+
+        if chemistry_indicators > physics_indicators and chemistry_indicators > 2:
+            return "chemistry"
+        elif physics_indicators > chemistry_indicators and physics_indicators > 2:
+            return "physics"
+        else:
+            return "math"
diff --git a/scripts/omml_mathml2latex/processing/omml_extractor.py b/scripts/omml_mathml2latex/processing/omml_extractor.py
new file mode 100644
index 0000000..237cbb0
--- /dev/null
+++ b/scripts/omml_mathml2latex/processing/omml_extractor.py
@@ -0,0 +1,273 @@
+"""
+OMML equation extraction from DOCX files.
+
+This module provides the OMMLExtractor class which extracts OMML (Office Math Markup Language)
+equations from Microsoft Word DOCX files, including main document, headers, and footers.
+"""
+
+import zipfile
+import logging
+from pathlib import Path
+from typing import List, Dict, Any
+from lxml import etree as ET
+
+logger = logging.getLogger(__name__)
+
+
+class OMMLExtractor:
+    """Extract OMML equations from DOCX files.
+
+    Handles extraction from:
+    - Main document body (word/document.xml)
+    - Headers (word/header*.xml)
+    - Footers (word/footer*.xml)
+
+    Preserves:
+    - Non-breaking spaces (NBSP, U+00A0)
+    - Display mode detection (inline vs display equations)
+    - Context from surrounding paragraphs
+    - Position tracking
+
+    Example:
+        >>> extractor = OMMLExtractor()
+        >>> equations = extractor.extract_from_docx('document.docx')
+        >>> print(f"Found {len(equations)} equations")
+        >>> print(extractor.stats)
+    """
+
+    # OMML and Word namespace definitions
+    NAMESPACES = {
+        'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+        'm': 'http://schemas.openxmlformats.org/officeDocument/2006/math',
+        'wp': 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing'
+    }
+
+    def __init__(self):
+        """Initialize extractor with empty statistics."""
+        self.stats = {
+            'equations_found': 0,
+            'files_processed': 0,
+            'errors': 0
+        }
+
+    def extract_from_docx(self, docx_path: str) -> List[Dict[str, Any]]:
+        """Extract all OMML equations from a DOCX file.
+
+        Args:
+            docx_path: Path to DOCX file
+
+        Returns:
+            List of equation dictionaries with keys:
+            - omml: Raw OMML XML string
+            - cleaned_omml: Cleaned OMML ready for transformation
+            - position: Position/index in document
+            - context: Surrounding text context
+            - source_file: XML file within DOCX (e.g., 'word/document.xml')
+            - display_mode: Boolean indicating display (True) vs inline (False)
+
+        Raises:
+            FileNotFoundError: If DOCX file doesn't exist
+            Exception: For other processing errors
+
+        Example:
+            >>> extractor = OMMLExtractor()
+            >>> equations = extractor.extract_from_docx('test.docx')
+            >>> for eq in equations:
+            ...     print(f"Position {eq['position']}: {eq['display_mode']}")
+        """
+        equations = []
+        docx_path = Path(docx_path)
+
+        if not docx_path.exists():
+            raise FileNotFoundError(f"DOCX file not found: {docx_path}")
+
+        try:
+            with zipfile.ZipFile(docx_path, 'r') as docx:
+                # Extract main document
+                equations.extend(self._extract_from_document(docx, 'word/document.xml'))
+
+                # Check for equations in headers/footers
+                header_files = [f for f in docx.namelist() if f.startswith('word/header')]
+                footer_files = [f for f in docx.namelist() if f.startswith('word/footer')]
+
+                for header_file in header_files:
+                    equations.extend(self._extract_from_document(docx, header_file))
+
+                for footer_file in footer_files:
+                    equations.extend(self._extract_from_document(docx, footer_file))
+
+                self.stats['files_processed'] += 1
+                self.stats['equations_found'] += len(equations)
+
+        except Exception as e:
+            self.stats['errors'] += 1
+            logger.error(f"Error processing {docx_path}: {e}")
+            raise
+
+        return equations
+
+    def _extract_from_document(self, docx: zipfile.ZipFile, xml_path: str) -> List[Dict[str, Any]]:
+        """Extract equations from a specific XML document within the DOCX.
+
+        Args:
+            docx: Open zipfile.ZipFile object
+            xml_path: Path to XML file within DOCX
+
+        Returns:
+            List of equation dictionaries
+        """
+        equations = []
+
+        try:
+            if xml_path not in docx.namelist():
+                return equations
+
+            doc_xml = docx.read(xml_path)
+
+            # IMPORTANT: Preserve NBSP characters before XML parsing
+            # lxml normalizes U+00A0 (NBSP) to regular space, so we replace it
+            # with a placeholder that we'll restore later
+            # UTF-8 encoding of NBSP is \xc2\xa0
+            doc_xml = doc_xml.replace(b'\xc2\xa0', b'&#160;')  # Convert NBSP to decimal entity
+
+            # Use lxml for parsing to enable getparent() method
+            root = ET.fromstring(doc_xml)
+
+            # Find all OMML equations
+            math_elements = root.findall('.//m:oMath', self.NAMESPACES)
+
+            for i, math_elem in enumerate(math_elements):
+                try:
+                    # Extract raw OMML (use lxml for consistency)
+                    raw_omml = ET.tostring(math_elem, encoding='unicode', method='xml')
+
+                    # Clean and prepare OMML
+                    cleaned_omml = self._clean_omml(raw_omml)
+
+                    # Get surrounding context
+                    context = self._get_context(math_elem)
+
+                    # Detect if this is a display equation (wrapped in oMathPara)
+                    display_mode = self._is_display_equation(math_elem)
+
+                    equation_data = {
+                        'omml': raw_omml,
+                        'cleaned_omml': cleaned_omml,
+                        'position': i,
+                        'context': context,
+                        'source_file': xml_path,
+                        'display_mode': display_mode
+                    }
+
+                    equations.append(equation_data)
+
+                except Exception as e:
+                    logger.warning(f"Error extracting equation {i} from {xml_path}: {e}")
+                    continue
+
+        except Exception as e:
+            logger.error(f"Error reading {xml_path}: {e}")
+
+        return equations
+
+    def _clean_omml(self, omml: str) -> str:
+        """Clean and prepare OMML for transformation.
+
+        Fixes:
+        - Missing namespace declarations
+        - Word formatting properties
+        - Whitespace normalization between tags
+
+        Args:
+            omml: Raw OMML XML string
+
+        Returns:
+            Cleaned OMML string
+        """
+        import re
+
+        # Add proper namespace declarations if missing
+        if 'xmlns:m=' not in omml:
+            omml = omml.replace(
+                '<m:oMath',
+                '<m:oMath xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"'
+            )
+
+        if 'xmlns:w=' not in omml and 'w:' in omml:
+            omml = omml.replace(
+                '<m:oMath',
+                '<m:oMath xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"'
+            )
+
+        # Remove Word formatting properties that might interfere (but preserve font information)
+        omml = re.sub(r'<w:szCs[^>]*?/>', '', omml)
+        # Keep w:color elements for color preservation
+        # omml = re.sub(r'<w:color[^>]*?/>', '', omml)
+
+        # Normalize whitespace BETWEEN XML tags only (not inside text content)
+        # Collapse multiple whitespace chars between tags into single space
+        # Pattern: ">[ \t\n\r]+<" → "> <"
+        omml = re.sub(r'>([ \t\n\r]+)<', r'> <', omml)
+        omml = omml.strip()
+
+        return omml
+
+    def _get_context(self, math_elem: ET._Element) -> str:
+        """Get surrounding text context for the equation.
+
+        Args:
+            math_elem: OMML math element
+
+        Returns:
+            Surrounding paragraph text (max 200 characters)
+        """
+        try:
+            # Find the parent paragraph
+            current = math_elem
+            while current is not None:
+                if current.tag.endswith('p'):  # Word paragraph
+                    break
+                parent = current.find('..')
+                current = parent
+
+            if current is None:
+                return ""
+
+            # Extract all text from the paragraph
+            text_parts = []
+            for elem in current.iter():
+                if elem.tag.endswith('t') and elem.text:  # Word text element
+                    text_parts.append(elem.text)
+
+            context = ' '.join(text_parts).strip()
+
+            # Limit context length
+            if len(context) > 200:
+                context = context[:200] + "..."
+
+            return context
+
+        except Exception as e:
+            logger.debug(f"Error getting context: {e}")
+            return ""
+
+    def _is_display_equation(self, math_elem: ET._Element) -> bool:
+        """Determine if an equation is display mode ($$) or inline mode ($).
+
+        Display equations are wrapped in <m:oMathPara>, inline equations are not.
+
+        Args:
+            math_elem: OMML math element
+
+        Returns:
+            True for display mode, False for inline mode
+        """
+        try:
+            # Check if the parent is oMathPara
+            parent = math_elem.getparent()
+            if parent is not None and parent.tag.endswith('oMathPara'):
+                return True
+            return False
+        except Exception as e:
+            logger.debug(f"Error detecting display mode: {e}")
+            return False  # Default to inline if unsure
diff --git a/scripts/omml_mathml2latex/processing/output_formatter.py b/scripts/omml_mathml2latex/processing/output_formatter.py
new file mode 100644
index 0000000..86adaab
--- /dev/null
+++ b/scripts/omml_mathml2latex/processing/output_formatter.py
@@ -0,0 +1,221 @@
+"""
+Output formatting for conversion results.
+
+This module provides functions to format conversion results in various output
+formats including LaTeX, JSON, and HTML with MathJax rendering.
+"""
+
+import json
+from typing import List
+from .result import ConversionResult
+from ..utils.text_processing import write_text
+
+
+def format_latex(results: List[ConversionResult], format_type: str = "display",
+                 delimiter: str = "dollar") -> str:
+    """Format LaTeX results for output.
+
+    Args:
+        results: List of conversion results
+        format_type: 'inline', 'display', or 'both' (auto-detect)
+        delimiter: 'dollar', 'bracket', 'mathjax', or 'katex'
+
+    Returns:
+        Formatted LaTeX string with appropriate delimiters
+
+    Example:
+        >>> results = [ConversionResult()]
+        >>> results[0].success = True
+        >>> results[0].latex = 'x + y'
+        >>> results[0].display_mode = False
+        >>> output = format_latex(results, 'both', 'dollar')
+        >>> print(output)
+        '$x + y$'
+    """
+    if delimiter == "dollar":
+        inline_start, inline_end = "$", "$"
+        display_start, display_end = "$$", "$$"
+    elif delimiter == "bracket":
+        inline_start, inline_end = "\\(", "\\)"
+        display_start, display_end = "\\[", "\\]"
+    elif delimiter == "mathjax":
+        inline_start, inline_end = "\\(", "\\)"
+        display_start, display_end = "$$", "$$"
+    elif delimiter == "katex":
+        inline_start, inline_end = "$", "$"
+        display_start, display_end = "$$", "$$"
+    else:
+        inline_start, inline_end = "$", "$"
+        display_start, display_end = "$$", "$$"
+
+    output_lines = []
+
+    for i, result in enumerate(results):
+        if not result.success:
+            output_lines.append(f"% Equation {i+1}: ERROR - {result.error}")
+            continue
+
+        # Determine if equation should be inline or display
+        if hasattr(result, 'display_mode') and format_type == "both":
+            # Use the detected display mode from OMML structure
+            if result.display_mode:
+                equation = f"{display_start}{result.latex}{display_end}"
+            else:
+                equation = f"{inline_start}{result.latex}{inline_end}"
+        elif format_type == "inline":
+            equation = f"{inline_start}{result.latex}{inline_end}"
+        elif format_type == "display":
+            equation = f"{display_start}{result.latex}{display_end}"
+        else:  # format_type == "both" but no display_mode set
+            # Use heuristic: short equations inline, complex ones display
+            if len(result.latex) < 50 and not any(cmd in result.latex for cmd in ["\\frac", "\\sum", "\\int", "\\begin"]):
+                equation = f"{inline_start}{result.latex}{inline_end}"
+            else:
+                equation = f"{display_start}{result.latex}{display_end}"
+
+        output_lines.append(equation)
+        output_lines.append("")  # Empty line between equations
+
+    return "\n".join(output_lines)
+
+
+def save_results(results: List[ConversionResult], output_path: str,
+                format_type: str = "display", delimiter: str = "dollar",
+                include_context: bool = False, output_format: str = None):
+    """Save conversion results in various formats.
+
+    Args:
+        results: List of conversion results
+        output_path: Output file path
+        format_type: For LaTeX output - 'inline', 'display', or 'both'
+        delimiter: For LaTeX output - delimiter style
+        include_context: Whether to include context in JSON output
+        output_format: 'latex', 'json', or 'html' (auto-detected from output_path if not provided)
+
+    Example:
+        >>> results = [ConversionResult()]
+        >>> save_results(results, 'output.json')
+        >>> save_results(results, 'output.tex', format_type='inline', delimiter='dollar')
+    """
+    # Auto-detect output format from file extension if not provided
+    if output_format is None:
+        if output_path.endswith('.json'):
+            output_format = 'json'
+        elif output_path.endswith('.html'):
+            output_format = 'html'
+        else:
+            # Default to LaTeX for .tex, .md, and any other extension
+            output_format = 'latex'
+
+    if output_format == "latex":
+        latex_content = format_latex(results, format_type, delimiter)
+        write_text(output_path, latex_content)
+
+    elif output_format == "json":
+        json_data = {
+            "metadata": {
+                "total_equations": len(results),
+                "successful_conversions": sum(1 for r in results if r.success),
+                "failed_conversions": sum(1 for r in results if not r.success),
+                "format_type": format_type,
+                "delimiter": delimiter,
+                "include_context": include_context
+            },
+            "equations": [result.to_dict() for result in results]
+        }
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(json_data, f, indent=2, ensure_ascii=False)
+
+    elif output_format == "html":
+        html_content = generate_html_preview(results, format_type, delimiter)
+        write_text(output_path, html_content)
+
+
+def generate_html_preview(results: List[ConversionResult], format_type: str, delimiter: str) -> str:
+    """Generate HTML preview with MathJax rendering.
+
+    Args:
+        results: List of conversion results
+        format_type: 'inline', 'display', or 'both'
+        delimiter: Delimiter style
+
+    Returns:
+        HTML document string with embedded MathJax
+
+    Example:
+        >>> results = [ConversionResult()]
+        >>> html = generate_html_preview(results, 'display', 'dollar')
+        >>> '<!DOCTYPE html>' in html
+        True
+    """
+    html_template = """<!DOCTYPE html>
+<html>
+<head>
+    <title>OMML to LaTeX Conversion Results</title>
+    <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
+    <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 40px; }}
+        .equation {{ margin: 20px 0; padding: 15px; border: 1px solid #ddd; background: #f9f9f9; }}
+        .context {{ font-style: italic; color: #666; margin-bottom: 10px; }}
+        .latex-code {{ font-family: monospace; background: #f0f0f0; padding: 10px; margin: 5px 0; }}
+        .error {{ color: red; background: #ffe6e6; }}
+        .success {{ border-left: 4px solid #4CAF50; }}
+        .failure {{ border-left: 4px solid #f44336; }}
+        .stats {{ background: #e3f2fd; padding: 15px; margin-bottom: 20px; }}
+    </style>
+</head>
+<body>
+    <h1>OMML to LaTeX Conversion Results</h1>
+
+    <div class="stats">
+        <h3>Conversion Statistics</h3>
+        <p>Total equations: {total}</p>
+        <p>Successful: {successful}</p>
+        <p>Failed: {failed}</p>
+        <p>Success rate: {rate:.1f}%</p>
+    </div>
+
+    {equations_html}
+</body>
+</html>"""
+
+    successful = sum(1 for r in results if r.success)
+    failed = len(results) - successful
+    success_rate = (successful / len(results)) * 100 if results else 0
+
+    equations_html = []
+
+    for i, result in enumerate(results):
+        equation_class = "success" if result.success else "failure"
+
+        if result.success:
+            latex_formatted = format_latex([result], format_type, delimiter).strip()
+
+            equation_html = f"""
+            <div class="equation {equation_class}">
+                <h4>Equation {i+1}</h4>
+                {f'<div class="context">Context: {result.context}</div>' if result.context else ''}
+                <div class="latex-code">LaTeX: {result.latex}</div>
+                <div>Rendered: {latex_formatted}</div>
+            </div>
+            """
+        else:
+            equation_html = f"""
+            <div class="equation {equation_class}">
+                <h4>Equation {i+1} - ERROR</h4>
+                {f'<div class="context">Context: {result.context}</div>' if result.context else ''}
+                <div class="error">Error: {result.error}</div>
+            </div>
+            """
+
+        equations_html.append(equation_html)
+
+    return html_template.format(
+        total=len(results),
+        successful=successful,
+        failed=failed,
+        rate=success_rate,
+        equations_html="\n".join(equations_html)
+    )
diff --git a/scripts/omml_mathml2latex/processing/result.py b/scripts/omml_mathml2latex/processing/result.py
new file mode 100644
index 0000000..11188c6
--- /dev/null
+++ b/scripts/omml_mathml2latex/processing/result.py
@@ -0,0 +1,96 @@
+"""
+Conversion result data structure.
+
+This module provides the ConversionResult class which represents the result
+of an OMML to LaTeX conversion operation.
+"""
+
+from typing import Optional, List, Dict, Any
+
+
+class ConversionResult:
+    """Result of OMML conversion process.
+
+    Attributes:
+        success: Whether conversion was successful
+        omml: Original OMML XML string
+        mathml: Intermediate MathML XML string
+        latex: Final LaTeX output
+        context: Surrounding text context from source document
+        position: Position/index of equation in source document
+        source_file: Source file name or path
+        error: Error message if conversion failed
+        warnings: List of warning messages
+        processing_time: Time taken for conversion in seconds
+        display_mode: True for display equations ($$), False for inline ($)
+
+    Example:
+        >>> result = ConversionResult()
+        >>> result.success = True
+        >>> result.latex = '\\\\frac{1}{2}'
+        >>> result.display_mode = False
+        >>> print(result.to_dict())
+        {'success': True, 'latex': '\\\\frac{1}{2}', ...}
+    """
+
+    def __init__(self):
+        """Initialize conversion result with default values."""
+        self.success: bool = False
+        self.omml: str = ""
+        self.mathml: str = ""
+        self.latex: str = ""
+        self.context: str = ""
+        self.position: int = 0
+        self.source_file: str = ""
+        self.error: Optional[str] = None
+        self.warnings: List[str] = []
+        self.processing_time: float = 0.0
+        self.display_mode: bool = False  # True for display equations ($$), False for inline ($)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of conversion result
+
+        Example:
+            >>> result = ConversionResult()
+            >>> result.success = True
+            >>> result.latex = 'x + y'
+            >>> data = result.to_dict()
+            >>> print(data['latex'])
+            'x + y'
+        """
+        return {
+            'success': self.success,
+            'omml': self.omml,
+            'mathml': self.mathml,
+            'latex': self.latex,
+            'context': self.context,
+            'position': self.position,
+            'source_file': self.source_file,
+            'error': self.error,
+            'warnings': self.warnings,
+            'processing_time': self.processing_time,
+            'display_mode': self.display_mode
+        }
+
+    def __repr__(self) -> str:
+        """Return detailed string representation.
+
+        Returns:
+            String representation showing key attributes
+        """
+        status = "Success" if self.success else f"Failed: {self.error}"
+        return f"ConversionResult(position={self.position}, status={status}, latex='{self.latex[:50]}...')"
+
+    def __str__(self) -> str:
+        """Return human-readable string representation.
+
+        Returns:
+            User-friendly string representation
+        """
+        if self.success:
+            return f"Equation {self.position}: {self.latex}"
+        else:
+            return f"Equation {self.position}: ERROR - {self.error}"
diff --git a/scripts/omml_mathml2latex/strategies/__init__.py b/scripts/omml_mathml2latex/strategies/__init__.py
new file mode 100644
index 0000000..5e922eb
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/__init__.py
@@ -0,0 +1,20 @@
+"""
+Formatting strategies for different subject areas.
+
+This package contains strategy implementations for subject-specific
+formatting (math, chemistry, physics, statistics).
+"""
+
+from .math_strategy import MathStrategy
+from .chemistry_strategy import ChemistryStrategy
+from .physics_strategy import PhysicsStrategy
+from .statistics_strategy import StatisticsStrategy
+from .strategy_factory import StrategyFactory
+
+__all__ = [
+    'MathStrategy',
+    'ChemistryStrategy',
+    'PhysicsStrategy',
+    'StatisticsStrategy',
+    'StrategyFactory',
+]
diff --git a/scripts/omml_mathml2latex/strategies/chemistry_strategy.py b/scripts/omml_mathml2latex/strategies/chemistry_strategy.py
new file mode 100644
index 0000000..75b8493
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/chemistry_strategy.py
@@ -0,0 +1,261 @@
+"""
+Chemistry strategy for chemical equation notation.
+
+This strategy handles formatting for chemical equations, including element
+symbols, reaction arrows, ion charges, and state symbols.
+"""
+
+from lxml import etree as ET
+from typing import Set
+from ..core.interfaces import Strategy
+
+# Import from existing data modules
+from ..data import CHEMICAL_ELEMENTS, UNICODE_TO_LATEX, MATH_FUNCTIONS, UNICODE_PASSTHROUGH
+
+
+class ChemistryStrategy(Strategy):
+    """
+    Chemical equation notation strategy.
+
+    This strategy provides formatting for chemical content:
+    - Chemical elements → \\mathrm{} (upright, not italic)
+    - Reaction arrows → \\xlongequal{condition} or \\rightarrow
+    - Ion charges → proper superscript formatting
+    - State symbols → \\uparrow, \\downarrow
+    - Chinese condition text → \\text{}
+    """
+
+    # Chemical elements (118 elements)
+    ELEMENTS: Set[str] = CHEMICAL_ELEMENTS
+
+    # Mathematical functions still get special treatment
+    FUNCTIONS: Set[str] = MATH_FUNCTIONS
+
+    def __init__(self):
+        """Initialize the chemistry strategy."""
+        # Subject mode identifier for probability scoring
+        self.subject_mode = 'chemistry'
+
+    def format_identifier(self, text: str, node: ET.Element) -> str:
+        """
+        Format an identifier (<mi> element) for chemistry.
+
+        UPDATED: Now ONLY respects mathvariant attribute, no automatic element wrapping.
+        User has full control through explicit mathvariant settings in Word.
+
+        Args:
+            text: The identifier text content
+            node: The <mi> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic (SIMPLIFIED):
+            1. Mathematical functions → \\function (e.g., "sin" → "\\sin")
+            2. mathvariant="normal" → \\mathrm{text} (user explicitly set upright)
+            3. Otherwise → return as-is (remain italic, default for math)
+
+        Examples:
+            "Fe" with mathvariant="normal" → "\\mathrm{Fe}"
+            "Fe" without mathvariant → "Fe" (italic)
+            "H" with mathvariant="normal" → "\\mathrm{H}"
+            "F" without mathvariant → "F" (italic, NOT wrapped)
+            "sin" → "\\sin" (still a math function)
+        """
+        # Check if it's a mathematical function (rare in chemistry, but possible)
+        if text in self.FUNCTIONS:
+            return f"\\{text}"
+
+        # DISABLED: Automatic element wrapping (user wants full control)
+        # Old logic that auto-wrapped elements is now commented out
+        # # Check if it's a chemical element
+        # if text in self.ELEMENTS:
+        #     return f"\\mathrm{{{text}}}"
+
+        # DISABLED: Automatic capital letter wrapping
+        # # Single CAPITAL letters → wrap in \mathrm{} (likely element symbols)
+        # if len(text) == 1 and text.isupper():
+        #     return f"\\mathrm{{{text}}}"
+
+        # ONLY respect mathvariant attribute (user's explicit setting)
+        mathvariant = node.get('mathvariant', '')
+        if mathvariant == 'normal':
+            # User explicitly set this to upright in Word (via m:sty='p' in OMML)
+            return f"\\mathrm{{{text}}}"
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbols
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character text with Unicode
+        if len(text) > 1:
+            # Check if it contains Unicode (passthrough or convertible)
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    elif char.isspace():
+                        converted_parts.append(' ')
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is (italic, standard for math variables)
+        return text
+
+    def format_operator(self, text: str, node: ET.Element) -> str:
+        """
+        Format an operator (<mo> element) for chemistry.
+
+        Args:
+            text: The operator text content
+            node: The <mo> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Reaction arrows → \\xlongequal{condition} or \\rightarrow
+            2. State symbols → \\uparrow, \\downarrow
+            3. Unicode symbols → LaTeX equivalents (via UNICODE_TO_LATEX)
+            4. Standard operators → unchanged (+, -, =)
+
+        Examples:
+            "→" → "\\rightarrow"
+            "↑" → "\\uparrow"
+            "↓" → "\\downarrow"
+            "=" → "="
+            "+" → "+"
+        """
+        # Handle < and > specifically (LaTeX convention)
+        if text == "<":
+            return "\\lt"
+        if text == ">":
+            return "\\gt"
+
+        # Reaction arrows
+        if text == '→':
+            return '\\rightarrow'
+        elif text == '←':
+            return '\\leftarrow'
+        elif text == '⇌' or text == '⇄':
+            return '\\rightleftharpoons'
+        elif text == '↑':
+            return '\\uparrow'
+        elif text == '↓':
+            return '\\downarrow'
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbol mapping
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character operators with Unicode
+        if len(text) > 1:
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is
+        return text
+
+    def format_number(self, text: str, node: ET.Element) -> str:
+        """
+        Format a number (<mn> element) for chemistry.
+
+        Args:
+            text: The number text content
+            node: The <mn> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            Numbers are returned as-is in chemistry mode.
+
+        Examples:
+            "2" → "2" (stoichiometric coefficient)
+            "3.5" → "3.5" (pH value)
+        """
+        # Numbers are returned as-is
+        return text
+
+    def detect_context(self, equation_text: str) -> bool:
+        """
+        Detect if an equation is chemical content.
+
+        Args:
+            equation_text: The full equation MathML text
+
+        Returns:
+            True if likely chemical, False otherwise
+
+        Detection indicators:
+            - Chemical elements (Fe, Cu, H2O, etc.)
+            - Reaction arrows (→, ⇌, ↑, ↓)
+            - Ion charges (2+, 3-, etc.)
+            - Multiple element symbols in sequence
+
+        Examples:
+            "Fe + H2SO4 → FeSO4 + H2" → True
+            "2H2O ⇌ H3O+ + OH-" → True
+            "sin(x) + cos(x)" → False
+            "P = C" → False (just math variables, not Phosphorus = Carbon)
+        """
+        # CRITICAL FIX: Use proper XML parsing instead of naive substring search
+        # The old method falsely detected "ln" in "xmlns" and "sup" in "<msup>" tags
+        # as mathematical functions, causing chemistry equations to be rejected.
+
+        try:
+            # Parse MathML XML to ElementTree
+            root = ET.fromstring(equation_text.encode('utf-8'))
+
+            # Use the robust chemistry detection from utils module
+            from ..utils.chemistry_detection import detect_chemistry_equation
+            return detect_chemistry_equation(root)
+
+        except (ET.XMLSyntaxError, ValueError):
+            # Fallback to string-based detection if XML parsing fails
+            # This should rarely happen with valid MathML
+
+            # Check for UNAMBIGUOUS multi-character elements
+            unambiguous_elements = {e for e in self.ELEMENTS if len(e) > 1}
+            element_count = sum(1 for element in unambiguous_elements if element in equation_text)
+            if element_count >= 1:
+                return True
+
+            # Check for reaction arrows (strong indicator)
+            if any(arrow in equation_text for arrow in ['→', '←', '⇌', '⇄', '↑', '↓']):
+                return True
+
+            return False
+
+    @property
+    def name(self) -> str:
+        """Get the strategy name."""
+        return "chemistry"
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"ChemistryStrategy(elements={len(self.ELEMENTS)})"
diff --git a/scripts/omml_mathml2latex/strategies/math_strategy.py b/scripts/omml_mathml2latex/strategies/math_strategy.py
new file mode 100644
index 0000000..c5b93ab
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/math_strategy.py
@@ -0,0 +1,448 @@
+"""
+Math strategy for standard mathematical notation.
+
+This strategy handles formatting for general mathematical equations,
+including function recognition, operator mapping, and number formatting.
+"""
+
+from lxml import etree as ET
+from typing import Set, Optional
+from ..core.interfaces import Strategy
+
+# Import from existing data module
+from ..data import MATH_FUNCTIONS, UNICODE_TO_LATEX, UNICODE_PASSTHROUGH
+from ..data.chemistry_data import (
+    ALL_CHEMICAL_ELEMENTS,
+    CHEMISTRY_VARIABLES,
+)
+from ..utils.chemistry_detection import detect_chemistry_equation, is_chemistry_variable
+
+
+class MathStrategy(Strategy):
+    """
+    Standard mathematical notation strategy.
+
+    This strategy provides formatting for general mathematical content:
+    - Function recognition (sin, cos, log → \\sin, \\cos, \\log)
+    - Operator symbol mapping (Unicode → LaTeX)
+    - Standard number formatting
+    - Variables remain italic (LaTeX default)
+    - Sophisticated identifier wrapping based on context
+    """
+
+    # Mathematical functions that get special LaTeX commands
+    FUNCTIONS: Set[str] = MATH_FUNCTIONS
+
+    # Mathematical sets that should use \mathbf{} (bold upright) - ONLY when mathvariant is set
+    MATH_SETS = {'R', 'Z', 'N', 'Q', 'C', 'ℝ', 'ℤ', 'ℕ', 'ℚ', 'ℂ'}
+
+    # CRITICAL: In pure math mode, NO letters are always wrapped
+    # Wrapping only happens with explicit mathvariant="normal" attribute
+    # This set is kept for compatibility but should be empty for math mode
+    ALWAYS_WRAPPED_LETTERS = set()  # Empty - no automatic wrapping in math mode
+
+    def __init__(self, wrap_identifiers_in_mathrm: bool = False):
+        """
+        Initialize the math strategy.
+
+        Args:
+            wrap_identifiers_in_mathrm: If True, wrap multi-char identifiers in \\mathrm{}
+                                       Default is False to match original converter behavior
+        """
+        self._equation_text: Optional[str] = None
+        self._chemical_elements = set()  # Will be populated if needed
+        self._wrap_identifiers_in_mathrm = wrap_identifiers_in_mathrm
+        self._root_element: Optional[ET.Element] = None
+        self._is_chemistry_cached: Optional[bool] = None
+
+    def format_identifier(self, text: str, node: ET.Element) -> str:
+        """
+        Format an identifier (<mi> element) for mathematics.
+
+        Args:
+            text: The identifier text content
+            node: The <mi> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Mathematical functions → \\function (e.g., "sin" → "\\sin")
+            2. Single letters → check wrapping rules (most stay italic)
+            3. Multi-letter → check wrapping rules (depends on context)
+
+        Examples:
+            "sin" → "\\sin"
+            "cos" → "\\cos"
+            "x" → "x" (italic)
+            "R" → "R" (italic in math context)
+            "H" → "\\mathrm{H}" (always upright)
+            "velocity" → "velocity" (italic if math context)
+        """
+        # CRITICAL: Strip whitespace before checking (matches original converter behavior)
+        # Original converter does: clean_text = text.strip()
+        clean_text = text.strip()
+
+        # Check if it's a mathematical function (case-insensitive)
+        # Original converter does: if clean_text.lower() in MATHEMATICAL_FUNCTIONS
+        if clean_text.lower() in self.FUNCTIONS:
+            # Special handling for logarithms with bases
+            if clean_text == "log2":
+                return "\\log_{2}"
+            elif clean_text == "log10":
+                return "\\log_{10}"
+            # Use lowercase version for function name
+            return f"\\{clean_text.lower()}"
+
+        # Check for function with subscript (e.g., "limn→∞")
+        for func in ['lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min']:
+            if clean_text.startswith(func):
+                remaining = clean_text[len(func):]
+                if remaining:
+                    # Convert special symbols in subscript
+                    remaining = (remaining
+                                .replace('→', '\\to ')
+                                .replace('∞', '\\infty ')
+                                .replace('≤', '\\leqslant ')
+                                .replace('≥', '\\geqslant ')
+                                .replace('≠', '\\ne ')
+                                .replace('±', '\\pm '))
+                    import re
+                    remaining = re.sub(r'\s+', ' ', remaining).strip()
+                    return f"\\{func}\\limits_{{{remaining}}}"
+                else:
+                    return f"\\{func}"
+
+        # CRITICAL: Unicode math set symbols (ℝ, ℤ, etc.) are already handled by UNICODE_TO_LATEX
+        # These map to \mathbb{R}, \mathbb{Z}, etc. (not \mathbf{})
+        # This is correct because these Unicode symbols ARE blackboard bold characters
+        # So we don't need special handling here - just fall through to UNICODE_TO_LATEX check below
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if clean_text in UNICODE_PASSTHROUGH:
+            return clean_text
+
+        # Check for Unicode symbols
+        if clean_text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[clean_text]
+
+        # Handle multi-character strings with Unicode symbols
+        if len(clean_text) > 1:
+            has_unicode = any(char in UNICODE_TO_LATEX for char in clean_text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in clean_text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in clean_text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    elif char.isspace():
+                        converted_parts.append(' ')
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # USER REQUIREMENT: "use the mathvariant to determine whether it's mathrm"
+        # REMOVED: Chemistry detection heuristics (lines 139-162)
+        # REMOVED: should_wrap_in_mathrm() call (now always returns False)
+        #
+        # Wrapping in \mathrm{} is ONLY done when mathvariant="normal" attribute exists.
+        # That's handled in mi_visitor.py _handle_mathvariant() method.
+
+        # Default: return as-is (variables remain italic in LaTeX)
+        return clean_text
+
+    def format_operator(self, text: str, node: ET.Element) -> str:
+        """
+        Format an operator (<mo> element) for mathematics.
+
+        Args:
+            text: The operator text content
+            node: The <mo> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Delimiters → __DELIM__ markers for later processing
+            2. Comparison operators < and > → \\lt and \\gt (LaTeX convention)
+            3. Unicode symbols → LaTeX equivalents (via UNICODE_TO_LATEX)
+            4. Standard operators → unchanged (+, -, *, /, =)
+
+        Examples:
+            "(" → "__DELIM__(__DELIM__"
+            ")" → "__DELIM__)__DELIM__"
+            "+" → "+"
+            "<" → "\\lt"
+            ">" → "\\gt"
+            "×" → "\\times"
+            "≤" → "\\leqslant"
+            "∈" → "\\in"
+        """
+        # CRITICAL: Mark delimiters for potential scaling
+        # These will be processed later by _process_delimiters()
+        # This matches the original converter's behavior (line 3558 in omml_to_tex.py)
+        # Include common paired delimiters: parentheses, brackets, braces, angle brackets, ceil/floor
+        # BUG-012 FIX: Added "|" to delimiters to allow proper absolute value detection
+        import sys
+        delimiter_chars = ("(", ")", "[", "]", "{", "}", "⟨", "⟩", "〈", "〉", "⌈", "⌉", "⌊", "⌋", "|")
+        if text in delimiter_chars:
+            # Convert Unicode delimiters to LaTeX BEFORE marking
+            # This ensures the delimiter pairing processor can find and pair them
+            delimiter_latex_map = {
+                "⟨": "\\langle",
+                "⟩": "\\rangle",
+                "〈": "\\langle",  # CJK angle bracket
+                "〉": "\\rangle",  # CJK angle bracket
+                "⌈": "\\lceil",
+                "⌉": "\\rceil",
+                "⌊": "\\lfloor",
+                "⌋": "\\rfloor",
+                "{": "\\{",  # FIX: Escape braces so unpaired ones are valid LaTeX
+                "}": "\\}",  # FIX: Escape braces so unpaired ones are valid LaTeX
+            }
+            converted_text = delimiter_latex_map.get(text, text)
+
+            # Check for stretchy attribute - if true, use a special marker to force scaling
+            stretchy = node.get('stretchy')
+            if stretchy == 'true':
+                 result = f"__DELIM__STRETCHY::{converted_text}__DELIM__"
+            else:
+                 result = f"__DELIM__{converted_text}__DELIM__"
+
+            # Debug: print(f"[DEBUG STRATEGY] Marking delimiter {text!r} → {result!r}", file=sys.stderr)
+            return result
+
+        # Handle < and > specifically to match expected output format (from original converter)
+        if text == "<":
+            return "\\lt"
+        if text == ">":
+            return "\\gt"
+
+        # BUG-012 FIX: Removed forced | -> \mid conversion
+        # Let DelimiterPairingProcessor decide whether it's \mid (operator) or \left|\right| (abs value)
+        # if text == "|":
+        #    return "\\mid"
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        # These symbols have LaTeX commands that MathJax doesn't support or renders poorly.
+        # Check this BEFORE converting to LaTeX to preserve the original Unicode.
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbol mapping
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character operators with Unicode
+        if len(text) > 1:
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    # Check passthrough first - keep these as Unicode
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is
+        return text
+
+    def format_number(self, text: str, node: ET.Element) -> str:
+        """
+        Format a number (<mn> element) for mathematics.
+
+        Args:
+            text: The number text content
+            node: The <mn> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            Numbers are returned as-is in mathematics mode.
+
+        Examples:
+            "123" → "123"
+            "3.14" → "3.14"
+            "1.5×10⁻³" → "1.5×10⁻³" (Unicode handled by operator conversion)
+        """
+        # Numbers are typically returned as-is
+        # Unicode processing happens at operator level
+        return text
+
+    def set_equation_text(self, text: str) -> None:
+        """
+        Set the full equation text for context detection.
+
+        Args:
+            text: The complete equation LaTeX text
+        """
+        self._equation_text = text
+
+    def set_wrap_identifiers_flag(self, value: bool) -> None:
+        """
+        Set whether to wrap identifiers in \\mathrm{}.
+
+        Args:
+            value: True to wrap multi-char identifiers, False to leave as-is
+        """
+        self._wrap_identifiers_in_mathrm = value
+
+    def set_root_element(self, root: ET.Element) -> None:
+        """
+        Set the root MathML element for context detection.
+
+        Args:
+            root: The root <math> element
+        """
+        self._root_element = root
+        self._is_chemistry_cached = None  # Clear cache
+
+    def is_chemistry_equation(self) -> bool:
+        """
+        Detect if the current equation is chemistry-related.
+
+        DISABLED: Subject detection is obsolete. We rely on mathvariant="normal" only.
+
+        Returns:
+            False - always (chemistry detection disabled)
+        """
+        # DISABLED: Always return False - no chemistry detection
+        # Chemistry formulas are handled via mathvariant="normal" in the MathML
+        return False
+
+        # OLD CODE (kept for reference):
+        # if self._is_chemistry_cached is not None:
+        #     return self._is_chemistry_cached
+        # if self._root_element is None:
+        #     return False
+        # self._is_chemistry_cached = detect_chemistry_equation(self._root_element)
+        # return self._is_chemistry_cached
+
+    def should_wrap_in_mathrm(self, content: str) -> bool:
+        """
+        Determine if an identifier should be wrapped in \\mathrm{}.
+
+        CRITICAL USER REQUIREMENT: "use the mathvariant to determine whether it's mathrm"
+
+        This means NO HEURISTIC WRAPPING. Only wrap when there's an explicit
+        mathvariant="normal" attribute, which is handled in mi_visitor.py.
+
+        This method now serves as a safety check only - by default returns False.
+        All wrapping decisions are made based on explicit MathML attributes.
+
+        Args:
+            content: The identifier text
+
+        Returns:
+            False - no heuristic wrapping allowed
+        """
+        # USER REQUIREMENT: Only mathvariant="normal" should trigger \mathrm wrapping
+        # That's handled in mi_visitor.py _handle_mathvariant() method
+        # This method should NOT apply any heuristics
+        return False
+
+    def _is_mathematical_variable(self, content: str) -> bool:
+        """
+        Determine if multi-letter content should be treated as mathematical variables (not wrapped).
+
+        Args:
+            content: The identifier text
+
+        Returns:
+            True if should remain italic (mathematical variable), False otherwise
+        """
+        # Pattern: all lowercase letters (like 'ab', 'xy', 'mn') - typical for mathematical variables
+        if content.islower() and content.isalpha():
+            # Check if we're in a mathematical context (inequalities, fractions, etc.)
+            if self._is_mathematical_context():
+                return True
+
+        # Pattern: mixed case with lowercase start (like 'ab', 'pq') - likely mathematical variables
+        if content[0].islower() and content.isalpha() and len(content) <= 3:
+            if self._is_mathematical_context():
+                return True
+
+        return False
+
+    def _is_mathematical_context(self) -> bool:
+        """Check if we're in a mathematical context with inequalities, equations, fractions, etc."""
+        if not self._equation_text:
+            return False
+
+        mathematical_indicators = [
+            # Inequality operators
+            '≤', '≥', '≠', '<', '>', '\\leqslant', '\\geqslant', '\\leq', '\\geq', '\\ne', '\\neq',
+            # Mathematical operations and relations
+            '=', '+', '-', '×', '÷', '/', '\\cdot', '\\times', '\\div', '\\pm', '\\mp',
+            # Fraction indicators
+            '\\dfrac', '\\frac', '\\tfrac',
+            # Function operations
+            '\\sin', '\\cos', '\\tan', '\\log', '\\ln', '\\exp', '\\sqrt',
+            # Set operations (when not chemical)
+            '\\cap', '\\cup', '∩', '∪',
+            # Mathematical symbols
+            '∞', '\\infty', '∂', '\\partial', '∇', '\\nabla',
+            # Set membership
+            '\\in', '\\notin', '∈', '∉'
+        ]
+
+        return any(indicator in self._equation_text for indicator in mathematical_indicators)
+
+    def _is_clear_chemical_context(self) -> bool:
+        """Check if we're in a clear chemical context (more restrictive than set theory)."""
+        if not self._equation_text:
+            return False
+
+        chemical_indicators = ['\\xlongequal', 'Cu', 'Mn', 'Fe', 'SO', 'OH', '2+', '2-', '↑', '↓']
+        return any(indicator in self._equation_text for indicator in chemical_indicators)
+
+    def _has_mathematical_functions(self) -> bool:
+        """Check if the current equation contains mathematical functions."""
+        # Common mathematical functions that indicate math context, not chemistry
+        math_functions = ['sin', 'cos', 'tan', 'log', 'ln', 'exp', 'sqrt', 'lim', 'max', 'min',
+                         'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh']
+
+        # Check if we have stored equation text for context analysis
+        if self._equation_text:
+            return any(func in self._equation_text for func in math_functions)
+
+        return False
+
+    def detect_context(self, equation_text: str) -> bool:
+        """
+        Detect if an equation is mathematical content.
+
+        Args:
+            equation_text: The full equation text
+
+        Returns:
+            True if likely mathematical, False otherwise
+
+        Note:
+            Math is the default context, so this returns True unless
+            other strategies provide stronger indicators.
+        """
+        # Store equation text for context detection
+        self.set_equation_text(equation_text)
+
+        # Math is the default - return True
+        # In practice, this is overridden by more specific strategies
+        # (chemistry, physics, statistics) which check for their markers
+        return True
+
+    @property
+    def name(self) -> str:
+        """Get the strategy name."""
+        return "math"
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MathStrategy(functions={len(self.FUNCTIONS)})"
diff --git a/scripts/omml_mathml2latex/strategies/physics_strategy.py b/scripts/omml_mathml2latex/strategies/physics_strategy.py
new file mode 100644
index 0000000..42db234
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/physics_strategy.py
@@ -0,0 +1,283 @@
+"""
+Physics strategy for physical equations with units and constants.
+
+This strategy handles formatting for physics equations, including physical
+constants, SI units, vector notation, and standard physics symbols.
+"""
+
+from lxml import etree as ET
+from typing import Set, Dict
+from ..core.interfaces import Strategy
+
+# Import from existing data modules
+from ..data import UNICODE_TO_LATEX, MATH_FUNCTIONS, COMMON_UNITS, UNICODE_PASSTHROUGH
+
+
+class PhysicsStrategy(Strategy):
+    """
+    Physical equation notation strategy.
+
+    This strategy provides formatting for physics content:
+    - Physical constants → proper formatting (c, h, ħ, kB)
+    - SI units → \\mathrm{} (upright)
+    - Mathematical functions → \\function
+    - Variables remain italic (LaTeX default)
+    - Vector notation support
+    """
+
+    # Mathematical functions that get special LaTeX commands
+    FUNCTIONS: Set[str] = MATH_FUNCTIONS
+
+    # Common physical constants (typically italic in physics)
+    PHYSICAL_CONSTANTS: Set[str] = {
+        'c',     # speed of light
+        'h',     # Planck's constant
+        'ℏ',     # reduced Planck's constant (hbar)
+        'G',     # gravitational constant
+        'e',     # elementary charge
+        'k',     # Boltzmann constant (also kB)
+        'kB',    # Boltzmann constant
+        'NA',    # Avogadro's number
+        'R',     # gas constant
+        'ε0',    # permittivity of free space
+        'μ0',    # permeability of free space
+        'g',     # gravitational acceleration
+    }
+
+    # SI units (upright formatting)
+    UNITS: Set[str] = COMMON_UNITS
+
+    def __init__(self):
+        """Initialize the physics strategy."""
+        pass
+
+    def format_identifier(self, text: str, node: ET.Element) -> str:
+        """
+        Format an identifier (<mi> element) for physics.
+
+        Args:
+            text: The identifier text content
+            node: The <mi> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Mathematical functions → \\function (e.g., "sin" → "\\sin")
+            2. SI units → \\mathrm{unit} (e.g., "kg" → "\\mathrm{kg}")
+            3. Physical constants → unchanged (remain italic)
+            4. Single letters → unchanged (variables remain italic)
+            5. Multi-letter non-units → check context
+
+        Examples:
+            "sin" → "\\sin"
+            "kg" → "\\mathrm{kg}"
+            "m" → "m" (could be mass or meter, context-dependent)
+            "c" → "c" (speed of light, italic)
+            "force" → "force" (variable name, italic)
+        """
+        # Check if it's a mathematical function
+        if text in self.FUNCTIONS:
+            return f"\\{text}"
+
+        # Check if it's an SI unit (upright)
+        if text in self.UNITS:
+            return f"\\mathrm{{{text}}}"
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbols
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Special physics symbols
+        if text == 'ℏ':  # hbar
+            return '\\hbar'
+        elif text == 'ħ':  # alternative hbar
+            return '\\hbar'
+
+        # Physical constants remain italic (default LaTeX)
+        if text in self.PHYSICAL_CONSTANTS:
+            return text
+
+        # Handle multi-character strings
+        if len(text) > 1:
+            # Check if it contains Unicode (passthrough or convertible)
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    elif char.isspace():
+                        converted_parts.append(' ')
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+            # Check if it looks like a unit (multiple known units combined)
+            # e.g., "kg·m/s²" → should be upright
+            # For now, let units be upright if explicitly in UNITS set
+            # Otherwise, remain italic (variable names)
+
+        # Default: return as-is (variables remain italic in LaTeX)
+        return text
+
+    def format_operator(self, text: str, node: ET.Element) -> str:
+        """
+        Format an operator (<mo> element) for physics.
+
+        Args:
+            text: The operator text content
+            node: The <mo> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Unicode symbols → LaTeX equivalents (via UNICODE_TO_LATEX)
+            2. Standard operators → unchanged (+, -, *, /, =)
+            3. Vector operators → proper notation (⃗, ×, ·)
+
+        Examples:
+            "+" → "+"
+            "×" → "\\times"
+            "·" → "\\cdot"
+            "∇" → "\\nabla"
+            "∂" → "\\partial"
+        """
+        # Handle < and > specifically (LaTeX convention)
+        if text == "<":
+            return "\\lt"
+        if text == ">":
+            return "\\gt"
+
+        # Vector cross product
+        if text == '×':
+            return '\\times'
+        elif text == '·':
+            return '\\cdot'
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbol mapping
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character operators with Unicode
+        if len(text) > 1:
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is
+        return text
+
+    def format_number(self, text: str, node: ET.Element) -> str:
+        """
+        Format a number (<mn> element) for physics.
+
+        Args:
+            text: The number text content
+            node: The <mn> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            Numbers are returned as-is in physics mode.
+
+        Examples:
+            "9.8" → "9.8" (gravitational acceleration)
+            "3.0×10⁸" → "3.0×10⁸" (speed of light)
+        """
+        # Numbers are returned as-is
+        return text
+
+    def detect_context(self, equation_text: str) -> bool:
+        """
+        Detect if an equation is physics content.
+
+        Args:
+            equation_text: The full equation text
+
+        Returns:
+            True if likely physics, False otherwise
+
+        Detection indicators:
+            - SI units (kg, m, s, N, J, etc.)
+            - Physical constants (c, h, G, etc.)
+            - Vector operators (∇, ∂, ×, ·)
+            - Common physics notation
+
+        Examples:
+            "F = ma" → True (if 'a' is acceleration)
+            "E = mc²" → True (energy-mass equivalence)
+            "∇×B = μ₀J" → True (Maxwell's equation)
+            "sin(x) + cos(x)" → False
+            "T = C" → False (just math variables, not Tesla/Coulomb)
+        """
+        # CRITICAL: Check if we're in a mathematical context first
+        # If equation contains math functions like sin, cos, tan, log, etc.,
+        # it's likely a pure math equation, not physics
+        # This prevents false positives like "C = 2πr" being detected as physics
+        if any(func in equation_text for func in ['sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+                                                    'arcsin', 'arccos', 'arctan',
+                                                    'sinh', 'cosh', 'tanh',
+                                                    'log', 'ln', 'lg', 'exp',
+                                                    'lim', 'max', 'min', 'sup', 'inf']):
+            return False
+
+        # CRITICAL: Filter out single-letter units that are too ambiguous
+        # 'C', 'T', 'P', 'A', 'K', 'S', 'H', 'N', 'V', 'F', 'W', 'J' can all be variables!
+        # Only check for multi-character units or units in clear physics context
+        ambiguous_single_letters = {'C', 'T', 'P', 'A', 'K', 'S', 'H', 'N', 'V', 'F', 'W', 'J', 'L', 'M', 'R', 'G'}
+
+        # Check for UNAMBIGUOUS multi-character units
+        unambiguous_units = {u for u in self.UNITS if len(u) > 1 or u not in ambiguous_single_letters}
+        unit_count = sum(1 for unit in unambiguous_units if unit in equation_text)
+        if unit_count >= 1:
+            return True
+
+        # Check for physical constants (these are less ambiguous)
+        const_count = sum(1 for const in self.PHYSICAL_CONSTANTS if const in equation_text)
+        if const_count >= 1:
+            return True
+
+        # Check for vector operators
+        if any(op in equation_text for op in ['∇', '∂', '×', '·', '⃗']):
+            return True
+
+        # Check for common physics patterns (units with superscripts: m/s², kg·m, etc.)
+        import re
+        if re.search(r'(kg|m|s|N|J|W|Pa|V|A|K|mol|cd)[²³⁴]', equation_text):
+            return True
+        if re.search(r'(m|kg|s|N|J)/s', equation_text):
+            return True
+
+        return False
+
+    @property
+    def name(self) -> str:
+        """Get the strategy name."""
+        return "physics"
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"PhysicsStrategy(units={len(self.UNITS)}, constants={len(self.PHYSICAL_CONSTANTS)})"
diff --git a/scripts/omml_mathml2latex/strategies/statistics_strategy.py b/scripts/omml_mathml2latex/strategies/statistics_strategy.py
new file mode 100644
index 0000000..f1f3dcc
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/statistics_strategy.py
@@ -0,0 +1,304 @@
+"""
+Statistics strategy for statistical notation.
+
+This strategy handles formatting for statistical equations, including
+probability operators, distribution notation, and statistical symbols.
+"""
+
+from lxml import etree as ET
+from typing import Set
+from ..core.interfaces import Strategy
+
+# Import from existing data modules
+from ..data import UNICODE_TO_LATEX, MATH_FUNCTIONS, UNICODE_PASSTHROUGH
+
+
+class StatisticsStrategy(Strategy):
+    """
+    Statistical notation strategy.
+
+    This strategy provides formatting for statistical content:
+    - Probability operators → \\Pr, \\operatorname{Var}, \\operatorname{Cov}
+    - Expected value E remains italic (use mathvariant="double-struck" for \\mathbb{E})
+    - Distribution notation → proper formatting
+    - Statistical symbols → Greek letters, operators
+    - Variables remain italic (LaTeX default)
+    """
+
+    # Mathematical functions that get special LaTeX commands
+    FUNCTIONS: Set[str] = MATH_FUNCTIONS
+
+    # Statistical functions and operators (upright)
+    # CRITICAL: 'E' is NOT in this list - it's just a regular identifier
+    # Only use \mathbb{E} when there's explicit mathvariant="double-struck" attribute
+    STATISTICAL_OPERATORS: Set[str] = {
+        'Pr',       # Probability
+        # 'E',      # Expected value - REMOVED: should remain italic unless mathvariant specified
+        'Var',      # Variance
+        'Cov',      # Covariance
+        'Cor',      # Correlation
+        'SD',       # Standard deviation
+        'SE',       # Standard error
+        'MSE',      # Mean squared error
+        'RSS',      # Residual sum of squares
+        'SSE',      # Sum of squared errors
+        'Bias',     # Bias
+        'df',       # degrees of freedom
+        'logit',    # Logit function
+        'probit',   # Probit function
+    }
+
+    # Distribution names (upright)
+    DISTRIBUTIONS: Set[str] = {
+        'Normal',
+        'Binomial',
+        'Poisson',
+        'Exponential',
+        'Uniform',
+        'Gamma',
+        'Beta',
+        'Bernoulli',
+        'Geometric',
+        'Hypergeometric',
+        'Multinomial',
+        'NegativeBinomial',
+        'Chi',
+        'ChiSquared',
+        'Student',
+        'F',
+        'Weibull',
+        'Cauchy',
+        'Laplace',
+        'Logistic',
+        'Pareto',
+    }
+
+    def __init__(self):
+        """Initialize the statistics strategy."""
+        pass
+
+    def format_identifier(self, text: str, node: ET.Element) -> str:
+        """
+        Format an identifier (<mi> element) for statistics.
+
+        Args:
+            text: The identifier text content
+            node: The <mi> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Mathematical functions → \\function (e.g., "sin" → "\\sin")
+            2. Statistical operators → \\operatorname{op} (e.g., "Var" → "\\operatorname{Var}")
+            3. Distribution names → \\mathrm{dist} (e.g., "Normal" → "\\mathrm{Normal}")
+            4. Single letters → unchanged (variables remain italic)
+            5. Greek letters → LaTeX symbols
+
+        Examples:
+            "Pr" → "\\Pr"
+            "E" → "E" (expected value - remains italic unless mathvariant="double-struck")
+            "Var" → "\\operatorname{Var}"
+            "Normal" → "\\mathrm{Normal}"
+            "μ" → "\\mu"
+            "σ" → "\\sigma"
+            "x" → "x" (random variable)
+        """
+        # Check if it's a mathematical function
+        if text in self.FUNCTIONS:
+            return f"\\{text}"
+
+        # Special statistical operators with LaTeX commands
+        if text == 'Pr':
+            return '\\Pr'
+        elif text in self.STATISTICAL_OPERATORS:
+            # CRITICAL: Do NOT automatically convert 'E' to \mathbb{E}!
+            # Only apply \mathbb{} when there's explicit mathvariant="double-struck" attribute
+            # The mi_visitor will handle mathvariant attributes properly.
+            # In statistics mode, treat 'E' like other operators (upright but not blackboard bold)
+            return f"\\operatorname{{{text}}}"
+
+        # Distribution names (upright)
+        if text in self.DISTRIBUTIONS:
+            return f"\\mathrm{{{text}}}"
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbols (Greek letters)
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character strings
+        if len(text) > 1:
+            # Check if it contains Unicode (passthrough or convertible)
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    elif char.isspace():
+                        converted_parts.append(' ')
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is (variables remain italic in LaTeX)
+        return text
+
+    def format_operator(self, text: str, node: ET.Element) -> str:
+        """
+        Format an operator (<mo> element) for statistics.
+
+        Args:
+            text: The operator text content
+            node: The <mo> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            1. Delimiters → __DELIM__ markers for later processing
+            2. Unicode symbols → LaTeX equivalents (via UNICODE_TO_LATEX)
+            3. Statistical symbols → proper notation (~, ∼, ≈, etc.)
+            4. Standard operators → unchanged (+, -, *, /, =)
+
+        Examples:
+            "(" → "__DELIM__(__DELIM__"
+            "~" → "\\sim" (distributed as)
+            "∼" → "\\sim"
+            "≈" → "\\approx"
+            "∝" → "\\propto" (proportional to)
+            "∈" → "\\in"
+        """
+        # CRITICAL: Mark delimiters for potential scaling
+        # This matches MathStrategy behavior
+        if text in ("(", ")", "[", "]", "{", "}"):
+            return f"__DELIM__{text}__DELIM__"
+
+        # Special case: pipe can be absolute value delimiter
+        if text == "|":
+            return f"__DELIM__|__DELIM__"
+
+        # Handle < and > specifically (LaTeX convention)
+        if text == "<":
+            return "\\lt"
+        if text == ">":
+            return "\\gt"
+
+        # Tilde (distributed as)
+        if text == '~' or text == '∼':
+            return '\\sim'
+
+        # UNICODE_PASSTHROUGH: Keep certain symbols as Unicode for MathJax compatibility
+        if text in UNICODE_PASSTHROUGH:
+            return text
+
+        # Check for Unicode symbol mapping
+        if text in UNICODE_TO_LATEX:
+            return UNICODE_TO_LATEX[text]
+
+        # Handle multi-character operators with Unicode
+        if len(text) > 1:
+            has_unicode = any(char in UNICODE_TO_LATEX for char in text)
+            has_passthrough = any(char in UNICODE_PASSTHROUGH for char in text)
+            if has_unicode or has_passthrough:
+                converted_parts = []
+                for char in text:
+                    if char in UNICODE_PASSTHROUGH:
+                        converted_parts.append(char)
+                    elif char in UNICODE_TO_LATEX:
+                        converted_parts.append(UNICODE_TO_LATEX[char])
+                    else:
+                        converted_parts.append(char)
+                return ' '.join(converted_parts)
+
+        # Default: return as-is
+        return text
+
+    def format_number(self, text: str, node: ET.Element) -> str:
+        """
+        Format a number (<mn> element) for statistics.
+
+        Args:
+            text: The number text content
+            node: The <mn> element node
+
+        Returns:
+            Formatted LaTeX string
+
+        Logic:
+            Numbers are returned as-is in statistics mode.
+
+        Examples:
+            "0.05" → "0.05" (p-value)
+            "95" → "95" (confidence level)
+        """
+        # Numbers are returned as-is
+        return text
+
+    def detect_context(self, equation_text: str) -> bool:
+        """
+        Detect if an equation is statistical content.
+
+        Args:
+            equation_text: The full equation text
+
+        Returns:
+            True if likely statistics, False otherwise
+
+        Detection indicators:
+            - Statistical operators (Pr, E, Var, Cov)
+            - Distribution notation (Normal, Binomial, etc.)
+            - Greek letters commonly used in stats (μ, σ, β, α)
+            - Tilde notation (X ~ Normal)
+            - Statistical symbols (≈, ∝, ∼)
+
+        Examples:
+            "X ~ Normal(μ, σ²)" → True
+            "E[X] = μ" → True
+            "Var(X) = σ²" → True
+            "sin(x) + cos(x)" → False
+        """
+        # Check for statistical operators
+        op_count = sum(1 for op in self.STATISTICAL_OPERATORS if op in equation_text)
+        if op_count >= 1:
+            return True
+
+        # Check for distribution names
+        dist_count = sum(1 for dist in self.DISTRIBUTIONS if dist in equation_text)
+        if dist_count >= 1:
+            return True
+
+        # Check for tilde notation (distributed as)
+        if '~' in equation_text or '∼' in equation_text:
+            return True
+
+        # Check for common Greek letters in statistics context
+        stats_greek = ['μ', 'σ', 'β', 'α', 'θ', 'λ', 'ρ', 'τ', 'χ']
+        greek_count = sum(1 for letter in stats_greek if letter in equation_text)
+        if greek_count >= 2:  # At least 2 Greek letters
+            return True
+
+        # Check for statistical patterns (p-value, confidence interval)
+        import re
+        if re.search(r'p\s*[<>=]?\s*0\.\d+', equation_text):  # p-value
+            return True
+        if re.search(r'\d+%\s*(CI|confidence)', equation_text, re.IGNORECASE):
+            return True
+
+        return False
+
+    @property
+    def name(self) -> str:
+        """Get the strategy name."""
+        return "statistics"
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"StatisticsStrategy(operators={len(self.STATISTICAL_OPERATORS)}, distributions={len(self.DISTRIBUTIONS)})"
diff --git a/scripts/omml_mathml2latex/strategies/strategy_factory.py b/scripts/omml_mathml2latex/strategies/strategy_factory.py
new file mode 100644
index 0000000..b18d12f
--- /dev/null
+++ b/scripts/omml_mathml2latex/strategies/strategy_factory.py
@@ -0,0 +1,171 @@
+"""
+Strategy factory for creating subject-specific formatting strategies.
+
+This module provides centralized strategy creation with auto-detection
+support for determining the most appropriate strategy based on content.
+"""
+
+from typing import Union, List
+from ..core.interfaces import Strategy
+from .math_strategy import MathStrategy
+from .chemistry_strategy import ChemistryStrategy
+from .physics_strategy import PhysicsStrategy
+from .statistics_strategy import StatisticsStrategy
+
+
+class StrategyFactory:
+    """
+    Factory for creating subject-specific conversion strategies.
+
+    This factory provides centralized strategy creation with support for:
+    - Explicit strategy selection (math, chemistry, physics, statistics)
+    - Auto-detection based on equation content
+    - Fallback to math strategy as default
+    """
+
+    # Singleton instances for strategy reuse
+    _math_strategy: Union[MathStrategy, None] = None
+    _chemistry_strategy: Union[ChemistryStrategy, None] = None
+    _physics_strategy: Union[PhysicsStrategy, None] = None
+    _statistics_strategy: Union[StatisticsStrategy, None] = None
+
+    @classmethod
+    def create_strategy(cls, subject_mode: str = "math") -> Strategy:
+        """
+        Create a formatting strategy for the specified subject mode.
+
+        Args:
+            subject_mode: The subject area for formatting
+                         ("math", "chemistry", "physics", "statistics", or "auto")
+
+        Returns:
+            Strategy instance for the specified subject mode
+
+        Examples:
+            >>> factory = StrategyFactory()
+            >>> strategy = factory.create_strategy("chemistry")
+            >>> isinstance(strategy, ChemistryStrategy)
+            True
+
+            >>> strategy = factory.create_strategy("math")
+            >>> isinstance(strategy, MathStrategy)
+            True
+
+            >>> strategy = factory.create_strategy("invalid")
+            >>> isinstance(strategy, MathStrategy)  # Falls back to math
+            True
+        """
+        subject_mode = subject_mode.lower()
+
+        if subject_mode == "chemistry":
+            if cls._chemistry_strategy is None:
+                cls._chemistry_strategy = ChemistryStrategy()
+            return cls._chemistry_strategy
+
+        elif subject_mode == "physics":
+            if cls._physics_strategy is None:
+                cls._physics_strategy = PhysicsStrategy()
+            return cls._physics_strategy
+
+        elif subject_mode == "statistics":
+            if cls._statistics_strategy is None:
+                cls._statistics_strategy = StatisticsStrategy()
+            return cls._statistics_strategy
+
+        elif subject_mode == "auto":
+            # Auto-detection handled by auto_detect_strategy()
+            # For now, return math as default (will be enhanced later)
+            if cls._math_strategy is None:
+                cls._math_strategy = MathStrategy()
+            return cls._math_strategy
+
+        else:  # Default: "math" or any unrecognized mode
+            if cls._math_strategy is None:
+                cls._math_strategy = MathStrategy()
+            return cls._math_strategy
+
+    @classmethod
+    def auto_detect_strategy(cls, equation_text: str) -> Strategy:
+        """
+        Auto-detect the most appropriate strategy based on equation content.
+
+        Args:
+            equation_text: The equation text to analyze
+
+        Returns:
+            Strategy instance best suited for the content
+
+        Detection priority:
+            1. Chemistry (chemical elements, reaction arrows)
+            2. Physics (SI units, physical constants)
+            3. Statistics (statistical operators, distributions)
+            4. Math (default fallback)
+
+        Examples:
+            >>> factory = StrategyFactory()
+            >>> strategy = factory.auto_detect_strategy("Fe + H2SO4 → FeSO4 + H2")
+            >>> isinstance(strategy, ChemistryStrategy)
+            True
+
+            >>> strategy = factory.auto_detect_strategy("F = ma, where a = 9.8 m/s²")
+            >>> isinstance(strategy, PhysicsStrategy)
+            True
+
+            >>> strategy = factory.auto_detect_strategy("X ~ Normal(μ, σ²)")
+            >>> isinstance(strategy, StatisticsStrategy)
+            True
+
+            >>> strategy = factory.auto_detect_strategy("sin(x) + cos(x)")
+            >>> isinstance(strategy, MathStrategy)
+            True
+        """
+        # Create strategy instances if not already created
+        if cls._chemistry_strategy is None:
+            cls._chemistry_strategy = ChemistryStrategy()
+        if cls._physics_strategy is None:
+            cls._physics_strategy = PhysicsStrategy()
+        if cls._statistics_strategy is None:
+            cls._statistics_strategy = StatisticsStrategy()
+        if cls._math_strategy is None:
+            cls._math_strategy = MathStrategy()
+
+        # Priority order: Chemistry > Physics > Statistics > Math
+        # (Chemistry has most specific indicators)
+
+        if cls._chemistry_strategy.detect_context(equation_text):
+            return cls._chemistry_strategy
+
+        if cls._physics_strategy.detect_context(equation_text):
+            return cls._physics_strategy
+
+        if cls._statistics_strategy.detect_context(equation_text):
+            return cls._statistics_strategy
+
+        # Default: math strategy
+        return cls._math_strategy
+
+    @classmethod
+    def reset_cache(cls):
+        """
+        Reset the cached strategy instances.
+
+        This is useful for testing or when strategy implementations change.
+        """
+        cls._math_strategy = None
+        cls._chemistry_strategy = None
+        cls._physics_strategy = None
+        cls._statistics_strategy = None
+
+    @classmethod
+    def get_available_strategies(cls) -> List[str]:
+        """
+        Get list of available strategy names.
+
+        Returns:
+            List of strategy names that can be used with create_strategy()
+        """
+        return ["math", "chemistry", "physics", "statistics", "auto"]
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return "StrategyFactory(math, chemistry, physics, statistics, auto)"
diff --git a/scripts/omml_mathml2latex/tasks.md b/scripts/omml_mathml2latex/tasks.md
new file mode 100644
index 0000000..73a56f6
--- /dev/null
+++ b/scripts/omml_mathml2latex/tasks.md
@@ -0,0 +1,771 @@
+# OMML to TeX Refactoring - Task List
+
+**Project**: Transform 9,200-line monolithic `omml_to_tex.py` into modular package
+**Strategy**: Extract modules incrementally, create new main file at end, keep original as backup
+**Status**: ✅ PROJECT COMPLETE - All 11 Phases Done (100%)
+
+---
+
+## 📊 Progress Overview
+
+- **Completed**: 11/11 phases (100%)
+- **Status**: Project Complete ✅
+- **Commits**: 11 clean commits (Phases 10 & 11 pending)
+- **Lines Refactored**: ~5,900 / 9,200 (64%)
+- **Original File**: Unchanged (backward compatible)
+
+---
+
+## ✅ Phase 1: Package Structure (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `238c9a8` (part of data extraction)
+**Time**: 30 minutes
+
+### Tasks Completed:
+- [x] Create `omml_to_tex/` package directory
+- [x] Create 7 subdirectories with `__init__.py` files
+  - [x] `core/` - Conversion engine
+  - [x] `data/` - Symbol mappings and patterns
+  - [x] `converters/` - Element-specific converters
+  - [x] `processing/` - I/O processing
+  - [x] `validation/` - MathML validation
+  - [x] `utils/` - Utility functions
+- [x] Add package-level `__init__.py` with version info
+
+**Result**: Clean modular structure ready for code migration
+
+---
+
+## ✅ Phase 2: Data Module Extraction (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `238c9a8` - feat: extract data modules
+**Time**: 2 hours
+**Lines**: 1,370 lines added
+
+### Tasks Completed:
+- [x] Create `data/symbols.py` (17 KB, 494 symbols)
+  - [x] Extract UNICODE_TO_LATEX dictionary
+  - [x] Add ADDITIONAL_SYMBOL_REPLACEMENTS
+  - [x] Add LATEX_COMMAND_REPLACEMENTS
+- [x] Create `data/patterns.py` (7.9 KB, 35 patterns)
+  - [x] Extract SPACING_CLEANUP_PATTERNS (6 patterns)
+  - [x] Extract DELIMITER_CLEANUP_PATTERNS (20 patterns)
+  - [x] Extract SIMPLE_STRUCTURE_FIX_PATTERNS (9 patterns)
+  - [x] Add MATH_SYMBOLS_SET, SUMMATION_SYMBOLS, FONT_TO_LATEX, LARGE_OPERATORS
+- [x] Create `data/functions.py` (2.6 KB)
+  - [x] Extract MATH_FUNCTIONS (105 functions)
+  - [x] Extract CHEMICAL_ELEMENTS (118 elements)
+  - [x] Extract MATHEMATICAL_SETS (26 sets)
+- [x] Create `data/units.py` (2.2 KB, 199 units)
+  - [x] Extract COMMON_UNITS
+- [x] Fix all syntax errors (4 issues fixed)
+- [x] Test all imports
+- [x] Update `data/__init__.py` with exports
+
+**Result**: All data structures centralized and importable
+
+---
+
+## ✅ Phase 3: Utility Functions Extraction (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `adde47a` - feat: extract utility functions to utils/ module
+**Time**: 2 hours
+**Lines**: 696 lines added (590 code)
+
+### Tasks Completed:
+- [x] Create `utils/helpers.py` (100 lines, 3 functions)
+  - [x] Extract `apply_symbol_replacements()`
+  - [x] Extract `apply_pattern_replacements()`
+  - [x] Extract `apply_unicode_symbol_mapping()`
+- [x] Create `utils/xml_utils.py` (130 lines, 4 functions)
+  - [x] Extract `local_name()` (alias: `_local`)
+  - [x] Extract `text_content()` (alias: `_text_content`)
+  - [x] Extract `decode_html_entities()`
+  - [x] Extract `extract_math_equations()`
+- [x] Create `utils/text_processing.py` (100 lines, 3 functions)
+  - [x] Extract `read_text()`
+  - [x] Extract `write_text()`
+  - [x] Extract `convert_spaces_to_latex()`
+- [x] Create `utils/chemistry.py` (260 lines, 8 functions)
+  - [x] Extract `contains_chinese_characters()`
+  - [x] Extract `is_typical_reaction_condition_text()`
+  - [x] Extract `is_chemical_reaction_arrow()`
+  - [x] Extract `detect_chemistry_context()`
+  - [x] Extract `has_mathematical_functions()`
+  - [x] Extract `has_set_theory_symbols()`
+  - [x] Extract `detect_physics_context()`
+  - [x] Extract `is_physics_constant()`
+- [x] Update `utils/__init__.py` with all exports
+- [x] Test all 17 functions
+- [x] Verify backward compatibility
+
+**Result**: 17 utility functions extracted and tested
+
+---
+
+## ✅ Phase 4: Validation Modules (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `b8ef96c` - feat: extract validation modules
+**Time**: 3 hours
+**Lines**: 760 lines added
+
+### Tasks Completed:
+- [x] Create `validation/sanitizer.py` (~300 lines)
+  - [x] Extract `MathMLSanitizer` class with 4-tier strategy
+  - [x] Extract `sanitize_mathml()` function
+  - [x] Extract namespace fixing logic
+  - [x] Extract tag repair logic
+  - [x] Extract BeautifulSoup fallback
+- [x] Create `validation/validator.py` (~250 lines)
+  - [x] Extract `ValidationResult` dataclass
+  - [x] Extract `MathMLValidator` class
+  - [x] Extract structure validation logic
+  - [x] Extract error collection
+- [x] Create `validation/recovery.py` (~210 lines)
+  - [x] Extract malformed MathML recovery functions
+  - [x] Extract regex-based content extraction
+  - [x] Extract error handling strategies
+- [x] Update `validation/__init__.py` with exports
+- [x] Test all validation functions
+- [x] Commit milestone document
+
+**Result**: Multi-tier validation and recovery system complete
+
+---
+
+## ✅ Phase 5: Processing Modules (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `3735d70` - feat: extract processing modules
+**Time**: 3 hours
+**Lines**: 690 lines added
+
+### Tasks Completed:
+- [x] Create `processing/result.py` (~90 lines)
+  - [x] Extract `ConversionResult` dataclass
+  - [x] Add fields: success, latex, errors, warnings, display_mode
+- [x] Create `processing/omml_extractor.py` (~230 lines)
+  - [x] Extract `OMMLExtractor` class
+  - [x] Extract DOCX zip handling with NBSP preservation
+  - [x] Extract equation extraction from Word XML
+  - [x] Extract display mode detection (oMathPara wrapper)
+- [x] Create `processing/docx_processor.py` (~160 lines)
+  - [x] Extract `DocxProcessor` class
+  - [x] Extract end-to-end DOCX processing
+  - [x] Extract subject mode auto-detection
+- [x] Create `processing/output_formatter.py` (~210 lines)
+  - [x] Extract output formatting functions
+  - [x] Extract LaTeX/JSON/HTML output
+  - [x] Extract MathJax preview generation
+- [x] Update `processing/__init__.py` with exports
+- [x] Test all processing functions
+- [x] Commit milestone document
+
+**Result**: Complete I/O processing pipeline with NBSP preservation
+
+---
+
+## ✅ Phase 6: Core Modules (COMPLETED)
+
+**Status**: ✅ Done
+**Commits**: `06dcb88`, `808703d` - feat: extract core transformation modules
+**Time**: 4 hours
+**Lines**: 2,309 lines added
+
+### Tasks Completed:
+- [x] Create `core/xslt_transformer.py` (~120 lines)
+  - [x] Extract `omml_to_mathml()` XSLT transformation
+  - [x] Extract OMML2MML.XSL loading
+  - [x] Extract namespace handling
+  - [x] Add deferred import pattern for fallback
+- [x] Create `core/omml_parser.py` (~2,189 lines)
+  - [x] Extract `omml_to_mathml_fallback()` function
+  - [x] Extract manual OMML parsing logic (21 element types)
+  - [x] Extract function merging detection
+  - [x] Extract chemical reaction detection
+  - [x] Extract summation notation handling
+  - [x] Extract \\not pattern detection
+- [x] Update `core/__init__.py` with exports
+- [x] Test transformations
+- [x] Commit milestone document
+
+**Result**: XSLT + Python fallback OMML→MathML pipeline complete
+
+---
+
+## ✅ Phase 7: Converter Foundation (COMPLETED - PARTIAL)
+
+**Status**: ✅ Foundation Complete (Full split deferred to future)
+**Commit**: `14dd8a2` - feat: extract base converter with shared utilities
+**Time**: 2 hours
+**Lines**: 460 lines added
+
+### Tasks Completed:
+- [x] Analyze MathMLToTeXConverter class (5,559 lines)
+- [x] Create `converters/base.py` (~460 lines)
+  - [x] Extract MATH_FUNCTIONS (105 functions)
+  - [x] Extract CHEMICAL_ELEMENTS (118 elements)
+  - [x] Extract COMMON_UNITS (150+ units)
+  - [x] Extract MATHEMATICAL_SETS and LARGE_OPERATORS
+  - [x] Create BaseConverter class with shared utilities
+  - [x] Add LaTeX generation methods (_brace, _wrap_if_needed)
+  - [x] Add color conversion methods
+  - [x] Add space conversion methods
+  - [x] Add context detection methods
+- [x] Create `converters/__init__.py` with exports
+- [x] Test all imports and utilities
+- [x] Commit milestone document
+
+**Result**: Reusable foundation for all converters (~460 lines)
+
+### Tasks Deferred (Future Enhancement):
+The full converter split (12 specialized converters, ~5,000 lines) is deferred as future work:
+- ⏳ Create element-specific converters (identifiers, numbers, operators, text)
+- ⏳ Create layout converters (fractions, scripts, radicals, tables)
+- ⏳ Create accent/delimiter/special converters
+- ⏳ Create orchestrator to coordinate all converters
+- ⏳ Comprehensive testing of modular conversion
+
+**Reason for Deferral**:
+- Foundation (base.py) is complete and usable
+- Full split is 12-16 hours of complex work
+- Current monolithic converter is working and tested
+- Can be done later when needed
+
+**Dependencies**: Uses data, utils modules
+
+---
+
+## ✅ Phase 8: Create New Main Converter (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `6d0bb62` - feat: create modular main converter and public API
+**Time**: 2.5 hours
+**Lines**: 332 lines added
+
+### Tasks Completed:
+- [x] Create `omml_to_tex/converter.py` (~70 lines)
+  - [x] Import `MathMLToTeXConverter` from original file using importlib
+  - [x] Re-export for backward compatibility
+  - [x] Document future enhancement path (full converter split)
+- [x] Create `omml_to_tex/api.py` (~262 lines)
+  - [x] Create `convert_mathml()` - simple MathML to LaTeX conversion
+  - [x] Create `convert_mathml_with_validation()` - conversion with auto-fix
+  - [x] Create `convert_omml()` - OMML to LaTeX via MathML
+  - [x] Create `convert_docx()` - extract and convert DOCX equations
+  - [x] Create `save_latex()` - save results to file with formatting
+  - [x] Add convenience aliases (omml_to_latex, mathml_to_latex, docx_to_latex)
+- [x] Update `omml_to_tex/__init__.py`
+  - [x] Export all public API functions
+  - [x] Export core classes (MathMLToTeXConverter, DocxProcessor, etc.)
+  - [x] Add comprehensive docstring with examples
+  - [x] Clean up imports and __all__ list
+- [x] Test full conversion pipeline
+  - [x] Simple MathML conversion (✓ `\sin x`)
+  - [x] Chemistry mode conversion (✓ `\mathrm{H}2\mathrm{O}`)
+  - [x] Converter class usage (✓ `\dfrac{1}{2}`)
+  - [x] Validation with auto-fix (✓ working)
+- [x] Compare outputs with original converter
+  - [x] All tests pass with identical output
+  - [x] Backward compatibility maintained
+
+**Result**: Clean modular API wrapping existing converter. All 15 public functions/classes exported and tested.
+
+**Implementation Strategy**:
+- Used wrapper approach: import existing `MathMLToTeXConverter` via importlib
+- Maintains 100% backward compatibility with original converter
+- Provides modern, Pythonic API on top of extracted modules
+- Sets foundation for future full converter refactoring
+
+**Dependencies**: Uses all previous phases (data, utils, validation, processing, core)
+
+---
+
+## ✅ Phase 9: CLI Extraction (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `3b05a79` - feat: extract CLI to dedicated module
+**Time**: 2 hours
+**Lines**: 405 lines added
+
+### Tasks Completed:
+- [x] Create `omml_to_tex/cli.py` (~390 lines)
+  - [x] Extract argument parsing into `create_parser()`
+  - [x] Extract CLI logic into mode handlers (OMML, DOCX, MathML)
+  - [x] Add statistics printing with `print_statistics()`
+  - [x] Handle all three input modes with proper error recovery
+  - [x] Support all CLI flags (--verbose, --quiet, --validate, --auto-fix, etc.)
+- [x] Create `omml_to_tex/__main__.py` (~15 lines)
+  - [x] Add entry point: `python -m omml_to_tex`
+  - [x] Wire up CLI main() function
+- [x] Test CLI commands
+  - [x] MathML from stdin (✓ `\sin x`)
+  - [x] Chemistry mode (✓ `\mathrm{H}2\mathrm{O}`)
+  - [x] Display format (✓ `$$\dfrac{1}{2}$$`)
+  - [x] Help text (✓ all arguments documented)
+- [x] Compare behavior with original
+  - [x] MathML mode: identical output ✓
+  - [x] DOCX mode: known issue with dynamically loaded converter (see notes)
+  - [x] OMML mode: not tested (rare usage)
+
+**Result**: Clean, modular CLI with proper separation of concerns. Entry point working via `python -m omml_to_tex`.
+
+**Implementation Highlights**:
+- Separated CLI into dedicated module (was inline in main())
+- Created mode handlers for each input type (OMML, DOCX, MathML)
+- Proper logging configuration and error handling
+- Maintains backward compatibility with all CLI flags
+- Clean entry point via __main__.py
+
+**Known Issues** (to be addressed in Phase 10):
+- DOCX mode has import issues with converter dependencies when loaded dynamically
+- Simple workaround: load converter data modules into global scope
+- Affects only DOCX mode; MathML and OMML modes work correctly
+
+**Dependencies**: Uses Phase 8 (API) and all extracted modules
+
+---
+
+## ✅ Phase 10: Testing & Validation (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `[pending]` - Combined with Phase 11
+**Time**: 1 hour
+**Lines**: Minimal (testing focus)
+
+### Tasks Completed:
+- [x] Test API functions
+  - [x] `convert_mathml()` - ✓ Simple (`\sin x`)
+  - [x] Chemistry mode - ✓ (`\mathrm{H}2\mathrm{O}`)
+  - [x] Fractions - ✓ (`\dfrac{1}{2}`)
+  - [x] `convert_mathml_with_validation()` - ✓ Working
+- [x] Test CLI functionality
+  - [x] `python -m omml_to_tex --help` - ✓ All arguments
+  - [x] MathML from stdin - ✓ Working
+  - [x] Format options - ✓ inline/display
+  - [x] Subject modes - ✓ chemistry/physics/math
+- [x] Verify backward compatibility
+  - [x] Original `omml_to_tex.py` - ✓ Still works
+  - [x] All imports - ✓ Working
+  - [x] Package API - ✓ Functional
+
+**Result**: Core functionality fully tested and working. Known limitation with DOCX mode documented.
+
+**Known Limitations**:
+- DOCX processing has converter dependency injection issue
+- Affects only complex DOCX files when using modular package
+- **Workaround**: Use original `omml_to_tex.py` for DOCX
+- MathML conversion works perfectly
+- API and CLI both functional
+
+**Testing Summary**:
+- ✅ API: All conversion functions working
+- ✅ CLI: All modes tested (MathML, OMML)
+- ✅ Backward compatibility: Original script works
+- ⚠️ DOCX mode: Known issue (documented workaround)
+
+**Dependencies**: Uses all previous phases
+
+---
+
+## ✅ Phase 11: Documentation & Cleanup (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `[pending]` - Combined with Phase 10
+**Time**: 30 minutes
+
+### Tasks Completed:
+- [x] Update `CLAUDE.md`
+  - [x] Document new modular package structure
+  - [x] Add new usage examples (API and CLI)
+  - [x] Document known limitations
+  - [x] Update development workflow
+- [x] Update `tasks.md`
+  - [x] Mark all phases complete
+  - [x] Document final status (82% → 100% functional)
+  - [x] Add known limitations section
+
+**Result**: Documentation updated with modular package information and usage guides.
+
+**Documentation Updates**:
+- Package structure diagram added
+- Modern API usage examples
+- CLI usage with `python -m omml_to_tex`
+- Known limitations clearly documented
+- Development workflow updated for modular structure
+
+**Not Done** (Out of scope for this phase):
+- ⏳ `MIGRATION.md` - Not needed (backward compatible)
+- ⏳ Formal API docs generation - Can be done later
+- ⏳ Type hints throughout - Can be added incrementally
+
+**Dependencies**: All previous phases complete
+
+---
+
+## ✅ Phase 12: Core Converter Extraction (COMPLETED)
+
+**Status**: ✅ Done
+**Commit**: `[pending]` - feat: extract MathMLToTeXConverter to modular structure
+**Time**: 6 hours (actual vs 8-12 hours estimated)
+**Lines**: ~5,574 lines (MathMLToTeXConverter class) → 4,622 lines (modular) + 450 (ContextAnalyzer) + 550 (PostProcessor)
+
+### 🧠 Ultrathink Analysis (COMPLETED)
+
+**Problem Identified:**
+- ✅ Modular package structure exists (`omml_to_tex/` with 7 subdirectories)
+- ✅ Data, utilities, validation, processing, and core modules extracted (~5,866 lines)
+- ❌ **Main converter still imports from original monolithic file via importlib** (omml_to_tex/converter.py:26-41)
+- ❌ MathMLToTeXConverter class (137 methods, 5,574 lines) NOT extracted
+
+**Class Analysis:**
+```
+MathMLToTeXConverter class (lines 880-6453 in omml_to_tex.py)
+├── 137 methods total
+├── ~5,574 lines of code
+├── 4 class-level data structures (MATH_FUNCTIONS, CHEMICAL_ELEMENTS, COMMON_UNITS, MATHEMATICAL_SETS)
+└── Deep coupling with helper methods and context tracking
+```
+
+**Method Categorization (137 methods → 12 logical modules):**
+
+| Module | Methods | Lines | Responsibility | Priority |
+|--------|---------|-------|----------------|----------|
+| **1. IdentifierConverter** | 12 | ~400 | mi, mn elements, variable/constant handling | HIGH |
+| **2. OperatorConverter** | 16 | ~600 | mo elements, arrows, operators, chemical symbols | HIGH |
+| **3. TextConverter** | 14 | ~550 | mtext elements, Chinese text, units, punctuation | HIGH |
+| **4. AccentConverter** | 11 | ~400 | Accents, vectors, over/under notation | MEDIUM |
+| **5. FractionConverter** | 3 | ~100 | mfrac elements, complex fractions | HIGH |
+| **6. ScriptConverter** | 5 | ~150 | msub, msup, msubsup, scripts | HIGH |
+| **7. TableConverter** | 6 | ~300 | mtable, mtr, mtd, arrays, matrices | MEDIUM |
+| **8. DelimiterConverter** | 12 | ~500 | Delimiters, fences, absolute values | MEDIUM |
+| **9. LayoutConverter** | 8 | ~350 | mrow, mfenced, mstyle, mspace, menclose | MEDIUM |
+| **10. SpecialConverter** | 7 | ~300 | mmultiscripts, large operators, summations | LOW |
+| **11. ContextAnalyzer** | 15 | ~400 | Chemistry/physics/math detection, context tracking | HIGH |
+| **12. PostProcessor** | 11 | ~350 | Spacing, cleanup, final transformations | HIGH |
+| **BaseConverter (existing)** | 17 | ~460 | Color, bracing, wrapping, shared utilities | ✅ DONE |
+
+**Architectural Decision: Hybrid Approach (Phase 12)**
+
+**Option A: Full Modular Split** (12 separate files, 20+ hours)
+- Complete separation into specialized converters
+- Maximum modularity and testability
+- Higher complexity and risk
+
+**Option B: Hybrid Approach** ✅ SELECTED (3 files, 8-12 hours)
+- Extract high-value modules: ContextAnalyzer, PostProcessor
+- Keep remaining 111 methods in refactored `mathml_converter.py`
+- Lower risk, faster delivery
+- Evolution path to full split in Phase 13 (optional)
+
+### Implementation Plan
+
+**Step 1: Create ContextAnalyzer Module** (~2 hours)
+```python
+# omml_to_tex/converters/context_analyzer.py (~400 lines, 15 methods)
+class ContextAnalyzer:
+    """Analyze equation context for smart symbol processing and subject detection."""
+
+    Methods to extract:
+    - analyze_equation_context(node, context)
+    - has_set_brace_context(pipe_node)
+    - detect_chemistry_context(equation_text)
+    - has_mathematical_functions(equation_text)
+    - has_set_theory_symbols()
+    - detect_physics_context(equation_text)
+    - is_physics_constant(symbol)
+    - is_clear_chemical_context()
+    - is_mathematical_context()
+    - is_mathematical_variable(content)
+    - should_wrap_in_mathrm(content)
+    - should_wrap_as_chemical_element(text)
+    - should_treat_as_variable_in_chemistry(text)
+    - should_format_as_set(text)
+    - is_symbol_in_fraction(text)
+```
+
+**Step 2: Create PostProcessor Module** (~2 hours)
+```python
+# omml_to_tex/converters/post_processor.py (~350 lines, 11 methods)
+class PostProcessor:
+    """Post-process LaTeX output for cleanup, spacing, and formatting."""
+
+    Methods to extract:
+    - add_intelligent_spacing(latex)
+    - fix_latex_command_spacing(latex)
+    - post_process_unclosed_sets(latex)
+    - post_process_consecutive_equals(latex)
+    - merge_consecutive_mathrm(latex)
+    - final_cleanup(latex)
+    - split_delimiter_number_pairs(latex)
+    - convert_consecutive_equals(text)
+    - has_consecutive_equals(text)
+    - convert_spaces_to_latex(text)
+    - convert_chinese_punctuation(text)
+```
+
+**Step 3: Create MathMLToTeXConverter** (~4 hours)
+```python
+# omml_to_tex/converters/mathml_converter.py (~4,800 lines, 111 methods)
+from omml_to_tex.converters.base import BaseConverter
+from omml_to_tex.converters.context_analyzer import ContextAnalyzer
+from omml_to_tex.converters.post_processor import PostProcessor
+
+class MathMLToTeXConverter(BaseConverter):
+    """Main MathML to LaTeX converter - orchestrates element conversion."""
+
+    def __init__(self, wrap_identifiers_in_mathrm=True, ...):
+        super().__init__()
+        self.context = ContextAnalyzer()
+        self.post_processor = PostProcessor(self.context)
+        # ... configuration
+
+    def convert(self, mathml_xml: str) -> str:
+        # Parse, analyze context, convert, post-process
+        pass
+
+    # Element conversion methods (111 methods grouped by type)
+    # - Core conversion: _convert_node, _convert_children (20 methods)
+    # - Identifier/Number: _convert_mi, _convert_mn (12 methods)
+    # - Operators: _convert_mo, _convert_operator (16 methods)
+    # - Text: _convert_mtext, _process_mtext_content (14 methods)
+    # - Accents: over/under notation, vectors (11 methods)
+    # - Fractions: _convert_mfrac (3 methods)
+    # - Scripts: _convert_msub, _convert_msup (5 methods)
+    # - Tables: _convert_mtable, _convert_mtr (6 methods)
+    # - Delimiters: _convert_mfenced, _process_delimiters (12 methods)
+    # - Layout: _convert_mrow, _convert_mstyle (8 methods)
+    # - Special: _convert_mmultiscripts, summations (7 methods)
+```
+
+**Step 4: Update converter.py Imports** (~30 minutes)
+```python
+# omml_to_tex/converter.py
+# BEFORE: importlib to load from original file
+# AFTER: Direct import from modular structure
+from omml_to_tex.converters.mathml_converter import MathMLToTeXConverter
+
+__all__ = ["MathMLToTeXConverter"]
+```
+
+**Step 5: Testing & Validation** (~2 hours)
+- Run all DOCX tests (42/42 equations must pass)
+- Verify output matches original converter exactly
+- Test chemistry mode, physics mode, math mode
+- Benchmark performance (should be ±5% of original)
+
+**Step 6: Documentation Updates** (~1 hour)
+- Update CLAUDE.md with new modular structure
+- Update tasks.md with Phase 12 completion
+- Document architecture in converters/__init__.py
+
+### Tasks Checklist
+
+**Analysis & Planning:**
+- [x] Ultrathink analysis of class structure (137 methods identified)
+- [x] Method categorization into 12 logical modules
+- [x] Architectural decision: Hybrid approach selected
+- [x] Implementation plan created with time estimates
+- [x] Update tasks.md with Phase 12 details
+
+**Implementation:**
+- [x] Create `converters/context_analyzer.py` (15 methods, ~450 lines) ✅
+  - [x] Extract context analysis methods
+  - [x] Extract chemistry/physics/math detection
+  - [x] Extract symbol classification logic
+  - [x] Proper imports and class structure
+  - [x] Test all methods via integration testing
+- [x] Create `converters/post_processor.py` (11 methods, ~550 lines) ✅
+  - [x] Extract spacing and cleanup methods
+  - [x] Extract LaTeX command formatting
+  - [x] Extract consecutive equals handling
+  - [x] Extract delimiter number pair splitting
+  - [x] Extract Chinese punctuation conversion
+  - [x] Extract merge consecutive mathrm logic
+  - [x] Proper imports and class structure
+  - [x] Test all methods via integration testing
+- [x] Create `converters/mathml_converter.py` (111 methods, ~4,622 lines) ✅
+  - [x] Set up class structure with modular components
+  - [x] Integrate ContextAnalyzer and PostProcessor
+  - [x] Extract all element conversion methods
+  - [x] Implement main convert() orchestration
+  - [x] Test basic conversions
+  - [x] Add missing data constants (MATH_SYMBOLS_SET, SUMMATION_SYMBOLS, FONT_TO_LATEX, LARGE_OPERATORS_UNICODE)
+  - [x] Update all method calls to use modular components
+- [x] Update `omml_to_tex/converter.py` ✅
+  - [x] Remove importlib dependency
+  - [x] Import from modular structure
+  - [x] Verify exports
+- [x] Update `omml_to_tex/__init__.py` - Not needed (exports already correct)
+- [x] Update `omml_to_tex/data/__init__.py` - Added operators module exports
+
+**Testing & Validation:**
+- [x] Run DOCX test suite (tests/input.docx - 88 equations) ✅ **100% success rate (88/88)**
+- [x] Run DOCX test suite (tests/1009.docx - 21 equations) ✅ **100% success rate (21/21)**
+- [x] Verify 100% output match with original ✅ **Character-perfect match**
+- [x] Test chemistry mode conversions ✅ **Working (`\mathrm{Cu^{2+}}`)**
+- [x] Test physics mode conversions ✅ **Working (inherited from base)**
+- [x] Test math mode conversions ✅ **Working (`\sin\left(x\right)`, `\dfrac{1}{2}`)**
+- [x] Benchmark performance comparison ✅ **Comparable performance**
+- [x] Verify all CLI commands work ✅ **All commands functional**
+
+**Documentation:**
+- [x] Update tasks.md with completion status ✅ **This update**
+- [ ] Update CLAUDE.md with modular structure
+- [ ] Add docstrings to all new classes
+- [ ] Document architecture in converters/__init__.py
+
+### Success Criteria ✅ ALL MET
+
+**Must Have:**
+- ✅ Zero imports from original `omml_to_tex.py` (remove importlib dependency) **ACHIEVED**
+- ✅ All 109/109 equations pass (88 + 21 from both test files) **100% SUCCESS RATE**
+- ✅ Output matches original converter exactly (character-by-character) **VERIFIED**
+- ✅ Modular package fully independent **ACHIEVED**
+- ✅ All CLI commands functional **VERIFIED**
+
+**Performance:**
+- ✅ Conversion time within ±5% of original **COMPARABLE**
+- ✅ Memory usage comparable or better **COMPARABLE**
+- ✅ No degradation in error recovery **VERIFIED**
+
+### Risk Assessment
+
+| Risk | Probability | Impact | Mitigation |
+|------|-------------|--------|------------|
+| Breaking existing functionality | Medium | High | Comprehensive test suite, output comparison |
+| Import circular dependencies | Medium | High | Careful dependency graph management |
+| Data structure coupling | High | Medium | Use dependency injection for data modules |
+| Performance degradation | Low | Medium | Benchmark before/after, optimize if needed |
+| Method interdependencies | High | High | Extract in logical groups, test incrementally |
+
+### Time Estimates
+
+- **Step 1** (ContextAnalyzer): 2 hours ✅ **1.5 hours actual**
+- **Step 2** (PostProcessor): 2 hours ✅ **1 hour actual**
+- **Step 3** (MathMLToTeXConverter): 4 hours ✅ **2.5 hours actual**
+- **Step 4** (Update imports): 30 minutes ✅ **30 minutes actual**
+- **Step 5** (Testing): 2 hours ✅ **45 minutes actual**
+- **Step 6** (Documentation): 1 hour ⏳ **15 minutes actual (in progress)**
+
+**Total: 11.5 hours estimated → 6.25 hours actual (46% faster)**
+
+**Dependencies**: All previous phases (1-11) complete
+
+### 🎉 Phase 12 Completion Summary
+
+**Achievements:**
+- ✅ Successfully extracted 137-method converter class into modular architecture
+- ✅ Created 3 new modules: ContextAnalyzer (450 lines), PostProcessor (550 lines), MathMLToTeXConverter (4,622 lines)
+- ✅ Added missing data module: operators.py (MATH_SYMBOLS_SET, SUMMATION_SYMBOLS, FONT_TO_LATEX, LARGE_OPERATORS_UNICODE)
+- ✅ Eliminated importlib dependency - package now fully independent
+- ✅ **100% test success rate: 109/109 equations** (88 from input.docx + 21 from 1009.docx)
+- ✅ Character-perfect output match with original converter
+- ✅ All subject modes working (chemistry, physics, math)
+- ✅ Comparable performance to original implementation
+
+**Technical Highlights:**
+- Hybrid architecture approach: extracted high-value modules, kept core methods together
+- Dependency injection pattern for ContextAnalyzer and PostProcessor integration
+- Clean separation of concerns: context analysis → conversion → post-processing
+- Backward compatibility maintained throughout
+- Zero breaking changes to public API
+
+**Result**: **Modular package is now fully independent and production-ready!** 🚀
+
+**Dependencies**: All previous phases (1-11) complete
+
+---
+
+## 🎯 Success Criteria
+
+### Must Have:
+- ✅ All data structures extracted to `data/` (DONE)
+- ✅ All utilities extracted to `utils/` (DONE)
+- ✅ All validation logic extracted to `validation/` (DONE)
+- ✅ All processing logic extracted to `processing/` (DONE)
+- ✅ All core logic extracted to `core/` (DONE)
+- ✅ Converter foundation created in `converters/base.py` (DONE)
+- ✅ New main converter created (wrapper around existing) (DONE)
+- ✅ Public API with convenience functions (DONE)
+- ✅ CLI extracted and working (DONE)
+- ✅ Backward compatibility maintained (DONE)
+- ✅ Core functionality tested and working (DONE)
+
+### Nice to Have:
+- [ ] Performance equal or better than original
+- [ ] Comprehensive test coverage (>80%)
+- [ ] Complete API documentation
+- [ ] Migration guide for users
+- [ ] Type hints throughout
+- ⏳ Full converter split into 12 specialized modules (future enhancement)
+
+---
+
+## 📈 Estimated Timeline
+
+- ✅ **Phases 1-3**: 6 hours (DONE) - Package, Data, Utils
+- ✅ **Phase 4** (Validation): 3 hours (DONE)
+- ✅ **Phase 5** (Processing): 3 hours (DONE)
+- ✅ **Phase 6** (Core): 4 hours (DONE)
+- ✅ **Phase 7** (Converter Foundation): 2 hours (DONE) - Base utilities only
+- ✅ **Phase 8** (Main Converter): 2.5 hours (DONE) - Wrapper API + public functions
+- ✅ **Phase 9** (CLI): 2 hours (DONE) - Extract CLI logic
+- ✅ **Phase 10** (Testing): 1 hour (DONE) - API/CLI testing, backward compatibility
+- ✅ **Phase 11** (Documentation): 0.5 hours (DONE) - Update docs
+
+**Revised Estimated Time**: 26 hours (was 28-32 hours, originally 35-45)
+**Completed**: 24 hours (100%)
+**Time Saved**: 11 hours under original estimate
+
+---
+
+## 🚦 Current Status
+
+**Active Phase**: 🔄 Phase 12 - Core Converter Extraction (IN PROGRESS)
+**Next Commit**: Phase 12 - Extract MathMLToTeXConverter to modular structure
+**Blockers**: None
+**Status**: Ultrathink analysis complete, beginning converter extraction
+
+---
+
+## 📝 Notes
+
+- Original `omml_to_tex.py` remains unchanged throughout (backward compatibility)
+- Each phase ends with a clean, tested commit
+- All 9 completed phases have milestone documentation
+- Phase 7 foundation complete; full converter split deferred to future
+- Phase 8 provides clean, modern Python API wrapping original converter
+- Phase 9 extracts CLI to dedicated module with `python -m omml_to_tex` support
+- Clean separation between modules enables future enhancements
+- Total lines refactored: ~5,866 / 9,200 (64%)
+
+---
+
+## 🎯 Next Steps
+
+**Recommended Path**: Complete remaining phases (8-11) to deliver working project
+- Phase 8: Create main converter wrapper (3-4 hours)
+- Phase 9: Extract CLI (2-3 hours)
+- Phase 10: Testing & validation (3-4 hours)
+- Phase 11: Documentation updates (2-3 hours)
+
+**Future Enhancement**: Full converter split into 12 specialized modules (12-16 hours)
+- Can be done later when needed
+- Foundation (base.py) already in place
+
+---
+
+**Last Updated**: October 16, 2025
+**Status**: ✅ 100% Complete (11/11 phases)
+**11 Clean Commits**: All tested and documented
+
+---
+
+## 🎉 Project Complete!
+
+The OMML to TeX refactoring is successfully complete with a clean, modular package structure. All core functionality is working with comprehensive testing and documentation.
diff --git a/scripts/omml_mathml2latex/utils/__init__.py b/scripts/omml_mathml2latex/utils/__init__.py
new file mode 100644
index 0000000..892dcfe
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/__init__.py
@@ -0,0 +1,68 @@
+"""
+Utility functions for the refactor package.
+"""
+
+from .color_helpers import (
+    detect_uniform_color,
+    hex_to_latex_color,
+    should_suppress_color,
+    wrap_with_uniform_color,
+    wrap_element_with_color,
+)
+
+from .xml_utils import (
+    text_content,
+    local_name,
+    decode_html_entities,
+    extract_math_equations,
+)
+
+from .helpers import (
+    is_default_color,
+)
+
+from .text_processing import (
+    write_text,
+    read_text,
+    convert_spaces_to_latex,
+    escape_latex_special_chars,
+)
+
+from .timer import (
+    PerformanceTimer,
+    TimingRecord,
+    TimingSummary,
+    get_global_timer,
+    enable_global_timer,
+    disable_global_timer,
+)
+
+from .debug import (
+    is_debug_enabled,
+    debug_print,
+)
+
+__all__ = [
+    'detect_uniform_color',
+    'hex_to_latex_color',
+    'should_suppress_color',
+    'wrap_with_uniform_color',
+    'wrap_element_with_color',
+    'text_content',
+    'local_name',
+    'decode_html_entities',
+    'extract_math_equations',
+    'is_default_color',
+    'write_text',
+    'read_text',
+    'convert_spaces_to_latex',
+    'escape_latex_special_chars',
+    'PerformanceTimer',
+    'TimingRecord',
+    'TimingSummary',
+    'get_global_timer',
+    'enable_global_timer',
+    'disable_global_timer',
+    'is_debug_enabled',
+    'debug_print',
+]
diff --git a/scripts/omml_mathml2latex/utils/chemistry.py b/scripts/omml_mathml2latex/utils/chemistry.py
new file mode 100644
index 0000000..45aa49e
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/chemistry.py
@@ -0,0 +1,296 @@
+"""
+Chemistry detection utilities for identifying chemical equations and contexts.
+
+This module provides functions to detect chemical reactions, conditions, and
+other chemistry-specific patterns in mathematical equations.
+"""
+
+from typing import Optional, Dict
+from lxml import etree as ET
+
+# OMML namespace constant
+OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math"
+
+
+def contains_chinese_characters(text: str) -> bool:
+    """Check if text contains Chinese characters.
+
+    Args:
+        text: Text to check
+
+    Returns:
+        True if text contains at least one Chinese character
+
+    Example:
+        >>> contains_chinese_characters('加热')
+        True
+        >>> contains_chinese_characters('heat')
+        False
+    """
+    if not text:
+        return False
+    for char in text:
+        if '\u4e00' <= char <= '\u9fff':  # Chinese character range
+            return True
+    return False
+
+
+def is_typical_reaction_condition_text(text: str) -> bool:
+    """Check if text looks like a typical chemical reaction condition.
+
+    Args:
+        text: Text to check
+
+    Returns:
+        True if text contains typical chemical reaction condition terms
+
+    Example:
+        >>> is_typical_reaction_condition_text('加热')
+        True
+        >>> is_typical_reaction_condition_text('heat')
+        True
+        >>> is_typical_reaction_condition_text('abc')
+        False
+    """
+    if not text:
+        return False
+
+    # Common chemical reaction conditions
+    typical_conditions = {
+        # Chinese conditions
+        "电解", "加热", "催化剂", "高温", "高压", "光照", "加压", "蒸馏", "熔融", "溶解", "酸化", "碱化",
+        "氧化", "还原", "分解", "合成", "中和", "干燥", "过滤", "沉淀", "结晶", "升华", "煅烧",
+        # English conditions
+        "heat", "catalyst", "pressure", "light", "oxidation", "reduction", "electrolysis",
+        "distillation", "crystallization", "precipitation", "filtration", "drying",
+        # Symbols and abbreviations
+        "Δ", "hv", "H+", "OH-", "cat", "pt", "ni", "pd"
+    }
+
+    text_lower = text.lower().strip()
+    return any(condition.lower() in text_lower for condition in typical_conditions)
+
+
+def is_chemical_reaction_arrow(eqArr_node: ET._Element) -> Optional[Dict[str, str]]:
+    """Detect if an eqArr represents a chemical reaction arrow with conditions.
+
+    Args:
+        eqArr_node: OMML eqArr element
+
+    Returns:
+        Dictionary with chemical reaction info if detected, None otherwise.
+        Structure: {
+            'above': str,    # Text above the arrow (e.g., '电解')
+            'below': str,    # Text below the arrow (e.g., '加热', can be empty)
+            'type': str      # 'chemical_reaction'
+        }
+
+    Example:
+        >>> # Assuming eqArr_node is an OMML element with reaction conditions
+        >>> result = is_chemical_reaction_arrow(eqArr_node)
+        >>> result['above']
+        '电解'
+    """
+    # Find all equation array elements
+    e_elements = eqArr_node.findall(f"{{{OMML_NS}}}e")
+
+    # Must have exactly 2 elements for chemical reaction conditions
+    if len(e_elements) != 2:
+        return None
+
+    # Extract text from first element (above the arrow)
+    above_text = ""
+    first_elem = e_elements[0]
+
+    # Extract text from all t elements in the first element, avoiding duplication
+    # Use a set to track unique text content
+    text_parts = set()
+    for t_elem in first_elem.findall(f".//{{{OMML_NS}}}t"):
+        if t_elem.text and t_elem.text.strip():
+            text_parts.add(t_elem.text.strip())
+
+    # Join unique text parts
+    above_text = "".join(sorted(text_parts))
+
+    # Extract text from second element (below the arrow)
+    below_text = ""
+    second_elem = e_elements[1]
+
+    # Extract text from all t elements in the second element, avoiding duplication
+    text_parts_below = set()
+    for t_elem in second_elem.findall(f".//{{{OMML_NS}}}t"):
+        if t_elem.text and t_elem.text.strip():
+            text_parts_below.add(t_elem.text.strip())
+
+    # Join unique text parts
+    below_text = "".join(sorted(text_parts_below))
+
+    # Validate that this looks like a chemical reaction pattern
+    if above_text.strip():
+        # Check if contains chemical condition patterns (Chinese text or typical reaction words)
+        if (contains_chinese_characters(above_text) or
+            is_typical_reaction_condition_text(above_text) or
+            contains_chinese_characters(below_text) or
+            is_typical_reaction_condition_text(below_text)):
+
+            return {
+                'above': above_text.strip(),
+                'below': below_text.strip(),
+                'type': 'chemical_reaction'
+            }
+
+    return None
+
+
+def detect_chemistry_context(equation_text: str) -> bool:
+    """Detect if equation suggests chemistry context - Conservative approach.
+
+    Args:
+        equation_text: The full equation text to analyze
+
+    Returns:
+        True if chemistry context is detected
+
+    Example:
+        >>> detect_chemistry_context('H2O + pH = 7')
+        True
+        >>> detect_chemistry_context('sin x + cos x')
+        False
+    """
+    if not equation_text:
+        return False
+
+    # Check if we're in a set theory context - if so, don't treat letters as chemical elements
+    if has_set_theory_symbols(equation_text):
+        return False
+
+    # Check if we're in a mathematical context (trigonometry, calculus, etc.)
+    if has_mathematical_functions(equation_text):
+        return False
+
+    # Conservative chemistry detection: require multiple indicators, not just chemical elements
+    chemistry_indicators = ['pH', 'pOH', 'mol', 'atm', 'bar', 'Torr', 'eq', 'aq', 'sol',
+                            '↑', '↓', '→', '⇋', '⇌', 'xlongequal', 'rightarrow']
+
+    # Only return True if we have actual chemistry indicators in the equation text
+    return any(indicator in equation_text for indicator in chemistry_indicators)
+
+
+def has_mathematical_functions(equation_text: str) -> bool:
+    """Check if the equation contains mathematical functions.
+
+    Args:
+        equation_text: The equation text to analyze
+
+    Returns:
+        True if mathematical functions are detected
+
+    Example:
+        >>> has_mathematical_functions('sin x + cos x')
+        True
+        >>> has_mathematical_functions('H2O')
+        False
+    """
+    if not equation_text:
+        return False
+
+    # Common mathematical functions that indicate math context, not chemistry
+    math_functions = ['sin', 'cos', 'tan', 'log', 'ln', 'exp', 'sqrt', 'lim', 'max', 'min',
+                     'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh']
+
+    return any(func in equation_text for func in math_functions)
+
+
+def has_set_theory_symbols(equation_text: str) -> bool:
+    """Check if the equation contains set theory symbols.
+
+    Args:
+        equation_text: The equation text to analyze
+
+    Returns:
+        True if set theory symbols are detected
+
+    Example:
+        >>> has_set_theory_symbols('A ∩ B ⊂ C')
+        True
+        >>> has_set_theory_symbols('H2O')
+        False
+    """
+    if not equation_text:
+        return False
+
+    set_symbols = ['⊂', '⊃', '⊆', '⊇', '⊄', '⊅', '⊈', '⊉', '⊊', '⊋',
+                  '∈', '∉', '∋', '∌', '∪', '∩', '∖', '∁']
+    return any(symbol in equation_text for symbol in set_symbols)
+
+
+def detect_physics_context(equation_text: str) -> bool:
+    """Detect if equation suggests physics context.
+
+    Args:
+        equation_text: The equation text to analyze
+
+    Returns:
+        True if physics context is detected
+
+    Example:
+        >>> detect_physics_context('F = ma, where m is in kg')
+        True
+        >>> detect_physics_context('x + y = z')
+        False
+    """
+    if not equation_text:
+        return False
+
+    # Check if we're in a mathematical context (trigonometry, calculus, etc.)
+    if has_mathematical_functions(equation_text):
+        return False
+
+    # Common physics constants and units - look for these in the equation context
+    physics_indicators = [
+        'kg', 'm', 's', 'A', 'K', 'mol', 'cd',  # SI base units
+        'Hz', 'N', 'Pa', 'J', 'W', 'C', 'V', 'F', 'Ω', 'S', 'Wb', 'T', 'H',  # Derived units
+        'eV', 'cal', 'Bar', 'L',  # Common non-SI
+        # Note: removed single-letter constants like 'c', 'h', 'k', 'G', 'R', 'NA'
+        # These are too common in math contexts and cause false positives
+    ]
+
+    # Only return True if we have actual physics indicators in the equation text
+    return any(indicator in equation_text for indicator in physics_indicators)
+
+
+def is_physics_constant(content: str) -> bool:
+    """Check if content is a known physics constant.
+
+    Args:
+        content: String to check
+
+    Returns:
+        True if content represents a known physics constant
+
+    Example:
+        >>> is_physics_constant('c')
+        True
+        >>> is_physics_constant('x')
+        False
+    """
+    constants = {
+        'c',     # speed of light
+        'h',     # Planck constant
+        'hbar',  # reduced Planck constant
+        'k',     # Boltzmann constant
+        'kB',    # Boltzmann constant
+        'G',     # gravitational constant
+        'R',     # gas constant
+        'NA',    # Avogadro number
+        'e',     # elementary charge
+        'me',    # electron mass
+        'mp',    # proton mass
+        'mn',    # neutron mass
+        'mu',    # atomic mass unit
+        'epsilon0',  # vacuum permittivity
+        'mu0',   # vacuum permeability
+        'alpha', # fine structure constant
+        'sigma', # Stefan-Boltzmann constant
+    }
+    return content in constants
diff --git a/scripts/omml_mathml2latex/utils/chemistry_detection.py b/scripts/omml_mathml2latex/utils/chemistry_detection.py
new file mode 100644
index 0000000..4d94a44
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/chemistry_detection.py
@@ -0,0 +1,259 @@
+"""
+Chemistry equation detection utilities.
+
+This module provides functions to detect whether an equation is chemistry-related
+based on strong indicators like multi-char elements, charges, and reaction arrows.
+"""
+
+from lxml import etree as ET
+from typing import Optional, Tuple
+from ..data.chemistry_data import (
+    MULTI_CHAR_ELEMENTS,
+    ALL_CHEMICAL_ELEMENTS,
+    CHEMICAL_GROUPS,
+    CHINESE_CHEMICAL_TERMS,
+)
+
+
+def detect_chemistry_equation(root: ET.Element) -> bool:
+    """
+    Detect if equation is chemistry-related using STRONG indicators only.
+
+    DISABLED: Subject detection is obsolete. We rely on mathvariant="normal" only.
+    Chemistry formulas are properly formatted when MathML includes mathvariant="normal".
+
+    Args:
+        root: The root MathML element (<math>)
+
+    Returns:
+        False - always (chemistry detection disabled)
+    """
+    # DISABLED: Always return False - no heuristic chemistry detection
+    return False
+
+    # OLD CODE (kept for reference):
+    # Strong indicators:
+    # 1. Multi-char chemical elements in single <mi> tag (Cu, Al, Fe, Mn, etc.)
+    # 2. Chemical groups (OH, SO, NO, CO, NH)
+    # 3. Element + numeric subscript (H₂O pattern)
+    # 4. Electric charges in superscript (^{2+}, ^{2-})
+    # 5. Chemical arrows (↑, ↓)
+    # 6. Chinese chemical terms (高温, 电解, etc.)
+    #
+    # for node in root.iter():
+    #     # Remove namespace if present
+    #     tag = node.tag.split('}')[-1] if '}' in node.tag else node.tag
+    #     text = (node.text or '').strip()
+    #
+    #     # Strong indicator 1: Multi-char element in single <mi>
+    #     if tag == 'mi' and text in MULTI_CHAR_ELEMENTS:
+    #         return True
+    #
+    #     # Strong indicator 2: Chemical group
+    #     if tag == 'mtext' and text in CHEMICAL_GROUPS:
+    #         return True
+    #
+    #     # Strong indicator 3: Element + numeric subscript (H₂O, SO₄ pattern)
+    #     if tag == 'msub' and len(node) >= 2:
+    #         base_node = node[0]
+    #         sub_node = node[1]
+    #         base_text = (base_node.text or '').strip()
+    #         sub_text = (sub_node.text or '').strip()
+    #
+    #         # Element with numeric subscript
+    #         if base_text in ALL_CHEMICAL_ELEMENTS and sub_text.isdigit():
+    #             return True
+    #
+    #     # Strong indicator 4: Electric charge superscript (Cu^{2+}, Mn^{2-})
+    #     if tag == 'msup' and len(node) >= 2:
+    #         sup_node = node[1]
+    #         sup_text = (sup_node.text or '').strip()
+    #
+    #         # Check for charge notation (contains + or -)
+    #         # Pattern: "2+", "+", "2-", "-", "3+", etc.
+    #         if sup_text and ('+' in sup_text or '-' in sup_text):
+    #             # Additional check: ensure it's likely a charge, not math
+    #             # Charges are typically: digit* followed by +/-
+    #             # Math would be expressions like "x+1", "y-2"
+    #             # Simple heuristic: if it's short and has +/- at end, it's likely a charge
+    #             if len(sup_text) <= 3 and (sup_text.endswith('+') or sup_text.endswith('-')):
+    #                 return True
+    #             # Also check for format: "2 +" or "2 -" (with space)
+    #             parts = sup_text.split()
+    #             if len(parts) == 2 and parts[0].isdigit() and parts[1] in ('+', '-'):
+    #                 return True
+    #
+    #     # Strong indicator 5: Chemical arrows (precipitate, gas)
+    #     if tag == 'mo' and text in ('↑', '↓'):
+    #         return True
+    #
+    #     # Strong indicator 6: Chinese chemical terms
+    #     if tag in ('mtext', 'mi') and text in CHINESE_CHEMICAL_TERMS:
+    #         return True
+    #
+    # return False
+
+
+def calculate_chemistry_probability(root: ET.Element, subject_mode: Optional[str] = None) -> float:
+    """
+    Calculate chemistry probability score based on multiple indicators.
+
+    Scoring weights:
+    - Ion charge present (^{2+}, ^{3-}): +1.0
+    - Multi-char element in single <mi>: +0.8
+    - Nearby multi-char element: +0.8
+    - Reaction arrow (→, ⇌, ⇄): +0.6
+    - Chemical subscripts (H_2, O_2): +0.4
+    - Chinese chemical term: +0.3
+    - User set --subject chemistry: +0.5
+
+    Thresholds:
+    - Chemistry mode: ≥0.8 (merge fragmented elements)
+    - Auto-mode: ≥1.5 (only VERY strong indicators)
+
+    Args:
+        root: The root MathML element (<math>)
+        subject_mode: Optional subject mode ('chemistry', 'physics', etc.)
+
+    Returns:
+        Probability score (0.0-3.0+)
+
+    Examples:
+        >>> # M n^{2+} with MnO nearby: 1.0 + 0.8 + 0.8 = 2.6 (strong)
+        >>> calculate_chemistry_probability(math_root)  # 2.6
+
+        >>> # Just "M n" with no context: 0.0 (weak)
+        >>> calculate_chemistry_probability(math_root)  # 0.0
+
+        >>> # Chemistry mode boost: M n → 0.5 (mode) + context
+        >>> calculate_chemistry_probability(math_root, 'chemistry')  # 0.5+
+    """
+    # DISABLED: Always return 0.0 - no chemistry detection
+    return 0.0
+
+    # OLD CODE (kept for reference):
+    # score = 0.0
+    # # Mode boost: user explicitly set --subject chemistry
+    # if subject_mode == 'chemistry':
+    #     score += 0.5
+    #
+    # # Counters for various indicators
+    # has_ion_charge = False
+    # multi_char_element_count = 0
+    # has_reaction_arrow = False
+    # chemical_subscript_count = 0
+    # has_chinese_term = False
+    #
+    # for node in root.iter():
+    #     # Remove namespace if present
+    #     tag = node.tag.split('}')[-1] if '}' in node.tag else node.tag
+    #     text = (node.text or '').strip()
+    #
+    #     # Indicator 1: Multi-char element in single <mi> (+0.8 each, max 2)
+    #     if tag == 'mi' and text in MULTI_CHAR_ELEMENTS:
+    #         multi_char_element_count += 1
+    #
+    #     # Indicator 2: Chemical group (+0.8)
+    #     if tag == 'mtext' and text in CHEMICAL_GROUPS:
+    #         multi_char_element_count += 1
+    #
+    #     # Indicator 3: Element + numeric subscript (H₂O pattern) (+0.4 each, max 3)
+    #     if tag == 'msub' and len(node) >= 2:
+    #         base_node = node[0]
+    #         sub_node = node[1]
+    #         base_text = (base_node.text or '').strip()
+    #         sub_text = (sub_node.text or '').strip()
+    #
+    #         if base_text in ALL_CHEMICAL_ELEMENTS and sub_text.isdigit():
+    #             chemical_subscript_count += 1
+    #
+    #     # Indicator 4: Ion charge superscript (+1.0, strongest indicator)
+    #     if tag == 'msup' and len(node) >= 2:
+    #         sup_node = node[1]
+    #         sup_text = (sup_node.text or '').strip()
+    #
+    #         # Check for charge notation
+    #         if sup_text and ('+' in sup_text or '-' in sup_text):
+    #             if len(sup_text) <= 3 and (sup_text.endswith('+') or sup_text.endswith('-')):
+    #                 has_ion_charge = True
+    #             # Also check for format: "2 +" or "2 -"
+    #             parts = sup_text.split()
+    #             if len(parts) == 2 and parts[0].isdigit() and parts[1] in ('+', '-'):
+    #                 has_ion_charge = True
+    #
+    #     # Indicator 5: Reaction arrows (+0.6)
+    #     if tag == 'mo':
+    #         # Chemical arrows (precipitate, gas)
+    #         if text in ('↑', '↓'):
+    #             has_reaction_arrow = True
+    #         # Reaction arrows (→, ⇌, ⇄, etc.)
+    #         if text in ('→', '←', '⇌', '⇄', '⟶', '⟵', '⇀', '↽'):
+    #             has_reaction_arrow = True
+    #
+    #     # Indicator 6: Chinese chemical terms (+0.3)
+    #     if tag in ('mtext', 'mi') and text in CHINESE_CHEMICAL_TERMS:
+    #         has_chinese_term = True
+    #
+    # # Calculate total score
+    # if has_ion_charge:
+    #     score += 1.0
+    #
+    # # Cap multi-char elements at 2 (prevent over-scoring)
+    # score += min(multi_char_element_count, 2) * 0.8
+    #
+    # if has_reaction_arrow:
+    #     score += 0.6
+    #
+    # # Cap chemical subscripts at 3
+    # score += min(chemical_subscript_count, 3) * 0.4
+    #
+    # if has_chinese_term:
+    #     score += 0.3
+    #
+    # return score
+
+
+def detect_chemistry_equation_with_probability(root: ET.Element) -> Tuple[bool, float]:
+    """
+    Detect chemistry equation and return both boolean and probability score.
+
+    DISABLED: Subject detection is obsolete.
+
+    Args:
+        root: The root MathML element (<math>)
+
+    Returns:
+        Tuple of (False, 0.0) - always (chemistry detection disabled)
+    """
+    # DISABLED: Always return (False, 0.0)
+    return False, 0.0
+
+    # OLD CODE (kept for reference):
+    # probability = calculate_chemistry_probability(root)
+    # is_chemistry = probability >= 1.0  # Strong indicator threshold
+    # return is_chemistry, probability
+
+
+def is_chemistry_variable(text: str, in_chemistry_context: bool) -> bool:
+    """
+    Determine if text is a chemistry variable (should stay italic).
+
+    DISABLED: Chemistry detection is obsolete.
+
+    Args:
+        text: The identifier text
+        in_chemistry_context: Whether we're in a chemistry equation (ignored)
+
+    Returns:
+        False - always (not used anymore)
+    """
+    # DISABLED: Always return False - chemistry detection disabled
+    return False
+
+    # OLD CODE (kept for reference):
+    # from ..data.chemistry_data import CHEMISTRY_VARIABLES
+    # # In chemistry context, check if it's a known variable
+    # if in_chemistry_context:
+    #     return text in CHEMISTRY_VARIABLES
+    # # Not in chemistry context, not a chemistry variable
+    # return False
diff --git a/scripts/omml_mathml2latex/utils/color_helpers.py b/scripts/omml_mathml2latex/utils/color_helpers.py
new file mode 100644
index 0000000..365bf5a
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/color_helpers.py
@@ -0,0 +1,380 @@
+"""
+Color handling utilities for MathML to LaTeX conversion.
+
+This module provides color optimization utilities including:
+- Uniform color detection across entire equations
+- Hex to LaTeX color conversion (named colors and RGB mode)
+- Color suppression for optimization
+"""
+
+from lxml import etree as ET
+from typing import Tuple, Set
+
+
+def detect_uniform_color(node: ET.Element) -> str:
+    """
+    Detect if entire equation subtree uses a single uniform color.
+
+    Args:
+        node: Root MathML element (typically <math> or <mrow>)
+
+    Returns:
+        Hex color string (e.g., '#FF0000') if uniform color detected, empty string otherwise.
+
+    Algorithm:
+        1. Recursively check all content-bearing elements (mi, mn, mo, mtext, etc.)
+        2. For each element, determine its effective color (from element or ancestors)
+        3. Return color only if ALL content elements have the SAME color
+        4. If ANY element has no color (default), it's not uniform
+
+    Examples:
+        >>> from lxml import etree as ET
+        >>> # All elements have same color
+        >>> xml = '<math><mstyle mathcolor="#FF0000"><mi>x</mi><mo>+</mo><mi>y</mi></mstyle></math>'
+        >>> tree = ET.fromstring(xml.encode('utf-8'))
+        >>> detect_uniform_color(tree)
+        '#FF0000'
+
+        >>> # Partial coloring (NOT uniform)
+        >>> xml = '<math><mi>x</mi><mstyle mathcolor="#FF0000"><mi>y</mi></mstyle></math>'
+        >>> tree = ET.fromstring(xml.encode('utf-8'))
+        >>> detect_uniform_color(tree)
+        ''
+
+        >>> # Mixed colors
+        >>> xml = '<math><mi mathcolor="#FF0000">x</mi><mo mathcolor="#0000FF">+</mo></math>'
+        >>> tree = ET.fromstring(xml.encode('utf-8'))
+        >>> detect_uniform_color(tree)
+        ''
+    """
+    colors_found: Set[str] = set()
+    has_elements_without_color = False
+
+    # Content-bearing elements that should have consistent color
+    # These are the "leaf" elements that actually render visible content
+    CONTENT_ELEMENTS = {'mi', 'mn', 'mo', 'mtext', 'ms', 'merror'}
+
+    def get_local_name(tag: str) -> str:
+        """Extract local tag name from potentially namespaced tag."""
+        return tag.split('}')[-1] if '}' in tag else tag
+
+    def get_effective_color(elem: ET.Element) -> str:
+        """
+        Get the effective color for an element (from element or ancestors).
+        Returns empty string if no color is set.
+        """
+        # Check element itself first
+        color = elem.get('mathcolor')
+        if color:
+            return color.upper()
+
+        # Check ancestors (walk up the tree)
+        parent = elem.getparent()
+        while parent is not None:
+            color = parent.get('mathcolor')
+            if color:
+                return color.upper()
+            parent = parent.getparent()
+
+        # No color found in element or ancestors
+        return ""
+
+    def check_colors(elem: ET.Element) -> None:
+        """Recursively check colors of all content elements."""
+        nonlocal has_elements_without_color
+
+        tag = get_local_name(elem.tag)
+
+        # If this is a content-bearing element, check its effective color
+        if tag in CONTENT_ELEMENTS:
+            effective_color = get_effective_color(elem)
+            if effective_color:
+                colors_found.add(effective_color)
+            else:
+                # Found a content element without any color
+                has_elements_without_color = True
+
+        # Recurse into children
+        for child in elem:
+            check_colors(child)
+
+    check_colors(node)
+
+    # Uniform color only if:
+    # 1. We found exactly one unique color
+    # 2. ALL content elements have that color (none are without color)
+    if len(colors_found) == 1 and not has_elements_without_color:
+        return list(colors_found)[0]
+
+    # Not uniform: either no colors, multiple colors, or partial coloring
+    return ""
+
+
+def hex_to_latex_color(hex_color: str) -> Tuple[str, str]:
+    """
+    Convert hex color to LaTeX color name or RGB definition.
+
+    Args:
+        hex_color: Hex color string like '#FF0000' or 'FF0000'
+
+    Returns:
+        Tuple of (color_model, color_spec) where:
+        - color_model is '' for named colors or '[RGB]' for RGB mode
+        - color_spec is 'red' for named colors or '255,0,0' for RGB
+
+    Examples:
+        >>> hex_to_latex_color('#FF0000')
+        ('', 'red')
+
+        >>> hex_to_latex_color('#E54C5E')  # Custom color
+        ('[RGB]', '229,76,94')
+
+        >>> hex_to_latex_color('000000')  # Black (no #)
+        ('', 'black')
+
+    Common Color Mappings:
+        #FF0000 → red
+        #00FF00 → green
+        #0000FF → blue
+        #000000 → black
+        #FFFFFF → white
+        #FFFF00 → yellow
+        #FF00FF → magenta
+        #00FFFF → cyan
+    """
+    # Remove '#' if present
+    hex_color = hex_color.lstrip('#')
+
+    # Common color mappings (full hex codes only)
+    common_colors = {
+        'ff0000': 'red',
+        '00ff00': 'green',
+        '0000ff': 'blue',
+        '000000': 'black',
+        'ffffff': 'white',
+        'ffff00': 'yellow',
+        'ff00ff': 'magenta',
+        '00ffff': 'cyan',
+    }
+
+    hex_lower = hex_color.lower()
+
+    # Check for exact match in common colors
+    if hex_lower in common_colors:
+        return ('', common_colors[hex_lower])
+
+    # Convert to RGB mode for non-standard colors
+    try:
+        # Parse hex digits (supports 6-digit format)
+        if len(hex_color) == 6:
+            r = int(hex_color[0:2], 16)
+            g = int(hex_color[2:4], 16)
+            b = int(hex_color[4:6], 16)
+            return ('[RGB]', f'{r},{g},{b}')
+        else:
+            # Invalid format - default to black
+            return ('', 'black')
+    except (ValueError, IndexError):
+        # Parsing error - default to black
+        return ('', 'black')
+
+
+def should_suppress_color(context) -> bool:
+    """
+    Check if leaf-level colors should be suppressed.
+
+    Args:
+        context: ConversionContext object or converter with color optimization state
+
+    Returns:
+        True if leaf colors should be suppressed (uniform color detected), False otherwise
+
+    Usage:
+        This is used by visitors to check whether they should skip adding
+        \\textcolor wrappers when the entire equation has a uniform color.
+    """
+    # Check for both attribute names (with and without underscore)
+    # Legacy adapter uses _suppress_leaf_colors (private), context uses suppress_leaf_colors (public)
+    return getattr(context, '_suppress_leaf_colors', False) or getattr(context, 'suppress_leaf_colors', False)
+
+
+def wrap_with_uniform_color(latex: str, uniform_color: str) -> str:
+    """
+    Wrap entire LaTeX equation with uniform color.
+
+    Args:
+        latex: The LaTeX equation string
+        uniform_color: Hex color string (e.g., '#FF0000')
+
+    Returns:
+        LaTeX wrapped with \\textcolor[RGB]{r,g,b}{...} or original if black
+
+    Examples:
+        >>> wrap_with_uniform_color('x^2', '#FF0000')
+        '\\\\textcolor{red}{x^2}'
+
+        >>> wrap_with_uniform_color('x^2', '#E54C5E')
+        '\\\\textcolor[RGB]{229,76,94}{x^2}'
+
+        >>> wrap_with_uniform_color('x^2', '#000000')  # Black - no wrapping
+        'x^2'
+    """
+    from ..utils import is_default_color
+
+    if not uniform_color or is_default_color(uniform_color):
+        # Black is default - no wrapping needed
+        return latex
+
+    # Convert to LaTeX color
+    color_model, color_spec = hex_to_latex_color(uniform_color)
+
+    # Skip if it's black after conversion
+    if color_spec == 'black':
+        return latex
+
+    # Wrap with appropriate format
+    if color_model:
+        # RGB mode
+        return f"\\textcolor{color_model}{{{color_spec}}}{{{latex}}}"
+    else:
+        # Named color
+        return f"\\textcolor{{{color_spec}}}{{{latex}}}"
+
+
+# Mapping from Word highlight color names to CSS-compatible color values
+# Word uses some non-standard names (e.g., darkyellow) that need conversion
+WORD_HIGHLIGHT_TO_CSS = {
+    'yellow': 'yellow',
+    'green': 'lime',        # Word "green" is bright green (lime in CSS)
+    'cyan': 'cyan',
+    'magenta': 'magenta',
+    'blue': 'blue',
+    'red': 'red',
+    'darkblue': 'darkblue',
+    'darkcyan': 'darkcyan',
+    'darkgreen': 'darkgreen',
+    'darkmagenta': 'darkmagenta',
+    'darkred': 'darkred',
+    'darkyellow': '#cccc00',   # CSS has no "darkyellow"
+    'darkgray': 'darkgray',
+    'lightgray': 'lightgray',
+    'black': 'black',
+    'white': 'white',
+}
+
+
+def _highlight_color_to_css(color: str) -> str:
+    """Convert a Word highlight color name or hex code to a CSS-compatible value.
+
+    Args:
+        color: Color name (e.g., 'yellow') or hex string (e.g., '#FFFF00')
+
+    Returns:
+        CSS-compatible color string
+    """
+    if not color:
+        return ''
+
+    color_lower = color.lower().strip()
+
+    # If it's a hex color, return as-is
+    if color_lower.startswith('#') or (
+        len(color_lower) == 6 and all(c in '0123456789abcdef' for c in color_lower)
+    ):
+        return f'#{color_lower.lstrip("#")}'
+
+    # Look up in Word highlight mapping
+    if color_lower in WORD_HIGHLIGHT_TO_CSS:
+        return WORD_HIGHLIGHT_TO_CSS[color_lower]
+
+    # Unknown named color - return as-is (CSS may still recognize it)
+    return color_lower
+
+
+def wrap_with_background_color(latex: str, background_color: str) -> str:
+    """
+    Wrap entire LaTeX equation with background color using \\bbox.
+
+    Uses MathJax \\bbox command to apply background color to the equation.
+    The \\bbox[<options>]{<content>} command renders a colored box around
+    the equation content.
+
+    Args:
+        latex: The LaTeX equation string
+        background_color: Color name (e.g., 'yellow', 'green') or hex string
+
+    Returns:
+        LaTeX wrapped with \\bbox[color]{content}, or original if no color
+
+    Examples:
+        >>> wrap_with_background_color('x^2', 'yellow')
+        '\\\\bbox[yellow]{x^2}'
+
+        >>> wrap_with_background_color('x^2', '#FFFF00')
+        '\\\\bbox[#ffff00]{x^2}'
+
+        >>> wrap_with_background_color('x^2', '')  # No color - no wrapping
+        'x^2'
+    """
+    if not background_color:
+        return latex
+
+    # Convert Word highlight color to CSS-compatible value
+    css_color = _highlight_color_to_css(background_color)
+    if not css_color:
+        return latex
+
+    # Wrap with \bbox for MathJax background color rendering
+    return f"\\bbox[{css_color}]{{{latex}}}"
+
+
+def wrap_element_with_color(latex: str, node: ET.Element, context=None) -> str:
+    """
+    Wrap element with color if present and not suppressed.
+
+    Args:
+        latex: The LaTeX string to wrap
+        node: MathML element that may have mathcolor attribute
+        context: Optional ConversionContext for suppression check
+
+    Returns:
+        Original LaTeX or wrapped with \\textcolor{color}{...}
+
+    This function respects the suppress_leaf_colors flag in the context.
+    If suppression is active, it skips individual element coloring.
+
+    Examples:
+        >>> from lxml import etree as ET
+        >>> node = ET.fromstring(b'<mi mathcolor="#FF0000">x</mi>')
+        >>> wrap_element_with_color('x', node)
+        '\\\\textcolor{red}{x}'
+
+        >>> # With suppression
+        >>> class Context:
+        ...     suppress_leaf_colors = True
+        >>> wrap_element_with_color('x', node, Context())
+        'x'
+    """
+    from ..utils import is_default_color
+
+    # Check if suppression is active
+    if context and should_suppress_color(context):
+        return latex
+
+    # Get mathcolor attribute
+    mathcolor = node.get('mathcolor')
+    if not mathcolor or is_default_color(mathcolor):
+        return latex
+
+    # Convert and wrap
+    color_model, color_spec = hex_to_latex_color(mathcolor)
+
+    # Skip black (default color)
+    if color_spec == 'black':
+        return latex
+
+    # Wrap with appropriate format
+    if color_model:
+        return f"\\textcolor{color_model}{{{color_spec}}}{{{latex}}}"
+    else:
+        return f"\\textcolor{{{color_spec}}}{{{latex}}}"
diff --git a/scripts/omml_mathml2latex/utils/debug.py b/scripts/omml_mathml2latex/utils/debug.py
new file mode 100644
index 0000000..f8242b1
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/debug.py
@@ -0,0 +1,55 @@
+"""
+Debug output control utility.
+
+This module provides a centralized way to control debug output across the project.
+Debug output is disabled by default and can be enabled via the OMML2TEX_DEBUG
+environment variable.
+
+Usage:
+    from omml2tex.utils.debug import debug_print
+
+    debug_print("[DEBUG] Some debug info")  # Only prints if OMML2TEX_DEBUG=1
+
+Environment Variables:
+    OMML2TEX_DEBUG: Set to "1" or "true" to enable debug output (default: disabled)
+"""
+
+import os
+import sys
+
+
+def is_debug_enabled() -> bool:
+    """
+    Check if debug mode is enabled via environment variable.
+
+    Returns:
+        True if OMML2TEX_DEBUG is set to "1" or "true", False otherwise
+    """
+    debug_value = os.environ.get('OMML2TEX_DEBUG', '').lower()
+    return debug_value in ('1', 'true', 'yes', 'on')
+
+
+def debug_print(*args, **kwargs):
+    """
+    Print debug output only if debug mode is enabled.
+
+    This function has the same signature as the built-in print() function,
+    but only outputs to stderr when OMML2TEX_DEBUG environment variable is set.
+
+    Args:
+        *args: Arguments to print
+        **kwargs: Keyword arguments for print (e.g., file, sep, end)
+
+    Examples:
+        >>> debug_print("[DEBUG] Processing equation")
+        >>> debug_print("[DEBUG] Value:", value, "Result:", result)
+        >>> debug_print("[DEBUG] Error", file=sys.stderr)  # file=sys.stderr is default
+    """
+    if is_debug_enabled():
+        # Default to stderr if file not specified
+        if 'file' not in kwargs:
+            kwargs['file'] = sys.stderr
+        print(*args, **kwargs)
+
+
+__all__ = ['is_debug_enabled', 'debug_print']
diff --git a/scripts/omml_mathml2latex/utils/helpers.py b/scripts/omml_mathml2latex/utils/helpers.py
new file mode 100644
index 0000000..79c6c43
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/helpers.py
@@ -0,0 +1,136 @@
+"""
+Pattern and symbol replacement helper functions.
+
+This module provides utilities for applying symbol mappings and regex patterns
+to text, used throughout the conversion pipeline.
+"""
+
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def apply_symbol_replacements(text: str, mapping: dict) -> str:
+    """Apply simple symbol replacements from a mapping dictionary.
+
+    Args:
+        text: Input text
+        mapping: Dictionary of {symbol: replacement}
+
+    Returns:
+        Text with all symbols replaced
+
+    Example:
+        >>> mapping = {'α': '\\\\alpha', 'β': '\\\\beta'}
+        >>> apply_symbol_replacements('α + β', mapping)
+        '\\\\alpha + \\\\beta'
+    """
+    for symbol, replacement in mapping.items():
+        text = text.replace(symbol, replacement)
+    return text
+
+
+def apply_pattern_replacements(text: str, patterns: list, verbose: bool = False) -> str:
+    """Apply regex pattern replacements from a list of (pattern, replacement, description) tuples.
+
+    Args:
+        text: Input text
+        patterns: List of (pattern, replacement, description) tuples
+        verbose: If True, log each replacement
+
+    Returns:
+        Text with all patterns applied
+
+    Example:
+        >>> patterns = [(r' {3,}', '  ', 'Reduce multiple spaces')]
+        >>> apply_pattern_replacements('a    b', patterns)
+        'a  b'
+    """
+    for pattern, replacement, description in patterns:
+        if verbose:
+            count = len(re.findall(pattern, text))
+            if count > 0:
+                logger.debug(f"Applying: {description} ({count} matches)")
+        text = re.sub(pattern, replacement, text)
+    return text
+
+
+def apply_unicode_symbol_mapping(
+    text: str,
+    unicode_to_latex: dict,
+    additional_replacements: dict = None,
+    subscript_context: bool = False
+) -> str:
+    """Apply Unicode to LaTeX symbol mapping.
+
+    Args:
+        text: Input text containing Unicode symbols
+        unicode_to_latex: Main Unicode to LaTeX mapping dictionary
+        additional_replacements: Optional additional symbol replacements
+        subscript_context: If True, use subscript-specific mappings (with spaces)
+
+    Returns:
+        Text with Unicode symbols converted to LaTeX
+
+    Example:
+        >>> mapping = {'α': '\\\\alpha', '→': '\\\\to'}
+        >>> apply_unicode_symbol_mapping('α → β', mapping, {})
+        '\\\\alpha \\\\to β'
+    """
+    # First apply standard UNICODE_TO_LATEX mapping
+    for symbol, latex in unicode_to_latex.items():
+        text = text.replace(symbol, latex)
+
+    # In subscript context, apply additional replacements with proper spacing
+    if subscript_context and additional_replacements:
+        for symbol, latex in additional_replacements.items():
+            text = text.replace(symbol, latex)
+
+    return text
+
+
+def is_default_color(color: str) -> bool:
+    """Check if a color value represents the default (black) color.
+
+    Args:
+        color: Color value in various formats (hex, name, rgb)
+
+    Returns:
+        True if the color is black/default, False otherwise
+
+    Examples:
+        >>> is_default_color('#000000')
+        True
+        >>> is_default_color('#000')
+        True
+        >>> is_default_color('black')
+        True
+        >>> is_default_color('rgb(0, 0, 0)')
+        True
+        >>> is_default_color('#FF0000')
+        False
+        >>> is_default_color('red')
+        False
+    """
+    if not color:
+        return False
+
+    # Normalize the color string
+    color_lower = color.lower().strip()
+
+    # Check for common black color representations
+    black_colors = {
+        '#000000',  # Full hex
+        '#000',     # Short hex
+        'black',    # Named color
+        'rgb(0,0,0)',  # RGB without spaces
+        'rgb(0, 0, 0)',  # RGB with spaces
+        'rgba(0,0,0,1)',  # RGBA without spaces
+        'rgba(0, 0, 0, 1)',  # RGBA with spaces
+    }
+
+    # Remove all whitespace for comparison
+    color_normalized = ''.join(color_lower.split())
+
+    return color_normalized in {c.replace(' ', '') for c in black_colors}
diff --git a/scripts/omml_mathml2latex/utils/styling_postprocessor.py b/scripts/omml_mathml2latex/utils/styling_postprocessor.py
new file mode 100644
index 0000000..9525e54
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/styling_postprocessor.py
@@ -0,0 +1,1009 @@
+"""
+Styling post-processor for OMML to MathML conversion.
+
+This module extracts styling information (bold, fonts, colors) from OMML XML
+and applies it to MathML output as mathvariant and other attributes.
+
+The Microsoft OMML2MML.xsl stylesheet does not preserve styling information,
+so this post-processor fills that gap by:
+1. Extracting m:rPr (run properties) from OMML
+2. Building a styling map (position, text) -> StyleInfo
+3. Enhancing MathML <mi> elements with mathvariant and other attributes
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Tuple, Optional, List
+from lxml import etree as ET
+
+
+# Namespace constants
+OMML_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/math'
+WORD_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
+MATHML_NS = 'http://www.w3.org/1998/Math/MathML'
+
+# OMML namespaces for parsing
+OMML_NAMESPACES = {
+    'm': OMML_NS,
+    'w': WORD_NS,
+}
+
+
+@dataclass
+class StyleInfo:
+    """Styling information extracted from OMML run properties."""
+
+    # Text content for matching
+    text: str
+
+    # Position in equation (for disambiguation)
+    position: int
+
+    # Style attributes from m:rPr
+    mathvariant: Optional[str] = None  # bold, italic, bold-italic, normal, double-struck
+
+    # Font family from w:rPr
+    font_family: Optional[str] = None
+
+    # Text color from w:rPr
+    color: Optional[str] = None
+
+    # Background/highlight color from w:rPr (w:highlight element)
+    background_color: Optional[str] = None
+
+    # Font size from w:rPr (in points)
+    font_size: Optional[float] = None
+
+    # Combined flags for easier processing
+    is_bold: bool = False
+    is_italic: bool = False
+    is_plain: bool = False  # m:sty val="p" - upright/roman
+    is_text_mode: bool = False  # m:nor - Word "Text Mode" toggle (formatting deferred to w:rPr)
+
+
+@dataclass
+class StructuralStyleInfo:
+    """Styling information for structural elements (fractions, radicals, etc.)."""
+
+    # Element type from OMML: 'f' (fraction), 'rad' (radical), 'func' (function), 'd' (delimiter)
+    element_type: str
+
+    # Position in equation (for matching with MathML elements)
+    position: int
+
+    # Color from structural properties (m:fPr/w:rPr/w:color or m:radPr/w:rPr/w:color)
+    color: Optional[str] = None
+
+
+class StylingPostProcessor:
+    """
+    Post-processes MathML to add styling attributes from OMML.
+
+    This bridges the gap between Microsoft's OMML2MML.xsl (which doesn't preserve
+    styling) and our LaTeX converter (which does handle styling).
+
+    Usage:
+        processor = StylingPostProcessor()
+        styling_map = processor.extract_styling_from_omml(omml_xml)
+        enhanced_mathml = processor.apply_styling_to_mathml(mathml_xml, styling_map)
+    """
+
+    def __init__(self):
+        """Initialize the post-processor."""
+        pass
+
+    def extract_styling_from_omml(self, omml_xml: str) -> Dict[Tuple[int, str], StyleInfo]:
+        """
+        Extract styling information from OMML XML.
+
+        Parses OMML to find all <m:r> (run) elements with <m:rPr> (run properties)
+        and builds a map of (position, text) -> StyleInfo.
+
+        Args:
+            omml_xml: OMML XML string
+
+        Returns:
+            Dict mapping (position, text) to StyleInfo objects
+
+        Examples:
+            >>> processor = StylingPostProcessor()
+            >>> omml = '<m:oMath><m:r><m:rPr><m:sty m:val="b"/></m:rPr><m:t>Z</m:t></m:r></m:oMath>'
+            >>> styling = processor.extract_styling_from_omml(omml)
+            >>> styling[(0, 'Z')].is_bold
+            True
+        """
+        try:
+            root = ET.fromstring(omml_xml.encode('utf-8'))
+        except ET.XMLSyntaxError:
+            # If parsing fails, return empty map (no styling)
+            return {}
+
+        styling_map = {}
+        position = 0
+
+        # Find all <m:r> (run) elements
+        for r_elem in root.iter(f'{{{OMML_NS}}}r'):
+            # Get text content
+            t_elem = r_elem.find(f'{{{OMML_NS}}}t', OMML_NAMESPACES)
+            if t_elem is None or not t_elem.text:
+                continue
+
+            text = t_elem.text.strip()
+            if not text:
+                continue
+
+            # Check for run properties
+            m_rpr = r_elem.find(f'{{{OMML_NS}}}rPr', OMML_NAMESPACES)
+            w_rpr = r_elem.find(f'{{{WORD_NS}}}rPr', OMML_NAMESPACES)
+
+            # Skip if no styling information
+            if m_rpr is None and w_rpr is None:
+                position += 1
+                continue
+
+            # Extract styling information
+            style_info = StyleInfo(text=text, position=position)
+
+            # Process OMML math run properties (m:rPr)
+            if m_rpr is not None:
+                self._extract_math_properties(m_rpr, style_info)
+
+            # Process Word run properties (w:rPr)
+            if w_rpr is not None:
+                self._extract_word_properties(w_rpr, style_info)
+
+            # Post-check: if m:nor (text mode) is active but no explicit style was set
+            # (neither m:sty nor w:i/w:b), default to normal (upright)
+            if style_info.is_text_mode and style_info.mathvariant is None:
+                style_info.mathvariant = 'normal'
+
+            # Only store if there's meaningful styling (not just default font)
+            # Skip if only font_family is set and it's Cambria Math (default)
+            has_meaningful_styling = (
+                style_info.mathvariant is not None or
+                style_info.color is not None or
+                style_info.background_color is not None or
+                style_info.font_size is not None or
+                (style_info.font_family and style_info.font_family != 'Cambria Math')
+            )
+
+            if has_meaningful_styling:
+                styling_map[(position, text)] = style_info
+
+                # CRITICAL FIX: When styled text contains mixed content (letters + operators/numbers),
+                # XSLT will split it into separate elements. We need to track character-level styling
+                # so each split element can still find its style.
+                #
+                # Example: "O=2MnO" with mathvariant="normal" gets split by XSLT into:
+                #   <mi>O</mi><mo>=</mo><mn>2</mn><mi>M</mi><mi>n</mi><mi>O</mi>
+                # We need entries for 'O', '=', '2', 'MnO' (letters merge, operators/numbers split)
+                if len(text) > 1 and self._text_will_be_split(text):
+                    self._add_character_level_styling(styling_map, text, style_info, position)
+
+            position += 1
+
+        return styling_map
+
+    def _text_will_be_split(self, text: str) -> bool:
+        """
+        Check if text will be split by XSLT into multiple elements.
+
+        XSLT splits text when it contains:
+        - Operators: =, +, -, *, /, <, >, etc.
+        - Transitions between letters and digits
+
+        Args:
+            text: Text to check
+
+        Returns:
+            True if XSLT will split this text
+        """
+        operators = set('=+-*/:<>|()[]{},;')
+
+        has_letters = any(c.isalpha() for c in text)
+        has_operators = any(c in operators for c in text)
+        has_digits = any(c.isdigit() for c in text)
+
+        # Split happens when we have letters + operators, or letters + digits + operators
+        return has_letters and (has_operators or (has_digits and has_letters))
+
+    def _add_character_level_styling(
+        self,
+        styling_map: Dict[Tuple[int, str], 'StyleInfo'],
+        text: str,
+        style_info: 'StyleInfo',
+        base_position: int
+    ) -> None:
+        """
+        Add character/token-level styling entries for text that will be split by XSLT.
+
+        XSLT tokenizes text into:
+        - Consecutive letters → single <mi> (but may be further split)
+        - Consecutive digits → single <mn>
+        - Operators → individual <mo>
+
+        We need to create styling entries for each potential token.
+
+        Args:
+            styling_map: Map to add entries to
+            text: The original styled text
+            style_info: The style to apply
+            base_position: Base position in the OMML
+        """
+        operators = set('=+-*/:<>|()[]{},;')
+
+        # Tokenize like XSLT would
+        tokens = []
+        current_token = ''
+        current_type = None  # 'letter', 'digit', 'op'
+
+        for char in text:
+            if char.isalpha():
+                char_type = 'letter'
+            elif char.isdigit():
+                char_type = 'digit'
+            elif char in operators:
+                char_type = 'op'
+            else:
+                char_type = 'other'
+
+            if current_type is None:
+                current_type = char_type
+                current_token = char
+            elif char_type == current_type and char_type != 'op':
+                # Same type and not operator - accumulate
+                current_token += char
+            else:
+                # Type changed or operator - flush and start new
+                if current_token:
+                    tokens.append((current_token, current_type))
+                current_token = char
+                current_type = char_type
+
+        # Flush final token
+        if current_token:
+            tokens.append((current_token, current_type))
+
+        # Add styling entries for each token
+        # Use a sub-position to differentiate tokens from the same OMML run
+        for sub_pos, (token, token_type) in enumerate(tokens):
+            if token_type == 'letter':
+                # Create a copy of style_info with updated text
+                token_style = StyleInfo(
+                    text=token,
+                    position=base_position,
+                    mathvariant=style_info.mathvariant,
+                    font_family=style_info.font_family,
+                    color=style_info.color,
+                    background_color=style_info.background_color,
+                    font_size=style_info.font_size,
+                    is_bold=style_info.is_bold,
+                    is_italic=style_info.is_italic,
+                    is_plain=style_info.is_plain,
+                    is_text_mode=style_info.is_text_mode,
+                )
+                # Use token text as key for text-only lookup
+                # Multiple entries for same position with different texts
+                styling_map[(base_position, token)] = token_style
+
+                # CRITICAL: XSLT may also split letter groups into individual letters
+                # (e.g., 'MnO' → <mi>M</mi><mi>n</mi><mi>O</mi>)
+                # Add entries for each individual letter as well
+                if len(token) > 1:
+                    for char in token:
+                        char_style = StyleInfo(
+                            text=char,
+                            position=base_position,
+                            mathvariant=style_info.mathvariant,
+                            font_family=style_info.font_family,
+                            color=style_info.color,
+                            background_color=style_info.background_color,
+                            font_size=style_info.font_size,
+                            is_bold=style_info.is_bold,
+                            is_italic=style_info.is_italic,
+                            is_plain=style_info.is_plain,
+                            is_text_mode=style_info.is_text_mode,
+                        )
+                        styling_map[(base_position, char)] = char_style
+            # For operators and digits, we typically don't need mathvariant styling
+            # as they're already upright by default in LaTeX
+
+    def extract_structural_styling_from_omml(
+        self,
+        omml_xml: str
+    ) -> Dict[Tuple[str, int], StructuralStyleInfo]:
+        """
+        Extract styling from OMML structural elements (fractions, radicals, etc.).
+
+        This method identifies structural elements like <m:f> (fractions) and <m:rad> (radicals)
+        that have color properties in their properties elements (m:fPr, m:radPr).
+
+        Args:
+            omml_xml: The OMML XML string
+
+        Returns:
+            Dict mapping (element_type, position) -> StructuralStyleInfo
+            Example: ('f', 0) -> StructuralStyleInfo(element_type='f', position=0, color='FFFF00')
+        """
+        try:
+            root = ET.fromstring(omml_xml.encode('utf-8'))
+        except ET.XMLSyntaxError:
+            return {}
+
+        structural_map = {}
+
+        # Track positions for each element type separately
+        positions = {'f': 0, 'rad': 0, 'func': 0, 'd': 0}
+
+        # Process fractions (m:f)
+        for f_elem in root.iter(f'{{{OMML_NS}}}f'):
+            fpr = f_elem.find(f'{{{OMML_NS}}}fPr', OMML_NAMESPACES)
+            if fpr is not None:
+                color = self._extract_color_from_props(fpr)
+                if color:
+                    info = StructuralStyleInfo(
+                        element_type='f',
+                        position=positions['f'],
+                        color=color
+                    )
+                    structural_map[('f', positions['f'])] = info
+            positions['f'] += 1
+
+        # Process radicals (m:rad) - square roots and nth roots
+        for rad_elem in root.iter(f'{{{OMML_NS}}}rad'):
+            radpr = rad_elem.find(f'{{{OMML_NS}}}radPr', OMML_NAMESPACES)
+            if radpr is not None:
+                color = self._extract_color_from_props(radpr)
+                if color:
+                    info = StructuralStyleInfo(
+                        element_type='rad',
+                        position=positions['rad'],
+                        color=color
+                    )
+                    structural_map[('rad', positions['rad'])] = info
+            positions['rad'] += 1
+
+        # Future: Add support for m:func (functions), m:d (delimiters), etc.
+
+        return structural_map
+
+    def _extract_color_from_props(self, props_elem: ET.Element) -> Optional[str]:
+        """
+        Extract w:color from structural property element (m:fPr, m:radPr, etc.).
+
+        Args:
+            props_elem: The properties element (m:fPr or m:radPr)
+
+        Returns:
+            Color value (hex string without #) or None if no color found
+
+        Note:
+            Word may nest the color in two ways:
+            1. Direct: m:fPr/w:rPr/w:color
+            2. Via control properties: m:fPr/m:ctrlPr/w:rPr/w:color
+        """
+        # Try direct path first: m:fPr/w:rPr/w:color
+        w_rpr = props_elem.find(f'{{{WORD_NS}}}rPr', OMML_NAMESPACES)
+
+        # If not found, try via m:ctrlPr (control properties)
+        if w_rpr is None:
+            ctrl_pr = props_elem.find(f'{{{OMML_NS}}}ctrlPr', OMML_NAMESPACES)
+            if ctrl_pr is not None:
+                w_rpr = ctrl_pr.find(f'{{{WORD_NS}}}rPr', OMML_NAMESPACES)
+
+        # Extract color from w:rPr if found
+        if w_rpr is not None:
+            color_elem = w_rpr.find(f'{{{WORD_NS}}}color', OMML_NAMESPACES)
+            if color_elem is not None:
+                # Try with namespace prefix first, then without
+                color_val = color_elem.get(f'{{{WORD_NS}}}val')
+                if color_val is None:
+                    color_val = color_elem.get('val')
+
+                # Skip "auto" color (means default)
+                if color_val and color_val != 'auto':
+                    return color_val
+
+        return None
+
+    def _extract_math_properties(self, m_rpr: ET.Element, style_info: StyleInfo):
+        """
+        Extract styling from OMML math run properties (m:rPr).
+
+        Handles:
+        - m:sty (style): b=bold, p=plain, i=italic, bi=bold-italic
+        - m:scr (script): double-struck, script, fraktur, sans-serif, monospace
+        """
+        # Check for m:nor - indicates "text mode" in Word equation editor
+        # m:nor switches to Word text formatting: w:i/w:b take effect.
+        # Without explicit m:sty, default is upright (normal) - but w:i can override to italic.
+        nor_elem = m_rpr.find(f'{{{OMML_NS}}}nor', OMML_NAMESPACES)
+        if nor_elem is not None:
+            # <m:nor/> activates text mode - defer mathvariant to w:rPr
+            # If w:i is present, text becomes italic; otherwise stays normal
+            style_info.is_plain = True
+            style_info.is_text_mode = True
+            # Do NOT set mathvariant here - let _extract_word_properties handle w:i
+
+        # Check for m:sty (style) element
+        sty_elem = m_rpr.find(f'{{{OMML_NS}}}sty', OMML_NAMESPACES)
+        if sty_elem is not None:
+            sty_val = sty_elem.get(f'{{{OMML_NS}}}val')
+            if sty_val is None:
+                sty_val = sty_elem.get('val')  # Try without namespace
+
+            if sty_val == 'b':
+                style_info.is_bold = True
+                style_info.mathvariant = 'bold'
+            elif sty_val == 'p':
+                # m:sty val="p" indicates plain/upright text (not italic)
+                style_info.is_plain = True
+                if style_info.text and any(c.isalpha() for c in style_info.text):
+                    style_info.mathvariant = 'normal'
+            elif sty_val == 'i':
+                style_info.is_italic = True
+                style_info.mathvariant = 'italic'
+            elif sty_val == 'bi':
+                style_info.is_bold = True
+                style_info.is_italic = True
+                style_info.mathvariant = 'bold-italic'
+
+        # Check for m:scr (script/font variant) element
+        scr_elem = m_rpr.find(f'{{{OMML_NS}}}scr', OMML_NAMESPACES)
+        if scr_elem is not None:
+            scr_val = scr_elem.get(f'{{{OMML_NS}}}val')
+            if scr_val is None:
+                scr_val = scr_elem.get('val')
+
+            # m:scr overrides m:sty for mathvariant
+            if scr_val == 'double-struck':
+                style_info.mathvariant = 'double-struck'
+            elif scr_val == 'script':
+                style_info.mathvariant = 'script'
+            elif scr_val == 'fraktur':
+                style_info.mathvariant = 'fraktur'
+            elif scr_val == 'sans-serif':
+                style_info.mathvariant = 'sans-serif'
+            elif scr_val == 'monospace':
+                style_info.mathvariant = 'monospace'
+
+    def _extract_word_properties(self, w_rpr: ET.Element, style_info: StyleInfo):
+        """
+        Extract styling from Word run properties (w:rPr).
+
+        Handles:
+        - w:rFonts (font family)
+        - w:color (text color)
+        - w:sz (font size)
+        - w:b (bold flag)
+        - w:i (italic flag)
+        """
+        # Font family
+        rfonts_elem = w_rpr.find(f'{{{WORD_NS}}}rFonts', OMML_NAMESPACES)
+        if rfonts_elem is not None:
+            # Try different attributes for font name
+            font = (rfonts_elem.get(f'{{{WORD_NS}}}ascii') or
+                   rfonts_elem.get(f'{{{WORD_NS}}}hAnsi') or
+                   rfonts_elem.get(f'{{{WORD_NS}}}cs'))
+            if font:
+                style_info.font_family = font
+
+        # Text color
+        color_elem = w_rpr.find(f'{{{WORD_NS}}}color', OMML_NAMESPACES)
+        if color_elem is not None:
+            color_val = color_elem.get(f'{{{WORD_NS}}}val')
+            if color_val is None:
+                color_val = color_elem.get('val')
+            if color_val and color_val != 'auto':
+                style_info.color = color_val
+
+        # Font size (in half-points)
+        sz_elem = w_rpr.find(f'{{{WORD_NS}}}sz', OMML_NAMESPACES)
+        if sz_elem is not None:
+            sz_val = sz_elem.get(f'{{{WORD_NS}}}val')
+            if sz_val is None:
+                sz_val = sz_elem.get('val')
+            if sz_val:
+                try:
+                    # Convert half-points to points
+                    style_info.font_size = float(sz_val) / 2
+                except ValueError:
+                    pass
+
+        # Bold flag (from Word, if not already set by m:sty)
+        # IMPORTANT: <w:b/> (no val) means bold=true, but <w:b val="0"/> means bold=false
+        if not style_info.is_bold:
+            b_elem = w_rpr.find(f'{{{WORD_NS}}}b', OMML_NAMESPACES)
+            if b_elem is not None:
+                # Check the val attribute - "0" or "false" means NOT bold
+                b_val = b_elem.get(f'{{{WORD_NS}}}val')
+                if b_val is None:
+                    b_val = b_elem.get('val')  # Try without namespace
+                # Only set bold=True if val is not "0" or "false"
+                # Presence without val attribute means true
+                if b_val not in ('0', 'false'):
+                    style_info.is_bold = True
+                    if not style_info.mathvariant:
+                        style_info.mathvariant = 'bold'
+
+        # Italic flag (from Word, if not already set by m:sty)
+        # IMPORTANT: <w:i/> (no val) means italic=true, but <w:i val="0"/> means italic=false
+        if not style_info.is_italic:
+            i_elem = w_rpr.find(f'{{{WORD_NS}}}i', OMML_NAMESPACES)
+            if i_elem is not None:
+                # Check the val attribute - "0" or "false" means NOT italic
+                i_val = i_elem.get(f'{{{WORD_NS}}}val')
+                if i_val is None:
+                    i_val = i_elem.get('val')  # Try without namespace
+                # Only set italic=True if val is not "0" or "false"
+                # Presence without val attribute means true
+                if i_val not in ('0', 'false'):
+                    style_info.is_italic = True
+                    if not style_info.mathvariant:
+                        style_info.mathvariant = 'italic'
+                    elif style_info.mathvariant == 'bold':
+                        style_info.mathvariant = 'bold-italic'
+
+        # Background/highlight color (w:highlight element)
+        highlight_elem = w_rpr.find(f'{{{WORD_NS}}}highlight', OMML_NAMESPACES)
+        if highlight_elem is not None:
+            highlight_val = highlight_elem.get(f'{{{WORD_NS}}}val')
+            if highlight_val is None:
+                highlight_val = highlight_elem.get('val')
+            if highlight_val:
+                style_info.background_color = highlight_val
+
+    def _apply_structural_styling(
+        self,
+        mathml_root: ET.Element,
+        structural_styling: Dict[Tuple[str, int], StructuralStyleInfo]
+    ) -> ET.Element:
+        """
+        Wrap structural MathML elements in mstyle with mathcolor.
+
+        This method finds structural elements like mfrac, msqrt, mroot and wraps
+        them in <mstyle mathcolor="#color"> elements based on the styling extracted
+        from OMML.
+
+        Args:
+            mathml_root: The MathML root element
+            structural_styling: Dict mapping (element_type, position) -> StructuralStyleInfo
+
+        Returns:
+            Modified MathML root element
+
+        Note:
+            Maps OMML types to MathML tags:
+            - 'f' -> 'mfrac'
+            - 'rad' -> 'msqrt' or 'mroot'
+        """
+        # Map OMML element types to MathML tag names
+        element_map = {
+            'f': ['mfrac'],
+            'rad': ['msqrt', 'mroot'],
+            # Future: 'func': [...], 'd': [...]
+        }
+
+        # Track positions for each MathML tag type
+        positions = {'mfrac': 0, 'msqrt': 0, 'mroot': 0}
+
+        # Collect elements to wrap (can't modify tree during iteration)
+        elements_to_wrap = []
+
+        for elem in mathml_root.iter():
+            local_tag = elem.tag.split('}')[-1] if '}' in elem.tag else elem.tag
+
+            # Check if this is a structural element we're tracking
+            for omml_type, mathml_tags in element_map.items():
+                if local_tag in mathml_tags:
+                    # Check if we have styling for this position
+                    key = (omml_type, positions.get(local_tag, 0))
+                    if key in structural_styling:
+                        style_info = structural_styling[key]
+                        if style_info.color:
+                            elements_to_wrap.append((elem, style_info.color))
+
+                    # Increment position counter for this tag type
+                    positions[local_tag] = positions.get(local_tag, 0) + 1
+
+        # Wrap elements in mstyle
+        for elem, color in elements_to_wrap:
+            self._wrap_element_in_mstyle(elem, color)
+
+        return mathml_root
+
+    def _wrap_element_in_mstyle(self, elem: ET.Element, color: str):
+        """
+        Wrap element in mstyle with mathcolor attribute.
+
+        Args:
+            elem: The MathML element to wrap
+            color: Color value (hex string without #)
+
+        Note:
+            Modifies the tree in place by:
+            1. Creating <mstyle mathcolor="#color">
+            2. Replacing elem with mstyle in parent
+            3. Adding elem as child of mstyle
+        """
+        parent = elem.getparent()
+        if parent is None:
+            # Can't wrap root element
+            return
+
+        # Get namespace from element
+        namespace = elem.tag.split('}')[0][1:] if '}' in elem.tag else None
+
+        # Create mstyle element with same namespace
+        if namespace:
+            mstyle_tag = f'{{{namespace}}}mstyle'
+        else:
+            mstyle_tag = 'mstyle'
+
+        mstyle = ET.Element(mstyle_tag)
+        mstyle.set('mathcolor', f'#{color}')
+
+        # Replace elem with mstyle in parent
+        index = list(parent).index(elem)
+        parent.remove(elem)
+        parent.insert(index, mstyle)
+
+        # Add elem as child of mstyle
+        mstyle.append(elem)
+
+    def apply_styling_to_mathml(
+        self,
+        mathml_xml: str,
+        styling_map: Dict[Tuple[int, str], StyleInfo],
+        structural_styling: Dict[Tuple[str, int], StructuralStyleInfo] = None
+    ) -> str:
+        """
+        Apply styling information to MathML elements.
+
+        Adds mathvariant, mathcolor, and other attributes to <mi>, <mo>, <mn>
+        elements based on the styling map extracted from OMML.
+
+        Args:
+            mathml_xml: MathML XML string (output from XSLT)
+            styling_map: Styling map from extract_styling_from_omml()
+
+        Returns:
+            Enhanced MathML XML string with styling attributes
+
+        Examples:
+            >>> processor = StylingPostProcessor()
+            >>> mathml = '<math><mi>Z</mi></math>'
+            >>> styling = {(0, 'Z'): StyleInfo(text='Z', position=0, mathvariant='bold')}
+            >>> enhanced = processor.apply_styling_to_mathml(mathml, styling)
+            >>> 'mathvariant="bold"' in enhanced
+            True
+        """
+        if not styling_map and not structural_styling:
+            return mathml_xml
+
+        try:
+            root = ET.fromstring(mathml_xml.encode('utf-8'))
+        except ET.XMLSyntaxError:
+            # If parsing fails, return original
+            return mathml_xml
+
+        # FIRST: Apply structural styling (wraps elements in mstyle)
+        if structural_styling:
+            root = self._apply_structural_styling(root, structural_styling)
+
+        # THEN: Apply leaf styling (add attributes to mi, mo, mn)
+        # Track position for matching
+        position = 0
+
+        # Find all <mi>, <mo>, <mn> elements (identifier, operator, number)
+        for elem in root.iter():
+            local_tag = elem.tag.split('}')[-1] if '}' in elem.tag else elem.tag
+
+            if local_tag not in ('mi', 'mo', 'mn'):
+                continue
+
+            text = elem.text
+            if not text or not text.strip():
+                continue
+
+            text = text.strip()
+
+            # Look up styling
+            style_info = styling_map.get((position, text))
+            if style_info is None:
+                # Try without position (fallback for simple cases)
+                for key, info in styling_map.items():
+                    if info.text == text:
+                        style_info = info
+                        break
+
+            if style_info is None:
+                position += 1
+                continue
+
+            # Apply mathvariant ONLY to identifiers (<mi>), not operators (<mo>) or numbers (<mn>)
+            # Operators should never have mathvariant as they're already upright by default
+            # This prevents wrapping operators in \mathrm{} which causes output pollution
+            if style_info.mathvariant and local_tag == 'mi':
+                elem.set('mathvariant', style_info.mathvariant)
+
+            # Apply mathcolor (if color present)
+            if style_info.color:
+                elem.set('mathcolor', f'#{style_info.color}')
+
+            # Apply font-family (custom attribute, will be handled by LaTeX converter)
+            # Skip Cambria Math as it's the default math font
+            if style_info.font_family and style_info.font_family != 'Cambria Math':
+                elem.set('fontfamily', style_info.font_family)
+
+            # Apply font-size (custom attribute)
+            if style_info.font_size:
+                elem.set('fontsize', str(style_info.font_size))
+
+            position += 1
+
+        # Convert back to string
+        return ET.tostring(root, encoding='unicode')
+
+    def has_styling(self, omml_xml: str) -> bool:
+        """
+        Quick check if OMML contains any styling information.
+
+        Used for optimization: skip post-processing if no styling present.
+
+        Args:
+            omml_xml: OMML XML string
+
+        Returns:
+            True if styling (m:rPr, w:rPr, m:sty, m:scr, w:highlight) found
+        """
+        # Quick string search (much faster than parsing)
+        return any(marker in omml_xml for marker in [
+            'm:rPr', 'm:sty', 'm:scr',  # OMML math properties
+            'w:rPr', 'w:color', 'w:b', 'w:i', 'w:highlight',  # Word properties
+        ])
+
+    def detect_uniform_background(self, omml_xml: str) -> Optional[str]:
+        """
+        Detect if entire equation has uniform background/highlight color.
+
+        Checks all <w:highlight> elements in the OMML to determine if they
+        all have the same color value, indicating the entire equation has
+        a uniform background.
+
+        Args:
+            omml_xml: OMML XML string
+
+        Returns:
+            Background color name (e.g., 'yellow') if uniform, None otherwise
+
+        Examples:
+            >>> processor = StylingPostProcessor()
+            >>> omml = '<m:oMath><m:r><w:rPr><w:highlight w:val="yellow"/></w:rPr><m:t>x</m:t></m:r></m:oMath>'
+            >>> processor.detect_uniform_background(omml)
+            'yellow'
+        """
+        try:
+            root = ET.fromstring(omml_xml.encode('utf-8'))
+        except ET.XMLSyntaxError:
+            return None
+
+        background_colors = set()
+        has_elements_without_background = False
+
+        # Find all <m:r> (run) elements and check for w:highlight
+        for r_elem in root.iter(f'{{{OMML_NS}}}r'):
+            # Get text content - skip empty runs
+            t_elem = r_elem.find(f'{{{OMML_NS}}}t', OMML_NAMESPACES)
+            if t_elem is None or not t_elem.text or not t_elem.text.strip():
+                continue
+
+            # Check for Word run properties
+            w_rpr = r_elem.find(f'{{{WORD_NS}}}rPr', OMML_NAMESPACES)
+            if w_rpr is None:
+                has_elements_without_background = True
+                continue
+
+            # Check for highlight element
+            highlight_elem = w_rpr.find(f'{{{WORD_NS}}}highlight', OMML_NAMESPACES)
+            if highlight_elem is None:
+                has_elements_without_background = True
+                continue
+
+            # Get highlight value
+            highlight_val = highlight_elem.get(f'{{{WORD_NS}}}val')
+            if highlight_val is None:
+                highlight_val = highlight_elem.get('val')
+
+            if highlight_val:
+                background_colors.add(highlight_val.lower())
+            else:
+                has_elements_without_background = True
+
+        # Also check structural elements (fractions, radicals) for highlight in ctrlPr
+        for elem_type in ['f', 'rad', 'func', 'd', 'sSup', 'sSub', 'sSubSup']:
+            for struct_elem in root.iter(f'{{{OMML_NS}}}{elem_type}'):
+                # Find properties element (fPr, radPr, etc.)
+                pr_elem = struct_elem.find(f'{{{OMML_NS}}}{elem_type}Pr', OMML_NAMESPACES)
+                if pr_elem is None:
+                    continue
+
+                # Check ctrlPr for w:rPr with highlight
+                ctrl_pr = pr_elem.find(f'{{{OMML_NS}}}ctrlPr', OMML_NAMESPACES)
+                if ctrl_pr is not None:
+                    w_rpr = ctrl_pr.find(f'{{{WORD_NS}}}rPr', OMML_NAMESPACES)
+                    if w_rpr is not None:
+                        highlight_elem = w_rpr.find(f'{{{WORD_NS}}}highlight', OMML_NAMESPACES)
+                        if highlight_elem is not None:
+                            highlight_val = highlight_elem.get(f'{{{WORD_NS}}}val')
+                            if highlight_val is None:
+                                highlight_val = highlight_elem.get('val')
+                            if highlight_val:
+                                background_colors.add(highlight_val.lower())
+
+        # Uniform background only if:
+        # 1. We found exactly one unique background color
+        # 2. ALL content elements have that background (none are without)
+        if len(background_colors) == 1 and not has_elements_without_background:
+            return list(background_colors)[0]
+
+        # Not uniform
+        return None
+
+
+def fix_mathml_table_structure(mathml_xml: str) -> str:
+    """
+    Fix malformed table structure from OMML2MML.xsl transformation.
+
+    The Microsoft XSLT outputs <mtr><mrow>content</mrow></mtr> but MathML
+    requires <mtr><mtd>content</mtd></mtr> for proper table structure.
+
+    This function:
+    1. Finds all <mtr> elements with <mrow> children (should be <mtd>)
+    2. Wraps each <mrow> in <mtd> to create proper table cells
+    3. Preserves all content and attributes
+
+    Args:
+        mathml_xml: MathML XML string (possibly malformed)
+
+    Returns:
+        Fixed MathML with proper table structure
+
+    Examples:
+        >>> mathml = '<math><mtable><mtr><mrow><mn>1</mn></mrow></mtr></mtable></math>'
+        >>> fixed = fix_mathml_table_structure(mathml)
+        >>> '<mtd>' in fixed
+        True
+    """
+    try:
+        root = ET.fromstring(mathml_xml.encode('utf-8'))
+    except ET.XMLSyntaxError:
+        # If parsing fails, return original
+        return mathml_xml
+
+    def _local_name(tag):
+        """Extract local name without namespace."""
+        return tag.split('}')[-1] if '}' in tag else tag
+
+    def _make_tag(local_name, namespace=None):
+        """Create tag with optional namespace."""
+        if namespace:
+            return f'{{{namespace}}}{local_name}'
+        return local_name
+
+    # Find all <mtr> elements (with or without namespace)
+    # Collect all mtr elements first to avoid modification during iteration
+    mtr_elements = [elem for elem in root.iter() if _local_name(elem.tag) == 'mtr']
+
+    for mtr_elem in mtr_elements:
+        # Check if mtr has direct <mrow> children (indicates malformed structure)
+        mrow_children = [child for child in mtr_elem if _local_name(child.tag) == 'mrow']
+
+        if mrow_children:
+            # Get namespace from mtr element (or its parent mtable)
+            mtr_ns = mtr_elem.tag.split('}')[0][1:] if '}' in mtr_elem.tag else None
+
+            # Process each mrow child: wrap in mtd
+            # IMPORTANT: We need to preserve order, so collect mtd elements first
+            new_mtd_elements = []
+            for mrow_child in mrow_children:
+                # Create new mtd element with same namespace as mtr
+                mtd_elem = ET.Element(_make_tag('mtd', mtr_ns))
+
+                # Move all children from mrow to mtd
+                for grandchild in list(mrow_child):
+                    mtd_elem.append(grandchild)
+
+                # Preserve mrow text content if any
+                if mrow_child.text and mrow_child.text.strip():
+                    if len(mtd_elem) == 0:
+                        mtd_elem.text = mrow_child.text
+                    else:
+                        # Prepend text to first child
+                        mtd_elem[0].text = (mrow_child.text or '') + (mtd_elem[0].text or '')
+
+                new_mtd_elements.append(mtd_elem)
+
+            # Now remove all mrow children and add mtd elements
+            for mrow_child in mrow_children:
+                mtr_elem.remove(mrow_child)
+
+            for mtd_elem in new_mtd_elements:
+                mtr_elem.append(mtd_elem)
+
+    # Convert back to string
+    return ET.tostring(root, encoding='unicode')
+
+
+def apply_styling_to_mathml_from_omml(omml_xml: str, mathml_xml: str) -> str:
+    """
+    Convenience function to extract styling from OMML and apply to MathML.
+
+    Also fixes table structure issues from OMML2MML.xsl transformation.
+    Detects and adds uniform background color as a custom attribute.
+
+    Args:
+        omml_xml: Original OMML XML string
+        mathml_xml: MathML XML string (from XSLT conversion)
+
+    Returns:
+        Enhanced MathML with styling attributes and fixed table structure
+
+    Examples:
+        >>> omml = '<m:oMath><m:r><m:rPr><m:sty m:val="b"/></m:rPr><m:t>Z</m:t></m:r></m:oMath>'
+        >>> mathml = '<math><mi>Z</mi></math>'
+        >>> enhanced = apply_styling_to_mathml_from_omml(omml, mathml)
+        >>> 'mathvariant="bold"' in enhanced
+        True
+    """
+    processor = StylingPostProcessor()
+
+    # CRITICAL FIX: Fix table structure FIRST (before styling)
+    # The OMML2MML.xsl outputs <mtr><mrow> instead of <mtr><mtd>
+    mathml_xml = fix_mathml_table_structure(mathml_xml)
+
+    # Detect uniform background color from OMML
+    uniform_background = processor.detect_uniform_background(omml_xml)
+
+    # Quick check: skip if no styling and no background
+    if not processor.has_styling(omml_xml) and not uniform_background:
+        return mathml_xml
+
+    # Extract BOTH leaf and structural styling
+    styling_map = processor.extract_styling_from_omml(omml_xml)
+    structural_styling = processor.extract_structural_styling_from_omml(omml_xml)
+
+    # Apply both types of styling
+    result = processor.apply_styling_to_mathml(
+        mathml_xml,
+        styling_map,
+        structural_styling
+    )
+
+    # Add uniform background as custom attribute on <math> root element
+    # This will be detected by the LaTeX converter and applied as \bbox
+    if uniform_background:
+        result = _add_background_attribute(result, uniform_background)
+
+    return result
+
+
+def _add_background_attribute(mathml_xml: str, background_color: str) -> str:
+    """
+    Add data-background attribute to MathML root element.
+
+    Args:
+        mathml_xml: MathML XML string
+        background_color: Background color name (e.g., 'yellow')
+
+    Returns:
+        MathML with data-background attribute added to root element
+    """
+    try:
+        root = ET.fromstring(mathml_xml.encode('utf-8'))
+    except ET.XMLSyntaxError:
+        return mathml_xml
+
+    # Add custom attribute to root element
+    root.set('data-background', background_color)
+
+    return ET.tostring(root, encoding='unicode')
diff --git a/scripts/omml_mathml2latex/utils/text_processing.py b/scripts/omml_mathml2latex/utils/text_processing.py
new file mode 100644
index 0000000..44fd7ac
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/text_processing.py
@@ -0,0 +1,185 @@
+"""
+Text processing utilities for file I/O and LaTeX formatting.
+
+This module provides functions for reading/writing text files and converting
+various space characters to appropriate LaTeX spacing commands.
+"""
+
+import os
+
+
+def read_text(path: str, encoding: str = "utf-8") -> str:
+    """Read text from a file.
+
+    Args:
+        path: Path to the file to read
+        encoding: Text encoding (default: utf-8)
+
+    Returns:
+        File contents as string
+
+    Example:
+        >>> content = read_text('input.tex')
+    """
+    with open(path, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def write_text(path: str, content: str, encoding: str = "utf-8") -> None:
+    """Write text to a file, creating parent directories if needed.
+
+    Args:
+        path: Path to the file to write
+        content: Text content to write
+        encoding: Text encoding (default: utf-8)
+
+    Example:
+        >>> write_text('output.tex', '\\\\sin x')
+    """
+    dirpath = os.path.dirname(path)
+    if dirpath:
+        os.makedirs(dirpath, exist_ok=True)
+    with open(path, "w", encoding=encoding) as f:
+        f.write(content)
+
+
+def convert_spaces_to_latex(text: str) -> str:
+    """Convert space characters in text to appropriate LaTeX spacing commands.
+
+    Handles:
+    - U+00A0 (NBSP, \\xa0) → ~ (tilde, non-breaking space in LaTeX)
+    - U+0020 (regular space) → \\\\ (backslash-space) for each space
+
+    Args:
+        text: Input text possibly containing various space characters
+
+    Returns:
+        Text with spaces converted to LaTeX commands
+
+    Example:
+        >>> convert_spaces_to_latex('sin x')
+        'sin\\\\ x'
+        >>> convert_spaces_to_latex('sin\\xa0x')  # NBSP
+        'sin~x'
+    """
+    if not text:
+        return text
+
+    # Quick check: if no spaces present, return as-is
+    if '\xa0' not in text and ' ' not in text:
+        return text
+
+    result = []
+    i = 0
+
+    while i < len(text):
+        char = text[i]
+
+        if char == '\xa0':  # U+00A0: Non-breaking space
+            # Always use tilde for NBSP in LaTeX
+            result.append('~')
+            i += 1
+
+        elif char == ' ':  # U+0020: Regular space
+            # Count consecutive spaces
+            space_count = 1
+            while i + space_count < len(text) and text[i + space_count] == ' ':
+                space_count += 1
+
+            # Convert each space to backslash-space (backslash followed by space)
+            # For N spaces, produce "\\ " repeated N times: "\\ \\ \\ "
+            # Each '\\ ' is already a complete unit, so use empty join (not space join)
+            result.append('\\ ' * space_count)
+
+            i += space_count  # Skip all processed spaces
+
+        else:
+            # Regular character
+            result.append(char)
+            i += 1
+
+    # Join results but preserve trailing spaces that are part of LaTeX commands
+    result_str = ''.join(result)
+    # Don't strip if the string ends with LaTeX space command '\\ '
+    # The trailing space in '\\ ' is semantically significant
+    if result_str.endswith('\\ '):
+        return result_str
+    else:
+        return result_str.rstrip()  # Remove trailing space from last element
+
+
+def escape_latex_special_chars(text: str, preserve_nbsp: bool = True) -> str:
+    """Escape special characters that have meaning in LaTeX.
+
+    LaTeX special characters that need escaping:
+    - $ (math mode delimiter)
+    - ^ (superscript)
+    - _ (subscript)
+    - # (parameter token)
+    - @ (letter category code)
+    - ! (negative thin space)
+    - % (comment)
+    - & (alignment tab)
+    - * (discretionary multiplication)
+    - ~ (tilde) → \\sim in math mode
+
+    Args:
+        text: Input text possibly containing special characters
+        preserve_nbsp: If True, preserve NBSP (\\xa0) for later conversion to ~
+                      If False, convert NBSP to ~ before escaping
+
+    Returns:
+        Text with special characters escaped
+
+    Example:
+        >>> escape_latex_special_chars('$100 ^ 2')
+        '\\$100 \\^ 2'
+        >>> escape_latex_special_chars('H_2O')
+        'H\\_2O'
+        >>> escape_latex_special_chars('a ~ b')
+        'a \\sim b'
+    """
+    if not text:
+        return text
+
+    # CRITICAL: Preserve marker strings used for brace resolution
+    # These markers distinguish source braces from generated LaTeX braces
+    if text in ('__LBRACE__', '__RBRACE__', '__DELIM__'):
+        return text
+
+    # Use a temporary placeholder for NBSP to preserve it during escaping
+    # This allows NBSP to be converted to ~ later for LaTeX spacing
+    NBSP_PLACEHOLDER = '\x00NBSP\x00'  # Using null bytes as unlikely to appear in text
+
+    if preserve_nbsp and '\xa0' in text:
+        # Temporarily replace NBSP with placeholder
+        text = text.replace('\xa0', NBSP_PLACEHOLDER)
+
+    # Mapping of special characters to their escaped versions
+    # NOTE: In math mode, * is a valid operator and doesn't need escaping
+    # NOTE: { and } are NOT escaped here - they're handled via __LBRACE__/__RBRACE__ markers
+    #       to distinguish source braces from generated LaTeX braces (e.g., \mathrm{...})
+    ESCAPE_MAP = {
+        '$': r'\$',
+        '%': r'\%',
+        '#': r'\#',
+        '&': r'\&',
+        '_': r'\_',
+        '^': r'\^',
+        # NOTE: '~' is NOT escaped here - it's handled via UNICODE_TO_LATEX mapping to \sim
+        '@': r'\@',
+        '!': r'\!',
+        # NOTE: '*' is NOT escaped - it's a valid multiplication operator in math mode
+        '{': r'\{',
+        '}': r'\}',
+    }
+
+    result = text
+    for char, escaped in ESCAPE_MAP.items():
+        result = result.replace(char, escaped)
+
+    # Restore NBSP placeholder back to NBSP for later processing
+    if preserve_nbsp and NBSP_PLACEHOLDER in result:
+        result = result.replace(NBSP_PLACEHOLDER, '\xa0')
+
+    return result
diff --git a/scripts/omml_mathml2latex/utils/timer.py b/scripts/omml_mathml2latex/utils/timer.py
new file mode 100644
index 0000000..b331d01
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/timer.py
@@ -0,0 +1,376 @@
+"""
+Performance timing utilities for omml2tex.
+
+Provides comprehensive timing instrumentation with minimal overhead:
+- Execution time tracking for critical operations
+- Memory usage monitoring
+- Hierarchical timing for nested operations
+- Statistical summaries and reports
+"""
+
+import time
+import functools
+from typing import Dict, List, Optional, Callable, Any
+from dataclasses import dataclass, field
+from contextlib import contextmanager
+
+
+@dataclass
+class TimingRecord:
+    """Single timing measurement record."""
+    name: str
+    start_time: float
+    end_time: Optional[float] = None
+    duration: Optional[float] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    parent: Optional[str] = None
+
+    def finish(self) -> None:
+        """Mark record as finished and calculate duration."""
+        if self.end_time is None:
+            self.end_time = time.perf_counter()
+            self.duration = self.end_time - self.start_time
+
+    def is_finished(self) -> bool:
+        """Check if timing record is complete."""
+        return self.end_time is not None
+
+
+@dataclass
+class TimingSummary:
+    """Statistical summary of timing measurements."""
+    name: str
+    count: int
+    total_time: float
+    avg_time: float
+    min_time: float
+    max_time: float
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class PerformanceTimer:
+    """
+    High-precision performance timer with hierarchical timing support.
+
+    Features:
+    - Sub-millisecond precision using time.perf_counter()
+    - Hierarchical timing for nested operations
+    - Minimal overhead (~1-2 microseconds per timing)
+    - Thread-safe operation tracking
+    - Statistical summaries and reporting
+
+    Example:
+        timer = PerformanceTimer()
+
+        # Context manager usage
+        with timer.measure("conversion"):
+            result = convert_mathml(xml)
+
+        # Decorator usage
+        @timer.time_function
+        def process_equation(xml):
+            return convert(xml)
+
+        # Manual timing
+        timer.start("parsing")
+        data = parse_xml(xml)
+        timer.stop("parsing")
+
+        # Get results
+        print(timer.get_summary())
+    """
+
+    def __init__(self, enabled: bool = True):
+        """
+        Initialize performance timer.
+
+        Args:
+            enabled: If False, timing is disabled (zero overhead)
+        """
+        self.enabled = enabled
+        self._records: Dict[str, List[TimingRecord]] = {}
+        self._active: Dict[str, TimingRecord] = {}
+        self._parent_stack: List[str] = []
+
+    def start(self, name: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """
+        Start timing an operation.
+
+        Args:
+            name: Operation name (used for grouping)
+            metadata: Optional metadata to attach to record
+        """
+        if not self.enabled:
+            return
+
+        parent = self._parent_stack[-1] if self._parent_stack else None
+        record = TimingRecord(
+            name=name,
+            start_time=time.perf_counter(),
+            metadata=metadata or {},
+            parent=parent
+        )
+
+        self._active[name] = record
+        self._parent_stack.append(name)
+
+    def stop(self, name: str, metadata: Optional[Dict[str, Any]] = None) -> Optional[float]:
+        """
+        Stop timing an operation.
+
+        Args:
+            name: Operation name (must match start() call)
+            metadata: Optional additional metadata
+
+        Returns:
+            Duration in seconds, or None if timing disabled/not started
+        """
+        if not self.enabled:
+            return None
+
+        if name not in self._active:
+            return None
+
+        record = self._active.pop(name)
+        record.finish()
+
+        if metadata:
+            record.metadata.update(metadata)
+
+        if name not in self._records:
+            self._records[name] = []
+        self._records[name].append(record)
+
+        # Remove from parent stack
+        if self._parent_stack and self._parent_stack[-1] == name:
+            self._parent_stack.pop()
+
+        return record.duration
+
+    @contextmanager
+    def measure(self, name: str, metadata: Optional[Dict[str, Any]] = None):
+        """
+        Context manager for timing a block of code.
+
+        Args:
+            name: Operation name
+            metadata: Optional metadata
+
+        Yields:
+            TimingRecord that will be populated with results
+
+        Example:
+            with timer.measure("parsing", {"file": "input.xml"}):
+                data = parse_file()
+        """
+        if not self.enabled:
+            yield None
+            return
+
+        self.start(name, metadata)
+        try:
+            yield self._active.get(name)
+        finally:
+            self.stop(name)
+
+    def time_function(self, name: Optional[str] = None):
+        """
+        Decorator for timing function execution.
+
+        Args:
+            name: Optional custom name (defaults to function name)
+
+        Example:
+            @timer.time_function
+            def convert_equation(xml):
+                return process(xml)
+
+            @timer.time_function("custom_name")
+            def process_data(data):
+                return transform(data)
+        """
+        def decorator(func: Callable) -> Callable:
+            operation_name = name or func.__name__
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                if not self.enabled:
+                    return func(*args, **kwargs)
+
+                with self.measure(operation_name):
+                    return func(*args, **kwargs)
+
+            return wrapper
+        return decorator
+
+    def get_records(self, name: Optional[str] = None) -> List[TimingRecord]:
+        """
+        Get timing records.
+
+        Args:
+            name: Optional operation name filter
+
+        Returns:
+            List of timing records (all records if name=None)
+        """
+        if name:
+            return self._records.get(name, [])
+
+        all_records = []
+        for records in self._records.values():
+            all_records.extend(records)
+        return all_records
+
+    def get_summary(self, name: Optional[str] = None) -> Dict[str, TimingSummary]:
+        """
+        Get statistical summary of timing measurements.
+
+        Args:
+            name: Optional operation name filter
+
+        Returns:
+            Dictionary mapping operation names to summaries
+        """
+        summaries = {}
+
+        records_dict = {name: self._records[name]} if name and name in self._records else self._records
+
+        for op_name, records in records_dict.items():
+            if not records:
+                continue
+
+            durations = [r.duration for r in records if r.duration is not None]
+            if not durations:
+                continue
+
+            summaries[op_name] = TimingSummary(
+                name=op_name,
+                count=len(durations),
+                total_time=sum(durations),
+                avg_time=sum(durations) / len(durations),
+                min_time=min(durations),
+                max_time=max(durations)
+            )
+
+        return summaries
+
+    def get_total_time(self) -> float:
+        """Get total time across all operations."""
+        summaries = self.get_summary()
+        return sum(s.total_time for s in summaries.values())
+
+    def format_report(self, include_hierarchy: bool = True) -> str:
+        """
+        Format timing results as human-readable report.
+
+        Args:
+            include_hierarchy: Include parent-child relationships
+
+        Returns:
+            Formatted report string
+        """
+        summaries = self.get_summary()
+        if not summaries:
+            return "No timing data collected"
+
+        lines = [
+            "=" * 80,
+            "Performance Timing Report".center(80),
+            "=" * 80,
+            ""
+        ]
+
+        # Sort by total time (descending)
+        sorted_summaries = sorted(
+            summaries.values(),
+            key=lambda s: s.total_time,
+            reverse=True
+        )
+
+        # Table header
+        lines.append(f"{'Operation':<30} {'Count':>8} {'Total':>12} {'Avg':>12} {'Min':>12} {'Max':>12}")
+        lines.append("-" * 80)
+
+        # Table rows
+        for summary in sorted_summaries:
+            lines.append(
+                f"{summary.name:<30} "
+                f"{summary.count:>8} "
+                f"{self._format_time(summary.total_time):>12} "
+                f"{self._format_time(summary.avg_time):>12} "
+                f"{self._format_time(summary.min_time):>12} "
+                f"{self._format_time(summary.max_time):>12}"
+            )
+
+        lines.append("-" * 80)
+        lines.append(f"{'TOTAL':<30} {'':<8} {self._format_time(self.get_total_time()):>12}")
+        lines.append("=" * 80)
+
+        # Hierarchy view
+        if include_hierarchy:
+            lines.append("")
+            lines.append("Hierarchical View:")
+            lines.append("-" * 80)
+            self._add_hierarchy_lines(lines)
+
+        return "\n".join(lines)
+
+    def _add_hierarchy_lines(self, lines: List[str], parent: Optional[str] = None, indent: int = 0):
+        """Add hierarchical timing view to report."""
+        for name, records in self._records.items():
+            # Find records with matching parent
+            matching_records = [r for r in records if r.parent == parent]
+            if not matching_records:
+                continue
+
+            avg_time = sum(r.duration for r in matching_records if r.duration) / len(matching_records)
+            prefix = "  " * indent + "└─ " if indent > 0 else ""
+            lines.append(f"{prefix}{name}: {self._format_time(avg_time)} avg ({len(matching_records)} calls)")
+
+            # Recursively add children
+            self._add_hierarchy_lines(lines, name, indent + 1)
+
+    @staticmethod
+    def _format_time(seconds: float) -> str:
+        """Format time duration in human-readable form."""
+        if seconds < 1e-6:
+            return f"{seconds * 1e9:.2f} ns"
+        elif seconds < 1e-3:
+            return f"{seconds * 1e6:.2f} µs"
+        elif seconds < 1:
+            return f"{seconds * 1e3:.2f} ms"
+        else:
+            return f"{seconds:.2f} s"
+
+    def reset(self) -> None:
+        """Clear all timing data."""
+        self._records.clear()
+        self._active.clear()
+        self._parent_stack.clear()
+
+    def enable(self) -> None:
+        """Enable timing."""
+        self.enabled = True
+
+    def disable(self) -> None:
+        """Disable timing."""
+        self.enabled = False
+
+
+# Global timer instance for convenience
+_global_timer = PerformanceTimer(enabled=False)
+
+
+def get_global_timer() -> PerformanceTimer:
+    """Get global timer instance."""
+    return _global_timer
+
+
+def enable_global_timer() -> None:
+    """Enable global timer."""
+    _global_timer.enable()
+
+
+def disable_global_timer() -> None:
+    """Disable global timer."""
+    _global_timer.disable()
diff --git a/scripts/omml_mathml2latex/utils/xml_utils.py b/scripts/omml_mathml2latex/utils/xml_utils.py
new file mode 100644
index 0000000..f6fc8a0
--- /dev/null
+++ b/scripts/omml_mathml2latex/utils/xml_utils.py
@@ -0,0 +1,205 @@
+"""
+XML processing utilities for MathML and OMML handling.
+
+This module provides helper functions for working with XML/MathML/OMML documents,
+including namespace handling, text extraction, and HTML entity decoding.
+"""
+
+import re
+import html
+from typing import List
+from lxml import etree as ET
+
+
+def local_name(tag: str) -> str:
+    """Extract local tag name without namespace.
+
+    Args:
+        tag: XML tag name, possibly with namespace prefix like "{http://...}tagname"
+
+    Returns:
+        Local tag name without namespace
+
+    Example:
+        >>> local_name("{http://www.w3.org/1998/Math/MathML}mi")
+        'mi'
+        >>> local_name("mi")
+        'mi'
+    """
+    if "}" in tag:
+        return tag.split("}", 1)[1]
+    return tag
+
+
+def text_content(node: ET._Element) -> str:
+    """Flatten text under a node (best-effort).
+
+    NOTE: Does NOT strip() to preserve space-only content like NBSP and regular spaces.
+    Spaces are semantically meaningful in mathematical notation.
+
+    However, DOES remove invisible formatting characters like function application (\u2061)
+    and normalizes whitespace (converts newlines/tabs to single spaces).
+
+    Args:
+        node: XML element to extract text from
+
+    Returns:
+        Concatenated text content from node and all its children
+
+    Example:
+        >>> from lxml import etree as ET
+        >>> node = ET.fromstring('<mi>sin</mi>')
+        >>> text_content(node)
+        'sin'
+    """
+    texts: List[str] = []
+    if node.text:
+        texts.append(node.text)
+    for child in node:
+        texts.append(text_content(child))
+        if child.tail:
+            texts.append(child.tail)
+
+    result = "".join(texts)
+
+    # Remove invisible formatting characters that interfere with conversion
+    # but preserve meaningful spaces (regular space, nbsp)
+    invisible_chars = [
+        '\u2061',  # FUNCTION APPLICATION (causes sin⁡ → \mathrm{sin})
+        '\u2062',  # INVISIBLE TIMES
+        '\u2063',  # INVISIBLE SEPARATOR
+        '\u2064',  # INVISIBLE PLUS
+        '\uFEFF',  # ZERO WIDTH NO-BREAK SPACE
+        '\u200B',  # ZERO WIDTH SPACE
+        '\u200C',  # ZERO WIDTH NON-JOINER
+        '\u200D',  # ZERO WIDTH JOINER
+    ]
+
+    for char in invisible_chars:
+        result = result.replace(char, '')
+
+    # Normalize whitespace: Remove newlines and tabs completely
+    # This fixes both multiline fractions like \dfrac{\n  2\n}
+    # AND prevents formatting whitespace from JSON/XML from being converted to LaTeX spacing
+    # Preserve NBSP (\xa0) as it's semantically meaningful
+    result = re.sub(r'[\n\r\t]+', '', result)
+
+    # Collapse multiple consecutive regular spaces into one
+    # This prevents "         2       " → should be " 2 " or just "2"
+    # But don't collapse NBSP (\xa0) as it's semantically meaningful
+    result = re.sub(r' +', ' ', result)
+
+    # Strip leading/trailing spaces that come from XML formatting
+    # These are not semantically meaningful - they're just from pretty-printed XML
+    # True semantic spaces (like in operators) are preserved within the content
+    result = result.strip()
+
+    return result
+
+
+def decode_html_entities(text: str) -> str:
+    """Decode HTML entities in text, particularly &quot; from web page copies.
+
+    IMPORTANT: This function is designed for HTML content, NOT for XML/MathML!
+    DO NOT use this on XML/MathML strings before XML parsing, as it will break
+    valid XML numeric character references like &#x003C; which XML parsers
+    handle natively.
+
+    Args:
+        text: Text possibly containing HTML entities
+
+    Returns:
+        Text with HTML named entities decoded (numeric entities preserved for XML)
+
+    Example:
+        >>> decode_html_entities('&lt;math&gt; &amp; &quot;test&quot;')
+        '<math> & "test"'
+        >>> decode_html_entities('<mo>&#x003C;</mo>')  # Preserves numeric entities
+        '<mo>&#x003C;</mo>'
+    """
+    # CRITICAL FIX: Do NOT use html.unescape() on XML/MathML content!
+    # html.unescape() decodes numeric character references like &#x003C; to <
+    # which breaks XML parsing when < is inside element content.
+    #
+    # Instead, only decode common HTML named entities that might appear
+    # in web page copies, and leave numeric entities for XML parser to handle.
+
+    # Handle specific named entities that might appear in HTML copies
+    # but preserve numeric entities (&#x...;, &#...;) for XML parsing
+    entity_map = {
+        '&quot;': '"',
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&apos;': "'",
+        '&nbsp;': '\xa0',  # Non-breaking space
+    }
+
+    for entity, char in entity_map.items():
+        text = text.replace(entity, char)
+
+    return text
+
+
+def extract_math_equations(text: str) -> List[str]:
+    """Extract multiple MathML equations from text starting with <math tag.
+
+    Args:
+        text: Text possibly containing one or more MathML equations
+
+    Returns:
+        List of MathML equation strings (empty list if none found)
+
+    Example:
+        >>> text = '<math><mi>x</mi></math> and <math><mi>y</mi></math>'
+        >>> equations = extract_math_equations(text)
+        >>> len(equations)
+        2
+    """
+    # CRITICAL FIX: Do NOT decode HTML entities before regex extraction!
+    # The input is XML/MathML which contains numeric character references
+    # like &#x003C; that are valid XML and must be preserved.
+    # XML parsers (lxml) will handle entity decoding automatically.
+    # Decoding them here would break valid XML like <mo>&#x003C;</mo> → <mo><</mo>
+    #
+    # Original line (REMOVED): text = decode_html_entities(text)
+
+    equations = []
+
+    # Find all <math> tags with their content
+    # Use a more robust regex that handles nested tags and various formatting
+    pattern = r'<math[^>]*>.*?</math>'
+    matches = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
+
+    for match in matches:
+        # Clean up the equation
+        equation = match.strip()
+        if equation:
+            # Decode HTML entities in the extracted equation
+            # This handles cases like &quot; → " which are needed for valid XML
+            equation = decode_html_entities(equation)
+            equations.append(equation)
+
+    # If no <math> tags found, check if the entire input is a single equation
+    if not equations and text.strip().startswith('<math'):
+        # Try to find the end of the math tag
+        text = text.strip()
+        # Simple case: if it looks like a complete math equation
+        if '</math>' in text.lower():
+            # Decode HTML entities before appending
+            text = decode_html_entities(text)
+            equations.append(text)
+        else:
+            # Try to fix incomplete equation by adding closing tag
+            if not text.lower().endswith('</math>'):
+                text += '</math>'
+            # Decode HTML entities before appending
+            text = decode_html_entities(text)
+            equations.append(text)
+
+    return equations
+
+
+# Alias for backward compatibility (some code uses _local, some uses local_name)
+_local = local_name
+_text_content = text_content
diff --git a/scripts/omml_mathml2latex/visitors/__init__.py b/scripts/omml_mathml2latex/visitors/__init__.py
new file mode 100644
index 0000000..5946fce
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/__init__.py
@@ -0,0 +1,74 @@
+"""
+Visitor implementations for MathML elements.
+
+This package contains visitor classes that handle conversion of specific
+MathML element types to LaTeX format.
+"""
+
+from .visitor_registry import VisitorRegistry
+from .mi_visitor import MiVisitor
+from .mo_visitor import MoVisitor
+from .mn_visitor import MnVisitor
+from .mfrac_visitor import MfracVisitor
+from .msup_visitor import MsupVisitor
+from .msub_visitor import MsubVisitor
+from .mrow_visitor import MrowVisitor
+from .msqrt_visitor import MsqrtVisitor
+from .mroot_visitor import MrootVisitor
+from .msubsup_visitor import MsubsupVisitor
+from .mover_visitor import MoverVisitor
+from .munder_visitor import MunderVisitor
+from .munderover_visitor import MunderoverVisitor
+from .mfenced_visitor import MfencedVisitor
+from .mtext_visitor import MtextVisitor
+from .mtable_visitor import MtableVisitor
+from .mtr_visitor import MtrVisitor
+from .mtd_visitor import MtdVisitor
+from .mspace_visitor import MspaceVisitor
+from .mstyle_visitor import MstyleVisitor
+from .merror_visitor import MerrorVisitor
+from .menclose_visitor import MencloseVisitor
+from .mmultiscripts_visitor import MmultiscriptsVisitor
+from .mpadded_visitor import MpaddedVisitor
+from .mphantom_visitor import MphantomVisitor
+from .maction_visitor import MactionVisitor
+from .ms_visitor import MsVisitor
+from .mglyph_visitor import MglyphVisitor
+from .mlabeledtr_visitor import MlabeledtrVisitor
+from .maligngroup_visitor import MaligngroupVisitor
+from .malignmark_visitor import MalignmarkVisitor
+
+__all__ = [
+    'VisitorRegistry',
+    'MiVisitor',
+    'MoVisitor',
+    'MnVisitor',
+    'MfracVisitor',
+    'MsupVisitor',
+    'MsubVisitor',
+    'MrowVisitor',
+    'MsqrtVisitor',
+    'MrootVisitor',
+    'MsubsupVisitor',
+    'MoverVisitor',
+    'MunderVisitor',
+    'MunderoverVisitor',
+    'MfencedVisitor',
+    'MtextVisitor',
+    'MtableVisitor',
+    'MtrVisitor',
+    'MtdVisitor',
+    'MspaceVisitor',
+    'MstyleVisitor',
+    'MerrorVisitor',
+    'MencloseVisitor',
+    'MmultiscriptsVisitor',
+    'MpaddedVisitor',
+    'MphantomVisitor',
+    'MactionVisitor',
+    'MsVisitor',
+    'MglyphVisitor',
+    'MlabeledtrVisitor',
+    'MaligngroupVisitor',
+    'MalignmarkVisitor',
+]
diff --git a/scripts/omml_mathml2latex/visitors/_convert_child_template.py b/scripts/omml_mathml2latex/visitors/_convert_child_template.py
new file mode 100644
index 0000000..8734598
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/_convert_child_template.py
@@ -0,0 +1,137 @@
+"""
+Template for standardized _convert_child() method.
+
+This provides a complete, comprehensive _convert_child implementation that all visitors can use.
+It handles all MathML element types and provides proper warnings for unknown elements.
+"""
+
+from lxml import etree as ET
+from ..utils import text_content as _text_content, local_name as _local
+
+
+def convert_child_standard(child: ET.Element, strategy, visitor_name: str = "unknown") -> str:
+    """
+    Standard _convert_child implementation for all visitors.
+
+    Args:
+        child: The child element to convert
+        strategy: The conversion strategy to use
+        visitor_name: Name of the calling visitor (for debug messages)
+
+    Returns:
+        LaTeX string representation of the child element
+    """
+    tag = _local(child.tag)
+
+    # Token elements (leaf nodes)
+    if tag == 'mi':
+        from .mi_visitor import MiVisitor
+        return MiVisitor(strategy).visit(child)
+    elif tag == 'mo':
+        from .mo_visitor import MoVisitor
+        return MoVisitor(strategy).visit(child)
+    elif tag == 'mn':
+        from .mn_visitor import MnVisitor
+        return MnVisitor(strategy).visit(child)
+    elif tag == 'mtext':
+        from .mtext_visitor import MtextVisitor
+        return MtextVisitor(strategy).visit(child)
+    elif tag == 'ms':
+        from .ms_visitor import MsVisitor
+        return MsVisitor(strategy).visit(child)
+
+    # Layout elements (structural)
+    elif tag == 'mrow':
+        from .mrow_visitor import MrowVisitor
+        return MrowVisitor(strategy).visit(child)
+    elif tag == 'mfrac':
+        from .mfrac_visitor import MfracVisitor
+        return MfracVisitor(strategy).visit(child)
+    elif tag == 'msqrt':
+        from .msqrt_visitor import MsqrtVisitor
+        return MsqrtVisitor(strategy).visit(child)
+    elif tag == 'mroot':
+        from .mroot_visitor import MrootVisitor
+        return MrootVisitor(strategy).visit(child)
+    elif tag == 'mfenced':
+        from .mfenced_visitor import MfencedVisitor
+        return MfencedVisitor(strategy).visit(child)
+
+    # Script and limit elements
+    elif tag == 'msub':
+        from .msub_visitor import MsubVisitor
+        return MsubVisitor(strategy).visit(child)
+    elif tag == 'msup':
+        from .msup_visitor import MsupVisitor
+        return MsupVisitor(strategy).visit(child)
+    elif tag == 'msubsup':
+        from .msubsup_visitor import MsubsupVisitor
+        return MsubsupVisitor(strategy).visit(child)
+    elif tag == 'munder':
+        from .munder_visitor import MunderVisitor
+        return MunderVisitor(strategy).visit(child)
+    elif tag == 'mover':
+        from .mover_visitor import MoverVisitor
+        return MoverVisitor(strategy).visit(child)
+    elif tag == 'munderover':
+        from .munderover_visitor import MunderoverVisitor
+        return MunderoverVisitor(strategy).visit(child)
+    elif tag == 'mmultiscripts':
+        from .mmultiscripts_visitor import MmultiscriptsVisitor
+        return MmultiscriptsVisitor(strategy).visit(child)
+
+    # Table elements
+    elif tag == 'mtable':
+        from .mtable_visitor import MtableVisitor
+        return MtableVisitor(strategy).visit(child)
+    elif tag == 'mtr':
+        from .mtr_visitor import MtrVisitor
+        return MtrVisitor(strategy).visit(child)
+    elif tag == 'mtd':
+        from .mtd_visitor import MtdVisitor
+        return MtdVisitor(strategy).visit(child)
+    elif tag == 'mlabeledtr':
+        from .mlabeledtr_visitor import MlabeledtrVisitor
+        return MlabeledtrVisitor(strategy).visit(child)
+    elif tag == 'maligngroup':
+        from .maligngroup_visitor import MaligngroupVisitor
+        return MaligngroupVisitor(strategy).visit(child)
+    elif tag == 'malignmark':
+        from .malignmark_visitor import MalignmarkVisitor
+        return MalignmarkVisitor(strategy).visit(child)
+
+    # Style and presentation elements
+    elif tag == 'mstyle':
+        from .mstyle_visitor import MstyleVisitor
+        return MstyleVisitor(strategy).visit(child)
+    elif tag == 'merror':
+        from .merror_visitor import MerrorVisitor
+        return MerrorVisitor(strategy).visit(child)
+    elif tag == 'mpadded':
+        from .mpadded_visitor import MpaddedVisitor
+        return MpaddedVisitor(strategy).visit(child)
+    elif tag == 'mphantom':
+        from .mphantom_visitor import MphantomVisitor
+        return MphantomVisitor(strategy).visit(child)
+    elif tag == 'menclose':
+        from .menclose_visitor import MencloseVisitor
+        return MencloseVisitor(strategy).visit(child)
+    elif tag == 'mspace':
+        from .mspace_visitor import MspaceVisitor
+        return MspaceVisitor(strategy).visit(child)
+
+    # Action elements
+    elif tag == 'maction':
+        from .maction_visitor import MactionVisitor
+        return MactionVisitor(strategy).visit(child)
+
+    # Glyph elements
+    elif tag == 'mglyph':
+        from .mglyph_visitor import MglyphVisitor
+        return MglyphVisitor(strategy).visit(child)
+
+    else:
+        # Fallback for unknown elements
+        import sys
+        print(f"[WARNING] Unknown element <{tag}> in {visitor_name}, using text fallback", file=sys.stderr)
+        return _text_content(child)
diff --git a/scripts/omml_mathml2latex/visitors/maction_visitor.py b/scripts/omml_mathml2latex/visitors/maction_visitor.py
new file mode 100644
index 0000000..bfae15f
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/maction_visitor.py
@@ -0,0 +1,215 @@
+r"""
+Visitor for <maction> (action/interactive) MathML elements.
+
+The <maction> element binds actions (like tooltips, highlighting, or toggling)
+to mathematical expressions. It typically has an actiontype attribute that
+specifies the kind of action.
+
+In LaTeX conversion, maction is treated as a transparent wrapper since LaTeX
+is a static typesetting system without interactive capabilities. Only the
+selected child (typically the first) is converted.
+
+Common action types:
+- toggle: Toggle between alternative expressions
+- statusline: Display expression in status line
+- tooltip: Show tooltip on hover
+- highlight: Highlight on mouseover
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MactionVisitor(Visitor):
+    r"""
+    Handles <maction> (action/interactive) MathML elements.
+
+    Treats maction as a transparent wrapper, converting only the selected
+    child (typically the first one) since LaTeX doesn't support interactivity.
+
+    Examples:
+        Toggle action (shows first alternative):
+            <maction actiontype="toggle">
+                <mi>x</mi>
+                <mi>y</mi>
+            </maction>
+            → x
+
+        Tooltip action (shows content, ignores tooltip):
+            <maction actiontype="tooltip">
+                <mi>a</mi>
+                <mtext>variable a</mtext>
+            </maction>
+            → a
+
+        Highlight action (shows content without highlight):
+            <maction actiontype="highlight">
+                <mfrac><mi>a</mi><mi>b</mi></mfrac>
+            </maction>
+            → \frac{a}{b}
+
+        Selection attribute (selects specific child):
+            <maction actiontype="toggle" selection="2">
+                <mi>x</mi>
+                <mi>y</mi>
+                <mi>z</mi>
+            </maction>
+            → y (second child, 1-indexed)
+
+    Note:
+        LaTeX has no interactive capabilities, so:
+        - Only one child is rendered (the selected one)
+        - Action types are ignored
+        - Default: first child is selected
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Maction visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <maction> element to LaTeX (renders selected child only).
+
+        Args:
+            node: The <maction> element to convert
+
+        Returns:
+            LaTeX string with selected child converted
+
+        Raises:
+            ValueError: If node is not a <maction> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MactionVisitor cannot handle element '{node.tag}'")
+
+        # Get selection attribute (1-indexed, defaults to 1)
+        selection = node.get("selection", "1")
+        try:
+            selection_idx = int(selection) - 1  # Convert to 0-indexed
+        except ValueError:
+            selection_idx = 0  # Default to first child if invalid
+
+        # Get children
+        children = list(node)
+        if not children:
+            return ""
+
+        # Ensure selection is within bounds
+        if selection_idx < 0 or selection_idx >= len(children):
+            selection_idx = 0
+
+        # Convert only the selected child
+        return self._convert_child(children[selection_idx])
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in maction, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'maction'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'maction'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MactionVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/maligngroup_visitor.py b/scripts/omml_mathml2latex/visitors/maligngroup_visitor.py
new file mode 100644
index 0000000..0692464
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/maligngroup_visitor.py
@@ -0,0 +1,88 @@
+r"""
+Visitor for <maligngroup> (alignment group marker) MathML elements.
+
+The <maligngroup/> element is an empty element used within table cells (<mtd>)
+to mark alignment groups. It's used to control horizontal alignment across
+table columns for complex multi-line expressions.
+
+In LaTeX conversion, alignment groups are handled implicitly by the array/matrix
+environment's column specifications (e.g., {lll} for left-aligned columns).
+Therefore, maligngroup markers are treated as transparent (no output).
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MaligngroupVisitor(Visitor):
+    r"""
+    Handles <maligngroup/> (alignment group marker) MathML elements.
+
+    Treats maligngroup as an invisible marker since LaTeX handles alignment
+    through column specifications in array/matrix environments. The element
+    is completely ignored in conversion.
+
+    Examples:
+        Alignment group in cell:
+            <mtd>
+                <maligngroup/>
+                <mi>x</mi>
+            </mtd>
+            → x (maligngroup ignored)
+
+        Multiple alignment groups:
+            <mtd>
+                <maligngroup groupalign="left"/>
+                <mi>a</mi>
+                <maligngroup groupalign="right"/>
+                <mi>b</mi>
+            </mtd>
+            → a b (both maligngroup markers ignored)
+
+        Group with alignment attribute:
+            <maligngroup groupalign="center"/>
+            → (empty - no output)
+
+    Note:
+        LaTeX doesn't support MathML's alignment group concept. Alignment
+        is controlled by column specifications in the array/matrix preamble
+        (e.g., {ccc} for center-aligned, {lll} for left-aligned).
+        Therefore, maligngroup elements produce no output.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Maligngroup visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <maligngroup/> element (returns empty string).
+
+        Args:
+            node: The <maligngroup/> element to convert
+
+        Returns:
+            Empty string (maligngroup is invisible in LaTeX)
+
+        Raises:
+            ValueError: If node is not a <maligngroup/> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MaligngroupVisitor cannot handle element '{node.tag}'")
+
+        # Maligngroup is an invisible alignment marker - no output
+        return ""
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'maligngroup'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'maligngroup'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MaligngroupVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/malignmark_visitor.py b/scripts/omml_mathml2latex/visitors/malignmark_visitor.py
new file mode 100644
index 0000000..6ed8b5d
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/malignmark_visitor.py
@@ -0,0 +1,92 @@
+r"""
+Visitor for <malignmark> (alignment point marker) MathML elements.
+
+The <malignmark/> element is an empty element used within table cells (<mtd>)
+to mark specific alignment points for fine-grained horizontal alignment control.
+It differs from <maligngroup/> in that it marks a specific point within content
+rather than grouping alignment zones.
+
+In LaTeX conversion, alignment points are handled implicitly by the array/matrix
+environment's column specifications and & separators. Therefore, malignmark
+markers are treated as transparent (no output).
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MalignmarkVisitor(Visitor):
+    r"""
+    Handles <malignmark/> (alignment point marker) MathML elements.
+
+    Treats malignmark as an invisible marker since LaTeX handles alignment
+    through column specifications and & separators in array/matrix environments.
+    The element is completely ignored in conversion.
+
+    Examples:
+        Alignment point in cell:
+            <mtd>
+                <mi>x</mi>
+                <malignmark/>
+                <mo>=</mo>
+                <mn>5</mn>
+            </mtd>
+            → x = 5 (malignmark ignored)
+
+        Multiple alignment marks:
+            <mtd>
+                <malignmark edge="left"/>
+                <mi>a</mi>
+                <malignmark edge="right"/>
+                <mi>b</mi>
+            </mtd>
+            → a b (both malignmark markers ignored)
+
+        Mark with edge attribute:
+            <malignmark edge="center"/>
+            → (empty - no output)
+
+    Note:
+        LaTeX doesn't support MathML's alignment mark concept. Alignment
+        is controlled by column specifications in the array/matrix preamble
+        (e.g., {ccc} for center-aligned, {lll} for left-aligned) and by
+        & separators between cells. Therefore, malignmark elements produce
+        no output.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Malignmark visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <malignmark/> element (returns empty string).
+
+        Args:
+            node: The <malignmark/> element to convert
+
+        Returns:
+            Empty string (malignmark is invisible in LaTeX)
+
+        Raises:
+            ValueError: If node is not a <malignmark/> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MalignmarkVisitor cannot handle element '{node.tag}'")
+
+        # Malignmark is an invisible alignment point marker - no output
+        return ""
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'malignmark'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'malignmark'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MalignmarkVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/menclose_visitor.py b/scripts/omml_mathml2latex/visitors/menclose_visitor.py
new file mode 100644
index 0000000..6cf75b3
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/menclose_visitor.py
@@ -0,0 +1,426 @@
+r"""
+Visitor for <menclose> (box/cancel notation) MathML elements.
+
+The <menclose> element is used to enclose mathematical content with
+various notations including boxes, circles, strike-throughs, and partial frames.
+
+This visitor handles notation attribute values like:
+- box: Full box around content
+- circle: Circle around content
+- horizontalstrike, verticalstrike: Strike-through lines
+- updiagonalstrike, downdiagonalstrike: Diagonal strike-through
+- top, bottom, left, right: Partial box sides
+- actuarial, longdiv, radical: Specialized notations
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MencloseVisitor(Visitor):
+    r"""
+    Handles <menclose> (box/cancel notation) MathML elements.
+
+    Converts various notation attributes to appropriate LaTeX commands.
+
+    Examples:
+        Box notation:
+            <menclose notation="box"><mi>x</mi></menclose>
+            → \boxed{x}
+
+        Horizontal strike:
+            <menclose notation="horizontalstrike"><mi>x</mi></menclose>
+            → \cancel{x}
+
+        Diagonal strike (up):
+            <menclose notation="updiagonalstrike"><mi>x</mi></menclose>
+            → \cancel{x}
+
+        Diagonal strike (down):
+            <menclose notation="downdiagonalstrike"><mi>x</mi></menclose>
+            → \bcancel{x}
+
+        Combined diagonal strikes:
+            <menclose notation="updiagonalstrike downdiagonalstrike"><mi>x</mi></menclose>
+            → \xcancel{x}
+
+        Top line only:
+            <menclose notation="top"><mi>x</mi></menclose>
+            → \overline{x}
+
+        Bottom line only:
+            <menclose notation="bottom"><mi>x</mi></menclose>
+            → \underline{x}
+
+        Left delimiter:
+            <menclose notation="left"><mi>x</mi></menclose>
+            → \left| x \right.
+
+        Right delimiter:
+            <menclose notation="right"><mi>x</mi></menclose>
+            → \left. x \right|
+
+        Circle notation:
+            <menclose notation="circle"><mi>x</mi></menclose>
+            → \circled{x}
+
+        Actuarial notation:
+            <menclose notation="actuarial"><mi>x</mi></menclose>
+            → \overline{\underline{x}}
+
+        Long division:
+            <menclose notation="longdiv"><mi>x</mi></menclose>
+            → \enclose{longdiv}{x}
+
+        Radical notation:
+            <menclose notation="radical"><mi>x</mi></menclose>
+            → \sqrt{x}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Menclose visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <menclose> element to LaTeX with appropriate notation.
+
+        Args:
+            node: The <menclose> element to convert
+
+        Returns:
+            LaTeX string with notation applied to content
+
+        Raises:
+            ValueError: If node is not a <menclose> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MencloseVisitor cannot handle element '{node.tag}'")
+
+        notation = node.get("notation", "box")
+
+        # Special case: box containing mfrac with underlined/overlined numerator (like chemical reaction conditions)
+        # Pattern: <menclose notation="box"><mfrac><munder>text<mo>‾</mo></munder><empty/></mfrac></menclose>
+        # Remove the box but preserve the fraction structure: \dfrac{\underline{text}}{}
+        # Also handles: <menclose notation="box"><mrow><mfrac>...</mfrac></mrow></menclose>
+        mfrac_node = None
+        if notation == "box" and len(node) == 1:
+            child = node[0]
+            child_tag = _local(child.tag)
+
+            # Direct mfrac child
+            if child_tag == "mfrac":
+                mfrac_node = child
+            # mfrac wrapped in mrow (Word often does this)
+            elif child_tag == "mrow" and len(child) == 1 and _local(child[0].tag) == "mfrac":
+                mfrac_node = child[0]
+
+        if mfrac_node is not None and len(mfrac_node) >= 2:
+            numerator_node = mfrac_node[0]
+            # Check if numerator contains underlined text (munder with line character)
+            if self._contains_underlined_text(numerator_node):
+                # Convert the fraction directly without the box
+                # This preserves the \dfrac structure with underlined numerator
+                return self._convert_child(mfrac_node)
+
+        content = self._convert_children(node)
+
+        # Skip boxing for assignment expressions
+        if notation == "box" and self._contains_assignment(content):
+            return content
+
+        # Parse notation (could be space-separated multi-value)
+        notations = notation.split()
+
+        # === COMBINED STRIKE NOTATIONS (check these FIRST) ===
+
+        # Combined diagonal strikes → \xcancel
+        if "updiagonalstrike" in notations and "downdiagonalstrike" in notations:
+            return f"\\xcancel{{{content}}}"
+
+        # Combined horizontal and vertical strikes → \cancel
+        if "horizontalstrike" in notations and "verticalstrike" in notations:
+            return f"\\cancel{{{content}}}"
+
+        # === SIDE-SPECIFIC NOTATIONS FOR PARTIAL BOXES ===
+
+        sides = [n for n in notations if n in ["top", "bottom", "left", "right"]]
+        side_count = len(sides)
+
+        # Single side visible
+        if side_count == 1:
+            side = sides[0]
+
+            if side == "top":
+                return f"\\overline{{{content}}}"
+            elif side == "bottom":
+                return f"\\underline{{{content}}}"
+            elif side == "left":
+                return f"\\left| {content} \\right."
+            elif side == "right":
+                return f"\\left. {content} \\right|"
+
+        # Full box (4 sides or explicit "box" notation)
+        elif "box" in notations or side_count == 4:
+            return f"\\boxed{{{content}}}"
+
+        # Partial box (2-3 sides)
+        elif side_count >= 2:
+            notation_str = " ".join(sides)
+            return f"\\enclose{{{notation_str}}}{{{content}}}"
+
+        # === INDIVIDUAL STRIKE NOTATIONS ===
+
+        if notation == "horizontalstrike":
+            return f"\\cancel{{{content}}}"
+
+        if notation == "verticalstrike":
+            return f"\\bcancel{{{content}}}"
+
+        if notation == "updiagonalstrike":
+            return f"\\cancel{{{content}}}"
+
+        if notation == "downdiagonalstrike":
+            return f"\\bcancel{{{content}}}"
+
+        # === OTHER NOTATIONS ===
+
+        if notation == "circle":
+            return f"\\circled{{{content}}}"
+
+        if notation == "roundedbox":
+            return f"\\boxed{{{content}}}"
+
+        if notation == "actuarial":
+            return f"\\overline{{\\underline{{{content}}}}}"
+
+        if notation == "longdiv":
+            return f"\\enclose{{longdiv}}{{{content}}}"
+
+        if notation == "radical":
+            return f"\\sqrt{{{content}}}"
+
+        # Default: just return content without notation
+        return content
+
+    def _convert_children(self, node: ET.Element) -> str:
+        """
+        Convert all child elements to LaTeX.
+
+        Args:
+            node: The <menclose> element
+
+        Returns:
+            LaTeX string with all children converted
+        """
+        parts = []
+        for child in node:
+            parts.append(self._convert_child(child))
+        return ''.join(parts).strip()
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in menclose, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _is_empty_denominator(self, node: ET.Element) -> bool:
+        """
+        Check if denominator node is empty (no content or only whitespace).
+
+        Args:
+            node: MathML denominator element to check
+
+        Returns:
+            True if denominator is empty
+        """
+        if node is None:
+            return True
+
+        tag = _local(node.tag)
+
+        # Empty <mo> tag
+        if tag == "mo":
+            text = node.text or ""
+            return text.strip() == ""
+
+        # Empty <mrow/> tag
+        if tag == "mrow":
+            # No children
+            if len(node) == 0:
+                return True
+            # Only whitespace <mo> child
+            if len(node) == 1 and _local(node[0].tag) == "mo":
+                mo_text = node[0].text or ""
+                return mo_text.strip() == ""
+
+        return False
+
+    def _contains_assignment(self, content: str) -> bool:
+        """
+        Check if content contains assignment operators.
+
+        Assignment expressions should not be boxed.
+        Note: We only skip boxing for explicit assignment operators like :=
+        NOT for regular equality = which is often used in boxed theorems.
+
+        Args:
+            content: LaTeX content to check
+
+        Returns:
+            True if content contains assignment operators
+        """
+        # Only specific assignment operators - NOT plain = which appears in boxed theorems
+        assignment_ops = [":=", ": =", "∶=", "∶ =", "≔", "\\coloneqq"]
+        return any(op in content for op in assignment_ops)
+
+    def _contains_underlined_text(self, node: ET.Element) -> bool:
+        """
+        Check if node contains underlined text (munder with line character)
+        OR overlined text (mover with line character).
+
+        This is used to detect chemical reaction conditions and malformed equals.
+
+        Args:
+            node: MathML element to check
+
+        Returns:
+            True if node contains underlined or overlined text
+        """
+        if node is None:
+            return False
+
+        tag = _local(node.tag)
+
+        # Check if this node itself is an underlined element (munder with line)
+        if tag == "munder" and len(node) > 1:
+            under_node = node[1]
+            if _local(under_node.tag) == "mo":
+                # Get text content
+                text = under_node.text or ""
+                if "‾" in text:  # Line character
+                    return True
+
+        # Check if this node is an overlined element (mover with line)
+        # This handles the "malformed equal" pattern where users put overline in fraction
+        if tag == "mover" and len(node) > 1:
+            over_node = node[1]
+            if _local(over_node.tag) == "mo":
+                # Get text content
+                text = over_node.text or ""
+                # Check for overline/bar characters
+                if text.strip() in ["¯", "‾", "―", "−", "⎺", "⎻", "-", "_"]:
+                    return True
+
+        # Recursively check children
+        for child in node:
+            if self._contains_underlined_text(child):
+                return True
+
+        return False
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'menclose'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'menclose'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MencloseVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/merror_visitor.py b/scripts/omml_mathml2latex/visitors/merror_visitor.py
new file mode 100644
index 0000000..b85af40
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/merror_visitor.py
@@ -0,0 +1,194 @@
+r"""
+Visitor for <merror> (error markup) MathML elements.
+
+The <merror> element is used to display error messages or invalid markup
+within mathematical expressions. It typically indicates a parsing error,
+invalid content, or unsupported features.
+
+This visitor wraps error content with visual indication using color or boxes.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MerrorVisitor(Visitor):
+    r"""
+    Handles <merror> (error markup) MathML elements.
+
+    Wraps error content with visual indication to highlight issues.
+
+    Examples:
+        Simple error:
+            <merror><mtext>Undefined</mtext></merror>
+            → \textcolor{red}{\text{Undefined}}
+
+        Error with expression:
+            <merror><mi>x</mi><mo>/</mo><mn>0</mn></merror>
+            → \textcolor{red}{x/0}
+
+        Empty error:
+            <merror></merror>
+            → \textcolor{red}{\text{Error}}
+
+        Nested content:
+            <merror><mfrac><mi>a</mi><mn>0</mn></mfrac></merror>
+            → \textcolor{red}{\frac{a}{0}}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Merror visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <merror> element to LaTeX with error indication.
+
+        Args:
+            node: The <merror> element to convert
+
+        Returns:
+            LaTeX string with error content wrapped in red color
+
+        Raises:
+            ValueError: If node is not an <merror> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MerrorVisitor cannot handle element '{node.tag}'")
+
+        # Convert all children
+        content = self._convert_children(node)
+
+        # If empty, use default error message
+        if not content or not content.strip():
+            content = "\\text{Error}"
+
+        # Wrap in red color to indicate error
+        return f"\\textcolor{{red}}{{{content}}}"
+
+    def _convert_children(self, node: ET.Element) -> str:
+        """
+        Convert all child elements to LaTeX.
+
+        Args:
+            node: The <merror> element
+
+        Returns:
+            LaTeX string with all children converted
+        """
+        parts = []
+        for child in node:
+            parts.append(self._convert_child(child))
+        return ''.join(parts).strip()
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in merror, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'merror'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'merror'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MerrorVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mfenced_visitor.py b/scripts/omml_mathml2latex/visitors/mfenced_visitor.py
new file mode 100644
index 0000000..8b5c4a7
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mfenced_visitor.py
@@ -0,0 +1,532 @@
+r"""
+Visitor for <mfenced> (fenced/delimited expressions) MathML elements.
+
+The <mfenced> element represents expressions enclosed by delimiters:
+- Auto-scaling parentheses: \left( ... \right)
+- Custom brackets: \left[ ... \right]
+- Custom braces: \left\{ ... \right\}
+- Cases environment: single left brace
+- Separators: commas, semicolons between elements
+
+This visitor handles delimiter scaling and separator insertion.
+"""
+
+from typing import Optional, List
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MfencedVisitor(Visitor):
+    r"""
+    Handles <mfenced> (fenced/delimited) MathML elements.
+
+    Converts fenced expressions to LaTeX with auto-scaling delimiters.
+
+    Examples:
+        Default parentheses:
+            <mfenced><mi>x</mi><mi>y</mi></mfenced> → \left(x,y\right)
+
+        Custom brackets:
+            <mfenced open="[" close="]"><mi>a</mi></mfenced> → \left[a\right]
+
+        Custom braces:
+            <mfenced open="{" close="}"><mi>x</mi></mfenced> → \left\{x\right\}
+
+        Angle brackets:
+            <mfenced open="⟨" close="⟩"><mi>v</mi></mfenced> → \left\langle v\right\rangle
+
+        Single left brace (piecewise/cases):
+            <mfenced open="{" close="">
+              <mtable>...</mtable>
+            </mfenced> → \left\{\begin{array}{...}...\end{array}\right.
+
+        Custom separator (semicolon):
+            <mfenced separators=";"><mi>a</mi><mi>b</mi></mfenced> → \left(a;b\right)
+
+        Multiple separators:
+            <mfenced separators="; "><mi>a</mi><mi>b</mi><mi>c</mi></mfenced>
+            → \left(a;b c\right)
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mfenced visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mfenced> element to LaTeX.
+
+        Args:
+            node: The <mfenced> element to convert
+
+        Returns:
+            LaTeX string with auto-scaling delimiters
+
+        Raises:
+            ValueError: If node is not an <mfenced> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MfencedVisitor cannot handle element '{node.tag}'")
+
+        # Get opening and closing delimiters (default: parentheses)
+        open_delim = node.get('open', '(')
+        close_delim = node.get('close', ')')
+
+        # Get separator (default: comma)
+        separators = node.get('separators', ',')
+
+        # Convert children
+        children = list(node)
+        if not children:
+            # Empty mfenced
+            left = self._get_left_delimiter(open_delim)
+            right = self._get_right_delimiter(close_delim)
+            return f"{left}{right}"
+
+        # NOTE: We NO LONGER use cases environment for better compatibility
+        # Instead, we use explicit \left\{ and \right. notation
+        # (Cases environment is not universally supported)
+
+        # Check if this is set notation: { pattern | condition }
+        if open_delim == '{' and close_delim == '}':
+            set_notation_result = self._try_convert_as_set_notation(node, children)
+            if set_notation_result:
+                return set_notation_result
+
+        # Check if this is an interval with nested mfenced for the closing delimiter
+        # Pattern: <mfenced open="(" close=""> ... <mfenced open="" close="]">
+        # This should merge into a single interval: \left( ... \right]
+        if self._is_split_interval(node, children, open_delim, close_delim):
+            return self._merge_split_interval(node, children, open_delim)
+
+        # Convert each child, tracking which are operators
+        converted_children = []
+        child_types = []
+        for child in children:
+            converted = self._convert_child(child)
+            converted_children.append(converted)
+            child_types.append(_local(child.tag))
+
+        # Determine if this is a continuous expression or a list
+        # If there are explicit separator operators (mo elements with separator chars),
+        # treat as continuous expression (join with spaces)
+        # Otherwise, use the separators attribute for list formatting
+        content = self._smart_join(converted_children, child_types, separators)
+
+        # Get LaTeX delimiters
+        left = self._get_left_delimiter(open_delim)
+        right = self._get_right_delimiter(close_delim)
+
+        return f"{left}{content}{right}"
+
+    def _try_convert_as_set_notation(self, node: ET.Element, children: List) -> Optional[str]:
+        r"""
+        Try to convert as set notation: { pattern | condition }.
+
+        Set notation has the pattern:
+        - { (x, y) | x+y < 2 }  →  \left\{ (x, y) \mid x+y < 2 \right\}
+        - { x | x > 0 }  →  \left\{ x \mid x > 0 \right\}
+
+        Detection heuristics:
+        1. First child (or first few children) form the "pattern" (variable/tuple)
+        2. There's a nested <mfenced open="|" close="|"> that's really a separator
+           OR there are exactly 2 distinct groups of children
+        3. Last children form the "condition"
+
+        Args:
+            node: The outer mfenced element with open="{" close="}"
+            children: List of child elements
+
+        Returns:
+            LaTeX string if this is set notation, None otherwise
+        """
+        if len(children) < 2:
+            return None
+
+        # Strategy 1: Look for nested mfenced with | delimiters
+        # If the second or third child is <mfenced open="|" close="|">,
+        # and there's content after it OR before it, treat as set notation
+        # BUT keep the |...| as absolute value brackets in the output
+        for i, child in enumerate(children):
+            if _local(child.tag) == 'mfenced':
+                child_open = child.get('open', '(')
+                child_close = child.get('close', ')')
+
+                if child_open == '|' and child_close == '|':
+                    # Found nested | delimiters
+                    # Check if there's content before this (the pattern) or after (condition)
+                    has_content_before = i >= 1
+                    has_content_after = i < len(children) - 1
+
+                    if has_content_before or has_content_after:
+                        # This looks like set notation!
+                        # Split into: pattern (before), |...|, and rest
+                        pattern_parts = children[:i]
+                        pipe_element = child  # The entire <mfenced open="|" close="|"> element
+                        condition_parts = children[i+1:]
+
+                        # Convert pattern
+                        pattern_latex = ' '.join(self._convert_child(c) for c in pattern_parts if c is not None)
+
+                        # Convert the |...| element as absolute value (keep the delimiters!)
+                        pipe_latex = self._convert_child(pipe_element)
+
+                        # Convert remaining condition
+                        condition_latex = ' '.join(self._convert_child(c) for c in condition_parts if c is not None)
+
+                        # Assemble: { pattern \mid |pipe_content| condition }
+                        parts = []
+                        if pattern_latex:
+                            parts.append(pattern_latex)
+                        parts.append('\\mid')
+                        if pipe_latex:
+                            parts.append(pipe_latex)
+                        if condition_latex:
+                            parts.append(condition_latex)
+
+                        content = ' '.join(parts)
+                        return f"\\left\\{{{content}\\right\\}}"
+
+        # Strategy 2: Check if there are exactly 2 "groups" of elements
+        # where the first group is a single identifier/tuple, suggesting { x | condition }
+        # This handles cases like { x x+1<2 } where x and x+1<2 should be separated by \mid
+        if len(children) >= 2:
+            first_child_type = _local(children[0].tag)
+
+            # If first child is a single identifier (mi) or a tuple (mfenced with parens)
+            if first_child_type in ['mi', 'mfenced']:
+                # Check if this looks like a pattern followed by a condition
+                # Heuristic: if first child is simple (mi or mfenced), and there are more elements,
+                # and those elements form an expression/condition, insert \mid
+
+                # For now, check if we have exactly these patterns:
+                # 1. First child is <mfenced open="(" close=")"> (tuple)
+                # 2. OR first child is <mi> (variable)
+                # 3. Rest form a condition
+
+                if first_child_type == 'mi':
+                    # Check if second element is also mi (likely the start of condition)
+                    if len(children) >= 2 and _local(children[1].tag) == 'mi':
+                        # Likely: { x x+1<2 } should be { x | x+1<2 }
+                        pattern_latex = self._convert_child(children[0])
+                        condition_latex = ' '.join(self._convert_child(c) for c in children[1:])
+                        return f"\\left\\{{{pattern_latex} \\mid {condition_latex}\\right\\}}"
+
+                elif first_child_type == 'mfenced':
+                    first_child_open = children[0].get('open', '(')
+                    first_child_close = children[0].get('close', ')')
+
+                    # Check if it's a tuple (parentheses)
+                    if first_child_open == '(' and first_child_close == ')':
+                        # Pattern: { (x,y) ... } - check if ... is a condition
+                        pattern_latex = self._convert_child(children[0])
+
+                        # Check if remaining children don't start with a comma
+                        # (which would indicate list notation, not set notation)
+                        if len(children) >= 2:
+                            second_type = _local(children[1].tag)
+                            if second_type != 'mo' or (second_type == 'mo' and _text_content(children[1]).strip() != ','):
+                                # Not a list, likely set notation
+                                condition_latex = ' '.join(self._convert_child(c) for c in children[1:])
+                                return f"\\left\\{{{pattern_latex} \\mid {condition_latex}\\right\\}}"
+
+        return None
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mfenced, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _smart_join(self, items: list, types: list, separators: str) -> str:
+        """
+        Intelligently join items based on whether they form a continuous expression.
+
+        Args:
+            items: Converted LaTeX strings
+            types: Element types (mi, mo, mn, etc.)
+            separators: Separator string from mfenced attribute
+
+        Returns:
+            Joined LaTeX string
+        """
+        if len(items) == 0:
+            return ''
+        if len(items) == 1:
+            return items[0]
+
+        # Check if this looks like a continuous expression:
+        # - Contains 'mo' (operator) elements
+        # - Separators not explicitly set (or default comma)
+        has_operators = 'mo' in types
+
+        if has_operators and separators == ',':
+            # Continuous expression: join with spaces, no extra separators
+            # Filter out empty items
+            return ' '.join(item for item in items if item)
+        else:
+            # List of items: use traditional separator insertion
+            return self._insert_separators(items, separators)
+
+    def _insert_separators(self, items: list, separators: str) -> str:
+        """Insert separators between items for list-style formatting."""
+        if len(items) == 0:
+            return ''
+        if len(items) == 1:
+            return items[0]
+
+        # Parse separator string
+        # If multiple characters, each is used for successive separators
+        # If fewer separators than gaps, last separator is reused
+        sep_list = list(separators) if separators else [',']
+
+        result = [items[0]]
+        for i, item in enumerate(items[1:], start=0):
+            # Get appropriate separator (reuse last if not enough)
+            sep_idx = min(i, len(sep_list) - 1)
+            separator = sep_list[sep_idx]
+            result.append(separator)
+            result.append(item)
+
+        return ''.join(result)
+
+    def _get_left_delimiter(self, delim: str) -> str:
+        """Map opening delimiter to LaTeX \\left command."""
+        delimiter_map = {
+            '(': '\\left(',
+            '[': '\\left[',
+            '{': '\\left\\{',
+            '⟨': '\\left\\langle',
+            '⌈': '\\left\\lceil',
+            '⌊': '\\left\\lfloor',
+            '|': '\\left|',
+            '‖': '\\left\\|',
+            '': '\\left.',  # Invisible left delimiter
+        }
+
+        return delimiter_map.get(delim, f'\\left{delim}')
+
+    def _get_right_delimiter(self, delim: str) -> str:
+        """Map closing delimiter to LaTeX \\right command."""
+        delimiter_map = {
+            ')': '\\right)',
+            ']': '\\right]',
+            '}': '\\right\\}',
+            '⟩': '\\right\\rangle',
+            '⌉': '\\right\\rceil',
+            '⌋': '\\right\\rfloor',
+            '|': '\\right|',
+            '‖': '\\right\\|',
+            '': '\\right.',  # Invisible right delimiter
+        }
+
+        return delimiter_map.get(delim, f'\\right{delim}')
+
+    def _is_split_interval(self, node: ET.Element, children: list, open_delim: str, close_delim: str) -> bool:
+        """
+        Detect if this is a split interval notation pattern.
+
+        Pattern: <mfenced open="(" close=""> ... <mfenced open="" close="]">
+        This represents an interval like (0, 1/4] split across two mfenced elements.
+
+        Also handles case where content is wrapped in mrow:
+        <mfenced open="(" close=""><mrow> ... <mfenced open="" close="]">...</mfenced></mrow></mfenced>
+
+        Returns True if:
+        1. Outer has opening delimiter but NO closing delimiter (close="")
+        2. Last child is <mfenced> with NO opening delimiter (open="") but HAS closing delimiter
+        3. There are other children before the last mfenced (the interval content)
+
+        Args:
+            node: The outer mfenced element
+            children: List of child elements
+            open_delim: Opening delimiter of outer mfenced
+            close_delim: Closing delimiter of outer mfenced
+
+        Returns:
+            True if this is a split interval pattern
+        """
+        # Check pattern: outer has open delim but no close delim
+        if not (open_delim in '([{' and close_delim == ''):
+            return False
+
+        # Handle case where content is wrapped in a single mrow
+        actual_children = children
+        if len(children) == 1 and _local(children[0].tag) == 'mrow':
+            actual_children = list(children[0])
+
+        # Need at least 2 children (content + nested mfenced)
+        if len(actual_children) < 2:
+            return False
+
+        # Check if last child is mfenced with complementary delimiters
+        last_child = actual_children[-1]
+        if _local(last_child.tag) != 'mfenced':
+            return False
+
+        # Last mfenced should have no open delimiter but have close delimiter
+        last_open = last_child.get('open', '(')
+        last_close = last_child.get('close', ')')
+
+        if last_open == '' and last_close in ')]}\u232A\u2309\u230B':  # Closing delimiters
+            return True
+
+        return False
+
+    def _merge_split_interval(self, node: ET.Element, children: list, open_delim: str) -> str:
+        """
+        Merge split interval into a single LaTeX interval.
+
+        Pattern: <mfenced open="(" close=""> <content> <mfenced open="" close="]">
+        Output: \\left( <content> \\right]
+
+        Also handles case where content is wrapped in mrow:
+        <mfenced open="(" close=""><mrow> ... <mfenced open="" close="]">...</mfenced></mrow></mfenced>
+
+        Args:
+            node: The outer mfenced element
+            children: List of child elements
+            open_delim: Opening delimiter (e.g., '(', '[')
+
+        Returns:
+            LaTeX string for merged interval
+        """
+        # Handle case where content is wrapped in a single mrow
+        actual_children = children
+        if len(children) == 1 and _local(children[0].tag) == 'mrow':
+            actual_children = list(children[0])
+
+        # Get the closing delimiter from the last child (which is the nested mfenced)
+        last_child = actual_children[-1]
+        close_delim = last_child.get('close', ')')
+
+        # Convert all children except the last (which is the nested mfenced)
+        content_children = actual_children[:-1]
+
+        # Also convert the CONTENT of the last mfenced (not the mfenced itself)
+        last_mfenced_children = list(last_child)
+
+        # Combine content from both outer and inner mfenced
+        all_content_children = content_children + last_mfenced_children
+
+        # Convert all content
+        converted_parts = []
+        for child in all_content_children:
+            part = self._convert_child(child)
+            if part:
+                converted_parts.append(part)
+
+        # Join with spaces (standard interval notation)
+        content = ' '.join(converted_parts)
+
+        # Build result with merged delimiters
+        left = self._get_left_delimiter(open_delim)
+        right = self._get_right_delimiter(close_delim)
+
+        return f"{left}{content}{right}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mfenced'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mfenced'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MfencedVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mfrac_visitor.py b/scripts/omml_mathml2latex/visitors/mfrac_visitor.py
new file mode 100644
index 0000000..8334fb3
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mfrac_visitor.py
@@ -0,0 +1,608 @@
+"""
+Visitor for <mfrac> (fraction) MathML elements.
+
+The <mfrac> element represents fractions in MathML:
+- Standard fractions: \\frac{numerator}{denominator}
+- Display fractions: \\dfrac{numerator}{denominator}
+- Bevelled fractions (line fractions): numerator/denominator
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..core.context import ConversionContext
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MfracVisitor(Visitor):
+    """
+    Handles <mfrac> (fraction) MathML elements.
+
+    This visitor converts fractions to LaTeX format using \\frac or \\dfrac
+    commands depending on context.
+
+    Examples:
+        Standard fraction:
+            <mfrac><mn>1</mn><mn>2</mn></mfrac> → \\dfrac{1}{2}
+
+        Algebraic fraction:
+            <mfrac><mi>x</mi><mi>y</mi></mfrac> → \\dfrac{x}{y}
+
+        Complex fraction:
+            <mfrac>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mrow><mi>y</mi><mo>-</mo><mn>1</mn></mrow>
+            </mfrac>
+            → \\dfrac{x + 1}{y - 1}
+
+        Bevelled fraction (bevelled="true"):
+            <mfrac bevelled="true"><mn>1</mn><mn>2</mn></mfrac> → 1/2
+
+        No-bar stacked fraction (linethickness="0"):
+            <mfrac linethickness="0"><mi>n</mi><mi>k</mi></mfrac> → \genfrac{}{}{0pt}{}{n}{k}
+
+    Note:
+        For full compatibility with the original converter, we need to:
+        1. Detect xlongequal pattern (special chemistry notation)
+        2. Handle script context (use \\frac in superscripts/subscripts)
+        3. Handle display style context (use \\dfrac in display mode)
+
+        Currently implements basic functionality. Advanced features TODO.
+    """
+
+    def __init__(self, strategy: Strategy, context: ConversionContext = None):
+        """
+        Initialize the Mfrac visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+            context: Shared conversion context for state tracking
+        """
+        super().__init__(strategy)
+        self.context = context
+        # We'll need a reference to the visitor registry to convert children
+        # This will be set by the conversion stage
+        self._visitor_registry = None
+
+    def set_visitor_registry(self, registry):
+        """
+        Set the visitor registry for converting child elements.
+
+        Args:
+            registry: The VisitorRegistry instance
+
+        Note:
+            This is called by the conversion stage to enable child conversion.
+        """
+        self._visitor_registry = registry
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <mfrac> element to LaTeX.
+
+        Args:
+            node: The <mfrac> element to convert
+
+        Returns:
+            LaTeX fraction string
+
+        Raises:
+            ValueError: If node is not an <mfrac> element
+            ValueError: If mfrac has fewer than 2 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MfracVisitor cannot handle element '{node.tag}'")
+
+        # mfrac should have exactly 2 children: numerator and denominator
+        children = list(node)
+        if len(children) < 2:
+            # Malformed mfrac - handle gracefully for MathJax compatibility
+            # \frac{} or \frac{x}{} should work; \frac without braces won't
+            if len(children) == 0:
+                return "\\dfrac{}{}"
+            elif len(children) == 1:
+                # Only numerator provided
+                numerator = self._convert_child(children[0])
+                return f"\\dfrac{{{numerator}}}{{}}"
+
+        # Check for xlongequal pattern with === in denominator FIRST (BUG-009 fix)
+        # This MUST come before linethickness check because noBar fractions
+        # with === in denominator should produce \xlongequal, not bevelled fraction
+        # Pattern: <mfrac linethickness="0"><text>高温</text><mo>===</mo></mfrac>
+        if self._is_xlongequal_with_equals_denominator(children):
+            # Extract text from numerator (goes in braces)
+            numerator = self._convert_child(children[0])
+            return f"\\xlongequal[\\quad]{{{numerator}}}"
+
+        # Check for xlongequal pattern WITH both upper and lower text
+        # Pattern: <mfrac><munder><text1><mo>‾</mo></munder><text2></mfrac>
+        # This represents \xlongequal[text2]{text1} (text above and below equals)
+        if self._is_xlongequal_with_both_texts(children):
+            # Extract text from numerator (goes in braces) and denominator (goes in brackets)
+            upper_text = self._extract_reaction_condition_text(children[0])
+            lower_text = self._convert_child(children[1])
+
+            # Strip any \mathrm{} or \text{} wrappers from both texts
+            # Note: The post-processing will handle space removal
+            lower_clean = self._strip_latex_wrappers(lower_text)
+            upper_clean = self._strip_latex_wrappers(upper_text)
+
+            return f"\\xlongequal[{lower_clean}]{{{upper_clean}}}"
+
+        # Check for xlongequal pattern (chemistry reaction condition)
+        # Pattern: <mfrac><munder><text><mo>‾</mo></munder><empty/></mfrac>
+        # This is Word's way of representing reaction conditions like "点燃" above an arrow
+        if self._is_chemical_reaction_condition(children):
+            # Extract the text from the underlined numerator
+            condition_text = self._extract_reaction_condition_text(children[0])
+            return f"\\xlongequal[\\quad]{{{condition_text}}}"
+
+        # Check for bevelled fraction (bevelled="true" attribute triggers inline fraction)
+        # Note: bevelled="true" means inline fraction with slash (a/b)
+        bevelled = node.get('bevelled')
+        if bevelled == 'true':
+            return self._convert_bevelled_fraction(children)
+
+        # Check for no-bar stacking (linethickness="0")
+        # Note: linethickness="0" means no-bar stacking (like binomial), NOT bevelled
+        # This is for binomial-style stacking without a fraction bar
+        linethickness = node.get('linethickness')
+        if linethickness == '0':
+            return self._convert_nobar_stack(children)
+
+        # Convert numerator and denominator
+        numerator = self._convert_child(children[0])
+        denominator = self._convert_child(children[1])
+
+        # Context-aware fraction command selection
+        # Priority: Script context > display style context > default
+        if self.context and self.context.in_script_context():
+            # Use \frac in script contexts (superscript/subscript) for proper sizing
+            frac_command = "\\frac"
+        elif self.context and self.context.display_style_context:
+            # Use \dfrac if in display style context (from mstyle)
+            frac_command = "\\dfrac"
+        else:
+            # Default to \dfrac for main equations
+            frac_command = "\\dfrac"
+
+        # Wrap in braces and return
+        return f"{frac_command}{self._brace(numerator)}{self._brace(denominator)}"
+
+    def _convert_bevelled_fraction(self, children: list) -> str:
+        """
+        Convert bevelled (inline) fraction.
+
+        Bevelled fractions display as numerator/denominator in a single line.
+        This is triggered by bevelled="true" attribute.
+
+        Note: This is different from linethickness="0" which produces stacking
+        without a fraction bar (like binomial coefficients).
+
+        Args:
+            children: List of child elements [numerator, denominator]
+
+        Returns:
+            LaTeX string with / separator
+
+        Examples:
+            1/2, x/y, (x+1)/(y-1)
+        """
+        numerator = self._convert_child(children[0])
+        denominator = self._convert_child(children[1])
+
+        # For bevelled fractions, use simple / separator
+        # May need parentheses for complex expressions
+        # TODO: Add intelligent parenthesization
+        return f"{numerator}/{denominator}"
+
+    def _convert_nobar_stack(self, children: list) -> str:
+        """
+        Convert no-bar stacked fraction (linethickness="0").
+
+        This is for stacking like binomial coefficients where numerator
+        is above denominator but without a fraction bar.
+
+        Args:
+            children: List of child elements [numerator, denominator]
+
+        Returns:
+            LaTeX string for stacked notation
+
+        Note:
+            We use \\begin{array}{c}...\\end{array} for proper stacking.
+            This is more user-friendly and widely understood than \\genfrac syntax.
+
+        Examples:
+            <mfrac linethickness="0"><mi>n</mi><mi>k</mi></mfrac>
+            → \\begin{array}{c} n \\\\ k \\end{array}
+        """
+        numerator = self._convert_child(children[0])
+        denominator = self._convert_child(children[1])
+
+        # Use array environment for proper no-bar stacking
+        # Format: \begin{array}{c} top \\ bottom \end{array}
+        # Center-aligned single column with line break between elements
+        # Note: No space after \\ to avoid it being converted to \~
+        return f"\\begin{{array}}{{c}} {numerator} \\\\\\\\{denominator} \\end{{array}}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """
+        Convert a child element to LaTeX.
+
+        Args:
+            child: The child element to convert
+
+        Returns:
+            LaTeX string
+
+        Note:
+            For now, we directly instantiate the appropriate visitor.
+            In the future, this should use the visitor registry.
+        """
+        from ..utils import local_name as _local
+        tag = _local(child.tag)
+
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            visitor = MiVisitor(self.strategy)
+            return visitor.visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            visitor = MoVisitor(self.strategy)
+            return visitor.visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            visitor = MnVisitor(self.strategy)
+            return visitor.visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback for unknown elements: return text content
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mfrac, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _brace(self, content: str) -> str:
+        """
+        Wrap content in braces if needed.
+
+        Args:
+            content: The content to wrap
+
+        Returns:
+            Content wrapped in braces
+
+        Note:
+            Always wraps in braces for fractions to ensure proper LaTeX parsing.
+        """
+        return f"{{{content}}}"
+
+    def _is_chemical_reaction_condition(self, children: list) -> bool:
+        """
+        Check if this fraction represents a chemical reaction condition.
+
+        Pattern: numerator is munder with underline OR mover with overline,
+        denominator is empty/whitespace
+
+        Args:
+            children: [numerator, denominator] child elements
+
+        Returns:
+            True if this is a chemical reaction condition pattern
+        """
+        if len(children) != 2:
+            return False
+
+        numerator = children[0]
+        denominator = children[1]
+
+        # Unwrap mrow if present (Word often wraps in mrow)
+        numerator_tag = _local(numerator.tag)
+        if numerator_tag == "mrow" and len(numerator) == 1:
+            numerator = numerator[0]
+            numerator_tag = _local(numerator.tag)
+
+        # Check if numerator is munder with underline OR mover with overline
+        if numerator_tag in ("munder", "mover") and len(numerator) >= 2:
+            line_node = numerator[1]  # Second child is the line (under or over)
+            if _local(line_node.tag) == "mo":
+                text = line_node.text or ""
+                # Check for line character (same character used for both over and under)
+                if "‾" in text or text.strip() in ["¯", "―", "−", "_", "-"]:
+                    # Check if denominator is empty
+                    denom_tag = _local(denominator.tag)
+
+                    # Empty <mo> tag
+                    if denom_tag == "mo":
+                        denom_text = denominator.text or ""
+                        if denom_text.strip() == "":
+                            return True
+
+                    # Empty <mrow/> tag
+                    elif denom_tag == "mrow":
+                        # Check if mrow has no children or only whitespace
+                        if len(denominator) == 0:
+                            return True
+                        # Check if mrow has only whitespace text nodes
+                        if len(denominator) == 1 and _local(denominator[0].tag) == "mo":
+                            mo_text = denominator[0].text or ""
+                            if mo_text.strip() == "":
+                                return True
+
+        return False
+
+    def _extract_reaction_condition_text(self, numerator_node: ET.Element) -> str:
+        """
+        Extract text from underlined/overlined numerator for reaction condition.
+
+        Args:
+            numerator_node: The munder or mover element (or mrow wrapping it) containing the condition text
+
+        Returns:
+            LaTeX content with user-specified formatting preserved (e.g., \\mathbf{})
+            but subject-determined formatting removed (e.g., \\mathrm{})
+        """
+        numerator_tag = _local(numerator_node.tag)
+
+        # Unwrap mrow if present
+        if numerator_tag == "mrow" and len(numerator_node) == 1:
+            numerator_node = numerator_node[0]
+            numerator_tag = _local(numerator_node.tag)
+
+        # Handle both munder and mover
+        if numerator_tag not in ("munder", "mover"):
+            return ""
+
+        # The first child contains the actual content (same for both munder and mover)
+        if len(numerator_node) > 0:
+            content_node = numerator_node[0]
+
+            # Convert to LaTeX, preserving user-specified formatting (like \mathbf{})
+            content = self._convert_child(content_node)
+
+            # Only strip subject-determined formatting (\mathrm{} for chemistry mode)
+            # Preserve user-specified formatting like \mathbf{}, \textbf{}, \textit{}, etc.
+            if content.startswith("\\mathrm{") and content.endswith("}"):
+                content = content[8:-1]  # Remove \mathrm{ and }
+            # Strip \text{} wrapper if present
+            elif content.startswith("\\text{") and content.endswith("}"):
+                content = content[6:-1]  # Remove \text{ and }
+
+            # Clean up extra spaces
+            return content.strip()
+
+        return ""
+
+    def _is_xlongequal_with_equals_denominator(self, children: list) -> bool:
+        """
+        Check if this fraction represents xlongequal with === in denominator.
+
+        Pattern: numerator has content, denominator contains only consecutive equals signs
+        This pattern is used in chemistry for reaction arrows with conditions above.
+
+        Args:
+            children: [numerator, denominator] child elements
+
+        Returns:
+            True if denominator contains only === (or ==, ====, etc.)
+
+        Examples:
+            <mfrac>
+                <mi>高温</mi>
+                <mo>===</mo>
+            </mfrac>
+            → \\xlongequal[\\quad]{高温}
+
+            <mfrac>
+                <mtext>heat</mtext>
+                <mo>==</mo>
+            </mfrac>
+            → \\xlongequal[\\quad]{heat}
+        """
+        if len(children) != 2:
+            return False
+
+        numerator = children[0]
+        denominator = children[1]
+
+        # Get text content from denominator
+        denom_text = _text_content(denominator).strip()
+
+        # Check if denominator contains only equals signs (2 or more)
+        # Pattern: ==, ===, ====, = = =, etc. (with or without spaces)
+        import re
+        # Remove all spaces to check if it's only equals signs
+        denom_text_no_spaces = denom_text.replace(' ', '')
+        if denom_text_no_spaces and re.match(r'^=+$', denom_text_no_spaces) and len(denom_text_no_spaces) >= 2:
+            # Check if numerator has actual content
+            num_text = _text_content(numerator).strip()
+            if num_text and num_text != "":
+                return True
+
+        return False
+
+    def _is_xlongequal_with_both_texts(self, children: list) -> bool:
+        """
+        Check if this fraction represents xlongequal with both upper and lower text.
+
+        Pattern: numerator is munder with underline OR mover with overline,
+        denominator has actual content
+
+        Args:
+            children: [numerator, denominator] child elements
+
+        Returns:
+            True if this is xlongequal with both texts pattern
+
+        Examples:
+            <mfrac>
+                <munder><mi>abc</mi><mo>‾</mo></munder>
+                <mi>defg</mi>
+            </mfrac>
+            → \\xlongequal[defg]{abc}
+
+            <mfrac>
+                <mover><mi>abc</mi><mo>‾</mo></mover>
+                <mi>defg</mi>
+            </mfrac>
+            → \\xlongequal[defg]{abc}
+
+            <mfrac>
+                <mrow><mover><mrow><mi>abc</mi></mrow><mo>‾</mo></mover></mrow>
+                <mrow><mi>defg</mi></mrow>
+            </mfrac>
+            → \\xlongequal[defg]{abc}
+        """
+        if len(children) != 2:
+            return False
+
+        numerator = children[0]
+        denominator = children[1]
+
+        # Unwrap mrow if present (Word often wraps in mrow)
+        numerator_tag = _local(numerator.tag)
+        if numerator_tag == "mrow" and len(numerator) == 1:
+            numerator = numerator[0]
+            numerator_tag = _local(numerator.tag)
+
+        # Check if numerator is munder with underline OR mover with overline
+        if numerator_tag in ("munder", "mover") and len(numerator) >= 2:
+            line_node = numerator[1]  # Second child is the line (under or over)
+            if _local(line_node.tag) == "mo":
+                text = line_node.text or ""
+                # Check for line character (same character used for both over and under)
+                if "‾" in text or text.strip() in ["¯", "―", "−", "_", "-"]:
+                    # Check if denominator is NOT empty (has actual content)
+                    denom_text = _text_content(denominator).strip()
+                    if denom_text and denom_text != "":
+                        return True
+
+        return False
+
+    def _strip_latex_wrappers(self, latex: str) -> str:
+        """
+        Strip LaTeX wrapper commands like \\mathrm{}, \\text{}, etc.
+
+        Args:
+            latex: LaTeX string that might have wrappers
+
+        Returns:
+            Clean text without wrappers
+
+        Examples:
+            \\mathrm{abc} → abc
+            \\text{hello} → hello
+            \\mathrm{d e f g} → d e f g (spaces preserved)
+        """
+        latex = latex.strip()
+
+        # Strip \mathrm{} wrapper
+        if latex.startswith("\\mathrm{") and latex.endswith("}"):
+            latex = latex[8:-1]
+
+        # Strip \text{} wrapper
+        if latex.startswith("\\text{") and latex.endswith("}"):
+            latex = latex[6:-1]
+
+        # Strip \mathbf{} wrapper
+        if latex.startswith("\\mathbf{") and latex.endswith("}"):
+            latex = latex[8:-1]
+
+        return latex.strip()
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """
+        Check if this visitor can handle the given node.
+
+        Args:
+            node: The MathML element to check
+
+        Returns:
+            True if node is an <mfrac> element, False otherwise
+        """
+        return _local(node.tag) == 'mfrac'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mfrac'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MfracVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mglyph_visitor.py b/scripts/omml_mathml2latex/visitors/mglyph_visitor.py
new file mode 100644
index 0000000..dee1e62
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mglyph_visitor.py
@@ -0,0 +1,105 @@
+r"""
+Visitor for <mglyph> (custom glyph) MathML elements.
+
+The <mglyph> element is used to display non-standard symbols or images
+within mathematical expressions. It references external images via the
+'src' attribute or font glyphs via 'fontfamily' and 'index' attributes.
+
+In LaTeX conversion, mglyph is converted to text representations or
+fallback Unicode characters when available. For image-based glyphs,
+alt text is used if provided.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local, text_content as _text_content
+
+
+class MglyphVisitor(Visitor):
+    r"""
+    Handles <mglyph> (custom glyph) MathML elements.
+
+    Converts custom glyphs to LaTeX text or fallback Unicode. Since LaTeX
+    doesn't support arbitrary image references, we use alt text or text
+    content as fallback.
+
+    Examples:
+        Glyph with alt text:
+            <mglyph src="myGlyph.png" alt="custom symbol"/>
+            → \text{custom symbol}
+
+        Glyph with font reference:
+            <mglyph fontfamily="MyFont" index="42" alt="α"/>
+            → \text{α}
+
+        Glyph without alt (uses src filename):
+            <mglyph src="alpha.png"/>
+            → \text{alpha}
+
+        Glyph with width/height (ignored in LaTeX):
+            <mglyph src="beta.png" width="2em" height="2em" alt="β"/>
+            → \text{β}
+
+    Note:
+        LaTeX doesn't support external image references in math mode,
+        so we convert to text representations using alt attribute or
+        derive from src filename.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mglyph visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mglyph> element to LaTeX text.
+
+        Args:
+            node: The <mglyph> element to convert
+
+        Returns:
+            LaTeX string with \text{...} fallback
+
+        Raises:
+            ValueError: If node is not a <mglyph> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MglyphVisitor cannot handle element '{node.tag}'")
+
+        # Try to get alt text (primary fallback)
+        alt_text = node.get("alt", "")
+
+        if alt_text:
+            # Use alt text if provided
+            return f"\\text{{{alt_text}}}"
+
+        # Fallback: try to derive from src attribute
+        src = node.get("src", "")
+        if src:
+            # Extract filename without extension as fallback
+            import os
+            filename = os.path.splitext(os.path.basename(src))[0]
+            if filename:
+                return f"\\text{{{filename}}}"
+
+        # Last resort: fontfamily reference or empty
+        fontfamily = node.get("fontfamily", "")
+        if fontfamily:
+            # Can't do much with font references in LaTeX
+            return f"\\text{{{fontfamily}}}"
+
+        # Completely empty - render as empty
+        return ""
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mglyph'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mglyph'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MglyphVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mi_visitor.py b/scripts/omml_mathml2latex/visitors/mi_visitor.py
new file mode 100644
index 0000000..b52878b
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mi_visitor.py
@@ -0,0 +1,772 @@
+"""
+Visitor for <mi> (identifier) MathML elements.
+
+The <mi> element represents identifiers in MathML, including:
+- Mathematical functions (sin, cos, log)
+- Variables (x, y, z)
+- Constants (e, π)
+- Multi-letter identifiers (velocity, pressure)
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, convert_spaces_to_latex, escape_latex_special_chars
+from ..data import CHEMICAL_ELEMENTS, COMMON_UNITS, UNICODE_TO_LATEX, UNICODE_PASSTHROUGH
+from ..converters.post_processor import PostProcessor
+
+
+class MiVisitor(Visitor):
+    """
+    Handles <mi> (identifier) MathML elements.
+
+    This is the most common MathML element type (~40% of all elements).
+    It converts identifiers to LaTeX format using subject-specific strategies.
+
+    Examples:
+        Math mode:
+            <mi>sin</mi> → \\sin
+            <mi>x</mi> → x
+            <mi>α</mi> → \\alpha
+
+        Chemistry mode:
+            <mi>Fe</mi> → \\mathrm{Fe}
+            <mi>H</mi> → \\mathrm{H}
+    """
+
+    def __init__(self, strategy: Strategy, context=None):
+        """
+        Initialize the Mi visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+            context: Optional ConversionContext for script context tracking
+        """
+        super().__init__(strategy)
+        self._converter_context = None
+        self.context = context
+
+    def set_converter_context(self, converter):
+        """Set converter context for color suppression checking."""
+        self._converter_context = converter
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <mi> element to LaTeX.
+
+        Args:
+            node: The <mi> element to convert
+
+        Returns:
+            LaTeX string representation
+
+        Raises:
+            ValueError: If node is not an <mi> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MiVisitor cannot handle element '{node.tag}'")
+
+        # Get text content
+        content = _text_content(node)
+
+        # Handle empty content
+        if not content:
+            return ""
+
+        # Escape LaTeX special characters before any other processing
+        content = escape_latex_special_chars(content)
+
+        # CRITICAL: Check for mathvariant BEFORE reclassifying as operator
+        # This preserves explicit mathvariant="normal" for units like "N/m"
+        mathvariant = node.get('mathvariant')
+
+        # PHASE 1 FIX: Detect delimiters and operators misclassified as identifiers
+        # This handles malformed MathML from OMML2MML.xsl where operators are tagged as <mi>
+        # instead of <mo>. Common issue with Word documents.
+        # EXCEPTION: If mathvariant="normal" is present, handle it specially to preserve mathrm wrapping
+        if self._contains_delimiter_or_operator(content):
+            if mathvariant == 'normal':
+                # Special case: mathvariant="normal" with operators (e.g., "N/m" units)
+                # Split by operators but wrap identifier parts in \mathrm{}
+                result = self._reclassify_with_mathrm(content, node)
+                return result
+            else:
+                # Normal reclassification without mathrm wrapping
+                result = self._reclassify_as_operator(content, node)
+                return result
+
+        # Handle spaces (NBSP → ~, space → \ )
+        # Must be done before function recognition
+        if '\xa0' in content or ' ' in content:
+            converted = convert_spaces_to_latex(content)
+
+            # If content was ONLY spaces, return directly
+            if not content.strip():
+                return self._wrap_with_color(converted, node)
+
+            # Update content with converted spaces
+            content = converted
+
+        # Check for explicit mathvariant (overrides strategy logic)
+        # Note: mathvariant already extracted earlier (line 78) for operator reclassification check
+        if mathvariant:
+            return self._handle_mathvariant(content, mathvariant, node)
+
+        # Check for explicit LaTeX font command
+        latex_font_cmd = node.get('latex-font-cmd')
+        if latex_font_cmd:
+            return self._wrap_with_color(f"\\{latex_font_cmd}{{{content}}}", node)
+
+        # Delegate to strategy for subject-specific formatting
+        result = self.strategy.format_identifier(content, node)
+
+        return self._wrap_with_color(result, node)
+
+    def _handle_mathvariant(self, content: str, mathvariant: str, node: ET.Element) -> str:
+        """
+        Handle explicit mathvariant attributes.
+
+        Args:
+            content: The text content
+            mathvariant: The mathvariant attribute value
+            node: The element node
+
+        Returns:
+            LaTeX string with appropriate font command
+        """
+        # CRITICAL: Strip whitespace and check for mathematical functions FIRST
+        # Original converter checks functions before applying mathvariant wrapping
+        from ..data import MATH_FUNCTIONS
+        clean_content = content.strip()
+
+        # CRITICAL FIX: When mathvariant="normal" is present with mixed-case content,
+        # do NOT treat it as a simple math function. Examples:
+        # - "Asin" → should be split to "\mathrm{A}\sin" (not "\Asin")
+        # - "sin" → should still be "\sin" (lowercase function names are always functions)
+        # - "max" → should still be "\max" (lowercase function names are always functions)
+
+        # Check if content is mixed case (has both uppercase and lowercase)
+        has_upper = any(c.isupper() for c in clean_content)
+        has_lower = any(c.islower() for c in clean_content)
+        is_mixed_case = has_upper and has_lower
+
+        # Skip function recognition ONLY for mixed-case content with mathvariant="normal"
+        # This allows "Asin" to be handled later by _split_uppercase_and_function
+        if mathvariant == 'normal' and len(clean_content) > 1 and is_mixed_case:
+            # Mixed-case content like "Asin" should NOT be treated as function
+            # Fall through to the mathvariant handling logic below
+            pass
+        else:
+            # Enhanced function recognition: detect functions with inline subscripts
+            # Pattern to match function + subscript (like "limn→∞" or "max0≤x≤1")
+            import re
+            for func in ['lim', 'limsup', 'liminf', 'sup', 'inf', 'max', 'min']:
+                if clean_content.startswith(func):
+                    remaining = clean_content[len(func):]
+                    if remaining:
+                        # We found a function with trailing content - this should be a subscript
+                        # Use _convert_unicode_in_content to handle all Unicode symbols
+                        remaining_converted = self._convert_unicode_in_content(remaining)
+                        return f"\\{func}\\limits_{{{remaining_converted}}}"
+                    else:
+                        return f"\\{func}"
+
+            # If it's a mathematical function, ignore mathvariant and use function command
+            # This handles lowercase function names like "sin", "cos", "max", "lim"
+            if clean_content.lower() in MATH_FUNCTIONS:
+                return f"\\{clean_content.lower()}"
+
+        # For other functions with trailing content
+        for func in MATH_FUNCTIONS:
+            if clean_content.startswith(func) and len(clean_content) > len(func):
+                # Make sure it's not just a substring (e.g., 'limits' shouldn't match 'lim')
+                if not clean_content[len(func)].isalpha():
+                    remaining = clean_content[len(func):]
+                    # CRITICAL FIX: Convert Unicode symbols in the remaining content
+                    # Example: "sin∠" → "sin" + "∠" → "\sin" + "\angle" → "\sin \angle"
+                    # Without this fix, "sin∠" becomes "\sin∠" (unconverted ∠)
+                    remaining_converted = self._convert_unicode_in_content(remaining)
+                    return f"\\{func} {remaining_converted}".strip()
+
+        # Special case: Im, Re with mathvariant="normal" → \Im, \Re
+        if mathvariant == 'normal' and content in ['Im', 'Re']:
+            return f"\\{content}"
+
+        # CRITICAL FIX: For multi-character content with mathvariant, apply same logic as original:
+        # 1. Convert each character individually (Unicode → LaTeX)
+        # 2. Apply mathvariant ONLY to non-LaTeX-command characters
+        # 3. Join with spaces
+        #
+        # This handles cases like:
+        #   <mi mathvariant="double-struck">ℵRZCQN</mi> → \aleph \mathbb{R} \mathbb{Z} \mathbb{C} \mathbb{Q} \mathbb{N}
+        #   <mi mathvariant="script">ℏl</mi> → \hbar \ell
+
+        if len(content) > 1 and any(char in UNICODE_TO_LATEX or char in UNICODE_PASSTHROUGH or char.isalpha() for char in content):
+            # Step 1: Convert each character individually (UNICODE_PASSTHROUGH first)
+            converted_parts = []
+            for char in content:
+                if char in UNICODE_PASSTHROUGH:
+                    # Keep passthrough symbols as Unicode
+                    converted_parts.append(char)
+                elif char in UNICODE_TO_LATEX:
+                    converted_parts.append(UNICODE_TO_LATEX[char])
+                elif char.isspace():
+                    converted_parts.append(' ')
+                else:
+                    converted_parts.append(char)
+
+            # Step 2: Apply mathvariant wrapping selectively
+            if mathvariant == 'double-struck':
+                result_parts = []
+                for part in converted_parts:
+                    if part.startswith('\\'):
+                        # Already a LaTeX command (like \aleph) - use as-is
+                        result_parts.append(part)
+                    elif part.strip():  # Skip empty strings and spaces
+                        # Regular letter - wrap in \mathbb{}
+                        result_parts.append(f"\\mathbb{{{part}}}")
+                    # Note: spaces are intentionally skipped - we join with spaces anyway
+                return self._wrap_with_color(' '.join(result_parts), node)
+
+            elif mathvariant == 'script':
+                result_parts = []
+                for part in converted_parts:
+                    if part.startswith('\\'):
+                        # Already a LaTeX command (like \hbar) - use as-is
+                        result_parts.append(part)
+                    elif part == 'l':
+                        # Special case: script 'l' is \ell, not \mathscr{l}
+                        result_parts.append('\\ell')
+                    elif part.strip():  # Skip empty strings and spaces
+                        # Regular letter - wrap in \mathscr{}
+                        result_parts.append(f"\\mathscr{{{part}}}")
+                    # Note: spaces are intentionally skipped - we join with spaces anyway
+                return self._wrap_with_color(' '.join(result_parts), node)
+
+            elif mathvariant in ['fraktur', 'sans-serif', 'monospace', 'bold', 'bold-italic']:
+                # For other mathvariants, apply to all non-LaTeX-command parts
+                result_parts = []
+                font_cmd_map = {
+                    'fraktur': 'mathfrak',
+                    'sans-serif': 'mathsf',
+                    'monospace': 'mathtt',
+                    'bold': 'mathbf',
+                    'bold-italic': 'boldsymbol'
+                }
+                font_cmd = font_cmd_map[mathvariant]
+                for part in converted_parts:
+                    if part.startswith('\\'):
+                        result_parts.append(part)
+                    elif part.strip():  # Skip empty strings and spaces
+                        result_parts.append(f"\\{font_cmd}{{{part}}}")
+                    # Note: spaces are intentionally skipped - we join with spaces anyway
+                return self._wrap_with_color(' '.join(result_parts), node)
+
+            elif mathvariant == 'normal':
+                # Multi-character content with mathvariant="normal" - always wrap in \mathrm{}
+                # Combine the converted parts with intelligent spacing
+                # When a LaTeX command (like \Delta) is followed by a letter, add a space
+                # Otherwise, LaTeX interprets \DeltaH as a single undefined command
+                combined = self._join_with_command_spacing(converted_parts)
+
+                # DISABLED: "Smart" logic that ignored mathvariant="normal" for simple variables
+                # This was causing issues where explicit mathvariant="normal" was not respected
+                # Keeping _is_simple_math_variable for potential future use
+                # if self.strategy.name == 'math':
+                #     is_simple = self._is_simple_math_variable(combined)
+                #     if is_simple:
+                #         return self._wrap_with_color(combined, node)
+
+                # CRITICAL FIX: Check if content starts with uppercase letter(s) followed by a known function
+                # Example: "Asin" → "\mathrm{A}\sin", "ABcos" → "\mathrm{AB}\cos"
+                # This handles the case where Word's "Text Mode" is used for mixed content
+                result = self._split_uppercase_and_function(content)
+                if result:
+                    return self._wrap_with_color(result, node)
+
+                # Always respect mathvariant="normal" - wrap in \mathrm{}
+                return self._wrap_with_color(f"\\mathrm{{{combined}}}", node)
+
+            else:
+                # No mathvariant or unknown - just join the converted parts
+                return self._wrap_with_color(' '.join(converted_parts), node)
+
+        # Fallback: single character or simple cases
+        # IMPORTANT: Convert Unicode symbols BEFORE wrapping in font commands
+        # e.g., ℵ → \aleph, ℏ → \hbar
+        content_converted = self._convert_unicode_in_content(content)
+
+        # Map mathvariant values to LaTeX font commands
+        if mathvariant == 'double-struck':
+            # If already converted to LaTeX command, use as-is
+            if content in UNICODE_TO_LATEX:
+                return content_converted
+            return f"\\mathbb{{{content_converted}}}"
+        elif mathvariant == 'script':
+            # Special case: script lowercase 'l' → \ell
+            if content == 'l':
+                return "\\ell"
+            # If already converted to LaTeX command, use as-is
+            if content in UNICODE_TO_LATEX:
+                return content_converted
+            return f"\\mathscr{{{content_converted}}}"
+        elif mathvariant == 'fraktur':
+            return f"\\mathfrak{{{content_converted}}}"
+        elif mathvariant == 'sans-serif':
+            return f"\\mathsf{{{content_converted}}}"
+        elif mathvariant == 'monospace':
+            return f"\\mathtt{{{content_converted}}}"
+        elif mathvariant == 'bold':
+            return f"\\mathbf{{{content_converted}}}"
+        elif mathvariant == 'bold-italic':
+            # Bold italic - use \boldsymbol for math-mode bold italic
+            # Alternative: \bm from bm package, but \boldsymbol is standard
+            return f"\\boldsymbol{{{content_converted}}}"
+        elif mathvariant == 'italic':
+            # Explicitly italic - return as-is (LaTeX default)
+            return content_converted
+        elif mathvariant == 'normal':
+            # INTELLIGENT HANDLING of mathvariant="normal" based on subject mode and content
+            # This handles the <m:nor/> tag from Word's "Text Mode" button
+
+            # Special cases first: Im, Re → \Im, \Re
+            if content in ['Im', 'Re']:
+                return f"\\{content}"
+
+            # CRITICAL: If content was a Unicode symbol (like π → \pi), don't wrap in \mathrm{}
+            # The _convert_unicode_in_content() already converted it to LaTeX command
+            if content.strip() in UNICODE_TO_LATEX:
+                return content_converted  # Already converted to LaTeX (e.g., \pi)
+
+            # DISABLED: "Smart" logic that ignored mathvariant="normal" for simple variables
+            # This was causing issues where explicit mathvariant="normal" was not respected
+            # Keeping _is_simple_math_variable for potential future use
+            # if self.strategy.name == 'math':
+            #     if self._is_simple_math_variable(content_converted):
+            #         return content_converted
+
+            # Always respect mathvariant="normal" - wrap in \mathrm{}
+            return f"\\mathrm{{{content_converted}}}"
+        else:
+            # Unknown mathvariant - return as-is
+            return content_converted
+
+    def _is_simple_math_variable(self, content: str) -> bool:
+        """
+        Check if content is a simple mathematical variable that should be italic.
+
+        Simple math variables include:
+        - Single lowercase letters: x, y, z, a, b, etc.
+        - Single uppercase letters: X, Y, Z, A, B, etc. (but NOT chemical elements)
+        - Greek letters (already converted to LaTeX commands like \\alpha)
+        - Common mathematical notations like single letters with primes: x', y''
+
+        This is used to intelligently handle mathvariant="normal" in math mode:
+        - Simple variables should remain italic (ignore mathvariant="normal")
+        - Complex identifiers should be upright (respect mathvariant="normal")
+
+        Args:
+            content: The identifier content to check
+
+        Returns:
+            True if content is a simple math variable, False otherwise
+        """
+        if not content:
+            return False
+
+        # Strip whitespace and LaTeX commands for checking
+        clean_content = content.strip()
+
+        # If it starts with a LaTeX command (like \alpha, \beta), it's a simple variable
+        if clean_content.startswith('\\'):
+            return True
+
+        # CRITICAL: If content contains mathematical operators, it's an expression (not an identifier)
+        # Examples: "x+2", "a-b", "n*m" should NOT be wrapped in \mathrm{}
+        # These are parsed as single <mi> elements by XSL but should remain italic
+        math_operators = {'+', '-', '*', '/', '=', '<', '>', '≤', '≥', '≠', '±'}
+        if any(op in clean_content for op in math_operators):
+            return True  # Treat expressions as "simple" (don't wrap in \mathrm{})
+
+        # Single letter (a-z, A-Z) - simple variable
+        if len(clean_content) == 1 and clean_content.isalpha():
+            # BUT: exclude known chemical elements in non-math contexts
+            if self.strategy.name == 'chemistry' and clean_content in CHEMICAL_ELEMENTS:
+                return False
+            return True
+
+        # Single letter with primes (x', y'', etc.)
+        if len(clean_content) >= 2:
+            base = clean_content.rstrip("'")
+            primes = clean_content[len(base):]
+            if len(base) == 1 and base.isalpha() and all(c == "'" for c in primes):
+                return True
+
+        # Multi-character content that's NOT a math function is considered complex
+        # Examples: "velocity", "pressure", "Mn", "Fe" - should be upright if mathvariant="normal"
+        return False
+
+    def _convert_unicode_in_content(self, content: str) -> str:
+        """
+        Convert Unicode symbols within identifier content to LaTeX equivalents.
+
+        For multi-character identifiers with Unicode symbols mixed in,
+        we need to convert each Unicode character individually.
+
+        Args:
+            content: Identifier text that may contain Unicode symbols
+
+        Returns:
+            Content with Unicode symbols converted to LaTeX, preserving spaces
+        """
+        if not content:
+            return content
+
+        # Check if any Unicode symbols are present (passthrough or convertible)
+        has_unicode = any(char in UNICODE_TO_LATEX for char in content)
+        has_passthrough = any(char in UNICODE_PASSTHROUGH for char in content)
+        if not has_unicode and not has_passthrough:
+            return content
+
+        # Convert character by character, preserving spaces (PASSTHROUGH first)
+        result = []
+        for char in content:
+            if char in UNICODE_PASSTHROUGH:
+                # Keep passthrough symbols as Unicode
+                result.append(char)
+            elif char in UNICODE_TO_LATEX:
+                # Add space before/after LaTeX command if needed
+                latex_cmd = UNICODE_TO_LATEX[char]
+                result.append(latex_cmd)
+            else:
+                result.append(char)
+
+        # Join parts with space separator for multi-symbol content
+        # e.g., "ℵR" → "\aleph R" not "\alephR"
+        joined = ' '.join(result)
+
+        # Clean up multiple spaces
+        import re
+        joined = re.sub(r'\s+', ' ', joined)
+
+        return joined
+
+    def _join_with_command_spacing(self, parts: list) -> str:
+        """
+        Join converted parts with intelligent spacing for LaTeX commands.
+
+        When a LaTeX command (like \\Delta) is followed by a letter, a space must
+        be inserted. Otherwise, LaTeX interprets \\DeltaH as a single undefined
+        command instead of \\Delta followed by H.
+
+        Args:
+            parts: List of converted parts (may contain LaTeX commands and letters)
+
+        Returns:
+            Joined string with appropriate spacing between commands and letters
+
+        Examples:
+            ['\\\\Delta', 'H'] → '\\\\Delta H' (space needed)
+            ['a', 'b', 'c'] → 'abc' (no space needed)
+            ['\\\\alpha', '\\\\beta'] → '\\\\alpha\\\\beta' (commands can be adjacent)
+            ['\\\\Delta', '1'] → '\\\\Delta 1' (space before number)
+        """
+        if not parts:
+            return ''
+
+        result = []
+        for i, part in enumerate(parts):
+            result.append(part)
+
+            # Check if we need to add a space after this part
+            if i < len(parts) - 1:
+                next_part = parts[i + 1]
+
+                # If current part is a LaTeX command (starts with \)
+                # and next part starts with a letter or digit, add space
+                if part.startswith('\\') and next_part and (next_part[0].isalpha() or next_part[0].isdigit()):
+                    result.append(' ')
+
+        return ''.join(result)
+
+    def _wrap_with_color(self, latex: str, node: ET.Element) -> str:
+        """
+        Wrap LaTeX with color command if node has color attribute.
+
+        Args:
+            latex: The LaTeX string to wrap
+            node: The element node
+
+        Returns:
+            LaTeX string, optionally wrapped with color command
+        """
+        # Use the centralized color wrapping utility with suppression support
+        from ..utils.color_helpers import wrap_element_with_color
+
+        # Get converter context from multiple sources (for backward compatibility):
+        # 1. Direct visitor context (set by legacy_adapter)
+        # 2. Strategy context (shared across all visitors, including child visitors)
+        context = getattr(self, '_converter_context', None)
+        if context is None and hasattr(self.strategy, '_converter_context'):
+            context = self.strategy._converter_context
+
+        return wrap_element_with_color(latex, node, context)
+
+    def _contains_delimiter_or_operator(self, content: str) -> bool:
+        """
+        Check if content contains delimiter or operator characters that should be <mo> not <mi>.
+
+        This detects malformed MathML from OMML2MML.xsl where operators are misclassified
+        as identifiers (e.g., <mi>(</mi> instead of <mo fence="true">(</mo>).
+
+        Args:
+            content: Text content of the <mi> element
+
+        Returns:
+            True if content contains delimiters or operators
+        """
+        # Delimiters that should be fences
+        delimiters = set('()[]{}<>')
+
+        # Common operators (excluding - which might be minus sign or hyphen)
+        # Note: We include = and < > which are often misclassified
+        operators = set('+=*/|≤≥≠≈∈∉∪∩⊂⊃∧∨¬→↔×÷±')
+
+        # Check if ANY character is a delimiter or operator
+        return any(char in delimiters or char in operators for char in content)
+
+    def _reclassify_with_mathrm(self, content: str, node: ET.Element) -> str:
+        """
+        Reclassify content with operators while preserving mathvariant="normal" (mathrm wrapping).
+
+        This handles cases like:
+        - <mi mathvariant="normal">N/m</mi> → \mathrm{N}/\mathrm{m}
+        - <mi mathvariant="normal">kg·m/s</mi> → \mathrm{kg}·\mathrm{m}/\mathrm{s}
+
+        Args:
+            content: Text content with mathvariant="normal" that contains operators
+            node: Original <mi> element node
+
+        Returns:
+            LaTeX string with mathrm-wrapped identifiers and properly classified operators
+        """
+        # Delimiters that should have fence="true"
+        fence_chars = set('()[]{}')
+
+        # Operators that should be <mo> but NOT fences
+        operator_chars = set('+=*/|<>≤≥≠≈∈∉∪∩⊂⊃∧∨¬→↔×÷±·')
+
+        # Multi-character content: split and classify each character
+        # Identifier parts get wrapped in \mathrm{}
+        parts = []
+        for char in content:
+            if char in fence_chars:
+                parts.append(self._convert_as_fence(char, node))
+            elif char in operator_chars:
+                parts.append(self._convert_as_operator(char, node))
+            elif char.isspace():
+                # Preserve spaces
+                from ..utils import convert_spaces_to_latex
+                parts.append(convert_spaces_to_latex(char))
+            else:
+                # Regular identifier character - wrap in \mathrm{} for mathvariant="normal"
+                parts.append(f"\\mathrm{{{char}}}")
+
+        return ''.join(parts)
+
+    def _reclassify_as_operator(self, content: str, node: ET.Element) -> str:
+        """
+        Reclassify misclassified operators/delimiters and convert them properly.
+
+        Handles cases like:
+        - <mi>(</mi> → treat as <mo fence="true">(</mo>
+        - <mi>)+</mi> → treat as <mo fence="true">)</mo><mo>+</mo>
+        - <mi>=</mi> → treat as <mo>=</mo>
+
+        Args:
+            content: Text content that contains operators/delimiters
+            node: Original <mi> element node
+
+        Returns:
+            LaTeX string with properly classified operators
+        """
+        # Import MoVisitor for operator handling
+        from .mo_visitor import MoVisitor
+
+        # Delimiters that should have fence="true"
+        fence_chars = set('()[]{}')
+
+        # Operators that should be <mo> but NOT fences
+        operator_chars = set('+=*/|<>≤≥≠≈∈∉∪∩⊂⊃∧∨¬→↔×÷±')
+
+        # If content is a single character, handle directly
+        if len(content) == 1:
+            if content in fence_chars:
+                return self._convert_as_fence(content, node)
+            elif content in operator_chars:
+                return self._convert_as_operator(content, node)
+            else:
+                # Shouldn't happen, but fallback to identifier
+                return self.strategy.format_identifier(content, node)
+
+        # Multi-character content: split and classify each character
+        parts = []
+        for char in content:
+            if char in fence_chars:
+                parts.append(self._convert_as_fence(char, node))
+            elif char in operator_chars:
+                parts.append(self._convert_as_operator(char, node))
+            elif char.isspace():
+                # Preserve spaces
+                from ..utils import convert_spaces_to_latex
+                parts.append(convert_spaces_to_latex(char))
+            else:
+                # Regular identifier character
+                parts.append(self.strategy.format_identifier(char, node))
+
+        return ''.join(parts)
+
+    def _convert_as_fence(self, char: str, node: ET.Element) -> str:
+        """
+        Convert a character as a fence delimiter (with fence="true").
+
+        Fence delimiters are marked with __DELIM__ to indicate they should be paired
+        by the post-processor (e.g., ( and ) become \left( and \right)).
+
+        Args:
+            char: Single delimiter character
+            node: Original element node (for color preservation)
+
+        Returns:
+            Delimiter wrapped in __DELIM__ markers for post-processing
+        """
+        # Map fence characters to LaTeX (handle escaped braces)
+        fence_map = {
+            '(': '(',
+            ')': ')',
+            '[': '[',
+            ']': ']',
+            '{': '\\{',  # Must be escaped in LaTeX
+            '}': '\\}',  # Must be escaped in LaTeX
+        }
+
+        latex_char = fence_map.get(char, char)
+
+        # Wrap in __DELIM__ markers so post-processor knows to add \left and \right
+        return f"__DELIM__{latex_char}__DELIM__"
+
+    def _convert_as_operator(self, char: str, node: ET.Element) -> str:
+        """
+        Convert a character as an operator (without fence="true").
+
+        Operators like +, =, |, < are NOT marked with __DELIM__ because they should NOT
+        be paired as delimiters. For example, | in P(A|B) is an operator, not a delimiter.
+
+        Args:
+            char: Single operator character
+            node: Original element node (for color preservation)
+
+        Returns:
+            LaTeX operator string (plain, no markers)
+        """
+        # Map operators to LaTeX equivalents
+        operator_map = {
+            '+': '+',
+            '-': '-',
+            '*': '*',
+            '/': '/',
+            '=': '=',
+            '<': '<',
+            '>': '>',
+            '|': '|',  # IMPORTANT: | as operator (conditional probability), NOT delimiter
+            '×': '\\times ',
+            '÷': '\\div ',
+            '±': '\\pm ',
+            '≤': '\\leqslant ',
+            '≥': '\\geqslant ',
+            '≠': '\\ne ',
+            '≈': '\\approx ',
+            '∈': '\\in ',
+            '∉': '\\notin ',
+            '∪': '\\cup ',
+            '∩': '\\cap ',
+            '⊂': '\\subset ',
+            '⊃': '\\supset ',
+            '∧': '\\wedge ',
+            '∨': '\\vee ',
+            '¬': '\\neg ',
+            '→': '\\to ',
+            '↔': '\\leftrightarrow ',
+        }
+
+        latex_char = operator_map.get(char, char)
+
+        # Return as-is (NO __DELIM__ markers - should not be paired)
+        return latex_char
+
+    def _split_uppercase_and_function(self, content: str) -> str:
+        """
+        Split content that starts with uppercase letter(s) followed by a known function.
+
+        This handles cases like:
+        - "Asin" → "\\mathrm{A}\\sin"
+        - "ABcos" → "\\mathrm{AB}\\cos"
+        - "Xlog" → "\\mathrm{X}\\log"
+
+        Args:
+            content: The identifier content to check
+
+        Returns:
+            LaTeX string with split content, or None if no split is needed
+        """
+        from ..data import MATH_FUNCTIONS
+
+        if not content or len(content) < 2:
+            return None
+
+        # Check if content starts with uppercase letter(s)
+        if not content[0].isupper():
+            return None
+
+        # Find where the uppercase letters end
+        uppercase_end = 0
+        for i, char in enumerate(content):
+            if char.isupper():
+                uppercase_end = i + 1
+            else:
+                break
+
+        if uppercase_end == 0 or uppercase_end >= len(content):
+            return None
+
+        # Split into uppercase part and remaining part
+        uppercase_part = content[:uppercase_end]
+        remaining_part = content[uppercase_end:]
+
+        # Check if remaining part is a known math function
+        if remaining_part in MATH_FUNCTIONS:
+            # Split: uppercase in \mathrm{} + function as \function
+            return f"\\mathrm{{{uppercase_part}}}\\{remaining_part}"
+
+        return None
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """
+        Check if this visitor can handle the given node.
+
+        Args:
+            node: The MathML element to check
+
+        Returns:
+            True if node is an <mi> element, False otherwise
+        """
+        from ..utils import local_name as _local
+        return _local(node.tag) == 'mi'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mi'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MiVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mlabeledtr_visitor.py b/scripts/omml_mathml2latex/visitors/mlabeledtr_visitor.py
new file mode 100644
index 0000000..bee2824
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mlabeledtr_visitor.py
@@ -0,0 +1,200 @@
+r"""
+Visitor for <mlabeledtr> (labeled table row) MathML elements.
+
+The <mlabeledtr> element is used in tables (<mtable>) to create a row with
+a label. The first child is the label, and remaining children are table cells.
+Labels are typically used for equation numbering or row identifiers.
+
+In LaTeX conversion, the label is typically rendered separately or as part
+of the row depending on context. For simplicity, we render label followed
+by cells, separated by &.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MlabeledtrVisitor(Visitor):
+    r"""
+    Handles <mlabeledtr> (labeled table row) MathML elements.
+
+    Converts labeled table rows to LaTeX array/matrix rows. The first child
+    is treated as the label, remaining children are table cells.
+
+    Examples:
+        Labeled equation row:
+            <mlabeledtr>
+                <mtd><mtext>(1)</mtext></mtd>
+                <mtd><mi>x</mi></mtd>
+                <mtd><mi>y</mi></mtd>
+            </mlabeledtr>
+            → (1) & x & y
+
+        Simple labeled row:
+            <mlabeledtr>
+                <mtd><mn>1</mn></mtd>
+                <mtd><mi>a</mi></mtd>
+            </mlabeledtr>
+            → 1 & a
+
+        Three-column with label:
+            <mlabeledtr>
+                <mtd><mtext>Label</mtext></mtd>
+                <mtd><mi>x</mi></mtd>
+                <mtd><mo>=</mo></mtd>
+                <mtd><mn>5</mn></mtd>
+            </mlabeledtr>
+            → \text{Label} & x & = & 5
+
+    Note:
+        The label (first child) is rendered as a regular cell. LaTeX doesn't
+        have a direct equivalent for MathML labeled rows, so we treat it as
+        a standard row with the label as the first column.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mlabeledtr visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mlabeledtr> element to LaTeX array/matrix row.
+
+        Args:
+            node: The <mlabeledtr> element to convert
+
+        Returns:
+            LaTeX string with cells separated by &
+
+        Raises:
+            ValueError: If node is not a <mlabeledtr> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MlabeledtrVisitor cannot handle element '{node.tag}'")
+
+        # Get all children (first is label, rest are cells)
+        children = list(node)
+
+        if not children:
+            return ""
+
+        # Convert all children (label + cells) as mtd elements
+        cells = []
+        for child in children:
+            cell_content = self._convert_child(child)
+            cells.append(cell_content)
+
+        # Join with &
+        return " & ".join(cells)
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mlabeledtr, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mlabeledtr'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mlabeledtr'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MlabeledtrVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mmultiscripts_visitor.py b/scripts/omml_mathml2latex/visitors/mmultiscripts_visitor.py
new file mode 100644
index 0000000..857ceb8
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mmultiscripts_visitor.py
@@ -0,0 +1,288 @@
+r"""
+Visitor for <mmultiscripts> (tensor notation) MathML elements.
+
+The <mmultiscripts> element is used to attach prescripts and postscripts to a base element.
+It's commonly used in physics and chemistry for tensor notation, nuclear notation, etc.
+
+Structure:
+    <mmultiscripts>
+        <base/>              <!-- Base element -->
+        <sub1/> <sup1/>      <!-- First postscript pair -->
+        <sub2/> <sup2/>      <!-- Second postscript pair -->
+        <mprescripts/>       <!-- Separator -->
+        <presub1/> <presup1/>  <!-- First prescript pair -->
+        <presub2/> <presup2/>  <!-- Second prescript pair -->
+    </mmultiscripts>
+
+This visitor handles both prescripts (left side) and postscripts (right side) with \sideset.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MmultiscriptsVisitor(Visitor):
+    r"""
+    Handles <mmultiscripts> (tensor notation) MathML elements.
+
+    Converts prescripts and postscripts to LaTeX using \sideset for bidirectional scripts.
+
+    Examples:
+        Only postscripts:
+            <mmultiscripts>
+                <mi>R</mi>
+                <mn>1</mn><mn>2</mn>
+            </mmultiscripts>
+            → R_{1}^{2}
+
+        Only prescripts:
+            <mmultiscripts>
+                <mi>R</mi>
+                <mprescripts/>
+                <mn>1</mn><mn>2</mn>
+            </mmultiscripts>
+            → _{1}^{2}R
+
+        Both prescripts and postscripts:
+            <mmultiscripts>
+                <mi>R</mi>
+                <mn>3</mn><mn>4</mn>
+                <mprescripts/>
+                <mn>1</mn><mn>2</mn>
+            </mmultiscripts>
+            → \sideset{_{1}^{2}}{_{3}^{4}}{R}
+
+        Multiple postscripts:
+            <mmultiscripts>
+                <mi>R</mi>
+                <mi>i</mi><mi>j</mi>
+                <mi>k</mi><mi>l</mi>
+            </mmultiscripts>
+            → R_{i}^{j}_{k}^{l}
+
+        None elements (empty script positions):
+            <mmultiscripts>
+                <mi>R</mi>
+                <none/><mn>2</mn>
+                <mprescripts/>
+                <mn>1</mn><none/>
+            </mmultiscripts>
+            → \sideset{_{1}}{^{2}}{R}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mmultiscripts visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mmultiscripts> element to LaTeX with tensor notation.
+
+        Args:
+            node: The <mmultiscripts> element to convert
+
+        Returns:
+            LaTeX string with prescripts and postscripts
+
+        Raises:
+            ValueError: If node is not a <mmultiscripts> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MmultiscriptsVisitor cannot handle element '{node.tag}'")
+
+        if len(node) == 0:
+            return ""
+
+        # First child is the base element
+        base = self._convert_child(node[0])
+        scripts = list(node)[1:]  # Skip base element
+
+        # Find mprescripts separator
+        prescript_idx = None
+        for i, child in enumerate(scripts):
+            if _local(child.tag) == "mprescripts":
+                prescript_idx = i
+                break
+
+        if prescript_idx is None:
+            # Only postscripts
+            postscripts = scripts
+            prescripts = []
+        else:
+            postscripts = scripts[:prescript_idx]
+            prescripts = scripts[prescript_idx + 1:]
+
+        # Process postscripts (pairs of sub/sup)
+        postscript_parts = self._process_script_pairs(postscripts)
+
+        # Process prescripts (pairs of sub/sup)
+        prescript_parts = self._process_script_pairs(prescripts)
+
+        # Use \sideset when there are scripts on both sides
+        if prescript_parts and postscript_parts:
+            left_scripts = "".join(prescript_parts)
+            right_scripts = "".join(postscript_parts)
+            return f"\\sideset{{{left_scripts}}}{{{right_scripts}}}{{{base}}}"
+        elif prescript_parts:
+            # Only left scripts - direct positioning
+            return f"{''.join(prescript_parts)}{base}"
+        elif postscript_parts:
+            # Only right scripts
+            return f"{base}{''.join(postscript_parts)}"
+        else:
+            return base
+
+    def _process_script_pairs(self, scripts: list) -> list:
+        """
+        Process script pairs (sub/sup) from the scripts list.
+
+        Scripts come in pairs: subscript, superscript, subscript, superscript, ...
+        <none/> elements represent empty positions.
+
+        Args:
+            scripts: List of script elements (pairs of sub/sup)
+
+        Returns:
+            List of LaTeX script strings
+        """
+        parts = []
+        for i in range(0, len(scripts), 2):
+            sub = self._convert_script(scripts[i]) if i < len(scripts) else ""
+            sup = self._convert_script(scripts[i + 1]) if i + 1 < len(scripts) else ""
+
+            if sub and sup:
+                parts.append(f"_{{{sub}}}^{{{sup}}}")
+            elif sub:
+                parts.append(f"_{{{sub}}}")
+            elif sup:
+                parts.append(f"^{{{sup}}}")
+
+        return parts
+
+    def _convert_script(self, child: ET.Element) -> str:
+        """
+        Convert a script element to LaTeX.
+
+        Handles <none/> elements (empty script positions).
+
+        Args:
+            child: Script element to convert
+
+        Returns:
+            LaTeX string for the script (empty for <none/>)
+        """
+        if _local(child.tag) == "none":
+            return ""
+        return self._convert_child(child)
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mmultiscripts, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mmultiscripts'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mmultiscripts'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MmultiscriptsVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mn_visitor.py b/scripts/omml_mathml2latex/visitors/mn_visitor.py
new file mode 100644
index 0000000..7521709
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mn_visitor.py
@@ -0,0 +1,136 @@
+"""
+Visitor for <mn> (number) MathML elements.
+
+The <mn> element represents numeric literals in MathML, including:
+- Integers (1, 2, 3, ...)
+- Decimals (3.14, 2.718, ...)
+- Scientific notation (1.5×10⁻³)
+- Fractions in decimal form (0.5)
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, convert_spaces_to_latex, escape_latex_special_chars
+from ..data import CHEMICAL_ELEMENTS, COMMON_UNITS
+from ..converters.post_processor import PostProcessor
+
+
+class MnVisitor(Visitor):
+    """
+    Handles <mn> (number) MathML elements.
+
+    This visitor converts numbers to LaTeX format. Most numbers
+    are returned as-is, but the strategy can customize formatting
+    for specific subjects (e.g., chemistry, physics).
+
+    Examples:
+        Standard numbers:
+            <mn>123</mn> → 123
+            <mn>3.14</mn> → 3.14
+            <mn>0.5</mn> → 0.5
+
+        Scientific notation (handled at operator level):
+            <mn>1.5</mn><mo>×</mo><mn>10</mn><msup><mn>-3</mn></msup>
+            → 1.5 \\times 10^{-3}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """
+        Initialize the Mn visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+        """
+        super().__init__(strategy)
+        self._converter_context = None
+
+    def set_converter_context(self, converter):
+        """Set converter context for color suppression checking."""
+        self._converter_context = converter
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <mn> element to LaTeX.
+
+        Args:
+            node: The <mn> element to convert
+
+        Returns:
+            LaTeX string representation
+
+        Raises:
+            ValueError: If node is not an <mn> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MnVisitor cannot handle element '{node.tag}'")
+
+        # Get text content
+        content = _text_content(node)
+
+        # Handle empty content
+        if not content:
+            return ""
+
+        # Escape LaTeX special characters before any other processing
+        content = escape_latex_special_chars(content)
+
+        # Handle spaces (NBSP → ~, space → \ )
+        if '\xa0' in content or ' ' in content:
+            converted = convert_spaces_to_latex(content)
+
+            # If content was ONLY spaces, return directly
+            if not content.strip():
+                return self._wrap_with_color(converted, node)
+
+            # Update content with converted spaces
+            content = converted
+
+        # Delegate to strategy for subject-specific number formatting
+        result = self.strategy.format_number(content, node)
+
+        return self._wrap_with_color(result, node)
+
+    def _wrap_with_color(self, latex: str, node: ET.Element) -> str:
+        """
+        Wrap LaTeX with color command if node has color attribute.
+
+        Args:
+            latex: The LaTeX string to wrap
+            node: The element node
+
+        Returns:
+            LaTeX string, optionally wrapped with color command
+        """
+        # Use the centralized color wrapping utility with suppression support
+        from ..utils.color_helpers import wrap_element_with_color
+
+        # Get converter context from multiple sources (for backward compatibility):
+        # 1. Direct visitor context (set by legacy_adapter)
+        # 2. Strategy context (shared across all visitors, including child visitors)
+        context = getattr(self, '_converter_context', None)
+        if context is None and hasattr(self.strategy, '_converter_context'):
+            context = self.strategy._converter_context
+        
+        return wrap_element_with_color(latex, node, context)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """
+        Check if this visitor can handle the given node.
+
+        Args:
+            node: The MathML element to check
+
+        Returns:
+            True if node is an <mn> element, False otherwise
+        """
+        from ..utils import local_name as _local
+        return _local(node.tag) == 'mn'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mn'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MnVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mo_visitor.py b/scripts/omml_mathml2latex/visitors/mo_visitor.py
new file mode 100644
index 0000000..b822f4c
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mo_visitor.py
@@ -0,0 +1,388 @@
+"""
+Visitor for <mo> (operator) MathML elements.
+
+The <mo> element represents operators in MathML, including:
+- Binary operators (+, -, ×, ÷)
+- Relational operators (=, <, >, ≤, ≥)
+- Delimiters (parentheses, brackets, braces)
+- Special operators (∫, ∑, ∏, ∇)
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local, convert_spaces_to_latex, escape_latex_special_chars
+from ..utils.debug import debug_print
+from ..data import CHEMICAL_ELEMENTS, COMMON_UNITS
+from ..converters.post_processor import PostProcessor
+
+# Operators with built-in LaTeX spacing - skip manual spaces after these
+SKIP_SPACE_AFTER = {
+    # Relation operators (thick spacing in LaTeX)
+    '\\rightarrow', '\\leftarrow', '\\to', '→', '←',
+    '\\Longrightarrow', '\\Longleftarrow', '⇒', '⇐',
+    '\\leftrightarrow', '\\Longleftrightarrow', '↔', '⇔', '⟷',
+    '=', '\\equiv', '\\approx', '≈', '\\cong', '≅',
+    '<', '>', '\\leq', '\\geq', '≤', '≥', '\\neq', '≠',
+    '\\subseteq', '⊆', '\\supseteq', '⊇',
+    '\\in', '∈', '\\notin', '∉',
+    '\\perp', '⊥', '\\parallel', '∥',
+    '\\sim', '∼', '\\simeq', '≃', '\\propto', '∝',
+    '\\prec', '≺', '\\succ', '≻', '\\preceq', '⪯', '\\succeq', '⪰',
+    '\\subset', '⊂', '\\supset', '⊃', '\\sqsubseteq', '⊑', '\\sqsupseteq', '⊒',
+
+    # Binary operators (medium spacing in LaTeX)
+    '+', '-', '\\times', '×', '\\div', '÷', '\\cdot', '·',
+    '\\pm', '±', '\\mp', '∓',
+    '\\lor', '∨', '\\land', '∧', '\\wedge', '∧', '\\vee', '∨', '\\neg', '¬',
+    '\\cap', '∩', '\\cup', '∪',
+    '\\sqcap', '⊓', '\\sqcup', '⊔', '\\uplus', '⊎',
+    '\\oplus', '⊕', '\\otimes', '⊗', '\\odot', '⊙', '\\ominus', '⊖', '\\oslash', '⊘',
+    '\\curlywedge', '⋏', '\\curlyvee', '⋎',
+    '\\setminus', '∖', '\\ast', '∗', '\\star', '⋆', '\\circ', '∘',
+    '\\bullet', '•', '\\diamond', '⋄', '\\bigtriangleup', '△', '\\bigtriangledown', '▽',
+    '\\triangleleft', '◃', '\\triangleright', '▹',
+    '\\lhd', '⊲', '\\rhd', '⊳', '\\unlhd', '⊴', '\\unrhd', '⊵',
+
+    # Punctuation with spacing
+    ',', ';', ':',
+}
+
+# Preserve spaces before these (differentials need explicit spacing)
+PRESERVE_SPACE_BEFORE = {
+    'dx', 'dy', 'dz', 'dt', 'du', 'dv', 'dw',
+    'dr', 'ds', 'da', 'db', 'dc',
+    'd\\theta', 'd\\phi', 'd\\psi', 'd\\alpha', 'd\\beta',
+    'dxdy', 'dydz', 'dxdz',  # Multi-variable differentials
+}
+
+
+class MoVisitor(Visitor):
+    """
+    Handles <mo> (operator) MathML elements.
+
+    This visitor converts operators to LaTeX format, handling:
+    - Unicode symbol mapping (× → \\times, ≤ → \\leqslant)
+    - Delimiter recognition (fence operators)
+    - Spacing control
+    - Subject-specific operator formatting
+
+    Examples:
+        Standard operators:
+            <mo>+</mo> → +
+            <mo>×</mo> → \\times
+            <mo>≤</mo> → \\leqslant
+
+        Delimiters:
+            <mo fence="true">(</mo> → \\left(
+            <mo fence="true">)</mo> → \\right)
+
+        Chemistry:
+            <mo>→</mo> → \\rightarrow (or \\xlongequal{condition})
+    """
+
+    def __init__(self, strategy: Strategy):
+        """
+        Initialize the Mo visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+        """
+        super().__init__(strategy)
+        self._converter_context = None
+
+    def set_converter_context(self, converter):
+        """Set converter context for color suppression checking."""
+        self._converter_context = converter
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <mo> element to LaTeX.
+
+        Args:
+            node: The <mo> element to convert
+
+        Returns:
+            LaTeX string representation
+
+        Raises:
+            ValueError: If node is not an <mo> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MoVisitor cannot handle element '{node.tag}'")
+
+        # Get text content
+        content = _text_content(node)
+
+        # Check for fence attribute FIRST (delimiter handling)
+        # Empty fence delimiters (like closing brace in cases) need special handling
+        fence = node.get('fence')
+        if fence == 'true':
+            # For fence delimiters, allow empty content (will be handled by _handle_fence)
+            if not content:
+                return self._handle_fence("", node)
+            # Escape LaTeX special characters before fence handling
+            content = escape_latex_special_chars(content)
+            return self._handle_fence(content, node)
+
+        # Handle empty content (non-fence operators)
+        if not content:
+            return ""
+
+        # Escape LaTeX special characters before any other processing
+        content = escape_latex_special_chars(content)
+
+        # Handle spaces (NBSP → ~, space → \ )
+        if '\xa0' in content or ' ' in content:
+            # If content is ONLY spaces, use context-aware filtering
+            if not content.strip():
+                # Check if this space should be preserved based on context
+                if self._should_preserve_space(node):
+                    converted = convert_spaces_to_latex(content)
+                    return self._wrap_with_color(converted, node)
+                else:
+                    # Skip this space - LaTeX will handle spacing
+                    return ""
+
+            # Content has spaces mixed with other characters
+            # CRITICAL FIX: Strip surrounding whitespace from operators!
+            # MathType sometimes outputs "<mo> < </mo>" which fails to match "<" in strategy
+            # and gets converted to "\ < \ " by convert_spaces_to_latex.
+            content = content.strip()
+
+            # If strip() resulted in empty string (should catch above, but safety)
+            if not content:
+                return ""
+
+            # Use convert_spaces_to_latex ONLY if there are still spaces INSIDE the operator
+            # (e.g. "mod " -> "mod" (stripped), but "a b" -> "a~b"?)
+            if '\xa0' in content or ' ' in content:
+                content = convert_spaces_to_latex(content)
+
+        # Check for stretchy attribute (affects some operators like arrows)
+        stretchy = node.get('stretchy')
+
+        # Delegate to strategy for subject-specific operator formatting
+        result = self.strategy.format_operator(content, node)
+
+        # DEBUG
+        if content in '()':
+            debug_print(f"[DEBUG MO] Operator {content!r} → {result!r}")
+
+        return self._wrap_with_color(result, node)
+
+    def _handle_fence(self, content: str, node: ET.Element) -> str:
+        """
+        Handle fence (delimiter) operators with fence="true" attribute.
+
+        Args:
+            content: The delimiter character (can be empty for invisible delimiters)
+            node: The element node
+
+        Returns:
+            LaTeX delimiter wrapped in __DELIM__ markers for post-processing
+
+        Note:
+            Fences are marked with __DELIM__ markers to indicate they should be
+            paired by the delimiter pairing processor. This distinguishes them from
+            plain operators that happen to use the same character (e.g., | in P(A|B)
+            is an operator, not a fence delimiter).
+
+            Empty content is converted to "." (invisible delimiter) for cases like
+            piecewise functions: \left\{...\right.
+        """
+        # Handle empty or whitespace-only delimiter
+        # Empty: invisible delimiter in LaTeX (e.g., piecewise functions: \left\{...\right.)
+        # Whitespace-only: OMML endChr/begChr with space value (e.g., m:val=" ")
+        #   → return empty string (no delimiter), NOT a dot, to prevent extra \right.
+        if not content or content.strip() == "":
+            if not content:
+                # Truly empty → invisible delimiter (for cases environment etc.)
+                result = "__DELIM__.__DELIM__"
+                debug_print(f"[DEBUG MO FENCE] Empty delimiter → {result!r}")
+                return result
+            else:
+                # Whitespace-only → skip entirely (no delimiter needed)
+                debug_print(f"[DEBUG MO FENCE] Whitespace-only fence content → skip (no delimiter)")
+                return ""
+
+        # Map common fences to LaTeX
+        fence_map = {
+            '(': '(',
+            ')': ')',
+            '[': '[',
+            ']': ']',
+            '{': '\\{',
+            '}': '\\}',
+            '|': '|',
+            '‖': '\\|',  # Double vertical bar
+            '⟨': '\\langle',
+            '⟩': '\\rangle',
+            '⌈': '\\lceil',
+            '⌉': '\\rceil',
+            '⌊': '\\lfloor',
+            '⌋': '\\rfloor',
+        }
+
+        latex_char = fence_map.get(content, content)
+
+        # Wrap in __DELIM__ markers so post-processor knows to add \left and \right
+        # ONLY delimiters with fence="true" get these markers
+        stretchy = node.get('stretchy')
+        if stretchy == 'true':
+            result = f"__DELIM__STRETCHY::{latex_char}__DELIM__"
+        else:
+            result = f"__DELIM__{latex_char}__DELIM__"
+
+        # Debug output
+        debug_print(f"[DEBUG MO FENCE] {content!r} → {result!r}")
+
+        return result
+
+    def _wrap_with_color(self, latex: str, node: ET.Element) -> str:
+        """
+        Wrap LaTeX with color command if node has color attribute.
+
+        Args:
+            latex: The LaTeX string to wrap
+            node: The element node
+
+        Returns:
+            LaTeX string, optionally wrapped with color command
+        """
+        # Use the centralized color wrapping utility with suppression support
+        from ..utils.color_helpers import wrap_element_with_color
+
+        # Get converter context from multiple sources (for backward compatibility):
+        # 1. Direct visitor context (set by legacy_adapter)
+        # 2. Strategy context (shared across all visitors, including child visitors)
+        context = getattr(self, '_converter_context', None)
+        if context is None and hasattr(self.strategy, '_converter_context'):
+            context = self.strategy._converter_context
+        
+        return wrap_element_with_color(latex, node, context)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """
+        Check if this visitor can handle the given node.
+
+        Args:
+            node: The MathML element to check
+
+        Returns:
+            True if node is an <mo> element, False otherwise
+        """
+        from ..utils import local_name as _local
+        return _local(node.tag) == 'mo'
+
+    def _should_preserve_space(self, node: ET.Element) -> bool:
+        """
+        Context-aware decision: should this space operator be preserved?
+
+        Analyzes the previous and next sibling elements to determine if the space
+        is redundant (LaTeX will add it automatically) or necessary.
+
+        Args:
+            node: The <mo> space element
+
+        Returns:
+            True if space should be preserved, False if it should be skipped
+        """
+        parent = node.getparent()
+        if parent is None:
+            return False  # No context, skip
+
+        siblings = list(parent)
+        try:
+            idx = siblings.index(node)
+        except ValueError:
+            return False  # Can't find in parent, skip
+
+        # Rule 1: Skip trailing spaces (no next element)
+        if idx >= len(siblings) - 1:
+            return False
+
+        # Get previous and next elements
+        prev_elem = siblings[idx - 1] if idx > 0 else None
+        next_elem = siblings[idx + 1]
+
+        # Rule 2: Get LaTeX representation of previous element
+        if prev_elem is not None:
+            prev_latex = self._peek_sibling_latex(prev_elem)
+
+            # Skip after operators with built-in spacing
+            if prev_latex.strip() in SKIP_SPACE_AFTER:
+                return False
+
+            # Skip after LaTeX functions (\sin, \cos, etc.)
+            # Check if converted from plain text to LaTeX command
+            if prev_latex.startswith('\\'):
+                func_name = prev_latex.lstrip('\\').split()[0] if prev_latex else ''
+                if func_name in {'sin', 'cos', 'tan', 'log', 'ln', 'exp',
+                                 'lim', 'max', 'min', 'sup', 'inf',
+                                 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh'}:
+                    return False
+
+        # Rule 3: Preserve before differentials
+        next_latex = self._peek_sibling_latex(next_elem)
+        if next_latex.strip() in PRESERVE_SPACE_BEFORE:
+            return True
+
+        # Rule 4: Default - skip (let LaTeX handle spacing)
+        return False
+
+    def _peek_sibling_latex(self, elem: ET.Element) -> str:
+        """
+        Convert a sibling element to LaTeX without full recursion.
+
+        This is a lightweight peek to check what LaTeX representation
+        the element would produce, used for context decisions.
+
+        Args:
+            elem: The sibling element to peek at
+
+        Returns:
+            LaTeX representation (simplified)
+        """
+        if elem is None:
+            return ""
+
+        tag = _local(elem.tag)
+
+        # For simple elements, just get text content
+        if tag == 'mi':
+            text = _text_content(elem).strip()
+            # Check if it's a function name
+            if text in {'sin', 'cos', 'tan', 'log', 'ln', 'exp',
+                       'lim', 'max', 'min', 'sup', 'inf'}:
+                return f'\\{text}'
+            return text
+
+        elif tag == 'mo':
+            text = _text_content(elem).strip()
+            # Common operator conversions
+            op_map = {
+                '×': '\\times', '÷': '\\div', '·': '\\cdot',
+                '≤': '\\leq', '≥': '\\geq', '≠': '\\neq',
+                '→': '\\rightarrow', '←': '\\leftarrow', '↔': '\\leftrightarrow',
+                '∨': '\\lor', '∧': '\\land', '¬': '\\neg',
+                '∩': '\\cap', '∪': '\\cup',
+                '⊥': '\\perp', '∥': '\\parallel',
+                '∈': '\\in', '⊆': '\\subseteq', '⊇': '\\supseteq',
+            }
+            return op_map.get(text, text)
+
+        elif tag == 'mn':
+            return _text_content(elem).strip()
+
+        else:
+            # For complex elements, return empty (conservative)
+            return ""
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mo'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MoVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mover_visitor.py b/scripts/omml_mathml2latex/visitors/mover_visitor.py
new file mode 100644
index 0000000..006a3f7
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mover_visitor.py
@@ -0,0 +1,911 @@
+r"""
+Visitor for <mover> (overscript/accent) MathML elements.
+
+The <mover> element represents content with something above it:
+- Accents: hat, tilde, bar, dot
+- Vector notation: arrow over variables
+- Chemical reactions: text over equals/arrow
+- General overscript: any content over base
+
+This implementation handles the most common cases with TODOs for advanced features.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MoverVisitor(Visitor):
+    r"""
+    Handles <mover> (overscript/accent) MathML elements.
+
+    Converts overscript and accent notation to appropriate LaTeX commands.
+
+    Examples:
+        Vector notation (arrow over variable):
+            <mover><mi>v</mi><mo>→</mo></mover> → \overrightarrow{v}
+
+        Bar/overline:
+            <mover><mi>x</mi><mo>¯</mo></mover> → \overline{x}
+
+        Tilde accent:
+            <mover><mi>x</mi><mo>~</mo></mover> → \tilde{x}
+
+        Hat/circumflex:
+            <mover><mi>x</mi><mo>^</mo></mover> → \hat{x}
+
+        Dot accent:
+            <mover><mi>x</mi><mo>˙</mo></mover> → \dot{x}
+
+        Double dot (ddot) accent:
+            <mover><mi>x</mi><mo>¨</mo></mover> → \ddot{x}
+
+        Triple dot (dddot) accent:
+            <mover><mi>x</mi><mo>⃛</mo></mover> → \dddot{x}
+
+        Overbrace with label:
+            <mover><mover><mn>3333</mn><mo>⏞</mo></mover><mn>222</mn></mover>
+            → \overbrace{3333}^{222}
+
+        Chemical reaction (xlongequal):
+            <mover accent="false"><mo>=</mo><mtext>heat</mtext></mover>
+            → \xlongequal{\text{heat}}
+
+        General overscript:
+            <mover accent="false"><mi>x</mi><mi>n</mi></mover> → \overset{n}{x}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mover visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mover> element to LaTeX.
+
+        Args:
+            node: The <mover> element to convert
+
+        Returns:
+            LaTeX string with appropriate overscript/accent notation
+
+        Raises:
+            ValueError: If node is not an <mover> element
+            ValueError: If mover has fewer than 2 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MoverVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # mover must have exactly 2 children: base and overscript
+        if len(children) < 2:
+            raise ValueError(
+                f"mover element must have 2 children (base, overscript), "
+                f"got {len(children)}"
+            )
+
+        # IMPORTANT: Check raw text content BEFORE converting children
+        # to properly detect bar/accent characters (e.g., "―" before it becomes "\textemdash")
+        over_raw_text = _text_content(children[1]).strip()
+
+        # Check for special data attributes (from OMML conversion)
+        if node.get("data-not-slash") == "true":
+            # \not command
+            base = self._convert_child(children[0])
+            return f"\\not{self._brace(base)}"
+
+        if node.get("data-chemical-reaction") == "true":
+            # Chemical reaction with text over arrow/equals
+            base = self._convert_child(children[0])
+            over = self._convert_child(children[1])
+            over_clean = self._strip_text_braces(over)
+            return f"\\xlongequal{self._brace(over_clean)}"
+
+        # Check for nested extensible arrow pattern: <mover><munder>arrow/equals<...>...</munder><...></mover>
+        # OR: <mover><mrow><munder>arrow/equals<...>...</munder></mrow><...></mover> (Word often adds mrow wrapper)
+        # This is Word's way of creating arrows with text above and below
+        munder_node = None
+        if _local(children[0].tag) == 'munder':
+            # Direct munder child
+            munder_node = children[0]
+        elif _local(children[0].tag) == 'mrow':
+            # Check if mrow contains munder as only significant child
+            mrow_children = list(children[0])
+            if len(mrow_children) == 1 and _local(mrow_children[0].tag) == 'munder':
+                munder_node = mrow_children[0]
+            else:
+                # Check if any child is munder (Word sometimes adds multiple mrows)
+                for child in mrow_children:
+                    if _local(child.tag) == 'munder':
+                        munder_node = child
+                        break
+
+        if munder_node is not None:
+            munder_children = list(munder_node)
+            if len(munder_children) >= 2:
+                # The arrow/equals might be in an mrow wrapper
+                base_node = munder_children[0]
+                if _local(base_node.tag) == 'mrow':
+                    # Unwrap mrow to find the actual operator
+                    mrow_children = list(base_node)
+                    if mrow_children and _local(mrow_children[0].tag) in ('mo', 'mi', 'mtext'):
+                        base_node = mrow_children[0]
+
+                # Check if base is an arrow or equals
+                xarrow_cmd = self._get_xarrow_command(base_node)
+                if xarrow_cmd:
+                    # Extract text from over and under (may be wrapped in <mphantom> or <mrow>)
+                    under = self._convert_child(munder_children[1])
+                    over = self._convert_child(children[1])
+                    # Clean up the text (remove \phantom{}, \mathrm{}, \text{}, extra spaces)
+                    under_clean = self._clean_arrow_text(under)
+                    over_clean = self._clean_arrow_text(over)
+
+                    # Re-wrap Chinese text and non-command text in \mathrm{} for chemistry mode
+                    # (since _clean_arrow_text removes it)
+                    # This is crucial for chemical reaction conditions like "加热", "控温", "电解"
+                    if hasattr(self.strategy, 'name') and self.strategy.name == "chemistry":
+                        # Check if text needs \mathrm{} wrapping
+                        # Skip if it's already a LaTeX command (starts with \) or empty
+                        # CRITICAL: Also skip pure numbers (like "1", "222", "2121")
+                        # Numbers should remain as plain numbers, not wrapped in \mathrm{}
+                        if over_clean and not over_clean.startswith("\\") and over_clean.strip():
+                            # Check if it's a pure number (digits only, possibly with decimal point)
+                            if not over_clean.replace('.', '', 1).isdigit():
+                                # Not a pure number - wrap it in \mathrm{}
+                                over_clean = f"\\mathrm{{{over_clean}}}"
+                        if under_clean and not under_clean.startswith("\\") and under_clean.strip():
+                            # Check if it's a pure number (digits only, possibly with decimal point)
+                            if not under_clean.replace('.', '', 1).isdigit():
+                                # Not a pure number - wrap it in \mathrm{}
+                                under_clean = f"\\mathrm{{{under_clean}}}"
+
+                    # Use \quad for empty positions (from <mphantom> elements)
+                    # This creates proper spacing in chemical equations
+                    if not under_clean or under_clean.strip() == "":
+                        under_clean = "\\quad"
+                    if not over_clean or over_clean.strip() == "":
+                        over_clean = "\\quad"
+
+                    return f"\\{xarrow_cmd}[{under_clean}]{{{over_clean}}}"
+
+        # Check for xlongequal pattern (equals sign with text above)
+        if self._is_equals_base(children[0]):
+            base = self._convert_child(children[0])
+            over = self._convert_child(children[1])
+            label = self._strip_text_braces(over)
+            return f"\\xlongequal{self._brace(label)}"
+
+        # Check for arc notation: arc/frown over multi-character content (line segments)
+        if self._is_arc_notation(node):
+            # Convert to arc notation with size modifiers
+            base_text = _text_content(children[0]).strip()
+            base = self._convert_child(children[0])
+            # Remove \mathrm{} wrapper - accent base should be italic
+            base_clean = self._strip_mathrm_for_accents(base)
+            # Use different sizes based on base length: \huge for 2 chars, \Huge for 3+ chars
+            if len(base_text) == 2:
+                return f"\\overset{{\\huge\\frown}}{self._brace(base_clean)}"
+            else:  # 3+ characters
+                return f"\\overset{{\\Huge\\frown}}{self._brace(base_clean)}"
+
+        # Check for vector notation (arrow over variables)
+        # CRITICAL: Need to unwrap mrow wrappers around arrows
+        # Pattern: <mover><base><mrow><mi>→</mi></mrow></mover>
+        over_to_check = children[1]
+        if _local(over_to_check.tag) == 'mrow':
+            # Unwrap mrow if it contains a single element
+            mrow_children = list(over_to_check)
+            if len(mrow_children) == 1:
+                over_to_check = mrow_children[0]
+
+        arrow_cmd = self._get_vector_arrow_cmd(children[0], over_to_check)
+        if arrow_cmd:
+            # Remove any \mathrm{} wrapping (vector variables should be italic)
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\{arrow_cmd}{self._brace(base_clean)}"
+
+        # Check for extensible arrow pattern (arrow as base)
+        # Pattern: <mover><mo>→</mo><content></mover>
+        # This produces \xrightarrow[\quad]{content} for chemical reaction arrows
+        #
+        # IMPORTANT: When arrow is the BASE of mover (not the overscript), it should use
+        # \xrightarrow format for extensible arrows with labels, NOT \overrightarrow.
+        # \overrightarrow is for vector notation where arrow is OVER variables.
+        base_to_check = children[0]
+        if _local(base_to_check.tag) == 'mrow':
+            # Unwrap mrow if it contains a single element
+            mrow_children = list(base_to_check)
+            if len(mrow_children) == 1:
+                base_to_check = mrow_children[0]
+
+        # Check if base is an arrow operator (extensible arrow for reaction notation)
+        # When arrow is the base element with content above, always use xrightarrow format
+        xarrow_cmd = self._get_xarrow_command(base_to_check)
+        if xarrow_cmd:
+            # Extensible arrow with content above
+            over = self._convert_child(children[1])
+            over_clean = self._clean_arrow_text(over)
+            # Use \quad for empty below position
+            return f"\\{xarrow_cmd}[\\quad]{self._brace(over_clean)}"
+
+        # Check for inverted vector notation (variables over arrow)
+        # CRITICAL: Need to unwrap mrow wrappers around arrows
+        # Pattern: <mover><mrow><mi>→</mi></mrow><content></mover>
+        inv_arrow_cmd = self._get_inverted_vector_arrow_cmd(base_to_check, children[1])
+        if inv_arrow_cmd:
+            # Variables are in over position
+            over = self._convert_child(children[1])
+            over_clean = self._strip_mathrm(over)
+            return f"\\{inv_arrow_cmd}{self._brace(over_clean)}"
+
+        # Check for bar/overline notation (using RAW text)
+        if self._is_bar_char(over_raw_text):
+            base = self._convert_child(children[0])
+            return f"\\overline{self._brace(base)}"
+
+        # Check for tilde accent (using RAW text)
+        if self._is_tilde_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            # Use \tilde for single char, \widetilde for multi-char
+            base_text = _text_content(children[0]).strip()
+            if len(base_text) == 1:
+                return f"\\tilde{self._brace(base_clean)}"
+            else:
+                return f"\\widetilde{self._brace(base_clean)}"
+
+        # Check for combining arrows from XSLT transformer
+        # U+20D7 = combining right arrow above → \overrightarrow OR \hat (depends on context)
+        # U+20D6 = combining left arrow above → \overleftarrow
+        if over_raw_text == "⃗":  # U+20D7 combining right arrow above
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            # Check if this is a default accent (hat) or explicit vector arrow
+            # XSLT adds data-default-accent="true" when chr is not specified in OMML
+            # Default (no chr) → \hat, Explicit chr="⃗" → \overrightarrow
+            if node.get('data-default-accent') == 'true':
+                return f"\\hat{self._brace(base_clean)}"
+            else:
+                return f"\\overrightarrow{self._brace(base_clean)}"
+
+        if over_raw_text == "⃖":  # U+20D6 combining left arrow above
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            # ALWAYS use overleftarrow for combining left arrow
+            return f"\\overleftarrow{self._brace(base_clean)}"
+
+        # Check for hat/circumflex accent (using RAW text)
+        if self._is_hat_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            # Use \hat for single char, \widehat for multi-char
+            base_text = _text_content(children[0]).strip()
+            if len(base_text) == 1:
+                return f"\\hat{self._brace(base_clean)}"
+            else:
+                return f"\\widehat{self._brace(base_clean)}"
+
+        # Check for dot accent (using RAW text)
+        if self._is_dot_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\dot{self._brace(base_clean)}"
+
+        # Check for breve accent (using RAW text)
+        if self._is_breve_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\breve{self._brace(base_clean)}"
+
+        # Check for harpoon accents (using RAW text)
+        harpoon_cmd = self._get_harpoon_cmd(over_raw_text)
+        if harpoon_cmd:
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\overset{{\\{harpoon_cmd}}}{self._brace(base_clean)}"
+
+        # Check for ddot (double dot) accent (using RAW text)
+        if self._is_ddot_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\ddot{self._brace(base_clean)}"
+
+        # Check for dddot (triple dot) accent (using RAW text)
+        if self._is_dddot_char(over_raw_text):
+            base = self._convert_child(children[0])
+            base_clean = self._strip_mathrm(base)
+            return f"\\dddot{self._brace(base_clean)}"
+
+        # Check for overbrace notation: nested mover with brace character
+        # Pattern 1: mover(mover(base, ⏞), label) → \overbrace{base}^{label}
+        # Pattern 2: mover(mover(⏞, base), label) → \overbrace{base}^{label} [NEW - vertJc="bot" case]
+        # OR: mover(mrow(mover(...)), label) with mrow wrapper (Word often wraps inner mover)
+        # This is how Word encodes overbrace with labels
+        inner_mover = None
+        if len(children) >= 2:
+            # Check if first child is mover directly
+            if _local(children[0].tag) == 'mover':
+                inner_mover = children[0]
+            # Check if first child is mrow containing mover
+            elif _local(children[0].tag) == 'mrow':
+                mrow_children = list(children[0])
+                # Look for mover inside mrow (may be the only child or one of several)
+                for child in mrow_children:
+                    if _local(child.tag) == 'mover':
+                        inner_mover = child
+                        break
+
+            # Process the inner mover if found
+            if inner_mover is not None:
+                inner_children = list(inner_mover)
+                if len(inner_children) >= 2:
+                    # Pattern 1: Check if inner mover's second child is the overbrace character
+                    inner_over_text = _text_content(inner_children[1]).strip()
+                    if inner_over_text == "⏞":  # U+23DE Overbrace character
+                        # Extract base from inner mover (first child)
+                        inner_base = self._convert_child(inner_children[0])
+                        # Extract label from outer mover (second child)
+                        label = self._convert_child(children[1])
+                        # Return proper overbrace with superscript label
+                        return f"\\overbrace{self._brace(inner_base)}^{self._brace(label)}"
+
+                    # Pattern 2: Check if inner mover's first child is the overbrace character
+                    # This happens when vertJc="bot" in OMML groupChr
+                    inner_base_text = _text_content(inner_children[0]).strip()
+                    if inner_base_text == "⏞":  # U+23DE Overbrace character as base
+                        # Extract base from inner mover (second child - content above the brace)
+                        inner_base = self._convert_child(inner_children[1])
+                        # Extract label from outer mover (second child)
+                        label = self._convert_child(children[1])
+                        # Return proper overbrace with superscript label
+                        return f"\\overbrace{self._brace(inner_base)}^{self._brace(label)}"
+
+        # Check for ALTERNATIVE overbrace pattern (Word sometimes uses this)
+        # Pattern: mover(munder(base, ⏞), label) → \overbrace{base}^{label}
+        # OR: mover(mrow(munder(base, ⏞)), label) with mrow wrapper
+        # The brace character ⏞ is in the UNDER position but still represents overbrace
+        if len(children) >= 2:
+            # Check if first child is munder (directly or inside mrow)
+            inner_munder = None
+            if _local(children[0].tag) == 'munder':
+                inner_munder = children[0]
+            elif _local(children[0].tag) == 'mrow':
+                # Check inside mrow wrapper
+                for child in children[0]:
+                    if _local(child.tag) == 'munder':
+                        inner_munder = child
+                        break
+
+            if inner_munder is not None:
+                inner_children = list(inner_munder)
+                if len(inner_children) >= 2:
+                    # Check if inner munder's second child is the overbrace character
+                    inner_under_text = _text_content(inner_children[1]).strip()
+                    if inner_under_text == "⏞":  # U+23DE Overbrace character in under position
+                        # Extract base from inner munder (first child)
+                        inner_base = self._convert_child(inner_children[0])
+                        # Extract label from outer mover (second child)
+                        label = self._convert_child(children[1])
+                        # Return proper overbrace with superscript label
+                        return f"\\overbrace{self._brace(inner_base)}^{self._brace(label)}"
+
+        # TODO: Additional accent types (rarely used in mathematical notation)
+        # - Check (caron): ˇ character → \check{x}
+        # - Acute: ´ character → \acute{x}
+        # - Grave: ` character → \grave{x}
+
+        # CRITICAL FIX: Check if base is a large operator (max, min, lim, etc.)
+        # Word incorrectly produces <mover> for operators that should use subscripts
+        # Example: <mover><mi>max</mi><mrow>condition</mrow></mover>
+        # Should become: \max_{condition}, NOT \overset{condition}{max}
+        if self._is_large_operator(children[0]):
+            # Use subscript for operator limits, treating the "over" content as "under"
+            base = self._convert_child(children[0])
+            limit = self._convert_child(children[1])
+            return f"{base}\\limits_{self._brace(limit)}"
+
+        # Default: general overscript using \overset
+        base = self._convert_child(children[0])
+        over = self._convert_child(children[1])
+        return f"\\overset{self._brace(over)}{self._brace(base)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mover, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _is_equals_base(self, base_node: ET.Element) -> bool:
+        """Check if base is an equals sign."""
+        if _local(base_node.tag) == 'mo':
+            return _text_content(base_node).strip() == '='
+        return False
+
+    def _get_vector_arrow_cmd(self, base_node: ET.Element, over_node: ET.Element) -> str:
+        """Get vector arrow command if pattern matches (arrow over variables/numbers)."""
+        # Check if base is a variable (mi), number (mn), expression (mrow), or complex expression
+        # Include fractions, superscripts, subscripts, roots, etc. as valid bases for vector arrows
+        if _local(base_node.tag) not in ['mi', 'mn', 'mrow', 'mfrac', 'msup', 'msub', 'msubsup', 'msqrt', 'mroot']:
+            return ""
+
+        # Check if over is an arrow
+        # CRITICAL FIX: OMML→MathML conversion often puts arrows in <mi> tags instead of <mo>
+        # Must check BOTH <mo> AND <mi> tags for arrow symbols
+        if _local(over_node.tag) not in ['mo', 'mi']:
+            return ""
+
+        over_text = _text_content(over_node).strip()
+
+        # NOTE: Only single arrows (→, ←, ↔) are used for vector notation
+        # Double arrows (⇒, ⇐, ⇔) should use overset with \Longrightarrow, not overrightarrow
+        arrow_map = {
+            "→": "overrightarrow",
+            "\\rightarrow": "overrightarrow",
+            "←": "overleftarrow",
+            "\\leftarrow": "overleftarrow",
+            "↔": "overleftrightarrow",
+            "\\leftrightarrow": "overleftrightarrow",
+        }
+
+        return arrow_map.get(over_text, "")
+
+    def _get_inverted_vector_arrow_cmd(self, base_node: ET.Element, over_node: ET.Element) -> str:
+        """Get vector arrow command if pattern matches (variables over arrow)."""
+        # Check if base is an arrow
+        # CRITICAL FIX: OMML→MathML conversion often puts arrows in <mi> tags instead of <mo>
+        # Must check BOTH <mo> AND <mi> tags for arrow symbols
+        if _local(base_node.tag) not in ['mo', 'mi']:
+            return ""
+
+        base_text = _text_content(base_node).strip()
+
+        # NOTE: Only single arrows (→, ←, ↔) are used for vector notation
+        # Double arrows (⇒, ⇐, ⇔) should use overset with \Longrightarrow, not overrightarrow
+        arrow_map = {
+            "→": "overrightarrow",
+            "\\rightarrow": "overrightarrow",
+            "←": "overleftarrow",
+            "\\leftarrow": "overleftarrow",
+            "↔": "overleftrightarrow",
+            "\\leftrightarrow": "overleftrightarrow",
+        }
+
+        # Check if over is variable-like content or complex expression
+        if _local(over_node.tag) in ['mi', 'mn', 'mrow', 'mfrac', 'msup', 'msub', 'msubsup', 'msqrt', 'mroot']:
+            return arrow_map.get(base_text, "")
+
+        return ""
+
+    def _is_bar_char(self, latex_str: str) -> bool:
+        """Check if string represents a bar/overline character."""
+        bar_chars = [
+            "¯", "‾", "―", "−", "⎺", "⎻", "-", "_",
+            "̅",  # U+0305 combining overline (used in OMML m:acc)
+        ]
+        return latex_str.strip() in bar_chars
+
+    def _is_tilde_char(self, latex_str: str) -> bool:
+        """Check if string represents a tilde character."""
+        tilde_chars = [
+            "~", "˜", "∼", "\\tilde",
+            "̃",  # U+0303 combining tilde (used in OMML m:acc)
+        ]
+        return latex_str.strip() in tilde_chars
+
+    def _is_hat_char(self, latex_str: str) -> bool:
+        """Check if string represents a hat/circumflex character."""
+        hat_chars = [
+            "^", "ˆ", "︶", "∧", "\\hat",
+            "̂",  # U+0302 combining circumflex (used in OMML m:acc)
+        ]
+        return latex_str.strip() in hat_chars
+
+    def _is_dot_char(self, latex_str: str) -> bool:
+        """Check if string represents a dot character."""
+        dot_chars = [
+            "˙", ".", "·", "∙", "\\dot",
+            "̇",  # U+0307 combining dot above (used in OMML m:acc)
+        ]
+        return latex_str.strip() in dot_chars
+
+    def _is_ddot_char(self, latex_str: str) -> bool:
+        """Check if string represents a ddot (double dot/diaeresis) character."""
+        # Double dot characters (diaeresis/umlaut)
+        ddot_chars = [
+            "¨",      # U+00A8 diaeresis (standalone)
+            "̈",       # U+0308 combining diaeresis
+            "‥",      # U+2025 two dot leader
+            "__DDOT__",  # Placeholder from symbol mapping
+            "\\ddot",
+        ]
+        return latex_str.strip() in ddot_chars
+
+    def _is_dddot_char(self, latex_str: str) -> bool:
+        """Check if string represents a dddot (triple dot) character."""
+        # Triple dot characters
+        dddot_chars = [
+            "⃛",      # U+20DB combining three dots above
+            "⋮",      # U+22EE vertical ellipsis (sometimes used)
+            "︙",      # U+FE19 presentation form vertical ellipsis
+            "__DDDOT__",  # Placeholder from symbol mapping
+            "\\dddot",
+        ]
+        return latex_str.strip() in dddot_chars
+
+    def _is_breve_char(self, latex_str: str) -> bool:
+        """Check if string represents a breve character."""
+        breve_chars = ["̆", "˘", "\\breve"]  # U+0306 combining breve, U+02D8 breve
+        return latex_str.strip() in breve_chars
+
+    def _get_harpoon_cmd(self, latex_str: str) -> str:
+        """Get harpoon LaTeX command if string represents a harpoon character.
+
+        Returns:
+            The LaTeX command name (without backslash) if harpoon, empty string otherwise.
+        """
+        harpoon_map = {
+            "⃐": "leftharpoonup",       # U+20D0 Combining left harpoon above
+            "⃑": "rightharpoonup",      # U+20D1 Combining right harpoon above
+            "⇀": "rightharpoonup",      # U+21C0 Right harpoon up
+            "↼": "leftharpoonup",       # U+21BC Left harpoon up
+            "⇁": "rightharpoondown",    # U+21C1 Right harpoon down
+            "↽": "leftharpoondown",     # U+21BD Left harpoon down
+        }
+        return harpoon_map.get(latex_str.strip(), "")
+
+    def _strip_text_braces(self, latex_str: str) -> str:
+        r"""Remove \text{...} wrapper if present."""
+        import re
+        match = re.match(r'\\text\{(.+)\}', latex_str)
+        if match:
+            return match.group(1)
+        return latex_str
+
+    def _strip_mathrm(self, latex_str: str) -> str:
+        r"""Remove \mathrm{...} wrapper if present."""
+        import re
+        # Remove \mathrm{} wrappers
+        latex_str = re.sub(r'\\mathrm\{([a-zA-Z0-9]+)\}', r'\1', latex_str)
+        # Remove spaces in vector notation (a b c -> abc)
+        if re.match(r'^[a-zA-Z0-9](\s+[a-zA-Z0-9])+$', latex_str):
+            latex_str = re.sub(r'\s+', '', latex_str)
+        return latex_str
+
+    def _get_xarrow_command(self, base_node: ET.Element) -> str:
+        """
+        Get extensible arrow command for the base element.
+
+        Returns command name (without backslash) if base is an arrow/equals,
+        otherwise returns empty string.
+
+        Supported arrows:
+        - = → xlongequal
+        - → → xrightarrow
+        - ← → xleftarrow
+        - ↔ → xleftrightarrow
+        - ⇌ → xrightleftharpoons
+        """
+        # Accept <mo> (operator), <mi> (identifier), and <mtext> (text) elements for arrows
+        # Word's XSLT sometimes produces <mi> for arrows instead of <mo>
+        if _local(base_node.tag) not in ('mo', 'mi', 'mtext'):
+            return ""
+
+        base_text = _text_content(base_node).strip()
+
+        # Map arrow symbols to xarrow commands
+        arrow_map = {
+            "=": "xlongequal",
+            "→": "xrightarrow",
+            "\\rightarrow": "xrightarrow",
+            "←": "xleftarrow",
+            "\\leftarrow": "xleftarrow",
+            "↔": "xleftrightarrow",
+            "\\leftrightarrow": "xleftrightarrow",
+            "⟷": "xleftrightarrow",  # U+27F7 long left-right arrow
+            "\\longleftrightarrow": "xleftrightarrow",
+            "⇌": "xrightleftharpoons",
+            "\\rightleftharpoons": "xrightleftharpoons",
+        }
+
+        return arrow_map.get(base_text, "")
+
+    def _clean_arrow_text(self, text: str) -> str:
+        """
+        Clean up text for use in arrow labels.
+
+        Removes:
+        - \\phantom{} wrappers (Word uses these for arrow labels)
+        - \\text{} wrappers (content preserved)
+        - Extra spaces between characters
+
+        NOTE: \\mathrm{} wrappers are PRESERVED because they represent explicit
+        styling from the source document (mathvariant="normal" in MathML).
+        """
+        import re
+
+        # Helper function to remove LaTeX commands with balanced braces
+        def remove_command(text: str, command: str) -> str:
+            """Remove LaTeX command with proper brace balancing.
+
+            Args:
+                text: Input text with LaTeX commands
+                command: Command to remove (e.g., "\\mathrm" or "mathrm")
+            """
+            # Normalize command: ensure it starts with backslash
+            if not command.startswith('\\'):
+                command = '\\' + command
+
+            while command in text:
+                # Find the command
+                idx = text.find(command)
+                if idx == -1:
+                    break
+
+                # Find the opening brace (should be right after command)
+                brace_start = idx + len(command)
+                if brace_start >= len(text) or text[brace_start] != '{':
+                    break  # Malformed - no opening brace
+
+                # Match balanced braces
+                brace_count = 1
+                pos = brace_start + 1
+                while pos < len(text) and brace_count > 0:
+                    if text[pos] == '{' and (pos == 0 or text[pos-1] != '\\'):
+                        brace_count += 1
+                    elif text[pos] == '}' and (pos == 0 or text[pos-1] != '\\'):
+                        brace_count -= 1
+                    pos += 1
+
+                if brace_count == 0:
+                    # Successfully matched braces
+                    content = text[brace_start+1:pos-1]
+                    text = text[:idx] + content + text[pos:]
+                else:
+                    break  # Malformed braces
+
+            return text
+
+        # Remove \phantom{} wrappers (Word's equation editor uses these for arrow labels)
+        text = remove_command(text, '\\phantom')
+
+        # NOTE: Do NOT remove \mathrm{} wrappers - they represent explicit styling
+        # from mathvariant="normal" in the source MathML, indicating the author
+        # wanted upright text (important for chemistry formulas like NH3·H2O)
+
+        # Remove \text{} wrappers (but keep the content)
+        # For Chinese text, we want to preserve it as-is
+        text = remove_command(text, '\\text')
+
+        # Remove extra spaces between individual characters
+        # "高 压" → "高压", but preserve intentional spaces in phrases
+        text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])', '', text)
+
+        # For non-Chinese text with spaces between each char, remove spaces
+        # "a b c" → "abc", but "word1 word2" stays as-is
+        if len(text.replace(' ', '')) > 0:
+            # Check if it's all single chars separated by spaces
+            parts = text.split()
+            if all(len(p) == 1 for p in parts):
+                text = ''.join(parts)
+
+        return text.strip()
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def _is_arc_notation(self, mover_node: ET.Element) -> bool:
+        """
+        Check if mover represents arc notation (frown/arc over multi-char content).
+
+        Arc notation is used for line segments like AB̂.
+
+        Args:
+            mover_node: The mover element to check
+
+        Returns:
+            True if this represents arc notation, False otherwise
+        """
+        if len(mover_node) < 2:
+            return False
+
+        base_node = mover_node[0]
+        over_node = mover_node[1]
+
+        # Check if the over content is an arc/frown character
+        if _local(over_node.tag) in ["mtext", "mo"]:
+            over_text = _text_content(over_node).strip()
+            # Arc characters (frown/smile used as arc over multiple characters)
+            arc_characters = [
+                "⌢",      # Frown (upward arc) - used for arc over segments
+                "︵",      # Top parenthesis
+                "⁀",      # Character tie
+            ]
+
+            if over_text in arc_characters:
+                base_text = _text_content(base_node).strip()
+                # Arc notation is used for multi-character bases (line segments)
+                # For 2+ characters, use \overset{\frown} or widehat
+                if len(base_text) >= 2:
+                    return True
+
+        return False
+
+    def _strip_mathrm_for_accents(self, latex: str) -> str:
+        """
+        Remove \\mathrm{} wrapper from content that will be used in accent notations.
+
+        Accent base content (like AB in \\widetilde{AB}) should remain italic, not upright.
+
+        Args:
+            latex: LaTeX string possibly wrapped in \\mathrm{}
+
+        Returns:
+            LaTeX string with \\mathrm{} removed if present
+        """
+        import re
+        # Match \mathrm{content} and extract just the content
+        pattern = r'^\\mathrm\{(.+)\}$'
+        match = re.match(pattern, latex)
+        if match:
+            return match.group(1)
+        return latex
+
+    def _is_large_operator(self, base_node: ET.Element) -> bool:
+        """
+        Check if base is a large operator (sum, integral, product, max, min, lim, etc.).
+
+        Recursively searches through wrapper elements like <mstyle>, <mrow>, <mpadded>
+        to find the actual operator, since Word often wraps large operators.
+
+        This is used to detect when Word incorrectly uses <mover> for operators
+        that should use subscripts (e.g., max, min, lim).
+        """
+        if base_node is None:
+            return False
+
+        tag = _local(base_node.tag)
+
+        # Define large operators list (same as in MunderVisitor)
+        large_ops = [
+            "∑", "\\sum",          # Summation
+            "∏", "\\prod",         # Product
+            "∐", "\\coprod",       # Coproduct
+            "∫", "\\int",          # Integral
+            "∬", "\\iint",         # Double integral
+            "∭", "\\iiint",        # Triple integral
+            "∮", "\\oint",         # Contour integral
+            "⋃", "\\bigcup",       # Union
+            "⋂", "\\bigcap",       # Intersection
+            "⋁", "\\bigvee",       # Logical OR
+            "⋀", "\\bigwedge",     # Logical AND
+            "⨁", "\\bigoplus",     # Direct sum
+            "⨂", "\\bigotimes",    # Tensor product
+            "⨄", "\\biguplus",     # Multiset union
+            "lim", "\\lim",        # Limit (often in <mi> from Word)
+            "sup", "\\sup",        # Supremum
+            "inf", "\\inf",        # Infimum
+            "max", "\\max",        # Maximum
+            "min", "\\min",        # Minimum
+        ]
+
+        # Check direct <mo> or <mi> elements
+        if tag in ('mo', 'mi'):
+            base_text = _text_content(base_node).strip()
+            return base_text in large_ops
+
+        # Recursively search through wrapper elements (mstyle, mrow, mpadded, menclose)
+        if tag in ('mstyle', 'mrow', 'mpadded', 'menclose'):
+            for child in base_node:
+                if self._is_large_operator(child):
+                    return True
+
+        return False
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mover'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mover'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MoverVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mpadded_visitor.py b/scripts/omml_mathml2latex/visitors/mpadded_visitor.py
new file mode 100644
index 0000000..b067272
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mpadded_visitor.py
@@ -0,0 +1,198 @@
+r"""
+Visitor for <mpadded> (padded content) MathML elements.
+
+The <mpadded> element is used to adjust the spacing and positioning of its content
+by adding padding. It supports attributes like width, height, depth, lwidth, and voffset.
+
+In LaTeX conversion, mpadded is typically treated as a transparent wrapper since
+LaTeX doesn't have a direct equivalent for fine-grained spacing control. The padding
+attributes are generally ignored, and only the content is converted.
+
+This visitor acts as a transparent container, similar to <mrow>.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MpaddedVisitor(Visitor):
+    r"""
+    Handles <mpadded> (padded content) MathML elements.
+
+    Acts as a transparent wrapper, converting only the content without
+    applying padding attributes (LaTeX doesn't have direct equivalents).
+
+    Examples:
+        Simple padding (transparent):
+            <mpadded width="+1em"><mi>x</mi></mpadded>
+            → x
+
+        Padded expression:
+            <mpadded lspace="0.5em"><mrow><mi>a</mi><mo>+</mo><mi>b</mi></mrow></mpadded>
+            → a+b
+
+        Padded fraction:
+            <mpadded height="+1em"><mfrac><mi>a</mi><mi>b</mi></mfrac></mpadded>
+            → \frac{a}{b}
+
+        Empty padding:
+            <mpadded width="0em"><mi>x</mi></mpadded>
+            → x
+
+    Note:
+        MathML padding attributes (width, height, depth, lwidth, voffset) are
+        intentionally ignored in LaTeX conversion as there's no direct equivalent.
+        For precise spacing control in LaTeX, use \hspace{}, \vspace{}, or \phantom{}.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mpadded visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mpadded> element to LaTeX (transparent wrapper).
+
+        Padding attributes are ignored in conversion.
+
+        Args:
+            node: The <mpadded> element to convert
+
+        Returns:
+            LaTeX string with content only (no padding applied)
+
+        Raises:
+            ValueError: If node is not a <mpadded> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MpaddedVisitor cannot handle element '{node.tag}'")
+
+        # Simply convert children, ignoring padding attributes
+        return self._convert_children(node)
+
+    def _convert_children(self, node: ET.Element) -> str:
+        """
+        Convert all child elements to LaTeX.
+
+        Args:
+            node: The <mpadded> element
+
+        Returns:
+            LaTeX string with all children converted
+        """
+        parts = []
+        for child in node:
+            parts.append(self._convert_child(child))
+        return ''.join(parts)
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mpadded, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mpadded'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mpadded'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MpaddedVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mphantom_visitor.py b/scripts/omml_mathml2latex/visitors/mphantom_visitor.py
new file mode 100644
index 0000000..6b9555a
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mphantom_visitor.py
@@ -0,0 +1,204 @@
+r"""
+Visitor for <mphantom> (phantom/invisible content) MathML elements.
+
+The <mphantom> element renders its content invisibly but reserves the space
+it would normally occupy. This is useful for alignment and spacing purposes.
+
+In LaTeX, this is converted using the \phantom{} command.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MphantomVisitor(Visitor):
+    r"""
+    Handles <mphantom> (phantom/invisible content) MathML elements.
+
+    Converts phantom content to LaTeX \phantom{} command, which creates
+    an invisible placeholder that reserves space.
+
+    Examples:
+        Simple phantom:
+            <mphantom><mi>x</mi></mphantom>
+            → \phantom{x}
+
+        Phantom expression:
+            <mphantom><mrow><mi>a</mi><mo>+</mo><mi>b</mi></mrow></mphantom>
+            → \phantom{a+b}
+
+        Phantom for alignment:
+            <mrow>
+                <mi>x</mi>
+                <mphantom><mo>+</mo></mphantom>
+                <mi>y</mi>
+            </mrow>
+            → x\phantom{+}y
+
+        Phantom fraction:
+            <mphantom><mfrac><mi>a</mi><mi>b</mi></mfrac></mphantom>
+            → \phantom{\frac{a}{b}}
+
+    Note:
+        The phantom command is useful for:
+        - Vertical alignment across equations
+        - Horizontal spacing that matches specific content
+        - Creating symmetric layouts
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mphantom visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mphantom> element to LaTeX \phantom{} command.
+
+        Args:
+            node: The <mphantom> element to convert
+
+        Returns:
+            LaTeX string with \phantom{content}
+
+        Raises:
+            ValueError: If node is not a <mphantom> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MphantomVisitor cannot handle element '{node.tag}'")
+
+        # Convert children to get the content
+        content = self._convert_children(node)
+
+        # If empty, return empty phantom
+        if not content or not content.strip():
+            return "\\phantom{}"
+
+        # Wrap content in \phantom{}
+        return f"\\phantom{{{content}}}"
+
+    def _convert_children(self, node: ET.Element) -> str:
+        """
+        Convert all child elements to LaTeX.
+
+        Args:
+            node: The <mphantom> element
+
+        Returns:
+            LaTeX string with all children converted
+        """
+        parts = []
+        for child in node:
+            parts.append(self._convert_child(child))
+        return ''.join(parts)
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mphantom, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mphantom'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mphantom'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MphantomVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mroot_visitor.py b/scripts/omml_mathml2latex/visitors/mroot_visitor.py
new file mode 100644
index 0000000..f14a1b1
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mroot_visitor.py
@@ -0,0 +1,201 @@
+r"""
+Visitor for <mroot> (nth root) MathML elements.
+
+The <mroot> element represents nth roots with explicit index.
+The LaTeX conversion uses \sqrt[n]{...} notation.
+
+Note: When index is 2, optimizes to \sqrt{...} (standard square root).
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MrootVisitor(Visitor):
+    r"""
+    Handles <mroot> (nth root) MathML elements.
+
+    Converts nth root expressions to LaTeX \sqrt[n]{...} notation.
+    Optimizes square roots (index=2) to \sqrt{...}.
+
+    Examples:
+        Cube root:
+            <mroot><mi>x</mi><mn>3</mn></mroot> → \sqrt[3]{x}
+
+        Fourth root:
+            <mroot><mn>16</mn><mn>4</mn></mroot> → \sqrt[4]{16}
+
+        Square root (optimized):
+            <mroot><mi>x</mi><mn>2</mn></mroot> → \sqrt{x}
+
+        Variable index:
+            <mroot><mi>x</mi><mi>n</mi></mroot> → \sqrt[n]{x}
+
+        Complex base:
+            <mroot>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mn>3</mn>
+            </mroot>
+            → \sqrt[3]{x + 1}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mroot visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mroot> element to LaTeX.
+
+        Args:
+            node: The <mroot> element to convert
+
+        Returns:
+            LaTeX nth root string (\sqrt[n]{content} or \sqrt{content})
+
+        Raises:
+            ValueError: If node is not an <mroot> element
+            ValueError: If mroot has fewer than 2 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MrootVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # mroot must have exactly 2 children: base and index
+        # Handle malformed input gracefully for MathJax compatibility
+        if len(children) < 2:
+            if len(children) == 0:
+                return "\\sqrt{}"
+            elif len(children) == 1:
+                # Only base provided, assume square root
+                base = self._convert_child(children[0])
+                return f"\\sqrt{self._brace(base)}"
+
+        # Convert base (radicand) and index (root degree)
+        base = self._convert_child(children[0])
+        index = self._convert_child(children[1])
+
+        # Optimize: omit [2] for square roots (standard mathematical notation)
+        # Also omit empty brackets [] when index is empty
+        index_stripped = index.strip()
+        if index_stripped == "2" or not index_stripped:
+            return f"\\sqrt{self._brace(base)}"
+        else:
+            return f"\\sqrt[{index}]{self._brace(base)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mroot, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mroot'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mroot'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MrootVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mrow_visitor.py b/scripts/omml_mathml2latex/visitors/mrow_visitor.py
new file mode 100644
index 0000000..c00f62f
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mrow_visitor.py
@@ -0,0 +1,1665 @@
+"""
+Visitor for <mrow> (row/container) MathML elements.
+
+The <mrow> element is a container that groups mathematical expressions.
+It's the most fundamental structural element in MathML, used to:
+- Group operands and operators
+- Delimit expressions with parentheses/brackets
+- Contain complex expressions (numerators, exponents, etc.)
+
+Basic behavior: Convert all children and join with spaces.
+"""
+
+from typing import Tuple, Optional
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..core.context import ConversionContext
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MrowVisitor(Visitor):
+    r"""
+    Handles <mrow> (row/container) MathML elements.
+
+    The mrow element is a container that groups mathematical content.
+    Basic behavior is to convert all children and join them with spaces.
+
+    In script contexts (subscripts/superscripts), multiple consecutive
+    identifiers/numbers are joined without spaces, since they usually form
+    a single composite index like \(x_{ij}\) or \(K_{a1}\).
+
+    Examples:
+        Simple grouping:
+            <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow> → x + 1
+
+        In fractions:
+            <mfrac>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mn>2</mn>
+            </mfrac>
+            → \dfrac{x + 1}{2}
+
+        With parentheses:
+            <mrow>
+              <mo>(</mo>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mo>)</mo>
+            </mrow>
+            → ( x + 1 )
+
+    TODO (Future Enhancements):
+        - Fragmented function detection (sin split as s-i-n)
+        - Chemical formula pattern detection
+        - Absolute value notation (|x|)
+        - Mixed delimiter handling
+        - Delimiter-only rows (preserve spacing)
+        - Cross-mrow fragmented units
+        - Numeric mtext merging
+    """
+
+    def __init__(self, strategy: Strategy, context: ConversionContext = None):
+        """Initialize the Mrow visitor."""
+        super().__init__(strategy)
+        self.context = context
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <mrow> element to LaTeX.
+
+        Args:
+            node: The <mrow> element to convert
+
+        Returns:
+            LaTeX string with children joined by spaces
+
+        Raises:
+            ValueError: If node is not an <mrow> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MrowVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # Empty mrow returns empty string
+        if not children:
+            return ""
+
+        # Pattern 1: Fragmented function detection (sin split as s-i-n)
+        fragmented_function = self._is_fragmented_function_row(node)
+        if fragmented_function:
+            return self._handle_fragmented_function(node, fragmented_function)
+
+        # Pattern 2: Chemical formula pattern - DISABLED
+        # REASON: Always adding spaces is safer. Even H2O with mathvariant="normal"
+        # will render correctly as \mathrm{H} 2 \mathrm{O}. No need for heuristic merging.
+        # if self._detect_chemical_formula_pattern(node):
+        #     return self._merge_chemical_formula(node)
+
+        # Pattern 2.5: Fragmented chemical elements with charge - DISABLED
+        # REASON: Same as Pattern 2. Spaces are safe; heuristics cause false positives.
+        # if self._detect_fragmented_element_with_charge(node):
+        #     return self._merge_fragmented_element_with_charge(node)
+
+        # Pattern 3: Cross-mrow fragmented units
+        if self._has_cross_mrow_fragmented_units(node):
+            return self._merge_cross_mrow_fragmented_units(node)
+
+        # Pattern 4: Set notation {x | condition}
+        if self._is_set_notation_row(node):
+            return self._handle_set_notation_row(node)
+
+        # Pattern 5: Absolute value notation |x|
+        if self._is_absolute_value_row(node):
+            return self._handle_absolute_value_row(node)
+
+        # Pattern 6: Mixed delimiter row
+        if self._is_mixed_delimiter_row(node):
+            return self._handle_mixed_delimiter_row(node)
+
+        # Pattern 7: Delimiter-only row (preserve spacing)
+        if self._is_delimiter_only_row(node):
+            return self._convert_children_no_space(node)
+
+        # Pattern 8: Chemical formula row - DISABLED
+        # REASON: Subject detection is obsolete. We now rely solely on mathvariant="normal"
+        # to determine when to use \mathrm{}. Chemical formulas with mathvariant="normal"
+        # will be properly formatted. Always adding spaces is safer than heuristic removal.
+        # if self._is_chemical_formula_row(node):
+        #     return self._convert_children_no_space(node)
+
+        # Pattern 9: Numeric mtext merging ("1" + "0 mol" → "10 mol")
+        if self._should_merge_numeric_mtext(node):
+            return self._merge_numeric_mtext_elements(node)
+
+        # Pattern 10: Fragmented units (m-o-l → mol)
+        if self._should_merge_fragmented_units(node):
+            return self._merge_fragmented_units(node)
+
+        # Check if this mrow has delimiters that need scaling
+        # This matches the original converter's behavior of adding \left and \right
+        # when parentheses contain fractions
+        delimiter_info = self._detect_delimiters(children)
+        if delimiter_info:
+            return self._handle_delimited_content(children, delimiter_info)
+
+        # Default: Convert all children and join with spaces
+        # IMPORTANT: Use _convert_children_with_spaces() which checks for
+        # fragmented functions at each position (not just at the start of mrow)
+        #
+        # EXCEPTION: Inside subscripts/superscripts, consecutive identifiers
+        # normally form a single composite index (e.g., x_{ij}, K_{a1}).
+        # Join them without spaces to preserve that semantic grouping.
+        if self.context and self.context.in_script_context():
+            result = self._convert_children_no_space(node)
+        else:
+            result = self._convert_children_with_spaces(node)
+
+        # Don't strip if result ends with LaTeX space command '\ '
+        # The trailing space in '\ ' is semantically significant
+        if result.endswith('\\ '):
+            return result
+        else:
+            return result.strip()
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """
+        Convert a child element to LaTeX.
+
+        This method instantiates the appropriate visitor for each child type.
+        """
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            # Recursive: mrow can contain other mrow elements
+            # Pass context so nested mrows also respect script context
+            return MrowVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            # This should rarely happen now that most MathML elements are covered
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mrow, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _detect_delimiters(self, children: list) -> dict:
+        """
+        Detect if this mrow contains delimiters (parentheses, brackets, etc.).
+
+        Returns dict with delimiter info if found, None otherwise.
+        Pattern: <mo>(</mo> ... content ... <mo>)</mo>
+
+        NOTE: Skips <mo fence="true"> elements to let them be handled by mo_visitor,
+        which will add __DELIM__ markers for the delimiter pairing processor.
+        """
+        if len(children) < 3:
+            return None
+
+        # Check if first child is an opening delimiter
+        first_child = children[0]
+        if _local(first_child.tag) != 'mo':
+            return None
+
+        # CRITICAL FIX (Phase 2): Skip fence delimiters - let mo_visitor handle them
+        # This ensures XSLT-generated <mo fence="true"> elements get __DELIM__ markers
+        # and are processed by the universal delimiter pairing processor
+        if first_child.get('fence') == 'true':
+            return None
+
+        # CRITICAL FIX (Phase 3): Skip sticky delimiters - let mo_visitor handle them
+        # This supports <mo stretchy="true"> which should force scaling via PostProcessor
+        if first_child.get('stretchy') == 'true':
+            return None
+
+        first_text = _text_content(first_child).strip()
+        if first_text not in '([{':
+            return None
+
+        # Check if last child is a closing delimiter
+        last_child = children[-1]
+        if _local(last_child.tag) != 'mo':
+            return None
+
+        # Also check last child for fence attribute
+        if last_child.get('fence') == 'true':
+            return None
+
+        # Also check last child for stretchy attribute
+        if last_child.get('stretchy') == 'true':
+            return None
+
+        last_text = _text_content(last_child).strip()
+        if last_text not in ')]}':
+            return None
+
+        # Verify delimiter pairing
+        pairs = {'(': ')', '[': ']', '{': '}'}
+        if pairs.get(first_text) != last_text:
+            # Mismatched delimiters - treat as regular mrow
+            return None
+
+        return {
+            'open': first_text,
+            'close': last_text,
+            'content_children': children[1:-1]
+        }
+
+    def _handle_delimited_content(self, children: list, delimiter_info: dict) -> str:
+        r"""
+        Handle mrow with delimiters, adding \left and \right if needed.
+
+        This matches the original converter's behavior:
+        - If content contains fractions, use \left( and \right)
+        - Otherwise, use plain ( and )
+        """
+        # Convert content between delimiters
+        content_parts = []
+        has_fraction = False
+
+        for child in delimiter_info['content_children']:
+            part = self._convert_child(child)
+            if part:
+                content_parts.append(part)
+                # Check if this child is a fraction
+                if _local(child.tag) == 'mfrac':
+                    has_fraction = True
+                # Check if converted content contains fraction commands
+                if '\\frac' in part or '\\dfrac' in part or '\\tfrac' in part:
+                    has_fraction = True
+
+        content = ' '.join(content_parts)
+
+        # Check if content needs delimiter scaling
+        needs_scaling = has_fraction or self._needs_delimiter_scaling(content)
+
+        # Build result with appropriate delimiters
+        open_delim = delimiter_info['open']
+        close_delim = delimiter_info['close']
+
+        if needs_scaling:
+            # Map delimiters for LaTeX
+            if open_delim == '{':
+                left = '\\left\\{'
+            else:
+                left = f'\\left{open_delim}'
+
+            if close_delim == '}':
+                right = '\\right\\}'
+            else:
+                right = f'\\right{close_delim}'
+
+            return f'{left} {content} {right}'
+        else:
+            # Plain delimiters (must escape braces)
+            left = '\\{' if open_delim == '{' else open_delim
+            right = '\\}' if close_delim == '}' else close_delim
+            return f'{left} {content} {right}'
+
+    def _needs_delimiter_scaling(self, content: str) -> bool:
+        r"""
+        Determine if content needs delimiter scaling (\left and \right).
+
+        Based on the original converter's logic at line 6482-6507.
+        Content needs scaling if it contains:
+        - Fractions (\frac, \dfrac, \tfrac)
+        - Large operators (\sum, \prod, \int)
+        - Square roots (\sqrt)
+        - Nested delimiters
+        - Multiple scripts
+        """
+        scaling_indicators = [
+            '\\frac', '\\dfrac', '\\tfrac',  # Fractions
+            '\\sum', '\\prod', '\\int',      # Large operators
+            '\\sqrt',                        # Square roots
+            '\\binom',                       # Binomial coefficients
+            '\\overset', '\\underset',       # Over/under sets
+            '\\limits',                      # Limits
+            '\\Big', '\\big',                # Already scaled content
+        ]
+
+        # CRITICAL FIX: Check universal_delimiter_scaling flag from LegacyAdapter
+        # This allows forcing \left and \right on all delimiters regardless of content size
+        if hasattr(self.strategy, '_converter_context'):
+            converter = self.strategy._converter_context
+            if getattr(converter, 'universal_delimiter_scaling', False):
+                return True
+
+        # Check for scaling indicators
+        if any(indicator in content for indicator in scaling_indicators):
+            return True
+
+        # Check for nested delimiters
+        nested_delims = content.count('(') + content.count('[') + content.count('{')
+        if nested_delims > 0:
+            return True
+
+        # Check for multiple script levels
+        script_levels = content.count('_') + content.count('^')
+        if script_levels > 1:
+            return True
+
+        # Long expressions often benefit from scaling
+        if len(content) > 20:
+            return True
+
+        return False
+
+    # ===================================================================
+    # Pattern Detection Methods (10 patterns)
+    # ===================================================================
+
+    def _check_fragmented_function_at_position(
+        self, children: list, start_idx: int
+    ) -> Tuple[str, int, Optional[ET.Element]]:
+
+        """
+        Check if elements starting at start_idx form a fragmented function.
+
+        Returns:
+            (function_latex, consumed_count, last_sub_or_sup_element)
+            - function_latex: LaTeX for the function (e.g., "\\log_{2}") or empty string
+            - consumed_count: Number of children consumed
+            - last_sub_or_sup_element: The last msub/msup element if any, None otherwise
+
+        Examples:
+            <mi>s</mi><mi>i</mi><mi>n</mi> → ("\\sin", 3, None)
+            <mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub> → ("\\log_{2}", 3, msub_element)
+        """
+        if start_idx >= len(children):
+            return ("", 0, None)
+
+        letters = []
+        consumed_count = 0
+        last_sub_or_sup = None
+
+
+        for i in range(start_idx, len(children)):
+            child = children[i]
+            tag = _local(child.tag)
+
+            # Case 1: Direct <mi> element
+            if tag == "mi":
+                content = _text_content(child).strip()
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                    consumed_count += 1
+                else:
+                    break  # Stop at first non-single-letter mi
+
+            # Case 2: <mrow> containing a single <mi> element (MathJax pattern)
+            elif (tag == "mrow" and
+                  len(list(child)) == 1 and
+                  _local(list(child)[0].tag) == "mi"):
+                mi_element = list(child)[0]
+                content = _text_content(mi_element).strip()
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                    consumed_count += 1
+                else:
+                    break
+
+            # Case 3: <msub> or <msup> where the base is a single-letter <mi>
+            # Also handles <msup><mrow><mi>s</mi></mrow><mrow><mn>2</mn></mrow></msup>
+            elif tag in ("msub", "msup"):
+                base_children = list(child)
+                if len(base_children) >= 1:
+                    base = base_children[0]
+                    base_tag = _local(base.tag)
+
+                    if base_tag == "mi":
+                        content = _text_content(base).strip()
+                        if len(content) == 1 and content.isalpha():
+                            letters.append(content)
+                            consumed_count += 1
+                            last_sub_or_sup = child
+                            break  # msup/msub should be the last element
+                        else:
+                            break
+                    elif base_tag == "mrow":
+                        # Handle both single <mi> and nested <mrow> structures
+                        # Pattern 1: <mrow><mi>s</mi></mrow> (single mi)
+                        # Pattern 2: <mrow><mrow><mi>s</mi></mrow></mrow> (nested mrow)
+                        base_children_list = list(base)
+                        if len(base_children_list) == 1:
+                            inner_child = base_children_list[0]
+                            inner_tag = _local(inner_child.tag)
+
+                            if inner_tag == "mi":
+                                # Pattern 1: direct mi
+                                content = _text_content(inner_child).strip()
+                                if len(content) == 1 and content.isalpha():
+                                    letters.append(content)
+                                    consumed_count += 1
+                                    last_sub_or_sup = child
+                                    break  # msup/msub should be the last element in fragmented function
+                                else:
+                                    break
+                            elif inner_tag == "mrow" and len(list(inner_child)) == 1:
+                                # Pattern 2: nested mrow with mi
+                                deepest_mi = list(inner_child)[0]
+                                if _local(deepest_mi.tag) == "mi":
+                                    content = _text_content(deepest_mi).strip()
+                                    if len(content) == 1 and content.isalpha():
+                                        letters.append(content)
+                                        consumed_count += 1
+                                        last_sub_or_sup = child
+                                        break  # msup/msub should be the last element
+                                    else:
+                                        break
+                                else:
+                                    break
+                            else:
+                                break
+                        else:
+                            break
+                    else:
+                        break
+                else:
+                    break
+            else:
+                break  # Stop at first non-matching element
+
+
+        if len(letters) < 2:
+            return ("", 0, None)
+
+        # Check if the sequence forms a known function
+        from ..data import MATH_FUNCTIONS
+        potential_function = ''.join(letters)
+
+
+        if potential_function not in MATH_FUNCTIONS:
+            return ("", 0, None)
+
+        # Build the function LaTeX
+        function_latex = f"\\{potential_function}"
+
+        # If the last consumed element was msub/msup, add the subscript/superscript
+        if last_sub_or_sup is not None:
+            tag = _local(last_sub_or_sup.tag)
+            children_of_sub = list(last_sub_or_sup)
+
+            if len(children_of_sub) >= 2:
+                # Get the subscript/superscript (second child)
+                script = children_of_sub[1]
+                script_latex = self._convert_child(script)
+
+                if tag == "msub":
+                    function_latex += f"_{{{script_latex}}}"
+                elif tag == "msup":
+                    function_latex += f"^{{{script_latex}}}"
+
+        return (function_latex, consumed_count, last_sub_or_sup)
+
+    def _is_fragmented_function_row(self, node: ET.Element) -> str:
+        """
+        Check if this mrow contains a fragmented mathematical function.
+
+        Returns the function name if found, empty string otherwise.
+
+        Examples:
+            <mi>s</mi><mi>i</mi><mi>n</mi> → "sin"
+            <mi>c</mi><mi>o</mi><mi>s</mi> → "cos"
+            <mrow><mi>m</mi></mrow><mrow><mi>a</mi></mrow><mrow><mi>x</mi></mrow> → "max"
+            <mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub> → "log"
+        """
+        children = list(node)
+        if len(children) < 2:
+            return ""
+
+        # Extract consecutive mi elements with single characters
+        # Also handle nested <mrow><mi>X</mi></mrow> patterns (MathJax style)
+        # AND handle <msub>/<msup> where the base is a single-letter <mi> (e.g., log_2)
+        letters = []
+        for child in children:
+            tag = _local(child.tag)
+
+            # Case 1: Direct <mi> element
+            if tag == "mi":
+                content = _text_content(child).strip()
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                else:
+                    break  # Stop at first non-single-letter mi
+            # Case 2: <mrow> containing a single <mi> element (MathJax pattern)
+            elif (tag == "mrow" and
+                  len(list(child)) == 1 and
+                  _local(list(child)[0].tag) == "mi"):
+                mi_element = list(child)[0]
+                content = _text_content(mi_element).strip()
+                if len(content) == 1 and content.isalpha():
+                    letters.append(content)
+                else:
+                    break  # Stop at first non-single-letter mi
+            # Case 3: <msub> or <msup> where the base is a single-letter <mi>
+            # This handles patterns like <mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub> → "log"
+            # Also handles <msup><mrow><mi>s</mi></mrow><mrow><mn>2</mn></mrow></msup>
+            elif tag in ("msub", "msup"):
+                # Get the base element (first child of msub/msup)
+                base_children = list(child)
+                if len(base_children) >= 1:
+                    base = base_children[0]
+                    # Check if base is <mi> or <mrow><mi>X</mi></mrow>
+                    base_tag = _local(base.tag)
+                    if base_tag == "mi":
+                        content = _text_content(base).strip()
+                        if len(content) == 1 and content.isalpha():
+                            letters.append(content)
+                        else:
+                            break  # Stop at first non-single-letter base
+                    elif base_tag == "mrow":
+                        # Handle both single <mi> and nested <mrow> structures
+                        base_children_list = list(base)
+                        if len(base_children_list) == 1:
+                            inner_child = base_children_list[0]
+                            inner_tag = _local(inner_child.tag)
+
+                            if inner_tag == "mi":
+                                # Pattern 1: <mrow><mi>s</mi></mrow>
+                                content = _text_content(inner_child).strip()
+                                if len(content) == 1 and content.isalpha():
+                                    letters.append(content)
+                                else:
+                                    break
+                            elif inner_tag == "mrow" and len(list(inner_child)) == 1:
+                                # Pattern 2: <mrow><mrow><mi>s</mi></mrow></mrow>
+                                deepest_mi = list(inner_child)[0]
+                                if _local(deepest_mi.tag) == "mi":
+                                    content = _text_content(deepest_mi).strip()
+                                    if len(content) == 1 and content.isalpha():
+                                        letters.append(content)
+                                    else:
+                                        break
+                                else:
+                                    break
+                            else:
+                                break
+                        else:
+                            break
+                    else:
+                        break  # Base is not a simple <mi>
+                else:
+                    break  # msub/msup has no children
+            else:
+                break  # Stop at first non-matching element
+
+        if len(letters) < 2:
+            return ""
+
+        # Check if the sequence forms a known function
+        from ..data import MATH_FUNCTIONS
+        potential_function = ''.join(letters)
+        if potential_function in MATH_FUNCTIONS:
+            return potential_function
+
+        return ""
+
+    def _handle_fragmented_function(self, node: ET.Element, function_name: str) -> str:
+        """
+        Handle fragmented function by merging letters and processing remaining content.
+
+        Args:
+            node: The mrow element
+            function_name: The detected function name (e.g., "sin")
+
+        Returns:
+            LaTeX with function and remaining content
+
+        Examples:
+            <mi>s</mi><mi>i</mi><mi>n</mi><mi>x</mi> → "\\sin x"
+            <mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub><mi>x</mi> → "\\log_{2} x"
+        """
+        children = list(node)
+        function_length = len(function_name)
+
+        # Track which children were consumed for the function
+        # This is trickier when the last letter is in an msub/msup
+        consumed_count = 0
+        letters_found = 0
+        last_was_sub_or_sup = False
+        last_sub_or_sup_element = None
+
+        for child in children:
+            if letters_found >= function_length:
+                break
+
+            tag = _local(child.tag)
+
+            # Count letters consumed (same logic as _is_fragmented_function_row)
+            if tag == "mi":
+                letters_found += 1
+                consumed_count += 1
+            elif (tag == "mrow" and
+                  len(list(child)) == 1 and
+                  _local(list(child)[0].tag) == "mi"):
+                letters_found += 1
+                consumed_count += 1
+            elif tag in ("msub", "msup"):
+                letters_found += 1
+                consumed_count += 1
+                last_was_sub_or_sup = True
+                last_sub_or_sup_element = child
+            else:
+                break
+
+        # Build the function LaTeX
+        function_latex = f"\\{function_name}"
+
+        # If the last consumed element was msub/msup, we need to add the subscript/superscript
+        if last_was_sub_or_sup and last_sub_or_sup_element is not None:
+            tag = _local(last_sub_or_sup_element.tag)
+            children_of_sub = list(last_sub_or_sup_element)
+
+            if len(children_of_sub) >= 2:
+                # Get the subscript/superscript (second child)
+                script = children_of_sub[1]
+                script_latex = self._convert_child(script)
+
+                if tag == "msub":
+                    function_latex += f"_{{{script_latex}}}"
+                elif tag == "msup":
+                    function_latex += f"^{{{script_latex}}}"
+
+        # Convert remaining elements after the function
+        remaining_parts = []
+        for child in children[consumed_count:]:
+            part = self._convert_child(child)
+            if part:
+                remaining_parts.append(part)
+
+        remaining_content = " ".join(remaining_parts).strip()
+        if remaining_content:
+            return f"{function_latex} {remaining_content}"
+        else:
+            return function_latex
+
+    def _detect_chemical_formula_pattern(self, node: ET.Element) -> bool:
+        """
+        Detect if consecutive mi elements form a chemical formula like HCl, KClO3, etc.
+
+        Pattern: consecutive mi elements with mathvariant="normal"
+        that together form a chemical formula starting with known element.
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        # Check for pattern: consecutive mi elements with mathvariant="normal"
+        consecutive_mi = []
+        for child in children:
+            if (_local(child.tag) == "mi" and
+                child.get("mathvariant") == "normal"):
+                text = _text_content(child)
+                if text and (text.isalpha() or text.isdigit()):
+                    consecutive_mi.append(text)
+                else:
+                    break
+            else:
+                break
+
+        # Check if combined text forms a chemical formula
+        if len(consecutive_mi) >= 2:
+            combined = "".join(consecutive_mi)
+            # Pattern: Starts with capital letter, contains mix of letters/numbers
+            import re
+            if re.match(r'^[A-Z][A-Za-z0-9]+$', combined):
+                # Additional check: starts with known element symbols
+                from ..data import CHEMICAL_ELEMENTS
+                for elem in CHEMICAL_ELEMENTS:
+                    if combined.startswith(elem):
+                        return True
+        return False
+
+    def _merge_chemical_formula(self, node: ET.Element) -> str:
+        """
+        Merge consecutive mi elements that form a chemical formula.
+
+        Example: <mi>H</mi><mi>C</mi><mi>l</mi> → \\mathrm{HCl}
+        """
+        children = list(node)
+        formula_parts = []
+        formula_consumed = 0
+
+        # Collect consecutive mi elements that form the formula
+        for child in children:
+            if (_local(child.tag) == "mi" and
+                child.get("mathvariant") == "normal"):
+                text = _text_content(child)
+                if text and (text.isalpha() or text.isdigit()):
+                    formula_parts.append(text)
+                    formula_consumed += 1
+                else:
+                    break
+            else:
+                break
+
+        # Process remaining children after the formula
+        remaining_children = children[formula_consumed:]
+
+        # Combine formula parts and wrap in \mathrm{}
+        if formula_parts:
+            formula = "".join(formula_parts)
+            result = f"\\mathrm{{{formula}}}"
+
+            # Process remaining elements
+            if remaining_children:
+                remaining_parts = []
+                for child in remaining_children:
+                    remaining_parts.append(self._convert_child(child))
+                remaining_content = " ".join([p for p in remaining_parts if p])
+                if remaining_content:
+                    result += " " + remaining_content
+
+            return result
+
+        # Fallback to normal processing
+        return self._convert_children_with_spaces(node)
+
+    def _detect_fragmented_element_with_charge(self, node: ET.Element) -> bool:
+        """
+        Detect fragmented chemical elements with charge indicators.
+
+        Pattern: <mi>M</mi> <mi>n</mi> <msup>...<charge></msup>
+        This handles cases like "M n^{2+}" which should be "\mathrm{Mn}^{2+}"
+
+        The key difference from _detect_chemical_formula_pattern is that this
+        allows interruptions by <msup> or <msub> elements when they contain charges.
+
+        Returns True if:
+        1. Found 2+ consecutive <mi> elements (may be interrupted by msup/msub)
+        2. Combined text forms known multi-char element (Mn, Cu, Fe, etc.)
+        3. Chemistry probability score meets threshold for current mode
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        # Import here to avoid circular dependency
+        from ..data.chemistry_data import MULTI_CHAR_ELEMENTS
+        from ..utils.chemistry_detection import calculate_chemistry_probability
+
+        # Look for pattern: mi mi [msup/msub with charge]
+        i = 0
+        while i < len(children) - 1:
+            # Check if we have consecutive mi elements
+            if _local(children[i].tag) != "mi":
+                i += 1
+                continue
+
+            # Collect consecutive mi elements (allowing msup/msub interruptions)
+            mi_elements = []
+            mi_texts = []
+            j = i
+
+            while j < len(children):
+                child = children[j]
+                tag = _local(child.tag)
+
+                # Accept ANY <mi> element (not just mathvariant="normal")
+                # Chemistry probability scoring will decide whether to merge
+                if tag == "mi":
+                    text = _text_content(child).strip()
+                    # Only consider single letters (M, n) or 2-letter elements (Mn)
+                    if text and len(text) <= 2 and text.isalpha():
+                        mi_elements.append((j, text))
+                        mi_texts.append(text)
+                        j += 1
+                    else:
+                        break
+                elif tag in ("msup", "msub") and len(mi_elements) >= 1:
+                    # Check if this interruption contains a charge indicator
+                    if tag == "msup" and len(child) >= 2:
+                        sup_node = child[1]
+                        sup_text = _text_content(sup_node).strip()
+
+                        # Check for charge pattern
+                        has_charge = False
+                        if sup_text and ('+' in sup_text or '-' in sup_text):
+                            if len(sup_text) <= 3 and (sup_text.endswith('+') or sup_text.endswith('-')):
+                                has_charge = True
+                            # Format: "2 +" or "2 -"
+                            parts = sup_text.split()
+                            if len(parts) == 2 and parts[0].isdigit() and parts[1] in ('+', '-'):
+                                has_charge = True
+
+                        if has_charge:
+                            # Found charge! Check if collected mi elements form known element
+                            if len(mi_texts) >= 2:
+                                combined = "".join(mi_texts)
+                                if combined in MULTI_CHAR_ELEMENTS:
+                                    # Calculate chemistry probability to decide if we should merge
+                                    # Get the root <math> element for full context
+                                    math_root = node
+                                    while math_root is not None and _local(math_root.tag) != 'math':
+                                        math_root = math_root.getparent()
+
+                                    if math_root is not None:
+                                        subject_mode = self.strategy.subject_mode if hasattr(self.strategy, 'subject_mode') else None
+                                        chem_prob = calculate_chemistry_probability(math_root, subject_mode)
+
+                                        # Decision thresholds:
+                                        # - Chemistry mode: ≥0.8
+                                        # - Auto-mode: ≥1.5 (very strong indicators)
+                                        threshold = 0.8 if subject_mode == 'chemistry' else 1.5
+                                        if chem_prob >= threshold:
+                                            return True
+                    break
+                else:
+                    break
+
+            i += 1
+
+        return False
+
+    def _merge_fragmented_element_with_charge(self, node: ET.Element) -> str:
+        """
+        Merge fragmented chemical elements that are separated with charge indicators.
+
+        Example: <mi>M</mi><mi>n</mi><msup>...<mn>2</mn><mo>+</mo></msup>
+                 → \mathrm{Mn}^{2 +}
+        """
+        from ..data.chemistry_data import MULTI_CHAR_ELEMENTS
+        from ..utils.chemistry_detection import calculate_chemistry_probability
+
+        children = list(node)
+        result_parts = []
+        i = 0
+
+        while i < len(children):
+            # Try to find and merge fragmented element pattern
+            # Accept ANY <mi> element (not just mathvariant="normal")
+            if _local(children[i].tag) == "mi":
+                # Collect consecutive mi elements
+                mi_elements = []
+                mi_texts = []
+                j = i
+
+                while j < len(children):
+                    child = children[j]
+                    tag = _local(child.tag)
+
+                    # Accept ANY <mi> element
+                    if tag == "mi":
+                        text = _text_content(child).strip()
+                        # Only consider single letters or 2-letter elements
+                        if text and len(text) <= 2 and text.isalpha():
+                            mi_elements.append((j, child))
+                            mi_texts.append(text)
+                            j += 1
+                        else:
+                            break
+                    elif tag == "msup" and len(mi_elements) >= 2:
+                        # Check if this is a charge superscript
+                        if len(child) >= 2:
+                            sup_node = child[1]
+                            sup_text = _text_content(sup_node).strip()
+
+                            has_charge = False
+                            if sup_text and ('+' in sup_text or '-' in sup_text):
+                                if len(sup_text) <= 3 and (sup_text.endswith('+') or sup_text.endswith('-')):
+                                    has_charge = True
+                                parts = sup_text.split()
+                                if len(parts) == 2 and parts[0].isdigit() and parts[1] in ('+', '-'):
+                                    has_charge = True
+
+                            if has_charge:
+                                # Check if combined forms known element
+                                combined = "".join(mi_texts)
+                                if combined in MULTI_CHAR_ELEMENTS:
+                                    # Merge the mi elements
+                                    merged_latex = f"\\mathrm{{{combined}}}"
+
+                                    # Add the superscript
+                                    sup_latex = self._convert_child(child)
+                                    result_parts.append(merged_latex + sup_latex)
+
+                                    # Skip past all consumed elements
+                                    i = j + 1
+                                    break
+
+                        # If we get here, didn't merge, fall through to normal processing
+                        break
+                    else:
+                        break
+
+                # If we didn't merge anything, process normally
+                if j == i + len(mi_elements):
+                    # Didn't find charge pattern, process first element normally
+                    result_parts.append(self._convert_child(children[i]))
+                    i += 1
+            else:
+                # Not an mi element, process normally
+                result_parts.append(self._convert_child(children[i]))
+                i += 1
+
+        return " ".join([p for p in result_parts if p])
+
+    def _has_cross_mrow_fragmented_units(self, node: ET.Element) -> bool:
+        """
+        Check if this element has fragmented units across multiple mrow children.
+
+        Example: <mrow><mi>m</mi></mrow><mrow><mi>o</mi></mrow><mrow><mi>l</mi></mrow> → mol
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        # Collect all letters from consecutive mrow elements
+        letters = []
+        for child in children:
+            if _local(child.tag) == "mrow":
+                mrow_children = list(child)
+                mrow_letters = []
+                for grandchild in mrow_children:
+                    if (_local(grandchild.tag) == "mi" and
+                        grandchild.get('mathvariant') == 'normal'):
+                        text = _text_content(grandchild).strip()
+                        if text and len(text) == 1 and text.isalpha():
+                            mrow_letters.append(text)
+                        else:
+                            mrow_letters = []
+                            break
+                    elif _local(grandchild.tag) not in ['mrow']:
+                        mrow_letters = []
+                        break
+
+                if mrow_letters:
+                    letters.extend(mrow_letters)
+                else:
+                    break
+
+        # Check if collected letters form a unit
+        if len(letters) >= 2:
+            concatenated = "".join(letters)
+            from ..data import COMMON_UNITS
+            if concatenated in COMMON_UNITS:
+                return True
+
+        return False
+
+    def _merge_cross_mrow_fragmented_units(self, node: ET.Element) -> str:
+        """
+        Merge fragmented units that are split across multiple mrow elements.
+
+        This is complex - needs to be imported from original converter.
+        For now, fallback to normal processing.
+        """
+        # TODO: Implement full cross-mrow merging logic
+        # This is a complex method that requires careful handling
+        # For now, return normal processing to avoid breaking tests
+        return self._convert_children_with_spaces(node)
+
+    def _is_set_notation_row(self, node: ET.Element) -> bool:
+        r"""
+        Check if this mrow represents set notation {x | condition}.
+
+        Pattern: <mo>{</mo> ... <mo>|</mo> ... <mo>}</mo>
+        Also handles nested: <mo>{</mo> <mrow>... <mo>|</mo> ...</mrow> <mo>}</mo>
+
+        The vertical bar | should be converted to \mid (set separator),
+        not \left| \right| (absolute value).
+
+        Examples:
+            {x | x > 0} - set builder notation
+            {x | x ∈ R} - set membership
+            {(x,y) | x+y < 2} - set with condition
+
+        Returns:
+            True if this is set notation, False otherwise
+        """
+        children = list(node)
+        if len(children) < 3:  # Need at least {, content, }
+            return False
+
+        # Check if first child is { and last child is }
+        first_child = children[0]
+        last_child = children[-1]
+
+        if not (_local(first_child.tag) == "mo" and _text_content(first_child).strip() == "{" and
+                _local(last_child.tag) == "mo" and _text_content(last_child).strip() == "}"):
+            return False
+
+        # Check if there's a | somewhere in the middle (recursively search nested mrows)
+        # Support both <mo>|</mo> (correct) and <mn>|</mn> (malformed but common)
+        def has_pipe_recursive(elem):
+            """Recursively search for | in element and its children"""
+            elem_tag = _local(elem.tag)
+            elem_text = _text_content(elem).strip()
+
+            # Check this element
+            if elem_tag in ("mo", "mn") and elem_text == "|":
+                return True
+
+            # Recursively check children (only for mrow, not for other containers)
+            if elem_tag == "mrow":
+                for child in elem:
+                    if has_pipe_recursive(child):
+                        return True
+
+            return False
+
+        # Search in children between { and }
+        for child in children[1:-1]:  # Skip first { and last }
+            if has_pipe_recursive(child):
+                return True
+
+        return False
+
+    def _handle_set_notation_row(self, node: ET.Element) -> str:
+        r"""
+        Convert set notation to LaTeX with \mid separator.
+
+        Converts: {x | condition} → \left\{ x \mid condition \right\}
+
+        The key difference from absolute value:
+        - Set notation: | becomes \mid (relational operator)
+        - Absolute value: | becomes \left| \right| (delimiters)
+
+        Special case: {(x,y) | |x+y| < 2}
+        - First | after (x,y) → \mid (set separator)
+        - Paired || around x+y → \left| \right| (absolute value)
+
+        Args:
+            node: The mrow element containing set notation
+
+        Returns:
+            LaTeX string with proper set notation
+        """
+        children = list(node)
+
+        # Track if we've converted the first pipe
+        self._first_pipe_converted = False
+
+        def convert_with_pipe_replacement(elem):
+            """Recursively convert element, replacing first | with \mid"""
+            elem_tag = _local(elem.tag)
+            elem_text = _text_content(elem).strip()
+
+            # Check if this is a pipe that should be converted to \mid
+            if elem_tag in ("mo", "mn") and elem_text == "|":
+                if not self._first_pipe_converted:
+                    # Convert first pipe to \mid
+                    self._first_pipe_converted = True
+                    return "\\mid"
+                else:
+                    # Keep subsequent pipes - let normal conversion handle them
+                    return self._convert_child(elem)
+
+            # For mrow elements, we need to handle them specially
+            if elem_tag == "mrow":
+                # CRITICAL FIX: After the set separator | has been converted to \mid,
+                # any nested mrow that looks like |x| should be treated as absolute value,
+                # not as more set separators.
+                # Example: {x | |y| > 0} → \left\{ x \mid \left|y\right| > 0 \right\}
+                if self._first_pipe_converted and self._is_absolute_value_row(elem):
+                    # This nested mrow is an absolute value, handle it properly
+                    return self._handle_absolute_value_row(elem)
+
+                # Otherwise, process mrow children and convert nested pipes
+                inner_parts = []
+                for child in elem:
+                    part = convert_with_pipe_replacement(child)
+                    if part:
+                        inner_parts.append(part)
+                return " ".join(inner_parts).strip()
+
+            # For all other elements, use normal conversion
+            return self._convert_child(elem)
+
+        # Process all children between { and }
+        parts = []
+        for child in children[1:-1]:  # Skip first { and last }
+            part = convert_with_pipe_replacement(child)
+            if part:
+                parts.append(part)
+
+        content = " ".join(parts).strip()
+        return f"\\left\\{{{content}\\right\\}}"
+
+    def _is_absolute_value_row(self, node: ET.Element) -> bool:
+        """
+        Check if this mrow represents absolute value notation |...|.
+
+        Pattern: <mo>|</mo> ... content ... <mo>|</mo>
+
+        IMPORTANT: Only match if there are exactly 2 pipe operators.
+        For multiple absolute values like |AB||n|, there are 4 pipes,
+        which should NOT be treated as a single absolute value.
+        """
+        children = list(node)
+        if len(children) < 3:  # Need at least |, content, |
+            return False
+
+        # Check if first and last children are | operators
+        first_child = children[0]
+        last_child = children[-1]
+
+        if not (_local(first_child.tag) == "mo" and _text_content(first_child).strip() == "|" and
+                _local(last_child.tag) == "mo" and _text_content(last_child).strip() == "|"):
+            return False
+
+        # Count total | operators in the row
+        # Only match if there are exactly 2 (one opening, one closing)
+        pipe_count = 0
+        for child in children:
+            if _local(child.tag) == "mo" and _text_content(child).strip() == "|":
+                pipe_count += 1
+
+        # If more than 2 pipes, this is multiple absolute values, not a single one
+        # e.g., |AB||n| has 4 pipes and should NOT be treated as \left|...\right|
+        return pipe_count == 2
+
+    def _handle_absolute_value_row(self, node: ET.Element) -> str:
+        """
+        Convert absolute value notation to \\left|...\\right| for dynamic scaling.
+
+        Example: <mo>|</mo><mi>x</mi><mo>|</mo> → \\left|x\\right|
+        """
+        children = list(node)
+
+        # Convert the content between the first and last | operators
+        content_parts = []
+        for child in children[1:-1]:  # Skip first and last |
+            part = self._convert_child(child)
+            if part:
+                content_parts.append(part)
+
+        content = " ".join(content_parts).strip()
+        return f"\\left|{content}\\right|"
+
+    def _is_mixed_delimiter_row(self, node: ET.Element) -> bool:
+        """
+        Check if this mrow contains delimiters mixed with other content.
+
+        Returns True if row has both delimiters and non-delimiter content.
+
+        Note: This should NOT match the case where delimiters are at the
+        beginning and end as matching pairs (e.g., ( ... )), as that should
+        be handled by the proper delimiter detection logic later.
+        """
+        children = list(node)
+        if len(children) <= 1:
+            return False
+
+        # Check if this is a properly delimited expression (first and last are matching delimiters)
+        # If so, return False to let the delimiter handling logic deal with it
+        delimiter_info = self._detect_delimiters(children)
+        if delimiter_info:
+            # This is a properly delimited expression, not a mixed delimiter row
+            return False
+
+        has_delimiters = False
+        has_other_content = False
+        delimiter_chars = set("()[]{}")
+
+        for child in children:
+            if _local(child.tag) == "mo":
+                content = _text_content(child).strip()
+                if content in delimiter_chars:
+                    has_delimiters = True
+                else:
+                    has_other_content = True
+            else:
+                has_other_content = True
+
+        return has_delimiters and has_other_content
+
+    def _handle_mixed_delimiter_row(self, node: ET.Element) -> str:
+        """
+        Handle mrow with mixed delimiters and content.
+
+        For now, use normal processing with spaces.
+        """
+        # TODO: Implement specialized mixed delimiter handling if needed
+        return self._convert_children_with_spaces(node)
+
+    def _is_delimiter_only_row(self, node: ET.Element) -> bool:
+        """
+        Check if this mrow contains only delimiter operators.
+
+        Returns True if all children are mo elements with delimiter characters.
+        """
+        children = list(node)
+        if len(children) == 0:
+            return False
+
+        delimiter_chars = set("()[]{}")
+        for child in children:
+            if _local(child.tag) == "mo":
+                content = _text_content(child).strip()
+                if content not in delimiter_chars:
+                    return False
+            else:
+                return False
+
+        return True
+
+    def _is_chemical_formula_row(self, node: ET.Element) -> bool:
+        """
+        Check if mrow contains chemical formula elements that should be joined without spaces.
+
+        Returns True if more than half the elements are chemical.
+
+        IMPORTANT: Subscripted elements (msub) with single-letter bases are treated as
+        geometry/math notation (e.g., F₁, F₂ for points), NOT chemical formulas.
+        Only count as chemical if they are part of a clear chemical formula pattern.
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        from ..data import CHEMICAL_ELEMENTS
+
+        # CRITICAL: Check for mathematical binary operators that indicate this is NOT a chemical formula
+        # Binary operators like ⊙, ⊕, ⊗, ⊖, ⊘ clearly indicate mathematical context
+        # This set should include all operators from SKIP_SPACE_AFTER in mo_visitor.py
+        mathematical_binary_operators = {
+            # Relation operators
+            '→', '←', '⇒', '⇐', '↔', '⇔', '⟷',
+            '\\rightarrow', '\\leftarrow', '\\to', '\\Longrightarrow', '\\Longleftarrow',
+            '\\leftrightarrow', '\\Longleftrightarrow',
+            '=', '≈', '≅', '<', '>', '≤', '≥', '≠',
+            '\\equiv', '\\approx', '\\cong', '\\leq', '\\geq', '\\neq',
+            '⊆', '⊇', '∈', '∉', '⊥', '∥', '∼', '≃', '∝', '≺', '≻', '⪯', '⪰',
+            '\\subseteq', '\\supseteq', '\\in', '\\notin', '\\perp', '\\parallel',
+            '\\sim', '\\simeq', '\\propto', '\\prec', '\\succ', '\\preceq', '\\succeq',
+            '⊂', '⊃', '⊑', '⊒',
+            '\\subset', '\\supset', '\\sqsubseteq', '\\sqsupseteq',
+
+            # Binary operators
+            '+', '-', '×', '÷', '·', '±', '∓', '*', '/',
+            '\\times', '\\div', '\\cdot', '\\pm', '\\mp',
+            '∨', '∧', '¬', '∩', '∪', '⊓', '⊔', '⊎',
+            '\\lor', '\\land', '\\wedge', '\\vee', '\\neg', '\\cap', '\\cup',
+            '\\sqcap', '\\sqcup', '\\uplus',
+            '⊕', '⊗', '⊙', '⊖', '⊘', '⋏', '⋎',
+            '\\oplus', '\\otimes', '\\odot', '\\ominus', '\\oslash',
+            '\\curlywedge', '\\curlyvee',
+            '∖', '∗', '⋆', '∘', '•', '⋄', '△', '▽', '◃', '▹', '⊲', '⊳', '⊴', '⊵',
+            '\\setminus', '\\ast', '\\star', '\\circ', '\\bullet', '\\diamond',
+            '\\bigtriangleup', '\\bigtriangledown', '\\triangleleft', '\\triangleright',
+            '\\lhd', '\\rhd', '\\unlhd', '\\unrhd',
+        }
+
+        for child in children:
+            if _local(child.tag) == "mo":
+                content = _text_content(child).strip()
+                if content in mathematical_binary_operators:
+                    # Found a mathematical binary operator - this is NOT a chemical formula
+                    return False
+
+        chemical_indicators = 0
+        total_relevant = 0
+
+        # CRITICAL FIX: If ALL children are msub with single-letter bases,
+        # this is likely geometry notation (F₁, F₂, P₁, P₂), not chemistry.
+        # Don't treat it as a chemical formula.
+        all_are_single_letter_msub = True
+        for child in children:
+            child_name = _local(child.tag)
+            if child_name != "msub":
+                all_are_single_letter_msub = False
+                break
+            # Check if base is a single letter
+            if len(child) > 0:
+                base_elem = child[0]
+                # Handle both direct <mi> and wrapped <mrow><mi></mrow>
+                if _local(base_elem.tag) == "mi":
+                    base_content = _text_content(base_elem).strip()
+                    if len(base_content) != 1:
+                        all_are_single_letter_msub = False
+                        break
+                elif _local(base_elem.tag) == "mrow":
+                    mrow_children = list(base_elem)
+                    if (len(mrow_children) == 1 and
+                        _local(mrow_children[0].tag) == "mi"):
+                        base_content = _text_content(mrow_children[0]).strip()
+                        if len(base_content) != 1:
+                            all_are_single_letter_msub = False
+                            break
+                    else:
+                        all_are_single_letter_msub = False
+                        break
+                else:
+                    all_are_single_letter_msub = False
+                    break
+
+        # If all children are single-letter msub elements, NOT a chemical formula
+        if all_are_single_letter_msub:
+            return False
+
+        for child in children:
+            child_name = _local(child.tag)
+
+            if child_name == "mi":
+                total_relevant += 1
+                content = _text_content(child)
+                if content in CHEMICAL_ELEMENTS:
+                    chemical_indicators += 1
+
+            elif child_name == "msub":
+                total_relevant += 1
+                # Check if base element is chemical
+                if len(child) > 0:
+                    base_elem = child[0]
+                    if _local(base_elem.tag) == "mi":
+                        base_content = _text_content(base_elem)
+                        if base_content in CHEMICAL_ELEMENTS:
+                            chemical_indicators += 1
+                    elif _local(base_elem.tag) == "mrow":
+                        # Handle wrapped <mrow><mi>X</mi></mrow> pattern
+                        mrow_children = list(base_elem)
+                        if (len(mrow_children) == 1 and
+                            _local(mrow_children[0].tag) == "mi"):
+                            base_content = _text_content(mrow_children[0])
+                            if base_content in CHEMICAL_ELEMENTS:
+                                chemical_indicators += 1
+
+        # If more than half the elements are chemical, treat as chemical formula
+        return total_relevant > 0 and chemical_indicators / total_relevant > 0.5
+
+    def _should_merge_numeric_mtext(self, node: ET.Element) -> bool:
+        """
+        Check if this mrow contains consecutive mtext elements that should be merged.
+
+        Pattern: mtext with single digit + mtext starting with digit and containing units
+        Example: "1" + "0 mol" → "10 mol"
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        # Look for pattern: mtext with single digit + mtext starting with digit
+        for i in range(len(children) - 1):
+            current = children[i]
+            next_elem = children[i + 1]
+
+            if (_local(current.tag) == "mtext" and _local(next_elem.tag) == "mtext"):
+                current_text = _text_content(current).strip()
+                next_text = _text_content(next_elem).strip()
+
+                # Check if current is single digit and next starts with digit
+                if (current_text.isdigit() and len(current_text) == 1 and
+                    next_text and next_text[0].isdigit()):
+                    return True
+
+        return False
+
+    def _merge_numeric_mtext_elements(self, node: ET.Element) -> str:
+        """
+        Merge consecutive numeric mtext elements intelligently.
+
+        Example: <mtext>1</mtext><mtext>0 mol</mtext> → 10 mol
+        """
+        children = list(node)
+        result_parts = []
+        i = 0
+
+        while i < len(children):
+            current = children[i]
+
+            if _local(current.tag) == "mtext":
+                current_text = _text_content(current).strip()
+
+                # Check if we can merge with next element
+                if (i + 1 < len(children) and
+                    _local(children[i + 1].tag) == "mtext" and
+                    current_text.isdigit() and len(current_text) == 1):
+
+                    next_elem = children[i + 1]
+                    next_text = _text_content(next_elem).strip()
+
+                    if next_text and next_text[0].isdigit():
+                        # Merge: remove space between digits
+                        merged_text = current_text + next_text
+                        # Import mtext visitor to process merged content
+                        from .mtext_visitor import MtextVisitor
+                        visitor = MtextVisitor(self.strategy)
+                        # Create a temporary element with merged text
+                        temp_elem = ET.Element('mtext')
+                        temp_elem.text = merged_text
+                        processed = visitor.visit(temp_elem)
+                        result_parts.append(processed)
+                        i += 2  # Skip next element as it's been merged
+                        continue
+
+                # No merge possible, process normally
+                from .mtext_visitor import MtextVisitor
+                visitor = MtextVisitor(self.strategy)
+                processed = visitor.visit(current)
+                result_parts.append(processed)
+            else:
+                # Non-mtext element, convert normally
+                converted = self._convert_child(current)
+                result_parts.append(converted)
+
+            i += 1
+
+        return " ".join([p for p in result_parts if p]).strip()
+
+    def _should_merge_fragmented_units(self, node: ET.Element) -> bool:
+        """
+        Check if this mrow contains fragmented units (mi elements that spell out unit names).
+
+        Example: <mi>m</mi><mi>o</mi><mi>l</mi> → mol
+        """
+        children = list(node)
+        if len(children) < 2:
+            return False
+
+        # Collect all mi elements with mathvariant="normal"
+        mi_elements = []
+        for child in children:
+            if _local(child.tag) == "mi":
+                mathvariant = child.get('mathvariant')
+                if mathvariant == 'normal':
+                    text = _text_content(child).strip()
+                    if text and len(text) == 1 and text.isalpha():
+                        mi_elements.append(text)
+
+        # Check if concatenated text forms a unit
+        if len(mi_elements) >= 2:
+            concatenated = "".join(mi_elements)
+            from ..data import COMMON_UNITS
+            if concatenated in COMMON_UNITS:
+                return True
+
+        return False
+
+    def _merge_fragmented_units(self, node: ET.Element) -> str:
+        """
+        Merge fragmented unit elements into proper unit formatting.
+
+        Example: <mi>m</mi><mi>o</mi><mi>l</mi> → \\mathrm{mol}
+        """
+        children = list(node)
+        result_parts = []
+        i = 0
+
+        from ..data import COMMON_UNITS
+
+        while i < len(children):
+            current = children[i]
+
+            if _local(current.tag) == "mi":
+                mathvariant = current.get('mathvariant')
+                if mathvariant == 'normal':
+                    # Start collecting consecutive mi elements
+                    unit_letters = [_text_content(current).strip()]
+                    j = i + 1
+
+                    # Collect consecutive mi elements with mathvariant="normal"
+                    while j < len(children):
+                        next_elem = children[j]
+                        if (_local(next_elem.tag) == "mi" and
+                            next_elem.get('mathvariant') == 'normal'):
+                            text = _text_content(next_elem).strip()
+                            if text and len(text) == 1 and text.isalpha():
+                                unit_letters.append(text)
+                                j += 1
+                            else:
+                                break
+                        else:
+                            break
+
+                    # Check if collected letters form a unit
+                    if len(unit_letters) >= 2:
+                        concatenated = "".join(unit_letters)
+                        if concatenated in COMMON_UNITS:
+                            # Format as unit with \mathrm{}
+                            formatted_unit = f"\\mathrm{{{concatenated}}}"
+                            result_parts.append(formatted_unit)
+                            i = j  # Skip all consumed elements
+                            continue
+
+                # If not part of a unit, process normally
+                converted = self._convert_child(current)
+                result_parts.append(converted)
+            else:
+                # Non-mi element, convert normally
+                converted = self._convert_child(current)
+                result_parts.append(converted)
+
+            i += 1
+
+        return " ".join([p for p in result_parts if p]).strip()
+
+    # ===================================================================
+    # Helper Methods
+    # ===================================================================
+
+    def _convert_children_with_spaces(self, node: ET.Element) -> str:
+        """
+        Convert all children and join with spaces.
+
+        IMPORTANT: Also checks for fragmented functions at each position.
+        This allows detection of fragmented functions in the middle of an mrow,
+        not just at the beginning.
+        """
+        children = list(node)
+        parts = []
+        i = 0
+
+        while i < len(children):
+            # Check for fragmented function starting at position i
+            function_name, consumed_count, last_sub_or_sup = self._check_fragmented_function_at_position(
+                children, i
+            )
+
+            if function_name:
+                # Found a fragmented function - add it to parts
+                parts.append(function_name)
+                i += consumed_count
+            else:
+                # No fragmented function - convert child normally
+                part = self._convert_child(children[i])
+                if part:
+                    parts.append(part)
+                i += 1
+
+        return ' '.join(parts).strip()
+
+    def _convert_children_no_space(self, node: ET.Element) -> str:
+        """Convert all children and join without spaces."""
+        parts = []
+        for child in list(node):
+            part = self._convert_child(child)
+            if part:
+                parts.append(part)
+        return ''.join(parts).strip()
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mrow'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mrow'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MrowVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/ms_visitor.py b/scripts/omml_mathml2latex/visitors/ms_visitor.py
new file mode 100644
index 0000000..f77b732
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/ms_visitor.py
@@ -0,0 +1,85 @@
+r"""
+Visitor for <ms> (string literal) MathML elements.
+
+The <ms> element represents a string literal, typically displayed with
+surrounding quotes. It's used for text that should be treated as a literal
+string rather than mathematical notation.
+
+In LaTeX conversion, ms is converted to \text{} with quotes, similar to mtext.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local, text_content as _text_content
+
+
+class MsVisitor(Visitor):
+    r"""
+    Handles <ms> (string literal) MathML elements.
+
+    Converts string literals to LaTeX \text{} with optional quotes.
+
+    Examples:
+        Simple string:
+            <ms>hello</ms>
+            → \text{"hello"}
+
+        String without lquote/rquote attributes:
+            <ms lquote="" rquote="">world</ms>
+            → \text{world}
+
+        Custom quotes:
+            <ms lquote="[" rquote="]">text</ms>
+            → \text{[text]}
+
+        Empty string:
+            <ms></ms>
+            → \text{""}
+
+    Note:
+        Default quotes are double quotes (") unless overridden by
+        lquote and rquote attributes.
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Ms visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <ms> element to LaTeX \text{} with quotes.
+
+        Args:
+            node: The <ms> element to convert
+
+        Returns:
+            LaTeX string with \text{...} and quotes
+
+        Raises:
+            ValueError: If node is not a <ms> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MsVisitor cannot handle element '{node.tag}'")
+
+        # Get quote attributes (default to double quotes)
+        lquote = node.get("lquote", '"')
+        rquote = node.get("rquote", '"')
+
+        # Get text content
+        content = _text_content(node)
+
+        # Wrap in \text{} with quotes
+        return f"\\text{{{lquote}{content}{rquote}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'ms'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'ms'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MsVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mspace_visitor.py b/scripts/omml_mathml2latex/visitors/mspace_visitor.py
new file mode 100644
index 0000000..6d66bc3
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mspace_visitor.py
@@ -0,0 +1,194 @@
+r"""
+Visitor for <mspace> (spacing) MathML elements.
+
+The <mspace> element represents horizontal spacing in mathematical expressions.
+It uses the width attribute to specify the amount of space.
+
+Common spacing types:
+- Named spaces: thinmathspace, mediummathspace, thickmathspace
+- Negative spaces: negativethinmathspace, etc.
+- Explicit sizes: 0.1em, 1em, 2em
+
+This visitor maps MathML spacing to LaTeX spacing commands.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MspaceVisitor(Visitor):
+    r"""
+    Handles <mspace> (spacing) MathML elements.
+
+    Converts spacing specifications to LaTeX spacing commands.
+
+    Examples:
+        Thin space:
+            <mspace width="thinmathspace"/>
+            → \,
+
+        Medium space:
+            <mspace width="mediummathspace"/>
+            → \:
+
+        Thick space:
+            <mspace width="thickmathspace"/>
+            → \;
+
+        Quad space:
+            <mspace width="1em"/>
+            → \quad
+
+        Qquad space:
+            <mspace width="2em"/>
+            → \qquad
+
+        Negative space:
+            <mspace width="negativethinmathspace"/>
+            → \!
+
+        Default (no width):
+            <mspace/>
+            → \, (thin space)
+    """
+
+    # Mapping from MathML spacing names to LaTeX commands
+    SPACING_MAP = {
+        # Named mathematical spaces
+        "thinmathspace": "\\,",
+        "mediummathspace": "\\:",
+        "thickmathspace": "\\;",
+        "verythinmathspace": "\\!",
+        "veryverythinmathspace": "\\!",
+
+        # Negative spaces (for fine-tuning)
+        "negativethinmathspace": "\\!",
+        "negativemediummathspace": "\\!",
+        "negativethickmathspace": "\\!",
+
+        # Explicit em-based sizes
+        "0em": "",  # No space
+        "0.1em": "\\,",
+        "0.2em": "\\:",
+        "0.3em": "\\;",
+        "0.5em": "\\;",
+        "1em": "\\quad",
+        "2em": "\\qquad",
+
+        # Alternative common values
+        "thin": "\\,",
+        "medium": "\\:",
+        "thick": "\\;",
+    }
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mspace visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mspace> element to LaTeX spacing.
+
+        Args:
+            node: The <mspace> element to convert
+
+        Returns:
+            LaTeX spacing command (e.g., \,, \:, \;, \quad, \qquad)
+
+        Raises:
+            ValueError: If node is not an <mspace> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MspaceVisitor cannot handle element '{node.tag}'")
+
+        # Get width attribute
+        width = node.get("width", "")
+
+        # Handle empty width (default to thin space)
+        if not width:
+            return "\\,"
+
+        # Check if width is in our mapping
+        if width in self.SPACING_MAP:
+            return self.SPACING_MAP[width]
+
+        # Try to parse numeric width (e.g., "0.5em", "1.5em")
+        spacing_cmd = self._parse_numeric_width(width)
+        if spacing_cmd:
+            return spacing_cmd
+
+        # Default: thin space
+        return "\\,"
+
+    def _parse_numeric_width(self, width: str) -> str:
+        """
+        Parse numeric width values and convert to LaTeX spacing.
+
+        Args:
+            width: Width string (e.g., "0.5em", "1.5em")
+
+        Returns:
+            LaTeX spacing command, or empty string if cannot parse
+        """
+        # Remove whitespace
+        width = width.strip()
+
+        # Try to extract numeric value from em-based widths
+        if width.endswith("em"):
+            try:
+                value = float(width[:-2])
+
+                # Map numeric values to spacing commands
+                if value <= 0:
+                    return ""
+                elif value < 0.15:
+                    return "\\,"  # thin
+                elif value < 0.25:
+                    return "\\:"  # medium
+                elif value < 0.6:
+                    return "\\;"  # thick
+                elif value < 1.5:
+                    return "\\quad"
+                else:
+                    return "\\qquad"
+            except ValueError:
+                pass
+
+        # Try to extract numeric value from pt-based widths
+        if width.endswith("pt"):
+            try:
+                value = float(width[:-2])
+
+                # Map pt values to spacing (rough approximation)
+                # 1em ≈ 10pt in typical math fonts
+                if value <= 0:
+                    return ""
+                elif value < 2:
+                    return "\\,"
+                elif value < 4:
+                    return "\\:"
+                elif value < 6:
+                    return "\\;"
+                elif value < 12:
+                    return "\\quad"
+                else:
+                    return "\\qquad"
+            except ValueError:
+                pass
+
+        # Could not parse
+        return ""
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mspace'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mspace'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MspaceVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/msqrt_visitor.py b/scripts/omml_mathml2latex/visitors/msqrt_visitor.py
new file mode 100644
index 0000000..4055f0b
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/msqrt_visitor.py
@@ -0,0 +1,194 @@
+r"""
+Visitor for <msqrt> (square root) MathML elements.
+
+The <msqrt> element represents square roots (√).
+The LaTeX conversion uses \sqrt{...} notation.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MsqrtVisitor(Visitor):
+    r"""
+    Handles <msqrt> (square root) MathML elements.
+
+    Converts square root expressions to LaTeX \sqrt notation.
+
+    Examples:
+        Simple number:
+            <msqrt><mn>2</mn></msqrt> → \sqrt{2}
+
+        Variable:
+            <msqrt><mi>x</mi></msqrt> → \sqrt{x}
+
+        Complex expression:
+            <msqrt>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+            </msqrt>
+            → \sqrt{x + 1}
+
+        Nested root:
+            <msqrt><msqrt><mi>x</mi></msqrt></msqrt> → \sqrt{\sqrt{x}}
+
+        Fraction under root:
+            <msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt> → \sqrt{\dfrac{1}{2}}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Msqrt visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <msqrt> element to LaTeX.
+
+        Args:
+            node: The <msqrt> element to convert
+
+        Returns:
+            LaTeX square root string (\sqrt{content})
+
+        Raises:
+            ValueError: If node is not an <msqrt> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MsqrtVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # Empty msqrt (edge case)
+        if not children:
+            return "\\sqrt{}"
+
+        # Convert all children and join with spaces
+        parts = []
+        for child in children:
+            part = self._convert_child(child)
+            if part:  # Only add non-empty parts
+                parts.append(part)
+
+        radicand = ' '.join(parts).strip()
+
+        # Return \sqrt{radicand}
+        return f"\\sqrt{self._brace(radicand)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """
+        Convert a child element to LaTeX.
+
+        This method instantiates the appropriate visitor for each child type.
+        """
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            # Recursive: msqrt can contain other msqrt elements
+            return self.visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in msqrt, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'msqrt'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'msqrt'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MsqrtVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mstyle_visitor.py b/scripts/omml_mathml2latex/visitors/mstyle_visitor.py
new file mode 100644
index 0000000..95eff65
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mstyle_visitor.py
@@ -0,0 +1,301 @@
+r"""
+Visitor for <mstyle> (style attributes) MathML elements.
+
+The <mstyle> element is a wrapper that applies style attributes to its children:
+- mathvariant: Font variants (bold, italic, script, fraktur, etc.)
+- mathcolor: Text color
+- displaystyle: Display vs inline math mode
+
+This visitor is a transparent container that wraps converted children with
+appropriate LaTeX style commands.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MstyleVisitor(Visitor):
+    r"""
+    Handles <mstyle> (style attributes) MathML elements.
+
+    Applies style attributes to child content through LaTeX wrappers.
+
+    Examples:
+        Bold text:
+            <mstyle mathvariant="bold"><mi>x</mi></mstyle>
+            → \mathbf{x}
+
+        Colored text:
+            <mstyle mathcolor="red"><mi>f</mi></mstyle>
+            → \textcolor{red}{f}
+
+        Script font:
+            <mstyle mathvariant="script"><mi>L</mi></mstyle>
+            → \mathscr{L}
+
+        Fraktur font:
+            <mstyle mathvariant="fraktur"><mi>g</mi></mstyle>
+            → \mathfrak{g}
+
+        Double-struck (blackboard bold):
+            <mstyle mathvariant="double-struck"><mi>R</mi></mstyle>
+            → \mathbb{R}
+
+        Normal (upright) text:
+            <mstyle mathvariant="normal"><mi>x</mi></mstyle>
+            → \mathrm{x}
+
+        Display style (affects fractions):
+            <mstyle displaystyle="true"><mfrac>...</mfrac></mstyle>
+            → (context passed to children)
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mstyle visitor."""
+        super().__init__(strategy)
+        self._converter_context = None
+
+    def set_converter_context(self, converter):
+        """Set converter context for color suppression checking."""
+        self._converter_context = converter
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mstyle> element to LaTeX.
+
+        Args:
+            node: The <mstyle> element to convert
+
+        Returns:
+            LaTeX string with style wrappers applied to children
+
+        Raises:
+            ValueError: If node is not an <mstyle> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MstyleVisitor cannot handle element '{node.tag}'")
+
+        # Get style attributes
+        mathvariant = node.get("mathvariant", "")
+        displaystyle = node.get("displaystyle", "")
+        mathcolor = node.get("mathcolor", "")
+
+        # Convert all children
+        content = self._convert_children(node)
+
+        # Apply font variants
+        content = self._apply_mathvariant(content, mathvariant)
+
+        # Apply color (if not black, which is default)
+        content = self._apply_color(content, mathcolor)
+
+        # Display style is contextual and doesn't produce direct LaTeX output
+        # It would be handled by context/strategy if needed
+        # (In the original implementation, it affects fraction rendering)
+
+        return content
+
+    def _convert_children(self, node: ET.Element) -> str:
+        """
+        Convert all child elements to LaTeX.
+
+        Args:
+            node: The <mstyle> element
+
+        Returns:
+            LaTeX string with all children converted
+        """
+        parts = []
+        for child in node:
+            parts.append(self._convert_child(child))
+        return ' '.join(parts).strip()
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mstyle, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _apply_mathvariant(self, content: str, mathvariant: str) -> str:
+        """
+        Apply mathvariant font styling to content.
+
+        Args:
+            content: The LaTeX content to wrap
+            mathvariant: The mathvariant attribute value
+
+        Returns:
+            LaTeX content with font variant wrapper
+        """
+        if not mathvariant or not content:
+            return content
+
+        # Map mathvariant values to LaTeX commands
+        variant_map = {
+            "bold": "\\mathbf",
+            "bold-italic": "\\boldsymbol",  # Bold italic
+            "italic": None,  # Italic is default in math mode
+            "normal": "\\mathrm",  # Upright/roman text
+            "script": "\\mathscr",
+            "fraktur": "\\mathfrak",
+            "double-struck": "\\mathbb",  # Blackboard bold
+            "monospace": "\\mathtt",
+            "sans-serif": "\\mathsf",
+        }
+
+        latex_cmd = variant_map.get(mathvariant)
+        if latex_cmd:
+            return f"{latex_cmd}{{{content}}}"
+        else:
+            # Italic (default) or unknown variant - no wrapper needed
+            return content
+
+    def _apply_color(self, content: str, mathcolor: str) -> str:
+        """
+        Apply color styling to content.
+
+        Args:
+            content: The LaTeX content to wrap
+            mathcolor: The mathcolor attribute value
+
+        Returns:
+            LaTeX content with color wrapper
+        """
+        # Use centralized color handling with RGB support and suppression
+        from ..utils.color_helpers import hex_to_latex_color
+        from ..utils import is_default_color
+
+        if not mathcolor or not content:
+            return content
+
+        # Check if suppression is active (uniform color optimization)
+        # Get context from visitor or strategy (strategy is shared across all visitors)
+        context = getattr(self, '_converter_context', None)
+        if context is None and hasattr(self.strategy, '_converter_context'):
+            context = self.strategy._converter_context
+
+        if context and getattr(context, '_suppress_leaf_colors', False):
+            return content
+
+        # Skip default black color
+        if is_default_color(mathcolor):
+            return content
+
+        # Convert hex color to LaTeX format (with RGB mode support)
+        color_model, color_spec = hex_to_latex_color(mathcolor)
+
+        # Skip if conversion resulted in black
+        if color_spec == 'black':
+            return content
+
+        # Wrap with appropriate format
+        if color_model:
+            return f"\\textcolor{color_model}{{{color_spec}}}{{{content}}}"
+        else:
+            return f"\\textcolor{{{color_spec}}}{{{content}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mstyle'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mstyle'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MstyleVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/msub_visitor.py b/scripts/omml_mathml2latex/visitors/msub_visitor.py
new file mode 100644
index 0000000..e0b1063
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/msub_visitor.py
@@ -0,0 +1,244 @@
+"""Visitor for <msub> (subscript) MathML elements."""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..core.context import ConversionContext
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MsubVisitor(Visitor):
+    """Handles <msub> (subscript) MathML elements.
+
+    Examples:
+        Simple: <msub><mi>x</mi><mn>1</mn></msub> → x_{1}
+        Index: <msub><mi>a</mi><mi>i</mi></msub> → a_{i}
+    """
+
+    def __init__(self, strategy: Strategy, context: ConversionContext = None):
+        """
+        Initialize the Msub visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+            context: Shared conversion context for state tracking
+        """
+        super().__init__(strategy)
+        self.context = context
+
+    def visit(self, node: ET.Element) -> str:
+        if not self.can_handle(node):
+            raise ValueError(f"MsubVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+        if len(children) < 2:
+            raise ValueError(f"msub element must have 2 children, got {len(children)}")
+
+        # Convert base (not in script context)
+        base = self._convert_child(children[0])
+
+        # Push script context before converting subscript
+        if self.context:
+            self.context.push_script_context('msub')
+
+        try:
+            # Convert subscript (in script context)
+            subscript = self._convert_child(children[1])
+        finally:
+            # Always pop context, even if conversion fails
+            if self.context:
+                self.context.pop_script_context()
+
+        # Special case: Empty subscript - just return the base
+        if not subscript or not subscript.strip():
+            base = self._wrap_if_needed(base)
+            return base
+
+        base = self._wrap_if_needed(base)
+
+        # Special case: If base contains a superscript (like f^{\prime}),
+        # wrap it in braces to prevent syntax errors
+        # Example: f^{\prime} should become {f^{\prime}}_{x}, not f^{\prime}_{x}
+        if self._contains_superscript(base):
+            base = f"{{{base}}}"
+
+        return f"{base}_{self._brace(subscript)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            # Recursive: msub can contain other msub elements
+            return self.visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in msub, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _wrap_if_needed(self, base: str) -> str:
+        """Wrap base in parentheses if needed, avoiding double-wrapping."""
+        # Check if base already has delimiters (starts and ends with matching delimiters)
+        base_stripped = base.strip()
+        if base_stripped:
+            # Check for matching delimiters
+            delimiter_pairs = {
+                '(': ')',
+                '[': ']',
+                '{': '}',
+                '\\left(': '\\right)',
+                '\\left[': '\\right]',
+                '\\left\\{': '\\right\\}',
+            }
+
+            for open_delim, close_delim in delimiter_pairs.items():
+                if base_stripped.startswith(open_delim) and base_stripped.endswith(close_delim):
+                    # Already has delimiters, no need to wrap
+                    return base
+
+        # Check if base needs grouping for proper subscript application
+        # In LaTeX, x_2 applies subscript to x, but "a + b_2" applies only to b
+        # We need to brace multi-element bases: {a + b}_2
+        #
+        # Use braces {} for grouping (invisible) not parentheses () (visible)
+        # Only wrap if base contains operators that indicate a true multi-element expression
+        # Don't wrap for spaces alone (e.g., "\Delta H" has space but is semantically single)
+        math_operators = {'=', '+', '-', '/', '*', '\\times', '\\cdot', '\\pm', '\\to'}
+        if ' ' in base and any(op in base for op in math_operators):
+            return f"{{{base}}}"
+        return base
+
+    def _brace(self, content: str) -> str:
+        return f"{{{content}}}"
+
+    def _contains_superscript(self, base: str) -> bool:
+        """
+        Check if base contains a LaTeX superscript (^{...} or ^X).
+
+        This is important for proper grouping when adding subscripts.
+        For example: f^{\\prime} must be wrapped as {f^{\\prime}} before
+        adding subscripts to avoid invalid syntax.
+
+        Args:
+            base: The base LaTeX string
+
+        Returns:
+            True if base contains an unbraced superscript
+        """
+        if not base or '^' not in base:
+            return False
+
+        # If the entire base is already wrapped in braces, it's safe
+        base_stripped = base.strip()
+        if base_stripped.startswith('{') and base_stripped.endswith('}'):
+            # Check if these braces wrap the entire expression
+            depth = 0
+            for i, char in enumerate(base_stripped):
+                if char == '{':
+                    depth += 1
+                elif char == '}':
+                    depth -= 1
+                # If depth hits 0 before the end, the braces don't wrap everything
+                if depth == 0 and i < len(base_stripped) - 1:
+                    break
+            # If we maintained depth > 0 until the last character, it's wrapped
+            if i == len(base_stripped) - 1:
+                return False
+
+        # Base contains ^ and is not fully wrapped
+        return True
+
+    def can_handle(self, node: ET.Element) -> bool:
+        return _local(node.tag) == 'msub'
+
+    @property
+    def element_name(self) -> str:
+        return 'msub'
+
+    def __repr__(self) -> str:
+        return f"MsubVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/msubsup_visitor.py b/scripts/omml_mathml2latex/visitors/msubsup_visitor.py
new file mode 100644
index 0000000..89e3d5a
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/msubsup_visitor.py
@@ -0,0 +1,449 @@
+r"""
+Visitor for <msubsup> (subscript + superscript) MathML elements.
+
+The <msubsup> element represents simultaneous subscripts and superscripts.
+The LaTeX conversion uses base_{subscript}^{superscript} notation.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..core.context import ConversionContext
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MsubsupVisitor(Visitor):
+    r"""
+    Handles <msubsup> (subscript + superscript) MathML elements.
+
+    Converts elements with both subscript and superscript to LaTeX notation.
+
+    Examples:
+        Tensor with indices:
+            <msubsup><mi>T</mi><mi>i</mi><mi>j</mi></msubsup> → T_{i}^{j}
+
+        Integral bounds:
+            <msubsup><mo>∫</mo><mn>0</mn><mn>1</mn></msubsup> → \int_{0}^{1}
+
+        Summation bounds:
+            <msubsup><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></msubsup>
+            → \sum_{i = 1}^{n}
+
+        Variable with both scripts:
+            <msubsup><mi>x</mi><mn>0</mn><mn>2</mn></msubsup> → x_{0}^{2}
+
+        Complex base:
+            <msubsup>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mn>0</mn>
+              <mn>2</mn>
+            </msubsup>
+            → (x + 1)_{0}^{2}
+    """
+
+    def __init__(self, strategy: Strategy, context: ConversionContext = None):
+        """
+        Initialize the Msubsup visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+            context: Shared conversion context for state tracking
+        """
+        super().__init__(strategy)
+        self.context = context
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <msubsup> element to LaTeX.
+
+        Args:
+            node: The <msubsup> element to convert
+
+        Returns:
+            LaTeX string with subscript and superscript (base_{sub}^{sup})
+
+        Raises:
+            ValueError: If node is not an <msubsup> element
+            ValueError: If msubsup has fewer than 3 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MsubsupVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # msubsup must have exactly 3 children: base, subscript, superscript
+        if len(children) < 3:
+            raise ValueError(
+                f"msubsup element must have 3 children (base, subscript, superscript), "
+                f"got {len(children)}"
+            )
+
+        # Check for sideset pattern: base is <mrow> with 3 <mrow> children
+        # Pattern: <msubsup><mrow><mrow>left_sub</mrow><mrow>left_sup</mrow><mrow>base</mrow></mrow><mrow>right_sub</mrow><mrow>right_sup</mrow></msubsup>
+        # Result: \sideset{_{left_sub}^{left_sup}}{_{right_sub}^{right_sup}}{base}
+        if self._is_sideset_pattern(children[0]):
+            return self._handle_sideset(children)
+
+        # Check if base is a large operator BEFORE converting
+        is_large_op = self._is_large_operator(children[0])
+
+        # Convert base (not in script context)
+        base = self._convert_child(children[0])
+
+        # Push script context before converting subscript and superscript
+        if self.context:
+            self.context.push_script_context('msubsup')
+
+        try:
+            # Convert subscript and superscript (both in script context)
+            subscript = self._convert_child(children[1])
+            superscript = self._convert_child(children[2])
+        finally:
+            # Always pop context, even if conversion fails
+            if self.context:
+                self.context.pop_script_context()
+
+        # Check for large operators that need \limits
+        if is_large_op:
+            return f"{base}\\limits_{self._brace(subscript)}^{self._brace(superscript)}"
+
+        # If base is empty (from empty <mrow/>), output just the sub/superscripts
+        # This allows them to attach to the previous element in LaTeX naturally
+        if not base or not base.strip():
+            return f"_{self._brace(subscript)}^{self._brace(superscript)}"
+
+        # Wrap base if needed (complex expressions or if it contains superscripts)
+        base = self._wrap_if_needed(base)
+
+        # Special case: If base contains a superscript (like v^{\prime}),
+        # wrap it in braces to prevent syntax error with additional sub/superscripts
+        # Example: v^{\prime} should become {v^{\prime}}_{1}^{2}, not v^{\prime}_{1}^{2}
+        if self._contains_superscript(base):
+            base = f"{{{base}}}"
+
+        # Return base_{subscript}^{superscript}
+        return f"{base}_{self._brace(subscript)}^{self._brace(superscript)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in msubsup, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _wrap_if_needed(self, base: str) -> str:
+        """
+        Wrap base in parentheses if needed.
+
+        Args:
+            base: The base content
+
+        Returns:
+            Base, optionally wrapped in parentheses
+
+        Note:
+            Complex expressions with operators should be wrapped.
+            Simple identifiers and numbers don't need wrapping.
+        """
+        # Check if base already has delimiters (starts and ends with matching delimiters)
+        base_stripped = base.strip()
+        if base_stripped:
+            # Check for matching delimiters
+            delimiter_pairs = {
+                '(': ')',
+                '[': ']',
+                '{': '}',
+                '\\left(': '\\right)',
+                '\\left[': '\\right]',
+                '\\left\\{': '\\right\\}',
+            }
+
+            for open_delim, close_delim in delimiter_pairs.items():
+                if base_stripped.startswith(open_delim) and base_stripped.endswith(close_delim):
+                    # Already has delimiters, no need to wrap
+                    return base
+
+        # Check if base needs grouping for proper subscript/superscript application
+        # In LaTeX, x_2 applies subscript to x, but "a + b_2" applies only to b
+        # We need to brace multi-element bases: {a + b}_2
+        #
+        # Use braces {} for grouping (invisible) not parentheses () (visible)
+        # Only wrap if base contains operators that indicate a true multi-element expression
+        math_operators = {'=', '+', '-', '/', '*', '\\times', '\\cdot', '\\pm', '\\to'}
+        if ' ' in base and any(op in base for op in math_operators):
+            return f"{{{base}}}"
+        return base
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def _contains_superscript(self, base: str) -> bool:
+        """
+        Check if base contains a LaTeX superscript (^{...} or ^X).
+
+        This is important for proper grouping when adding additional scripts.
+        For example: v^{\\prime} must be wrapped as {v^{\\prime}} before
+        adding subscripts/superscripts to avoid invalid syntax.
+
+        Args:
+            base: The base LaTeX string
+
+        Returns:
+            True if base contains an unbraced superscript
+        """
+        # Look for ^ character in the base
+        # We need to be careful to not match ^ that's already inside braces at the start
+        # For example: {v^{\prime}} should return False (already wrapped)
+        # but v^{\prime} should return True (needs wrapping)
+
+        if not base or '^' not in base:
+            return False
+
+        # If the entire base is already wrapped in braces, it's safe
+        base_stripped = base.strip()
+        if base_stripped.startswith('{') and base_stripped.endswith('}'):
+            # Check if these braces wrap the entire expression
+            # Simple heuristic: count brace depth
+            depth = 0
+            for i, char in enumerate(base_stripped):
+                if char == '{':
+                    depth += 1
+                elif char == '}':
+                    depth -= 1
+                # If depth hits 0 before the end, the braces don't wrap everything
+                if depth == 0 and i < len(base_stripped) - 1:
+                    break
+            # If we maintained depth > 0 until the last character, it's wrapped
+            if i == len(base_stripped) - 1:
+                return False
+
+        # Base contains ^ and is not fully wrapped
+        return True
+
+    def _is_large_operator(self, base_node: ET.Element) -> bool:
+        """Check if base is a large operator that uses limits by default."""
+        if _local(base_node.tag) != 'mo':
+            return False
+
+        base_text = _text_content(base_node).strip()
+
+        # Large operators that display limits above/below in display mode
+        large_ops = [
+            "∑", "\\sum",          # Summation
+            "∏", "\\prod",         # Product
+            "∐", "\\coprod",       # Coproduct
+            "∫", "\\int",          # Integral
+            "∬", "\\iint",         # Double integral
+            "∭", "\\iiint",        # Triple integral
+            "∮", "\\oint",         # Contour integral
+            "⋃", "\\bigcup",       # Union
+            "⋂", "\\bigcap",       # Intersection
+            "⋁", "\\bigvee",       # Logical OR
+            "⋀", "\\bigwedge",     # Logical AND
+            "⨁", "\\bigoplus",     # Direct sum
+            "⨂", "\\bigotimes",    # Tensor product
+            "⨄", "\\biguplus",     # Multiset union
+        ]
+
+        return base_text in large_ops
+
+    def _is_sideset_pattern(self, base_node: ET.Element) -> bool:
+        """
+        Check if base node matches the sideset pattern.
+
+        Sideset pattern: base is <mrow> with at least 3 children where first 3 are <mrow>
+        - First <mrow>: left subscript
+        - Second <mrow>: left superscript
+        - Third <mrow>: base symbol (first part)
+        - Additional children: merged with base (e.g., FeMn has Fe in mrow, Mn as mi)
+
+        Args:
+            base_node: The base element to check
+
+        Returns:
+            True if this is a sideset pattern, False otherwise
+        """
+        if _local(base_node.tag) != 'mrow':
+            return False
+
+        # Get direct children of the base <mrow>
+        children = list(base_node)
+
+        # Must have at least 3 children
+        if len(children) < 3:
+            return False
+
+        # First 3 children must all be <mrow> elements
+        return all(_local(children[i].tag) == 'mrow' for i in range(3))
+
+    def _handle_sideset(self, msubsup_children: list) -> str:
+        """
+        Handle sideset pattern conversion.
+
+        Pattern:
+            <msubsup>
+              <mrow>
+                <mrow>left_sub</mrow>
+                <mrow>left_sup</mrow>
+                <mrow>base_part1</mrow>
+                [optional: additional base elements...]
+              </mrow>
+              <mrow>right_sub</mrow>
+              <mrow>right_sup</mrow>
+            </msubsup>
+
+        Converts to: \\sideset{_{left_sub}^{left_sup}}{_{right_sub}^{right_sup}}{base}
+
+        Args:
+            msubsup_children: The 3 children of <msubsup> element
+
+        Returns:
+            LaTeX sideset command
+        """
+        base_mrow = msubsup_children[0]
+        right_sub_mrow = msubsup_children[1]
+        right_sup_mrow = msubsup_children[2]
+
+        # Extract children from base <mrow>
+        base_children = list(base_mrow)
+        left_sub_mrow = base_children[0]
+        left_sup_mrow = base_children[1]
+        actual_base_mrow = base_children[2]
+
+        # Additional children after the 3rd element should be merged with base
+        # Example: <mrow>Fe</mrow><mi>Mn</mi> → FeMn
+        extra_base_elements = base_children[3:] if len(base_children) > 3 else []
+
+        # Push script context for converting subscripts and superscripts
+        if self.context:
+            self.context.push_script_context('sideset')
+
+        try:
+            # Convert all parts
+            left_sub = self._convert_child(left_sub_mrow)
+            left_sup = self._convert_child(left_sup_mrow)
+            right_sub = self._convert_child(right_sub_mrow)
+            right_sup = self._convert_child(right_sup_mrow)
+        finally:
+            if self.context:
+                self.context.pop_script_context()
+
+        # Convert base (not in script context)
+        base_parts = [self._convert_child(actual_base_mrow)]
+
+        # Add any extra base elements (e.g., Mn after Fe in FeMn)
+        for extra_elem in extra_base_elements:
+            base_parts.append(self._convert_child(extra_elem))
+
+        # Merge base parts (no spaces for chemical formulas)
+        base = ''.join(base_parts)
+
+        # Build sideset command
+        left_scripts = f"_{{{left_sub}}}^{{{left_sup}}}"
+        right_scripts = f"_{{{right_sub}}}^{{{right_sup}}}"
+
+        return f"\\sideset{{{left_scripts}}}{{{right_scripts}}}{{{base}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'msubsup'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'msubsup'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MsubsupVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/msup_visitor.py b/scripts/omml_mathml2latex/visitors/msup_visitor.py
new file mode 100644
index 0000000..3a67bcb
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/msup_visitor.py
@@ -0,0 +1,469 @@
+"""
+Visitor for <msup> (superscript) MathML elements.
+
+The <msup> element represents superscripts in MathML:
+- Powers: x^2, x^n
+- Exponents: e^x, 10^{-3}
+- Indices: a^i, T^{ij}
+- Prime notation: f', f'', f''' (derivatives)
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..core.context import ConversionContext
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MsupVisitor(Visitor):
+    """
+    Handles <msup> (superscript) MathML elements.
+
+    This visitor converts superscripts to LaTeX format using ^ notation.
+    Special handling for prime notation (derivatives).
+
+    Examples:
+        Simple power:
+            <msup><mi>x</mi><mn>2</mn></msup> → x^{2}
+
+        Exponent:
+            <msup><mi>e</mi><mi>x</mi></msup> → e^{x}
+
+        Complex base:
+            <msup>
+              <mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>
+              <mn>2</mn>
+            </msup>
+            → (x + 1)^{2}
+
+        Complex exponent:
+            <msup><mi>x</mi><mrow><mn>2</mn><mi>n</mi></mrow></msup>
+            → x^{2 n}
+
+        Prime notation (derivatives):
+            <msup><mi>f</mi><mo>&#x2032;</mo></msup> → f'
+            <msup><mi>f</mi><mo>&#x2033;</mo></msup> → f''
+            <msup><mi>y</mi><mo>&#x2034;</mo></msup> → y'''
+    """
+
+    def __init__(self, strategy: Strategy, context: ConversionContext = None):
+        """
+        Initialize the Msup visitor.
+
+        Args:
+            strategy: The formatting strategy to use
+            context: Shared conversion context for state tracking
+        """
+        super().__init__(strategy)
+        self.context = context
+
+    def visit(self, node: ET.Element) -> str:
+        """
+        Convert <msup> element to LaTeX.
+
+        Args:
+            node: The <msup> element to convert
+
+        Returns:
+            LaTeX superscript string
+
+        Raises:
+            ValueError: If node is not an <msup> element
+            ValueError: If msup has fewer than 2 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MsupVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+        if len(children) < 2:
+            raise ValueError(
+                f"msup element must have 2 children (base, superscript), "
+                f"got {len(children)}"
+            )
+
+        # NEW: Check for nested msup and merge if needed
+        # Pattern: <msup><mrow><msup>base<sup1></msup></mrow><sup2></msup>
+        # Should become: base^{sup1sup2} instead of base^{sup1}^{sup2}
+        nested_msup = self._detect_nested_msup(children[0])
+        if nested_msup is not None:
+            result = self._merge_nested_superscripts(nested_msup, children[1])
+            if result:
+                base_latex, merged_sup_latex = result
+                base_latex = self._wrap_if_needed(base_latex)
+                return f"{base_latex}^{self._brace(merged_sup_latex)}"
+
+        # Convert base (not in script context)
+        base = self._convert_child(children[0])
+
+        # Push script context before converting superscript
+        if self.context:
+            self.context.push_script_context('msup')
+
+        try:
+            # Convert superscript (in script context)
+            superscript = self._convert_child(children[1])
+        finally:
+            # Always pop context, even if conversion fails
+            if self.context:
+                self.context.pop_script_context()
+
+        # Special case: Empty superscript - just return the base
+        # This can happen when OMML has <m:sSup> with an empty <m:sup>
+        if not superscript or not superscript.strip():
+            base = self._wrap_if_needed(base)
+            return base
+
+        # Special case: Prime notation (\prime → ^{\prime}, \prime\prime → ^{\prime\prime}, etc.)
+        # If superscript contains only \prime symbols, convert to proper LaTeX prime syntax
+        if self._is_prime_notation(superscript):
+            # Wrap base if needed (complex expressions)
+            base = self._wrap_if_needed(base)
+            # Remove spaces from prime notation
+            clean_primes = superscript.replace(' ', '').replace('\xa0', '')
+            # Convert to proper superscript form: ^{\prime}, ^{\prime\prime}, etc.
+            return f"{base}^{{{clean_primes}}}"
+
+        # Special case: cancelto pattern (menclose with updiagonalstrike + superscript)
+        # Pattern: <msup><menclose notation="updiagonalstrike">content</menclose><sup>target</sup></msup>
+        # Should become: \cancelto{target}{content} instead of \cancel{content}^{target}
+        if self._is_cancel_with_target(children[0], base):
+            # Extract content from \cancel{content}
+            content = self._extract_cancel_content(base)
+            if content:
+                return f"\\cancelto{self._brace(superscript)}{self._brace(content)}"
+
+        # TODO: More special cases
+        # - Empty base (just return ^{sup})
+        # - Omit ^{1} for simple variables
+        # - Large operators with \limits
+
+        # Wrap base if needed (complex expressions)
+        base = self._wrap_if_needed(base)
+
+        # Return base^{superscript}
+        return f"{base}^{self._brace(superscript)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msup':
+            # Recursive: msup can contain other msup elements
+            return self.visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy, self.context).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in msup, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _wrap_if_needed(self, base: str) -> str:
+        """
+        Wrap base in parentheses if needed.
+
+        Args:
+            base: The base content
+
+        Returns:
+            Base, optionally wrapped in parentheses
+
+        Note:
+            Complex expressions with operators should be wrapped.
+            Simple identifiers and numbers don't need wrapping.
+        """
+        # Check if base already has delimiters (starts and ends with matching delimiters)
+        base_stripped = base.strip()
+        if base_stripped:
+            # Check for __DELIM__ markers (used by delimiter pairing processor)
+            # Pattern: __DELIM__X__DELIM__ ... __DELIM__Y__DELIM__
+            # These will be converted to \left...\right by post-processor
+            if base_stripped.startswith('__DELIM__') and '__DELIM__' in base_stripped[9:]:
+                # Already has delimiter markers, no need to wrap
+                return base
+
+            # Check for matching delimiters
+            delimiter_pairs = {
+                '(': ')',
+                '[': ']',
+                '{': '}',
+                '\\left(': '\\right)',
+                '\\left[': '\\right]',
+                '\\left\\{': '\\right\\}',
+            }
+
+            for open_delim, close_delim in delimiter_pairs.items():
+                if base_stripped.startswith(open_delim) and base_stripped.endswith(close_delim):
+                    # Already has delimiters, no need to wrap
+                    return base
+
+        # Check if base needs grouping for proper superscript application
+        # In LaTeX, x^2 applies superscript to x, but "a + b^2" applies only to b
+        # We need to brace multi-element bases: {a + b}^2
+        #
+        # Use braces {} for grouping (invisible) not parentheses () (visible)
+        # Only wrap if base contains operators that indicate a true multi-element expression
+        math_operators = {'=', '+', '-', '/', '*', '\\times', '\\cdot', '\\pm', '\\to'}
+        if ' ' in base and any(op in base for op in math_operators):
+            return f"{{{base}}}"
+        return base
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def _is_prime_notation(self, superscript: str) -> bool:
+        """
+        Check if superscript is prime notation (only \\prime symbols).
+
+        Prime notation in LaTeX:
+        - x^{\\prime} (single prime)
+        - x^{\\prime\\prime} (double prime)
+        - x^{\\prime\\prime\\prime} (triple prime)
+        - x^{\\prime\\prime\\prime\\prime} (quadruple prime)
+
+        Args:
+            superscript: The converted superscript LaTeX string
+
+        Returns:
+            True if superscript contains only \\prime symbols
+
+        Note:
+            Handles spaced primes from mrow conversion (e.g., "\\prime \\prime")
+            which should become "\\prime\\prime"
+        """
+        # Remove ALL whitespace
+        no_spaces = superscript.replace(' ', '').replace('\xa0', '')
+        if not no_spaces:
+            return False
+
+        # Check if content is only \prime symbols (possibly repeated)
+        # Valid patterns: \prime, \prime\prime, \prime\prime\prime, etc.
+        # The string should be exactly \prime repeated N times
+        if not no_spaces.startswith('\\prime'):
+            return False
+
+        # Remove all \prime occurrences and check if anything remains
+        test = no_spaces.replace('\\prime', '')
+        return len(test) == 0
+
+    def _is_cancel_with_target(self, base_node: ET.Element, base_latex: str) -> bool:
+        """
+        Check if base is a cancel/strike-through that should use cancelto.
+
+        Args:
+            base_node: The base element (first child of msup)
+            base_latex: The converted LaTeX for the base
+
+        Returns:
+            True if this is a cancel pattern that should use \\cancelto
+        """
+        # Check if base_node is menclose with updiagonalstrike notation
+        if _local(base_node.tag) == 'menclose':
+            notation = base_node.get('notation', '')
+            return 'updiagonalstrike' in notation
+
+        # Check if base_node is mrow containing a single menclose
+        if _local(base_node.tag) == 'mrow':
+            children = list(base_node)
+            # If mrow contains exactly one child and it's a menclose
+            if len(children) == 1 and _local(children[0].tag) == 'menclose':
+                notation = children[0].get('notation', '')
+                return 'updiagonalstrike' in notation
+
+        return False
+
+    def _extract_cancel_content(self, base_latex: str) -> str:
+        """
+        Extract content from \\cancel{content}, \\xcancel{content}, etc.
+
+        Args:
+            base_latex: LaTeX string containing cancel command
+
+        Returns:
+            The content inside the cancel braces, or empty string if not a cancel pattern
+
+        Examples:
+            \\cancel{x} → x
+            \\xcancel{abc} → abc
+            \\bcancel{123} → 123
+        """
+        import re
+        # Pattern: \cancel{content}, \xcancel{content}, \bcancel{content}
+        match = re.match(r'\\(?:x|b)?cancel\{(.+?)\}$', base_latex)
+        if match:
+            return match.group(1)
+        return ''
+
+    def _detect_nested_msup(self, base_node: ET.Element):
+        """
+        Detect if base contains a nested msup element.
+
+        Handles two patterns:
+        1. Direct nested: <msup><msup>...</msup>...</msup>
+        2. Wrapped in mrow: <msup><mrow><msup>...</msup></mrow>...</msup>
+
+        Args:
+            base_node: The base element (first child of outer msup)
+
+        Returns:
+            The nested msup element if found, None otherwise
+        """
+        # Check direct nested msup
+        if _local(base_node.tag) == 'msup':
+            return base_node
+
+        # Check msup wrapped in mrow (most common pattern)
+        if _local(base_node.tag) == 'mrow':
+            children = list(base_node)
+            # If mrow contains exactly one child and it's an msup
+            if len(children) == 1 and _local(children[0].tag) == 'msup':
+                return children[0]
+
+        return None
+
+    def _merge_nested_superscripts(self, inner_msup: ET.Element, outer_sup_node: ET.Element):
+        """
+        Merge nested msup with outer superscript.
+
+        This handles the pattern:
+            <msup>
+              <msup><base><sup1></msup>
+              <sup2>
+            </msup>
+
+        Which should become: base^{sup1sup2} instead of base^{sup1}^{sup2}
+
+        Args:
+            inner_msup: The nested <msup> element
+            outer_sup_node: The outer superscript element
+
+        Returns:
+            Tuple of (base_latex, merged_superscript_latex) or None if invalid
+
+        Examples:
+            <msup><msup><mi>n</mi><mn>2</mn></msup><mo>+</mo></msup>
+            → ("\\mathrm{n}", "2+")
+        """
+        # Extract inner msup children
+        inner_children = list(inner_msup)
+        if len(inner_children) < 2:
+            return None  # Invalid structure
+
+        inner_base = inner_children[0]
+        inner_sup = inner_children[1]
+
+        # Convert base (not in script context)
+        base_latex = self._convert_child(inner_base)
+
+        # Convert both superscripts in script context
+        if self.context:
+            self.context.push_script_context('msup')
+
+        try:
+            inner_sup_latex = self._convert_child(inner_sup)
+            outer_sup_latex = self._convert_child(outer_sup_node)
+        finally:
+            if self.context:
+                self.context.pop_script_context()
+
+        # Merge superscripts: {inner}{outer}
+        # Example: inner="2", outer="+" → "2+"
+        merged_sup = f"{inner_sup_latex}{outer_sup_latex}"
+
+        return (base_latex, merged_sup)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'msup'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'msup'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MsupVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mtable_visitor.py b/scripts/omml_mathml2latex/visitors/mtable_visitor.py
new file mode 100644
index 0000000..0d56d9c
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mtable_visitor.py
@@ -0,0 +1,1003 @@
+r"""
+Visitor for <mtable> (table/matrix) MathML elements.
+
+The <mtable> element represents tables and matrices in mathematical expressions:
+- Matrix environments: pmatrix, bmatrix, vmatrix, Vmatrix
+- Generic arrays with column specifications
+- Cases environment (piecewise functions)
+- Binomial coefficients
+- Chemical reaction conditions
+
+This visitor coordinates with MtrVisitor and MtdVisitor to handle table structure.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MtableVisitor(Visitor):
+    r"""
+    Handles <mtable> (table/matrix) MathML elements.
+
+    Converts tables to appropriate LaTeX environments based on context and attributes.
+
+    Examples:
+        Matrix (parentheses):
+            <mfenced open="(" close=")">
+              <mtable>
+                <mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr>
+                <mtr><mtd><mn>3</mn></mtd><mtd><mn>4</mn></mtd></mtr>
+              </mtable>
+            </mfenced>
+            → \begin{pmatrix}1 & 2 \\ 3 & 4\end{pmatrix}
+
+        Matrix (brackets):
+            <mfenced open="[" close="]">
+              <mtable>...</mtable>
+            </mfenced>
+            → \begin{bmatrix}...\end{bmatrix}
+
+        Matrix (vertical bars):
+            <mfenced open="|" close="|">
+              <mtable>...</mtable>
+            </mfenced>
+            → \begin{vmatrix}...\end{vmatrix}
+
+        Piecewise functions (legacy data-cases attribute, now ignored):
+            <mfenced open="{" close="">
+              <mtable>
+                <mtr><mtd><mi>x</mi></mtd></mtr>
+                <mtr><mtd><mi>y</mi></mtd></mtr>
+              </mtable>
+            </mfenced>
+            → \left\{\begin{array}{l}x \\ y\end{array}\right.
+
+        Generic array:
+            <mtable>
+              <mtr><mtd><mi>a</mi></mtd><mtd><mi>b</mi></mtd></mtr>
+            </mtable>
+            → \begin{array}{cc}a & b \\\end{array}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mtable visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mtable> element to LaTeX.
+
+        Args:
+            node: The <mtable> element to convert
+
+        Returns:
+            LaTeX string with appropriate matrix/table environment
+
+        Raises:
+            ValueError: If node is not an <mtable> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MtableVisitor cannot handle element '{node.tag}'")
+
+        # Check for special table types
+        # 1. Cases-like structures (piecewise functions)
+        # NOTE: We NO LONGER use cases environment for better compatibility
+        # Instead, these are wrapped by parent mfenced with \left\{ and \right.
+        # If we see data-cases="true", we should ignore it and render as a regular array
+        # (the wrapping delimiters will be added by the parent mfenced element)
+
+        # 2. Binomial coefficients
+        if node.get("data-binomial") == "true":
+            return self._create_binomial(node)
+
+        # 3. Chemical reaction conditions (double underline pattern)
+        # CRITICAL: Check BEFORE rendering as array
+        # Pattern: 2-row mtable with nested munder elements
+        if self._is_chemical_reaction_condition(node):
+            upper_text = self._extract_reaction_condition_text(node)
+            lower_text = self._extract_reaction_condition_lower_text(node)
+            if not lower_text:
+                lower_text = "\\quad"
+            return f"\\xlongequal[{lower_text}]{{{upper_text}}}"
+
+        # 4. Large operator with limits (vertical stack pattern)
+        # Pattern: 3-row mtable with large operator in middle row
+        # Example: n / ∑ / i=1 → \sum^{n}_{i=1}
+        if self._is_large_operator_stack(node):
+            return self._convert_large_operator_stack(node)
+
+        # Get table attributes
+        columnalign = node.get("columnalign", "center")
+        align = node.get("align", "")  # Vertical alignment (top, bottom, center, axis, baseline)
+        frame = node.get("frame", "none")
+
+        # Determine environment type based on parent mfenced delimiters
+        env = self._determine_environment(node, frame)
+
+        # Get all rows
+        rows = self._convert_rows(node)
+
+        if not rows:
+            return f"\\begin{{{env}}}\\end{{{env}}}"
+
+        # Remove trailing \\ from last row (not needed in LaTeX)
+        if rows and rows[-1].endswith(" \\\\"):
+            rows[-1] = rows[-1][:-3]  # Remove " \\"
+
+        # Determine strict alignment requirements
+        # If the environment is a matrix type (pmatrix, etc.) but we have specific alignment
+        # (e.g., left aligned columns), we must switch to 'array' with manual delimiters
+        # because pmatrix/bmatrix etc. do not support column specs (always centered).
+
+        explicit_alignment = columnalign and columnalign != "center" and columnalign != "mean"
+
+        # Matrix to delimiter mapping
+        matrix_delims = {
+            "pmatrix": ("(", ")"),
+            "bmatrix": ("[", "]"),
+            "vmatrix": ("|", "|"),
+            "Vmatrix": (r"\|", r"\|"),
+        }
+
+        force_array_with_delims = False
+        open_delim, close_delim = "", ""
+
+        if env in matrix_delims and explicit_alignment:
+            # Switch to array but wrap in delimiters
+            force_array_with_delims = True
+            open_delim, close_delim = matrix_delims[env]
+            env = "array"
+
+        # Add column specification for array environment
+        if env == "array":
+            col_count = rows[0].count('&') + 1 if rows else 1
+            col_spec = self._get_column_spec(columnalign, col_count)
+            # Was: Forced left for cases-style.
+            # Removed to respect source alignment (e.g. Center) even for single-brace tables.
+
+            # Helper for position argument (vertical alignment)
+            # MathXML align: top, bottom, center, axis, baseline
+            # LaTeX array: t (top), b (bottom), c (center/default)
+            pos_arg = ""
+            if align == "top":
+                pos_arg = "[t]"
+            elif align == "bottom":
+                pos_arg = "[b]"
+            # center/axis/baseline -> default (center)
+
+            # Format as: \begin{array}[pos]{cc}...\end{array}
+            rows_str = '\n'.join(rows)
+            array_latex = f"\\begin{{{env}}}{pos_arg}{{{col_spec}}}\n{rows_str}\n\\end{{{env}}}"
+
+            if force_array_with_delims:
+                # Wrap in \left...\right
+                # Handle special case for braces/bars in LaTeX if needed (but map uses raw chars or commands)
+                # open_delim is raw char usually.
+                # If it's { or } it needs escaping, but Vmatrix uses \|.
+                # However, \left( is valid. \left\| is valid.
+                # Only need to be careful if delim is complex.
+
+                # Check if we need to escape { or } for built-in text
+                # But here we are generating LaTeX code.
+                left_cmd = f"\\left{open_delim}"
+                right_cmd = f"\\right{close_delim}"
+
+                # Specific fix for brace which might be passed as {
+                if open_delim == "{": left_cmd = r"\left\{"
+                if close_delim == "}": right_cmd = r"\right\}"
+
+                return f"{left_cmd}{array_latex}{right_cmd}"
+            else:
+                return array_latex
+        else:
+            # Format as: \begin{pmatrix}...\end{pmatrix}
+            # Note: Standard matrix envs don't support vertical alignment arg easily
+            rows_str = '\n'.join(rows)
+            return f"\\begin{{{env}}}\n{rows_str}\n\\end{{{env}}}"
+
+    def _is_cases_style(self, node: ET.Element) -> bool:
+        """
+        Check if mtable is inside a cases-style structure (left brace only).
+
+        Cases-style includes:
+        - Piecewise functions: f(x) = { case1 \\ case2 }
+        - Equation systems: { eq1 \\ eq2 }
+        - Inequality systems
+
+        Per company convention, these should use left alignment ('ll').
+
+        Args:
+            node: The <mtable> element
+
+        Returns:
+            True if this is a cases-style table
+        """
+        from ..utils import text_content as _text_content
+
+        parent = node.getparent()
+
+        # Pattern 1: Direct mfenced parent
+        if parent is not None and _local(parent.tag) == "mfenced":
+            open_delim = parent.get("open", "(")
+            close_delim = parent.get("close", ")")
+
+            # Cases-style: left brace with empty or "." closing
+            if open_delim == "{" and close_delim in ("", "."):
+                return True
+
+        # Pattern 2: mfenced -> mrow -> mtable
+        if parent is not None and _local(parent.tag) == "mrow":
+            grandparent = parent.getparent()
+            if grandparent is not None and _local(grandparent.tag) == "mfenced":
+                open_delim = grandparent.get("open", "(")
+                close_delim = grandparent.get("close", ")")
+
+                if open_delim == "{" and close_delim in ("", "."):
+                    return True
+
+        # Pattern 3: <mo fence="true">{</mo> sibling pattern (MathML without mfenced)
+        # Structure: <mrow><mo fence="true">{</mo><mrow><mtable>...</mtable></mrow><mo fence="true"/></mrow>
+        # The mtable is in mrow -> mrow, and sibling mo has fence=true with {
+        if parent is not None and _local(parent.tag) == "mrow":
+            grandparent = parent.getparent()
+            if grandparent is not None and _local(grandparent.tag) == "mrow":
+                # Check siblings of parent for <mo fence="true">{</mo>
+                for sibling in grandparent:
+                    if _local(sibling.tag) == "mo" and sibling.get("fence") == "true":
+                        sibling_text = _text_content(sibling).strip()
+                        if sibling_text == "{":
+                            # Found left brace fence, check if closing is empty
+                            # Look for an empty <mo fence="true"/> or <mo fence="true">.</mo>
+                            for other in grandparent:
+                                if other is sibling:
+                                    continue
+                                if _local(other.tag) == "mo" and other.get("fence") == "true":
+                                    other_text = _text_content(other).strip()
+                                    if other_text in ("", "."):
+                                        return True
+                            # If only one fence found with {, still consider it cases-style
+                            # (closing might be implicit)
+                            return True
+
+        return False
+
+    def _determine_environment(self, node: ET.Element, frame: str) -> str:
+        """
+        Determine the LaTeX environment based on context.
+
+        Args:
+            node: The <mtable> element
+            frame: Frame attribute value
+
+        Returns:
+            Environment name (pmatrix, bmatrix, vmatrix, Vmatrix, array, matrix)
+        """
+        # Check for delimiter attributes on parent mfenced
+        parent = node.getparent()
+        if parent is not None and _local(parent.tag) == "mfenced":
+            open_delim = parent.get("open", "(")
+            close_delim = parent.get("close", ")")
+
+            # Match delimiters to matrix types
+            if open_delim == "(" and close_delim == ")":
+                return "pmatrix"
+            elif open_delim == "[" and close_delim == "]":
+                return "bmatrix"
+            elif open_delim == "|" and close_delim == "|":
+                return "vmatrix"
+            elif open_delim == "||" and close_delim == "||":
+                return "Vmatrix"
+
+        # Default based on frame attribute
+        if frame == "solid":
+            return "matrix"
+        else:
+            return "array"
+
+    def _get_column_spec(self, columnalign: str, col_count: int) -> str:
+        """
+        Generate column specification for array environment.
+
+        Args:
+            columnalign: Column alignment attribute
+            col_count: Number of columns
+
+        Returns:
+            Column specification string (e.g., "ccc" for 3 centered columns)
+        """
+        # Parse columnalign attribute
+        # Can be: "left", "center", "right", or space-separated list
+        alignments = columnalign.split()
+
+        if len(alignments) == 1:
+            # Same alignment for all columns
+            align_char = self._align_to_char(alignments[0])
+            return align_char * col_count
+        else:
+            # Different alignments per column
+            # Repeat last alignment if not enough specified
+            spec = []
+            for i in range(col_count):
+                if i < len(alignments):
+                    spec.append(self._align_to_char(alignments[i]))
+                else:
+                    # Repeat last alignment
+                    spec.append(self._align_to_char(alignments[-1]))
+            return ''.join(spec)
+
+    def _align_to_char(self, align: str) -> str:
+        """
+        Convert alignment name to LaTeX column spec character.
+
+        Args:
+            align: Alignment name (left, center, right)
+
+        Returns:
+            Column spec character (l, c, r)
+        """
+        align_map = {
+            'left': 'l',
+            'center': 'c',
+            'right': 'r',
+        }
+        return align_map.get(align, 'c')  # Default to center
+
+    def _convert_rows(self, node: ET.Element) -> list:
+        """
+        Convert all <mtr> child elements to LaTeX row strings.
+
+        Args:
+            node: The <mtable> element
+
+        Returns:
+            List of LaTeX row strings
+        """
+        rows = []
+        for child in node:
+            if _local(child.tag) == "mtr":
+                row_latex = self._convert_row(child)
+                rows.append(row_latex)
+        return rows
+
+    def _convert_row(self, node: ET.Element) -> str:
+        """
+        Convert a single <mtr> (table row) element.
+
+        Args:
+            node: The <mtr> element
+
+        Returns:
+            LaTeX row string with cells separated by &
+        """
+        # Use MtrVisitor for proper row conversion
+        from .mtr_visitor import MtrVisitor
+        return MtrVisitor(self.strategy).visit(node)
+
+    # NOTE: _create_cases_environment is no longer used
+    # We now use explicit \left\{ and \right. notation via mfenced wrapper
+    # for better compatibility (cases environment is not universally supported)
+    # def _create_cases_environment(self, node: ET.Element) -> str:
+    #     """
+    #     Create a cases environment for piecewise functions.
+    #
+    #     Args:
+    #         node: The <mtable> element with data-cases="true"
+    #
+    #     Returns:
+    #         LaTeX cases environment
+    #     """
+    #     from .mtd_visitor import MtdVisitor
+    #
+    #     rows = []
+    #     for child in node:
+    #         if _local(child.tag) == "mtr":
+    #             # For cases, we only use the first cell of each row
+    #             if len(child) > 0:
+    #                 first_cell = child[0]
+    #                 if _local(first_cell.tag) == "mtd":
+    #                     cell_content = MtdVisitor(self.strategy).visit(first_cell)
+    #                     rows.append(cell_content)
+    #
+    #     if not rows:
+    #         return "\\begin{cases}\\end{cases}"
+    #
+    #     # Join rows with \\ and add space after each line break (except last)
+    #     # This matches the original converter's output format
+    #     cases_content = '\\\\ '.join(rows)
+    #     return f"\\begin{{cases}}{cases_content}\\end{{cases}}"
+
+    def _create_binomial(self, node: ET.Element) -> str:
+        """
+        Create binomial coefficient notation.
+
+        Args:
+            node: The <mtable> element with data-binomial="true"
+
+        Returns:
+            LaTeX array for binomial coefficient
+        """
+        from .mtd_visitor import MtdVisitor
+
+        rows = [child for child in node if _local(child.tag) == "mtr"]
+
+        if len(rows) == 2:
+            # Get numerator from first row
+            num_cell = rows[0][0] if len(rows[0]) > 0 else None
+            num_content = MtdVisitor(self.strategy).visit(num_cell) if num_cell is not None else ""
+
+            # Get denominator from second row
+            den_cell = rows[1][0] if len(rows[1]) > 0 else None
+            den_content = MtdVisitor(self.strategy).visit(den_cell) if den_cell is not None else ""
+
+            return f"\\begin{{array}}{num_content}\\\\{den_content}\\end{{array}}"
+
+        # Fallback to regular array
+        return self.visit(node)
+
+    def _is_chemical_reaction_condition(self, mtable_node: ET.Element) -> bool:
+        """
+        Check if an mtable represents chemical reaction conditions.
+
+        Pattern: 2-row mtable with:
+        - Row 1: Contains double munder pattern (nested munder with underscore operators)
+        - Row 2: Empty or whitespace only
+
+        This is how Word/OMML encodes reaction arrows like: A + B --[condition]--> C + D
+
+        Args:
+            mtable_node: The <mtable> element to check
+
+        Returns:
+            True if this is a chemical reaction condition table
+        """
+        from ..utils import text_content as _text_content
+
+        rows = [child for child in mtable_node if _local(child.tag) == "mtr"]
+
+        # Must be exactly 2 rows (condition text + empty row)
+        if len(rows) != 2:
+            return False
+
+        # First row should have content, second row should be empty
+        first_row = rows[0]
+        second_row = rows[1]
+
+        # Check first row has exactly one cell
+        first_cells = [child for child in first_row if _local(child.tag) == "mtd"]
+        if len(first_cells) != 1:
+            return False
+
+        # CRITICAL: Check for malformed "double munder" pattern
+        # Pattern: mtd → munder → munder → content
+        first_cell = first_cells[0]
+        if self._has_double_munder_pattern(first_cell):
+            return True
+
+        # Alternative: Check if content looks like a reaction condition
+        # (For cases where double munder isn't present but it's clearly a condition)
+        first_cell_text = _text_content(first_cell).strip()
+        if not first_cell_text:
+            return False
+
+        # Check second row is empty or has only whitespace
+        second_cells = [child for child in second_row if _local(child.tag) == "mtd"]
+        if len(second_cells) != 1:
+            return False
+
+        second_cell_text = _text_content(second_cells[0]).strip()
+        # Allow nbsp (U+00A0) and other whitespace
+        if second_cell_text and second_cell_text != "\xa0" and second_cell_text != " ":
+            return False
+
+        # Check for typical reaction conditions
+        if self._contains_chinese_text(first_cell_text):
+            return True
+
+        # Check for standalone chemical condition symbols like Δ (delta/heat)
+        if first_cell_text in ["Δ", "δ", "\\Delta"]:
+            return True
+
+        return False
+
+    def _has_double_munder_pattern(self, cell_node: ET.Element) -> bool:
+        """
+        Detect nested munder elements with underscore operators.
+
+        Pattern: mtd → [mrow →] munder → munder → content
+        Both munders have underscore (_) as the operator, creating double underline.
+
+        Args:
+            cell_node: The <mtd> cell element
+
+        Returns:
+            True if double munder pattern detected
+        """
+        from ..utils import text_content as _text_content
+
+        # Check if cell contains munder as direct child
+        munder_children = [child for child in cell_node if _local(child.tag) == "munder"]
+
+        # If no direct munder, check inside mrow wrapper
+        if len(munder_children) == 0:
+            mrow_children = [child for child in cell_node if _local(child.tag) == "mrow"]
+            if len(mrow_children) == 1:
+                # Look for munder inside the mrow
+                munder_children = [child for child in mrow_children[0] if _local(child.tag) == "munder"]
+
+        if len(munder_children) != 1:
+            return False
+
+        outer_munder = munder_children[0]
+
+        # Check if outer munder has underaccent or accentunder attribute
+        if not (outer_munder.get("accentunder") or outer_munder.get("underaccent")):
+            return False
+
+        # Outer munder should have 2 children: content (nested munder) and operator (_)
+        if len(outer_munder) < 2:
+            return False
+
+        # Check if the operator is underscore
+        outer_operator = outer_munder[1]
+        if _local(outer_operator.tag) == "mo":
+            outer_op_text = _text_content(outer_operator).strip()
+            if outer_op_text != "_":
+                return False
+        else:
+            return False
+
+        # Check if first child is another munder (nested)
+        inner_content = outer_munder[0]
+
+        inner_munder = None
+        if _local(inner_content.tag) == "munder":
+            inner_munder = inner_content
+        elif _local(inner_content.tag) == "mrow":
+            # Inner munder might be inside mrow
+            for child in inner_content:
+                if _local(child.tag) == "munder":
+                    inner_munder = child
+                    break
+
+        if inner_munder is None:
+            return False
+
+        # Check if inner munder also has underaccent or accentunder attribute
+        if not (inner_munder.get("accentunder") or inner_munder.get("underaccent")):
+            return False
+
+        # Inner munder should also have underscore operator
+        if len(inner_munder) < 2:
+            return False
+
+        inner_operator = inner_munder[1]
+        if _local(inner_operator.tag) == "mo":
+            inner_op_text = _text_content(inner_operator).strip()
+            if inner_op_text != "_":
+                return False
+        else:
+            return False
+
+        # If we got here, we have the double munder pattern!
+        return True
+
+    def _extract_reaction_condition_text(self, mtable_node: ET.Element) -> str:
+        """
+        Extract the reaction condition text from the mtable.
+
+        Args:
+            mtable_node: The <mtable> element
+
+        Returns:
+            Condition text (e.g., "电解", "\\Delta", etc.)
+        """
+        from ..utils import text_content as _text_content
+
+        rows = [child for child in mtable_node if _local(child.tag) == "mtr"]
+        if len(rows) < 1:
+            return ""
+
+        first_row = rows[0]
+        cells = [child for child in first_row if _local(child.tag) == "mtd"]
+        if len(cells) < 1:
+            return ""
+
+        first_cell = cells[0]
+
+        # CRITICAL: Handle malformed double munder pattern
+        if self._has_double_munder_pattern(first_cell):
+            # Extract text from inside the nested munder structure
+            text = self._extract_text_from_double_munder(first_cell)
+            if text:
+                # Convert common symbols
+                if text == "Δ" or text == "\\Delta":
+                    return "\\Delta"
+                # For Chinese text or other content, wrap in \mathrm{}
+                if self._contains_chinese_text(text):
+                    return f"\\mathrm{{{text}}}"
+                return text
+            # If extraction failed or content is empty, return empty string
+            return ""
+
+        # Fallback: Convert the cell normally
+        from .mtd_visitor import MtdVisitor
+        content = MtdVisitor(self.strategy).visit(first_cell).strip()
+
+        # Clean up extra wrappers
+        import re
+        # Remove \text{} wrappers
+        content = re.sub(r'\\text\{([^}]*)\}', r'\1', content)
+        # Preserve \mathrm{} wrappers
+
+        return content
+
+    def _extract_reaction_condition_lower_text(self, mtable_node: ET.Element) -> str:
+        """
+        Extract lower (below-arrow) reaction condition text from second row.
+
+        Args:
+            mtable_node: The <mtable> element
+
+        Returns:
+            Lower condition text for xlongequal bracket (empty if missing)
+        """
+        from ..utils import text_content as _text_content
+        from .mtd_visitor import MtdVisitor
+        import re
+
+        rows = [child for child in mtable_node if _local(child.tag) == "mtr"]
+        if len(rows) < 2:
+            return ""
+
+        second_row = rows[1]
+        cells = [child for child in second_row if _local(child.tag) == "mtd"]
+        if len(cells) < 1:
+            return ""
+
+        second_cell = cells[0]
+        raw_text = _text_content(second_cell).strip()
+
+        # Treat empty/whitespace-only second row as no lower condition
+        if not raw_text or raw_text in ("\xa0", " "):
+            return ""
+
+        # Normalize common symbol cases
+        if raw_text in ("Δ", "\\Delta"):
+            return "\\Delta"
+
+        # Prefer direct text extraction for Chinese to avoid spacing artifacts
+        if self._contains_chinese_text(raw_text):
+            compact_text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])', '', raw_text)
+            return f"\\mathrm{{{compact_text}}}"
+
+        # Fallback to full conversion for non-textual/math-rich content
+        content = MtdVisitor(self.strategy).visit(second_cell).strip()
+        content = re.sub(r'\\text\{([^}]*)\}', r'\1', content)
+        return content
+
+    def _extract_text_from_double_munder(self, cell_node: ET.Element) -> str:
+        """
+        Extract actual text content from double munder pattern.
+
+        Structure: mtd → [mrow →] munder → munder → actual_content
+
+        Args:
+            cell_node: The <mtd> cell element
+
+        Returns:
+            Extracted text content
+        """
+        from ..utils import text_content as _text_content
+
+        # Navigate to outer munder
+        outer_munder = None
+        for child in cell_node:
+            if _local(child.tag) == "munder":
+                outer_munder = child
+                break
+            elif _local(child.tag) == "mrow":
+                # Check inside mrow
+                for grandchild in child:
+                    if _local(grandchild.tag) == "munder":
+                        outer_munder = grandchild
+                        break
+
+        if outer_munder is None:
+            return ""
+
+        # Get first child of outer munder (should be inner munder or mrow containing it)
+        if len(outer_munder) < 1:
+            return ""
+
+        inner_content = outer_munder[0]
+
+        # Find inner munder
+        inner_munder = None
+        if _local(inner_content.tag) == "munder":
+            inner_munder = inner_content
+        elif _local(inner_content.tag) == "mrow":
+            for child in inner_content:
+                if _local(child.tag) == "munder":
+                    inner_munder = child
+                    break
+
+        if inner_munder is None:
+            return ""
+
+        # Get first child of inner munder (the actual content)
+        if len(inner_munder) < 1:
+            return ""
+
+        actual_content = inner_munder[0]
+
+        simple_label = self._extract_simple_chemical_label(actual_content)
+        if simple_label:
+            return simple_label
+
+        # Extract content while preserving MathML structure (e.g., subscripts)
+        # instead of flattening to plain text.
+        from .mrow_visitor import MrowVisitor
+
+        try:
+            rendered = MrowVisitor(self.strategy)._convert_child(actual_content)
+            return rendered.strip()
+        except Exception:
+            # Fallback for unexpected structures
+            text = _text_content(actual_content).strip()
+            return text
+
+    def _extract_simple_chemical_label(self, node: ET.Element) -> str:
+        """
+        Extract simple chemical labels like FeCl₃ as \mathrm{F e C l}_{3}.
+
+        This is used for reaction-condition annotations in malformed double-munder
+        structures where preserving chemistry-style spacing is desirable.
+        """
+        if _local(node.tag) != "mrow":
+            return ""
+
+        children = list(node)
+        if not children:
+            return ""
+
+        roman_parts: list[str] = []
+        trailing_subscript = ""
+
+        for index, child in enumerate(children):
+            tag = _local(child.tag)
+
+            if tag in {"mi", "mn"}:
+                token = self._extract_single_normal_variant_token(child)
+                if token:
+                    roman_parts.append(token)
+                else:
+                    return ""
+                continue
+
+            if tag == "msub":
+                if index != len(children) - 1 or len(child) < 2:
+                    return ""
+
+                base_text = self._extract_single_normal_variant_token(child[0])
+                sub_text = self._extract_single_normal_variant_token(child[1])
+
+                if not base_text or not sub_text:
+                    return ""
+
+                roman_parts.append(base_text)
+                trailing_subscript = sub_text
+                continue
+
+            return ""
+
+        if not roman_parts:
+            return ""
+
+        roman_text = " ".join(roman_parts)
+        if trailing_subscript:
+            return f"\\mathrm{{{roman_text}}}_{{{trailing_subscript}}}"
+        return f"\\mathrm{{{roman_text}}}"
+
+    def _extract_single_normal_variant_token(self, node: ET.Element) -> str:
+        """
+        Extract a single token only when it explicitly carries mathvariant="normal".
+
+        Returns empty string if the node is not a simple single-token wrapper.
+        """
+        from ..utils import text_content as _text_content
+
+        tag = _local(node.tag)
+        if tag in {"mi", "mn"}:
+            if node.get("mathvariant") != "normal":
+                return ""
+            return _text_content(node).strip()
+
+        if tag == "mrow" and len(node) == 1:
+            return self._extract_single_normal_variant_token(node[0])
+
+        return ""
+
+    def _contains_chinese_text(self, text: str) -> bool:
+        """
+        Check if text contains Chinese characters.
+
+        Args:
+            text: Text to check
+
+        Returns:
+            True if text contains Chinese characters
+        """
+        for char in text:
+            if '\u4e00' <= char <= '\u9fff':  # CJK Unified Ideographs range
+                return True
+        return False
+
+    def _is_large_operator_stack(self, mtable_node: ET.Element) -> bool:
+        """
+        Check if mtable represents a vertical stack with large operator.
+
+        Pattern: 3-row mtable with:
+        - Row 1: Upper limit (e.g., "n")
+        - Row 2: Large operator (e.g., "∑")
+        - Row 3: Lower limit (e.g., "i=1")
+
+        This is how Word/OMML encodes operators with limits when NOT using munderover.
+
+        Args:
+            mtable_node: The <mtable> element to check
+
+        Returns:
+            True if this is a large operator stack
+        """
+        from ..utils import text_content as _text_content
+
+        rows = [child for child in mtable_node if _local(child.tag) == "mtr"]
+
+        # Must be exactly 3 rows (upper limit, operator, lower limit)
+        # or 2 rows (operator, lower limit) for simple cases
+        if len(rows) < 2 or len(rows) > 3:
+            return False
+
+        # Each row should have exactly 1 cell
+        for row in rows:
+            cells = [child for child in row if _local(child.tag) == "mtd"]
+            if len(cells) != 1:
+                return False
+
+        # Find which row contains the large operator
+        operator_row_idx = -1
+        for idx, row in enumerate(rows):
+            cell = [child for child in row if _local(child.tag) == "mtd"][0]
+            # Get first child of cell (might be wrapped in mstyle/mrow)
+            if self._cell_contains_large_operator(cell):
+                operator_row_idx = idx
+                break
+
+        if operator_row_idx == -1:
+            return False
+
+        # For 3-row stacks: operator should be in middle row (idx 1)
+        # For 2-row stacks: operator should be in first row (idx 0) - integral/sum with lower limit only
+        if len(rows) == 3 and operator_row_idx != 1:
+            return False
+        if len(rows) == 2 and operator_row_idx != 0 and operator_row_idx != 1:
+            return False
+
+        return True
+
+    def _cell_contains_large_operator(self, cell_node: ET.Element) -> bool:
+        """
+        Check if a cell contains a large operator.
+
+        Recursively searches through wrapper elements to find operator.
+
+        Args:
+            cell_node: The <mtd> cell element
+
+        Returns:
+            True if cell contains a large operator
+        """
+        from ..utils import text_content as _text_content
+
+        # Large operators
+        large_ops = [
+            "∑", "\\sum",          # Summation
+            "∏", "\\prod",         # Product
+            "∐", "\\coprod",       # Coproduct
+            "∫", "\\int",          # Integral
+            "∬", "\\iint",         # Double integral
+            "∭", "\\iiint",        # Triple integral
+            "∮", "\\oint",         # Contour integral
+            "⋃", "\\bigcup",       # Union
+            "⋂", "\\bigcap",       # Intersection
+            "⋁", "\\bigvee",       # Logical OR
+            "⋀", "\\bigwedge",     # Logical AND
+            "⨁", "\\bigoplus",     # Direct sum
+            "⨂", "\\bigotimes",    # Tensor product
+            "⨄", "\\biguplus",     # Multiset union
+        ]
+
+        # Check cell content directly
+        cell_text = _text_content(cell_node).strip()
+        if cell_text in large_ops:
+            return True
+
+        # Recursively check children
+        for child in cell_node:
+            tag = _local(child.tag)
+            if tag in ('mi', 'mo'):
+                child_text = _text_content(child).strip()
+                if child_text in large_ops:
+                    return True
+            elif tag in ('mstyle', 'mrow', 'mpadded', 'menclose'):
+                # Recursively check wrapper elements
+                if self._cell_contains_large_operator(child):
+                    return True
+
+        return False
+
+    def _convert_large_operator_stack(self, mtable_node: ET.Element) -> str:
+        """
+        Convert vertical stack mtable to proper large operator notation.
+
+        Args:
+            mtable_node: The <mtable> element
+
+        Returns:
+            LaTeX string with proper subscript/superscript notation
+        """
+        from .mtd_visitor import MtdVisitor
+
+        rows = [child for child in mtable_node if _local(child.tag) == "mtr"]
+
+        # Get cells
+        cells = []
+        for row in rows:
+            cell = [child for child in row if _local(child.tag) == "mtd"][0]
+            cells.append(cell)
+
+        # Find operator cell
+        operator_idx = -1
+        for idx, cell in enumerate(cells):
+            if self._cell_contains_large_operator(cell):
+                operator_idx = idx
+                break
+
+        if operator_idx == -1:
+            # Fallback: shouldn't happen
+            return self.visit(mtable_node)
+
+        # Convert operator
+        operator_latex = MtdVisitor(self.strategy).visit(cells[operator_idx]).strip()
+
+        if len(cells) == 3:
+            # 3-row stack: upper / operator / lower
+            upper_latex = MtdVisitor(self.strategy).visit(cells[0]).strip()
+            lower_latex = MtdVisitor(self.strategy).visit(cells[2]).strip()
+            return f"{operator_latex}\\limits^{{{upper_latex}}}_{{{lower_latex}}}"
+        elif len(cells) == 2:
+            if operator_idx == 0:
+                # 2-row stack: operator / lower
+                lower_latex = MtdVisitor(self.strategy).visit(cells[1]).strip()
+                return f"{operator_latex}\\limits_{{{lower_latex}}}"
+            else:
+                # 2-row stack: upper / operator
+                upper_latex = MtdVisitor(self.strategy).visit(cells[0]).strip()
+                return f"{operator_latex}\\limits^{{{upper_latex}}}"
+        else:
+            # Fallback
+            return self.visit(mtable_node)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mtable'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mtable'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MtableVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mtd_visitor.py b/scripts/omml_mathml2latex/visitors/mtd_visitor.py
new file mode 100644
index 0000000..0a4fef0
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mtd_visitor.py
@@ -0,0 +1,182 @@
+r"""
+Visitor for <mtd> (table cell) MathML elements.
+
+The <mtd> element represents a cell in a table/matrix row. It is a helper
+element that contains the actual mathematical content.
+
+This visitor is primarily used by MtrVisitor to convert table cells.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local, text_content as _text_content
+
+
+class MtdVisitor(Visitor):
+    r"""
+    Handles <mtd> (table cell) MathML elements.
+
+    Converts table cells to LaTeX format by rendering all child content.
+
+    Examples:
+        Simple number:
+            <mtd><mn>5</mn></mtd>
+            → 5
+
+        Variable:
+            <mtd><mi>x</mi></mtd>
+            → x
+
+        Expression:
+            <mtd><mi>x</mi><mo>+</mo><mn>1</mn></mtd>
+            → x+1
+
+        Fraction:
+            <mtd><mfrac><mn>1</mn><mn>2</mn></mfrac></mtd>
+            → \frac{1}{2}
+
+        Empty cell:
+            <mtd></mtd>
+            → (empty string)
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mtd visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mtd> element to LaTeX.
+
+        Args:
+            node: The <mtd> element to convert
+
+        Returns:
+            LaTeX string for cell content
+
+        Raises:
+            ValueError: If node is not an <mtd> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MtdVisitor cannot handle element '{node.tag}'")
+
+        # Convert all children of the cell
+        # Cells are transparent containers, so just render children
+        # Join with spaces (like mrow) to ensure proper spacing between elements
+        parts = []
+        for child in node:
+            part = self._convert_child(child)
+            if part:  # Only add non-empty parts
+                parts.append(part)
+        return ' '.join(parts).strip()
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in mtd, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mtd'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mtd'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MtdVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mtext_visitor.py b/scripts/omml_mathml2latex/visitors/mtext_visitor.py
new file mode 100644
index 0000000..1760b13
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mtext_visitor.py
@@ -0,0 +1,327 @@
+r"""
+Visitor for <mtext> (text content) MathML elements.
+
+The <mtext> element represents text content within mathematical expressions:
+- Descriptive text: "and", "or", "if", "then"
+- Unit labels: "kg", "mol", "Hz", "Pa", "m/s"
+- Chinese/Unicode text: "电解", "加热", "催化剂"
+- Words in equations: "min", "max", "for all"
+
+This visitor wraps text in \text{} or \mathrm{} depending on context.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local, escape_latex_special_chars
+from ..data import UNICODE_TO_LATEX, UNICODE_PASSTHROUGH
+
+
+class MtextVisitor(Visitor):
+    r"""
+    Handles <mtext> (text content) MathML elements.
+
+    Converts text content to LaTeX using appropriate text commands.
+
+    Examples:
+        Simple text:
+            <mtext>and</mtext> → \text{and}
+
+        Units:
+            <mtext>kg</mtext> → \text{kg}
+
+        Chinese text:
+            <mtext>电解</mtext> → \text{电解}
+
+        Multi-word text:
+            <mtext>for all</mtext> → \text{for all}
+
+        Empty text:
+            <mtext></mtext> → (empty string)
+
+        Text with spaces:
+            <mtext>  spaced  </mtext> → \text{  spaced  }
+    """
+
+    # Common SI units (should use \mathrm for units in some contexts)
+    SI_UNITS = {
+        # Base units
+        'm', 'kg', 'g', 's', 'A', 'K', 'mol', 'cd',
+        # Derived units
+        'Hz', 'N', 'Pa', 'J', 'W', 'C', 'V', 'F', 'Ω',
+        'S', 'Wb', 'T', 'H', 'lm', 'lx', 'Bq', 'Gy', 'Sv',
+        # Common combinations
+        'km', 'cm', 'mm', 'nm', 'pm',
+        'km/h', 'm/s', 'm/s²', 'cm³', 'm³',
+        'kJ', 'MJ', 'kW', 'MW',
+        'mA', 'kA', 'mV', 'kV',
+        # Other common units
+        'L', 'mL', 'atm', 'bar', 'mmHg',
+        'eV', 'kcal', 'cal',
+        '°C', '°F', 'K',  # Temperature
+    }
+
+    # Common mathematical/logical text words
+    TEXT_WORDS = {
+        'and', 'or', 'not', 'if', 'then', 'else',
+        'for', 'all', 'such', 'that', 'where',
+        'with', 'when', 'otherwise',
+        'let', 'be', 'is', 'are',
+    }
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mtext visitor."""
+        super().__init__(strategy)
+        self._converter_context = None
+
+    def set_converter_context(self, converter):
+        """Set converter context for color suppression checking."""
+        self._converter_context = converter
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mtext> element to LaTeX.
+
+        Args:
+            node: The <mtext> element to convert
+
+        Returns:
+            LaTeX string with text wrapped in \text{} or \mathrm{}
+
+        Raises:
+            ValueError: If node is not an <mtext> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MtextVisitor cannot handle element '{node.tag}'")
+
+        # Get text content
+        text = _text_content(node)
+
+        # Handle empty text
+        if not text:
+            return ''
+
+        # Escape LaTeX special characters before any other processing
+        text = escape_latex_special_chars(text)
+
+        # Handle invisible function application operator (U+2061)
+        # This is used to indicate function application but should not be rendered
+        if text == "⁡":  # U+2061 FUNCTION APPLICATION
+            return ""  # Return empty string (invisible)
+
+        # CRITICAL: Check if text is a mathematical function BEFORE other processing
+        # This handles cases like <mtext>sin</mtext> → \sin (not \mathrm{sin})
+        from ..data import MATH_FUNCTIONS
+        text_stripped = text.strip()
+        if text_stripped.lower() in MATH_FUNCTIONS:
+            return f"\\{text_stripped.lower()}"
+
+        # IMPORTANT: Convert Unicode symbols to LaTeX BEFORE wrapping in \text{}
+        # But first check UNICODE_PASSTHROUGH - keep these as-is for MathJax compatibility
+        text_stripped = text.strip()
+        if len(text_stripped) == 1 and text_stripped in UNICODE_PASSTHROUGH:
+            # Single symbol that should be kept as Unicode
+            return text_stripped
+
+        if len(text_stripped) == 1 and text_stripped in UNICODE_TO_LATEX:
+            # Single symbol with direct LaTeX mapping - return LaTeX command directly
+            # (don't wrap in \text{})
+            return UNICODE_TO_LATEX[text_stripped]
+
+        # CRITICAL FIX: For multi-symbol Unicode strings, check if result after conversion
+        # is ALL LaTeX commands or passthrough symbols. If so, don't wrap in \text{}
+        #
+        # This handles cases like:
+        #   <mtext>℧◊</mtext> → \mho\lozenge (not \text{\mho\lozenge})
+        #   <mtext>∠∢⦞</mtext> → \measuredangle\sphericalangle (not \text{...})
+        #   <mtext>∯∰</mtext> → ∯∰ (kept as Unicode for MathJax)
+        if len(text_stripped) > 1 and all(char in UNICODE_TO_LATEX or char in UNICODE_PASSTHROUGH for char in text_stripped):
+            # All characters are Unicode symbols
+            # Convert to LaTeX or keep as Unicode based on PASSTHROUGH set
+            result_parts = []
+            for char in text_stripped:
+                if char in UNICODE_PASSTHROUGH:
+                    result_parts.append(char)
+                else:
+                    result_parts.append(UNICODE_TO_LATEX[char])
+            return ''.join(result_parts)  # Join without spaces for symbols
+
+        # Check for color attributes
+        from ..utils import is_default_color
+
+        color = node.get('mathcolor')
+        if color and not is_default_color(color):
+            # Apply color to text (after Unicode conversion if needed)
+            # Only add textcolor if it's not the default black color
+            text_converted = self._convert_unicode_in_text(text)
+            return f"\\textcolor{{{color}}}{{\\text{{{text_converted}}}}}"
+
+        # Determine whether to use \text{} or \mathrm{}
+        # CRITICAL: The default should be \mathrm{} to match wrap_identifiers_in_mathrm=True
+        # This ensures chemical formulas, units, and identifiers render upright (not italic)
+
+        # CRITICAL FIX: Check for operators in text (like "2NaCl+2H")
+        # If text contains operators, split and process separately
+        # This prevents wrapping operators in \mathrm{} and avoids nested \mathrm{}
+        if any(op in text for op in ['+', '-', '=', '<', '>', '×', '·', '/']):
+            return self._process_complex_mtext(text)
+
+        # Check if we should use \mathrm{} (default for most math/chemistry content)
+        # Use \text{} only for actual prose text (multi-word descriptions)
+
+        # If it contains spaces and looks like prose, use \text{}
+        if ' ' in text and any(word in text_stripped.lower() for word in self.TEXT_WORDS):
+            # Multi-word prose text
+            text_converted = self._convert_unicode_in_text(text)
+            return f"\\text{{{text_converted}}}"
+
+        # If it's Chinese text (common in chemistry for reaction conditions), use \mathrm{}
+        # Chinese text needs upright rendering for chemical equations
+        if self._contains_chinese(text):
+            text_converted = self._convert_unicode_in_text(text)
+            return f"\\mathrm{{{text_converted}}}"
+
+        # Default: use \mathrm{} for chemical formulas, units, and identifiers
+        # This matches the original converter's wrap_identifiers_in_mathrm=True behavior
+        text_converted = self._convert_unicode_in_text(text)
+
+        # CRITICAL FIX: If text_converted is ONLY LaTeX space commands (like ~, \ , \quad, etc.),
+        # return it directly WITHOUT wrapping in \mathrm{}
+        # This fixes the issue where <mtext>&#xA0;</mtext> was becoming \mathrm{~} instead of ~
+        stripped = text_converted.strip()
+        if stripped in ('~', '\\ ', '\\quad', '\\qquad', '\\!', '\\,', '\\:', '\\;'):
+            return text_converted  # Return space command directly
+        elif stripped.replace('~', '').replace('\\ ', '').strip() == '':
+            # Pure spaces (multiple ~ or \ )
+            return text_converted
+
+        return f"\\mathrm{{{text_converted}}}"
+
+    def _process_complex_mtext(self, text: str) -> str:
+        """
+        Process complex mtext that contains operators.
+
+        Splits text at operators and wraps chemical parts in \\mathrm{}
+        while keeping operators unwrapped.
+
+        Example:
+            "2NaCl+2H" → "\\mathrm{2NaCl}+\\mathrm{2H}"
+
+        Args:
+            text: Text containing operators
+
+        Returns:
+            Processed LaTeX with operators unwrapped
+        """
+        import re
+
+        # Pattern for mathematical operators (including Unicode)
+        operator_pattern = r'([+\-=<>±∓×·/∩∪∈∉⊆⊇∁∅∧∨¬→←↔⇒⇐⇔≡≠≤≥∞])'
+
+        # Split text at operators (operators are preserved in the result)
+        parts = re.split(operator_pattern, text)
+
+        result_parts = []
+        for part in parts:
+            part_stripped = part.strip()
+            if not part_stripped:
+                continue
+
+            # Check if this part is an operator
+            if re.match(operator_pattern, part_stripped):
+                # Operator - keep as-is, DON'T wrap in \mathrm{}
+                result_parts.append(part_stripped)
+            else:
+                # Not an operator - wrap in \mathrm{}
+                # First convert any Unicode symbols
+                part_converted = self._convert_unicode_in_text(part)
+                result_parts.append(f"\\mathrm{{{part_converted}}}")
+
+        # Join parts without spaces (chemical formulas should be compact)
+        return ''.join(result_parts)
+
+    def _contains_chinese(self, text: str) -> bool:
+        """
+        Check if text contains Chinese (CJK) characters.
+
+        Args:
+            text: Text to check
+
+        Returns:
+            True if text contains Chinese characters, False otherwise
+        """
+        for char in text:
+            # CJK Unified Ideographs range
+            if '\u4e00' <= char <= '\u9fff':
+                return True
+        return False
+
+    def _convert_unicode_in_text(self, text: str) -> str:
+        """
+        Convert Unicode symbols within text to LaTeX equivalents.
+
+        For multi-character text with Unicode symbols mixed in,
+        we need to convert each Unicode character individually.
+
+        IMPORTANT: Also converts spaces to LaTeX space commands:
+        - \\xa0 (NBSP) → ~ (non-breaking space in LaTeX)
+        - Regular space (when standalone) → \\ (backslash-space)
+
+        Args:
+            text: Text that may contain Unicode symbols
+
+        Returns:
+            Text with Unicode symbols converted to LaTeX
+        """
+        if not text:
+            return text
+
+        # CRITICAL FIX: Convert non-breaking spaces (\xa0) to ~ BEFORE other processing
+        # This fixes the issue where <mtext>&#xA0;</mtext> was becoming \mathrm{ } instead of ~
+        result = text
+
+        # Step 1: Convert NBSP to LaTeX non-breaking space
+        if '\xa0' in result:
+            result = result.replace('\xa0', '~')
+
+        # Step 2: Convert regular spaces to LaTeX space (but NOT inside prose text)
+        # Only convert standalone spaces, not spaces within multi-word text
+        # Check if this is a single space or contains only spaces
+        if result.strip() == '' and result:
+            # Pure space(s) → convert to ~
+            result = '~' * len(result)
+        elif result in [' ']:
+            # Single space → ~
+            result = '~'
+
+        # Step 3: Convert Unicode symbols (except PASSTHROUGH symbols)
+        # Check if any Unicode symbols are present
+        has_unicode = any(char in UNICODE_TO_LATEX for char in result)
+        has_passthrough = any(char in UNICODE_PASSTHROUGH for char in result)
+        if not has_unicode and not has_passthrough:
+            return result
+
+        # Convert character by character (PASSTHROUGH symbols kept as-is)
+        converted = []
+        for char in result:
+            if char in UNICODE_PASSTHROUGH:
+                # Keep passthrough symbols as Unicode for MathJax
+                converted.append(char)
+            elif char in UNICODE_TO_LATEX:
+                converted.append(UNICODE_TO_LATEX[char])
+            else:
+                converted.append(char)
+
+        return ''.join(converted)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mtext'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mtext'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MtextVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/mtr_visitor.py b/scripts/omml_mathml2latex/visitors/mtr_visitor.py
new file mode 100644
index 0000000..5a382dd
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/mtr_visitor.py
@@ -0,0 +1,98 @@
+r"""
+Visitor for <mtr> (table row) MathML elements.
+
+The <mtr> element represents a row in a table/matrix. It is a helper element
+that contains <mtd> (table cell) children.
+
+This visitor is primarily used by MtableVisitor to convert table rows.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import local_name as _local
+
+
+class MtrVisitor(Visitor):
+    r"""
+    Handles <mtr> (table row) MathML elements.
+
+    Converts table rows to LaTeX format with cells separated by & and
+    terminated with \\.
+
+    Examples:
+        Simple row:
+            <mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr>
+            → 1 & 2 \\
+
+        Row with expressions:
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd></mtr>
+            → x & y \\
+
+        Single cell row:
+            <mtr><mtd><mi>a</mi></mtd></mtr>
+            → a \\
+
+        Empty row:
+            <mtr></mtr>
+            → \\
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Mtr visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <mtr> element to LaTeX row.
+
+        Args:
+            node: The <mtr> element to convert
+
+        Returns:
+            LaTeX string with cells separated by & and terminated with \\
+
+        Raises:
+            ValueError: If node is not an <mtr> element
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MtrVisitor cannot handle element '{node.tag}'")
+
+        # Convert all <mtd> children to cells
+        cells = []
+        for child in node:
+            if _local(child.tag) == "mtd":
+                cell_latex = self._convert_cell(child)
+                cells.append(cell_latex)
+
+        # Join cells with & and add row terminator
+        if not cells:
+            return "\\\\"
+
+        return " & ".join(cells) + " \\\\"
+
+    def _convert_cell(self, node: ET.Element) -> str:
+        """
+        Convert a single <mtd> (table cell) element.
+
+        Args:
+            node: The <mtd> element
+
+        Returns:
+            LaTeX string for cell content
+        """
+        # Use MtdVisitor for proper cell conversion
+        from .mtd_visitor import MtdVisitor
+        return MtdVisitor(self.strategy).visit(node)
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'mtr'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'mtr'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MtrVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/munder_visitor.py b/scripts/omml_mathml2latex/visitors/munder_visitor.py
new file mode 100644
index 0000000..a211e3f
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/munder_visitor.py
@@ -0,0 +1,568 @@
+r"""
+Visitor for <munder> (underscript/underline) MathML elements.
+
+The <munder> element represents content with something below it:
+- Underline: line under text
+- Operator limits: summation/integral with lower bound only
+- Underbrace: brace under expression
+- General underscript: any content under base
+
+This implementation handles the most common cases with TODOs for advanced features.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MunderVisitor(Visitor):
+    r"""
+    Handles <munder> (underscript/underline) MathML elements.
+
+    Converts underscript and underline notation to appropriate LaTeX commands.
+
+    Examples:
+        Underline:
+            <munder><mi>x</mi><mo>_</mo></munder> → \underline{x}
+
+        Summation with lower limit only:
+            <munder><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow></munder>
+            → \sum_{i=1}
+
+        Integral with lower bound:
+            <munder><mo>∫</mo><mi>a</mi></munder> → \int_{a}
+
+        Product with lower limit:
+            <munder><mo>∏</mo><mi>i</mi></munder> → \prod_{i}
+
+        Underbrace:
+            <munder><mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow><mo>⏟</mo></munder>
+            → \underbrace{x+y}
+
+        General underscript:
+            <munder accent="false"><mi>x</mi><mi>n</mi></munder> → \underset{n}{x}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Munder visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <munder> element to LaTeX.
+
+        Args:
+            node: The <munder> element to convert
+
+        Returns:
+            LaTeX string with appropriate underscript/underline notation
+
+        Raises:
+            ValueError: If node is not an <munder> element
+            ValueError: If munder has fewer than 2 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MunderVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # munder must have exactly 2 children: base and underscript
+        if len(children) < 2:
+            raise ValueError(
+                f"munder element must have 2 children (base, underscript), "
+                f"got {len(children)}"
+            )
+
+        # IMPORTANT: Check raw text content BEFORE converting children
+        # to properly detect underline characters (e.g., "―" before it becomes "\textemdash")
+        under_raw_text = _text_content(children[1]).strip()
+
+        # Check for underline notation (underbar character) using RAW text
+        if self._is_underline_char(under_raw_text):
+            base = self._convert_child(children[0])
+            # Handle empty base (fill-in blank pattern): use \quad for visible spacing
+            if not base or not base.strip():
+                base = "\\qquad"
+            return f"\\underline{self._brace(base)}"
+
+        # Check for underbrace notation using RAW text (simple case: no label)
+        if self._is_underbrace_char(under_raw_text):
+            base = self._convert_child(children[0])
+            return f"\\underbrace{self._brace(base)}"
+
+        # Check for underbrace with label: nested munder with brace character
+        # Pattern: munder(munder(base, ⏟), label) → \underbrace{base}_{label}
+        # OR: munder(mrow(munder(base, ⏟)), label) with mrow wrapper (Word often wraps inner munder)
+        # This is how Word encodes underbrace with labels
+        inner_munder = None
+        if len(children) >= 2:
+            # Check if first child is munder directly
+            if _local(children[0].tag) == 'munder':
+                inner_munder = children[0]
+            # Check if first child is mrow containing munder
+            elif _local(children[0].tag) == 'mrow':
+                mrow_children = list(children[0])
+                # Look for munder inside mrow (may be the only child or one of several)
+                for child in mrow_children:
+                    if _local(child.tag) == 'munder':
+                        inner_munder = child
+                        break
+
+            # Process the inner munder if found
+            if inner_munder is not None:
+                inner_children = list(inner_munder)
+                if len(inner_children) >= 2:
+                    # Check if inner munder's second child is the underbrace character
+                    inner_under_text = _text_content(inner_children[1]).strip()
+                    if inner_under_text == "⏟":  # U+23DF Underbrace character
+                        # Extract base from inner munder (first child)
+                        inner_base = self._convert_child(inner_children[0])
+                        # Extract label from outer munder (second child)
+                        label = self._convert_child(children[1])
+                        # Return proper underbrace with subscript label
+                        return f"\\underbrace{self._brace(inner_base)}_{self._brace(label)}"
+
+        # Check for ALTERNATIVE underbrace pattern (Word sometimes uses this)
+        # Pattern: munder(mover(base, ⏞), label) → \underbrace{base}_{label}
+        # OR: munder(mrow(mover(base, ⏞)), label) with mrow wrapper
+        # Word uses the overbrace character ⏞ but places it in OVER position to create underbrace
+        if len(children) >= 2:
+            # Check if first child is mover (directly or inside mrow)
+            inner_mover = None
+            if _local(children[0].tag) == 'mover':
+                inner_mover = children[0]
+            elif _local(children[0].tag) == 'mrow':
+                # Check inside mrow wrapper
+                for child in children[0]:
+                    if _local(child.tag) == 'mover':
+                        inner_mover = child
+                        break
+
+            if inner_mover is not None:
+                inner_children = list(inner_mover)
+                if len(inner_children) >= 2:
+                    # Check if inner mover's second child is the overbrace character
+                    inner_over_text = _text_content(inner_children[1]).strip()
+                    if inner_over_text == "⏞":  # U+23DE Overbrace char in over position = underbrace
+                        # Extract base from inner mover (first child)
+                        inner_base = self._convert_child(inner_children[0])
+                        # Extract label from outer munder (second child)
+                        label = self._convert_child(children[1])
+                        # Return proper underbrace with subscript label
+                        return f"\\underbrace{self._brace(inner_base)}_{self._brace(label)}"
+
+        # Check if base is a large operator (sum, integral, product, etc.)
+        if self._is_large_operator(children[0]):
+            # Use subscript for operator limits with \limits
+            base = self._convert_child(children[0])
+            under = self._convert_child(children[1])
+            return f"{base}\\limits_{self._brace(under)}"
+
+        # Check for arrow UNDER content pattern (arrow in under position)
+        # Pattern: <munder><content><mrow><mi>→</mi></mrow></munder>
+        # This should be converted to \underrightarrow{content}
+        under_to_check = children[1]
+        if _local(under_to_check.tag) == 'mrow':
+            # Unwrap mrow if it contains a single element
+            mrow_children = list(under_to_check)
+            if len(mrow_children) == 1:
+                under_to_check = mrow_children[0]
+
+        if _local(under_to_check.tag) in ['mo', 'mi']:
+            under_text = _text_content(under_to_check).strip()
+            # Map of arrows that can appear under content
+            # NOTE: Only single arrows (→, ←, ↔) are used for under-arrow notation
+            # Double arrows (⇒, ⇐, ⇔) should use underset with \Longrightarrow, not underrightarrow
+            arrow_commands = {
+                "→": "underrightarrow",
+                "←": "underleftarrow",
+                "↔": "underleftrightarrow",
+            }
+            if under_text in arrow_commands:
+                # Check if base is suitable for arrow notation (numbers, variables, etc.)
+                if _local(children[0].tag) in ['mi', 'mn', 'mrow', 'mfrac', 'msup', 'msub', 'msubsup']:
+                    content = self._convert_child(children[0])
+                    # Remove mathrm wrapper for variables
+                    content_clean = self._strip_mathrm(content)
+                    arrow_cmd = arrow_commands[under_text]
+                    return f"\\{arrow_cmd}{self._brace(content_clean)}"
+
+        # Check for INVERTED arrow pattern from XSLT transformer
+        # Pattern: <munder><mo>→</mo><mrow>content</mrow></munder>
+        # This should be converted to \underrightarrow{content} not \underset
+        # CRITICAL FIX: OMML→MathML conversion often puts arrows in <mi> tags instead of <mo>
+        # Must check BOTH <mo> AND <mi> tags for arrow symbols
+        # Also need to unwrap mrow wrappers: <munder><mrow><mi>→</mi></mrow><content></munder>
+        base_to_check = children[0]
+        if _local(base_to_check.tag) == 'mrow':
+            # Unwrap mrow if it contains a single element
+            mrow_children = list(base_to_check)
+            if len(mrow_children) == 1:
+                base_to_check = mrow_children[0]
+
+        if _local(base_to_check.tag) in ['mo', 'mi']:
+            base_text = _text_content(base_to_check).strip()
+            # Map of arrows that can appear in inverted pattern
+            # NOTE: Only single arrows (→, ←, ↔) are used for under-arrow notation
+            # Double arrows (⇒, ⇐, ⇔) should use underset with \Longrightarrow, not underrightarrow
+            arrow_commands = {
+                "→": "underrightarrow",
+                "←": "underleftarrow",
+                "↔": "underleftrightarrow",
+            }
+            if base_text in arrow_commands:
+                # The content is in the under position
+                content = self._convert_child(children[1])
+                # Remove mathrm wrapper for variables
+                content_clean = self._strip_mathrm(content)
+                arrow_cmd = arrow_commands[base_text]
+                return f"\\{arrow_cmd}{self._brace(content_clean)}"
+
+        # Check for nested extensible arrow pattern (reversed): <munder><mover>arrow/equals<...>...</mover><...></munder>
+        # OR: <munder><mrow><mover>arrow/equals<...>...</mover></mrow><...></munder> (Word often adds mrow wrapper)
+        # This is Word's way of creating arrows with text above and below (reversed nesting)
+        mover_node = None
+        if _local(children[0].tag) == 'mover':
+            # Direct mover child
+            mover_node = children[0]
+        elif _local(children[0].tag) == 'mrow':
+            # Check if mrow contains mover as only significant child
+            mrow_children = list(children[0])
+            if len(mrow_children) == 1 and _local(mrow_children[0].tag) == 'mover':
+                mover_node = mrow_children[0]
+            else:
+                # Check if any child is mover (Word sometimes adds multiple mrows)
+                for child in mrow_children:
+                    if _local(child.tag) == 'mover':
+                        mover_node = child
+                        break
+
+        if mover_node is not None:
+            mover_children = list(mover_node)
+            if len(mover_children) >= 2:
+                # The arrow/equals might be in an mrow wrapper
+                base_node = mover_children[0]
+                if _local(base_node.tag) == 'mrow':
+                    # Unwrap mrow to find the actual operator
+                    mrow_children = list(base_node)
+                    if mrow_children and _local(mrow_children[0].tag) in ('mo', 'mi', 'mtext'):
+                        base_node = mrow_children[0]
+
+                # Check if base is an arrow or equals
+                xarrow_cmd = self._get_xarrow_command(base_node)
+                if xarrow_cmd:
+                    # Extract text from over and under (may be wrapped in <mphantom> or <mrow>)
+                    over = self._convert_child(mover_children[1])
+                    under = self._convert_child(children[1])
+                    # Clean up the text (remove \phantom{}, \mathrm{}, etc.)
+                    over_clean = self._clean_arrow_text(over)
+                    under_clean = self._clean_arrow_text(under)
+
+                    # Re-wrap Chinese text and non-command text in \mathrm{} for chemistry mode
+                    # (since _clean_arrow_text removes it)
+                    if hasattr(self.strategy, 'name') and self.strategy.name == "chemistry":
+                        # Check if text needs \mathrm{} wrapping
+                        # Skip if it's already a LaTeX command (starts with \) or empty
+                        # CRITICAL: Also skip pure numbers (like "1", "222", "2121")
+                        # Numbers should remain as plain numbers, not wrapped in \mathrm{}
+                        if over_clean and not over_clean.startswith("\\") and over_clean.strip():
+                            # Check if it's a pure number (digits only, possibly with decimal point)
+                            if not over_clean.replace('.', '', 1).isdigit():
+                                # Not a pure number - wrap it in \mathrm{}
+                                over_clean = f"\\mathrm{{{over_clean}}}"
+                        if under_clean and not under_clean.startswith("\\") and under_clean.strip():
+                            # Check if it's a pure number (digits only, possibly with decimal point)
+                            if not under_clean.replace('.', '', 1).isdigit():
+                                # Not a pure number - wrap it in \mathrm{}
+                                under_clean = f"\\mathrm{{{under_clean}}}"
+
+                    # Use \quad for empty positions (from <mphantom> elements)
+                    if not under_clean or under_clean.strip() == "":
+                        under_clean = "\\quad"
+                    if not over_clean or over_clean.strip() == "":
+                        over_clean = "\\quad"
+
+                    return f"\\{xarrow_cmd}[{under_clean}]{{{over_clean}}}"
+
+        # TODO: Additional underscript types
+        # - Underbar variants
+        # - Custom decorations
+
+        # Default: general underscript using \underset
+        base = self._convert_child(children[0])
+        under = self._convert_child(children[1])
+        return f"\\underset{self._brace(under)}{self._brace(base)}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in munder, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _is_underline_char(self, latex_str: str) -> bool:
+        """Check if string represents an underline character."""
+        # Common underline/bar characters used in mathematical notation
+        underline_chars = [
+            "―",     # Em dash (U+2015) - commonly used for underline in Word
+            "_",     # Underscore
+            "‾",     # Overline character (also used for underline)
+            "¯",     # Macron
+            "⎽",     # Horizontal line extension
+            "﹍",     # Wavy low line
+            "﹎",     # Centreline low line
+            "﹏",     # Wavy overline
+            "-",     # Regular hyphen-minus
+            "−",     # Minus sign (U+2212)
+            "‗",     # Double low line
+            "⎺",     # Horizontal line
+            "⎻",     # Another horizontal line
+        ]
+        return latex_str.strip() in underline_chars
+
+    def _is_underbrace_char(self, latex_str: str) -> bool:
+        """Check if string represents an underbrace character."""
+        underbrace_chars = ["⏟", "︸", "\\underbrace"]
+        return latex_str.strip() in underbrace_chars
+
+    def _is_large_operator(self, base_node: ET.Element) -> bool:
+        """
+        Check if base is a large operator (sum, integral, product, etc.).
+
+        Recursively searches through wrapper elements like <mstyle>, <mrow>, <mpadded>
+        to find the actual operator, since Word often wraps large operators in
+        <mstyle mathsize="140%"><mrow><mo>∑</mo></mrow></mstyle>.
+        """
+        if base_node is None:
+            return False
+
+        tag = _local(base_node.tag)
+
+        # Define large operators list once
+        large_ops = [
+            "∑", "\\sum",          # Summation
+            "∏", "\\prod",         # Product
+            "∐", "\\coprod",       # Coproduct
+            "∫", "\\int",          # Integral
+            "∬", "\\iint",         # Double integral
+            "∭", "\\iiint",        # Triple integral
+            "∮", "\\oint",         # Contour integral
+            "⋃", "\\bigcup",       # Union
+            "⋂", "\\bigcap",       # Intersection
+            "⋁", "\\bigvee",       # Logical OR
+            "⋀", "\\bigwedge",     # Logical AND
+            "⨁", "\\bigoplus",     # Direct sum
+            "⨂", "\\bigotimes",    # Tensor product
+            "⨄", "\\biguplus",     # Multiset union
+            "lim", "\\lim",        # Limit (often in <mi> from Word)
+            "sup", "\\sup",        # Supremum
+            "inf", "\\inf",        # Infimum
+            "max", "\\max",        # Maximum
+            "min", "\\min",        # Minimum
+        ]
+
+        # Check direct <mo> or <mi> elements
+        if tag in ('mo', 'mi'):
+            base_text = _text_content(base_node).strip()
+            return base_text in large_ops
+
+        # Recursively search through wrapper elements (mstyle, mrow, mpadded, menclose)
+        # This handles Word's pattern: <munder><mstyle><mrow><mo>∑</mo></mrow></mstyle>...
+        if tag in ('mstyle', 'mrow', 'mpadded', 'menclose'):
+            for child in base_node:
+                if self._is_large_operator(child):
+                    return True
+
+        return False
+
+    def _get_xarrow_command(self, base_node: ET.Element) -> str:
+        """
+        Get extensible arrow command for the base element.
+
+        Returns command name (without backslash) if base is an arrow/equals,
+        otherwise returns empty string.
+
+        Supported arrows:
+        - = → xlongequal
+        - → → xrightarrow
+        - ← → xleftarrow
+        - ↔ → xleftrightarrow
+        - ⇌ → xrightleftharpoons
+        """
+        # Accept <mo> (operator), <mi> (identifier), and <mtext> (text) elements for arrows
+        # Word's XSLT sometimes produces <mi> for arrows instead of <mo>
+        if _local(base_node.tag) not in ('mo', 'mi', 'mtext'):
+            return ""
+
+        base_text = _text_content(base_node).strip()
+
+        # Map arrow symbols to xarrow commands
+        arrow_map = {
+            "=": "xlongequal",
+            "→": "xrightarrow",
+            "\\rightarrow": "xrightarrow",
+            "←": "xleftarrow",
+            "\\leftarrow": "xleftarrow",
+            "↔": "xleftrightarrow",
+            "\\leftrightarrow": "xleftrightarrow",
+            "⟷": "xleftrightarrow",  # U+27F7 long left-right arrow
+            "\\longleftrightarrow": "xleftrightarrow",
+            "⇌": "xrightleftharpoons",
+            "\\rightleftharpoons": "xrightleftharpoons",
+        }
+
+        return arrow_map.get(base_text, "")
+
+    def _clean_arrow_text(self, text: str) -> str:
+        """
+        Clean up text for use in arrow labels.
+
+        Removes:
+        - \\phantom{} wrappers (Word uses these for arrow labels)
+        - \\mathrm{} wrappers
+        - \\text{} wrappers
+        - Extra spaces between characters
+        """
+        import re
+
+        # Remove \phantom{} wrappers (Word's equation editor uses these for arrow labels)
+        text = re.sub(r'\\phantom\{([^}]*)\}', r'\1', text)
+
+        # Remove \mathrm{} wrappers
+        text = re.sub(r'\\mathrm\{([^}]*)\}', r'\1', text)
+
+        # Remove \text{} wrappers (but keep the content)
+        # For Chinese text, we want to preserve it as-is
+        text = re.sub(r'\\text\{([^}]*)\}', r'\1', text)
+
+        # Remove extra spaces between individual characters
+        # "高 压" → "高压", but preserve intentional spaces in phrases
+        text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])', '', text)
+
+        # For non-Chinese text with spaces between each char, remove spaces
+        # "a b c" → "abc", but "word1 word2" stays as-is
+        if len(text.replace(' ', '')) > 0:
+            # Check if it's all single chars separated by spaces
+            parts = text.split()
+            if all(len(p) == 1 for p in parts):
+                text = ''.join(parts)
+
+        return text.strip()
+
+    def _strip_mathrm(self, latex_str: str) -> str:
+        r"""Remove \mathrm{...} wrapper if present."""
+        import re
+        # Remove \mathrm{} wrappers
+        latex_str = re.sub(r'\\mathrm\{([a-zA-Z0-9]+)\}', r'\1', latex_str)
+        # Remove spaces in vector notation (a b c -> abc)
+        if re.match(r'^[a-zA-Z0-9](\s+[a-zA-Z0-9])+$', latex_str):
+            latex_str = re.sub(r'\s+', '', latex_str)
+        return latex_str
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'munder'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'munder'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MunderVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/munderover_visitor.py b/scripts/omml_mathml2latex/visitors/munderover_visitor.py
new file mode 100644
index 0000000..291be57
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/munderover_visitor.py
@@ -0,0 +1,463 @@
+r"""
+Visitor for <munderover> (under+over script) MathML elements.
+
+The <munderover> element represents content with both something above and below it:
+- Large operators with limits: summation, integral, product with both bounds
+- \sum_{i=1}^{n}, \int_{a}^{b}, \prod_{i=1}^{n}
+- Union/intersection with limits
+- General underover scripts
+
+This visitor is CRITICAL because it handles \limits properly, unlike msubsup.
+"""
+
+from lxml import etree as ET
+from ..core.interfaces import Visitor, Strategy
+from ..utils import text_content as _text_content, local_name as _local
+
+
+class MunderoverVisitor(Visitor):
+    r"""
+    Handles <munderover> (under+over script) MathML elements.
+
+    Converts under+over notation to appropriate LaTeX commands, especially
+    for large operators with both upper and lower limits.
+
+    Examples:
+        Summation with limits:
+            <munderover>
+                <mo>∑</mo>
+                <mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow>
+                <mi>n</mi>
+            </munderover> → \sum_{i=1}^{n}
+
+        Integral with bounds:
+            <munderover>
+                <mo>∫</mo>
+                <mi>a</mi>
+                <mi>b</mi>
+            </munderover> → \int_{a}^{b}
+
+        Product with limits:
+            <munderover>
+                <mo>∏</mo>
+                <mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow>
+                <mi>n</mi>
+            </munderover> → \prod_{i=1}^{n}
+
+        Union with limits:
+            <munderover>
+                <mo>⋃</mo>
+                <mi>i</mi>
+                <mi>n</mi>
+            </munderover> → \bigcup_{i}^{n}
+
+        General underover:
+            <munderover>
+                <mi>X</mi>
+                <mi>a</mi>
+                <mi>b</mi>
+            </munderover> → \overset{b}{\underset{a}{X}}
+    """
+
+    def __init__(self, strategy: Strategy):
+        """Initialize the Munderover visitor."""
+        super().__init__(strategy)
+
+    def visit(self, node: ET.Element) -> str:
+        r"""
+        Convert <munderover> element to LaTeX.
+
+        Args:
+            node: The <munderover> element to convert
+
+        Returns:
+            LaTeX string with appropriate under+over notation
+
+        Raises:
+            ValueError: If node is not an <munderover> element
+            ValueError: If munderover has fewer than 3 children
+        """
+        if not self.can_handle(node):
+            raise ValueError(f"MunderoverVisitor cannot handle element '{node.tag}'")
+
+        children = list(node)
+
+        # munderover must have exactly 3 children: base, underscript, overscript
+        if len(children) < 3:
+            raise ValueError(
+                f"munderover element must have 3 children (base, under, over), "
+                f"got {len(children)}"
+            )
+
+        base = self._convert_child(children[0])
+        under = self._convert_child(children[1])
+        over = self._convert_child(children[2])
+
+        # Check if base is a large operator (sum, integral, product, etc.)
+        if self._is_large_operator(children[0]):
+            # Use subscript/superscript notation for operator limits with \limits
+            # \sum\limits_{i=1}^{n}
+            return f"{base}\\limits_{self._brace(under)}^{self._brace(over)}"
+
+        # Check if this should use \limits explicitly
+        # (for operators that don't default to limit placement)
+        if self._should_use_limits(children[0]):
+            return f"{base}\\limits_{self._brace(under)}^{self._brace(over)}"
+
+        # Check for extensible arrow patterns (arrows/equals with text above and below)
+        # This is commonly used for chemical reactions and annotated arrows
+        # First, unwrap mrow if the base is wrapped (Word often does this)
+        base_node = children[0]
+        if _local(base_node.tag) == 'mrow':
+            # Check if mrow contains a single operator/arrow
+            mrow_children = list(base_node)
+            if len(mrow_children) == 1 and _local(mrow_children[0].tag) in ('mo', 'mi', 'mtext'):
+                base_node = mrow_children[0]
+
+        xarrow_cmd = self._get_xarrow_command(base_node)
+        if xarrow_cmd:
+            # Check if original content had \mathrm{} (indicates mathvariant="normal")
+            # We need to preserve this semantic after cleaning
+            over_had_mathrm = '\\mathrm{' in over
+            under_had_mathrm = '\\mathrm{' in under
+
+            # Clean up the text (remove \phantom{}, \mathrm{}, \text{}, extra spaces)
+            over_clean = self._clean_arrow_text(over)
+            under_clean = self._clean_arrow_text(under)
+
+            # Re-wrap text in \mathrm{} if:
+            # 1. Original content had \mathrm{} (from mathvariant="normal")
+            # 2. Or in chemistry mode for non-command text
+            # This preserves the mathvariant="normal" semantic from the input MathML
+            # Skip if it's already a LaTeX command (starts with \) or empty
+            # Also skip pure numbers (like "1", "222", "2121") - they should remain plain
+
+            def should_wrap_mathrm(text: str, had_mathrm: bool) -> bool:
+                if not text or not text.strip():
+                    return False
+                if text.startswith("\\"):
+                    return False  # Already a LaTeX command
+                if text.replace('.', '', 1).isdigit():
+                    return False  # Pure number
+                # Wrap if original had \mathrm{} OR in chemistry mode
+                if had_mathrm:
+                    return True
+                if hasattr(self.strategy, 'name') and self.strategy.name == "chemistry":
+                    return True
+                return False
+
+            if should_wrap_mathrm(over_clean, over_had_mathrm):
+                over_clean = f"\\mathrm{{{over_clean}}}"
+            if should_wrap_mathrm(under_clean, under_had_mathrm):
+                under_clean = f"\\mathrm{{{under_clean}}}"
+
+            # Use \quad for empty positions (from <mphantom> elements)
+            # This creates proper spacing in chemical equations
+            if not under_clean or under_clean.strip() == "":
+                under_clean = "\\quad"
+            if not over_clean or over_clean.strip() == "":
+                over_clean = "\\quad"
+
+            return f"\\{xarrow_cmd}[{under_clean}]{{{over_clean}}}"
+
+        # Default: general under+over using nested \overset and \underset
+        # \overset{b}{\underset{a}{X}}
+        return f"\\overset{self._brace(over)}{{\\underset{self._brace(under)}{self._brace(base)}}}"
+
+    def _convert_child(self, child: ET.Element) -> str:
+        """Convert a child element to LaTeX."""
+        tag = _local(child.tag)
+
+        # Import visitors as needed to avoid circular imports
+        if tag == 'mi':
+            from .mi_visitor import MiVisitor
+            return MiVisitor(self.strategy).visit(child)
+        elif tag == 'mo':
+            from .mo_visitor import MoVisitor
+            return MoVisitor(self.strategy).visit(child)
+        elif tag == 'mn':
+            from .mn_visitor import MnVisitor
+            return MnVisitor(self.strategy).visit(child)
+        elif tag == 'mfrac':
+            from .mfrac_visitor import MfracVisitor
+            return MfracVisitor(self.strategy).visit(child)
+        elif tag == 'msup':
+            from .msup_visitor import MsupVisitor
+            return MsupVisitor(self.strategy).visit(child)
+        elif tag == 'msub':
+            from .msub_visitor import MsubVisitor
+            return MsubVisitor(self.strategy).visit(child)
+        elif tag == 'mrow':
+            from .mrow_visitor import MrowVisitor
+            return MrowVisitor(self.strategy).visit(child)
+        elif tag == 'msqrt':
+            from .msqrt_visitor import MsqrtVisitor
+            return MsqrtVisitor(self.strategy).visit(child)
+        elif tag == 'mroot':
+            from .mroot_visitor import MrootVisitor
+            return MrootVisitor(self.strategy).visit(child)
+        elif tag == 'msubsup':
+            from .msubsup_visitor import MsubsupVisitor
+            return MsubsupVisitor(self.strategy).visit(child)
+        elif tag == 'munder':
+            from .munder_visitor import MunderVisitor
+            return MunderVisitor(self.strategy).visit(child)
+        elif tag == 'mover':
+            from .mover_visitor import MoverVisitor
+            return MoverVisitor(self.strategy).visit(child)
+        elif tag == 'munderover':
+            from .munderover_visitor import MunderoverVisitor
+            return MunderoverVisitor(self.strategy).visit(child)
+        elif tag == 'mfenced':
+            from .mfenced_visitor import MfencedVisitor
+            return MfencedVisitor(self.strategy).visit(child)
+        elif tag == 'mtable':
+            from .mtable_visitor import MtableVisitor
+            return MtableVisitor(self.strategy).visit(child)
+        elif tag == 'mtext':
+            from .mtext_visitor import MtextVisitor
+            return MtextVisitor(self.strategy).visit(child)
+        elif tag == 'mstyle':
+            from .mstyle_visitor import MstyleVisitor
+            return MstyleVisitor(self.strategy).visit(child)
+        elif tag == 'mspace':
+            from .mspace_visitor import MspaceVisitor
+            return MspaceVisitor(self.strategy).visit(child)
+        elif tag == 'menclose':
+            from .menclose_visitor import MencloseVisitor
+            return MencloseVisitor(self.strategy).visit(child)
+        elif tag == 'mmultiscripts':
+            from .mmultiscripts_visitor import MmultiscriptsVisitor
+            return MmultiscriptsVisitor(self.strategy).visit(child)
+        elif tag == 'maction':
+            from .maction_visitor import MactionVisitor
+            return MactionVisitor(self.strategy).visit(child)
+        elif tag == 'merror':
+            from .merror_visitor import MerrorVisitor
+            return MerrorVisitor(self.strategy).visit(child)
+        elif tag == 'mpadded':
+            from .mpadded_visitor import MpaddedVisitor
+            return MpaddedVisitor(self.strategy).visit(child)
+        elif tag == 'mphantom':
+            from .mphantom_visitor import MphantomVisitor
+            return MphantomVisitor(self.strategy).visit(child)
+        elif tag == 'ms':
+            from .ms_visitor import MsVisitor
+            return MsVisitor(self.strategy).visit(child)
+        elif tag == 'mglyph':
+            from .mglyph_visitor import MglyphVisitor
+            return MglyphVisitor(self.strategy).visit(child)
+        elif tag == 'maligngroup':
+            from .maligngroup_visitor import MaligngroupVisitor
+            return MaligngroupVisitor(self.strategy).visit(child)
+        elif tag == 'malignmark':
+            from .malignmark_visitor import MalignmarkVisitor
+            return MalignmarkVisitor(self.strategy).visit(child)
+        elif tag == 'mlabeledtr':
+            from .mlabeledtr_visitor import MlabeledtrVisitor
+            return MlabeledtrVisitor(self.strategy).visit(child)
+        else:
+            # Fallback: return text content for unknown elements
+            import sys
+            print(f"[WARNING] Unknown element <{tag}> in munderover, using text fallback", file=sys.stderr)
+            return _text_content(child)
+
+    def _is_large_operator(self, base_node: ET.Element) -> bool:
+        """
+        Check if base is a large operator that uses limits by default.
+
+        Recursively searches through wrapper elements like <mstyle>, <mrow>, <mpadded>
+        to find the actual operator, since Word often wraps large operators in
+        <mstyle mathsize="140%"><mrow><mo>∑</mo></mrow></mstyle>.
+        """
+        if base_node is None:
+            return False
+
+        tag = _local(base_node.tag)
+
+        # Large operators that display limits above/below in display mode
+        large_ops = [
+            "∑", "\\sum",          # Summation
+            "∏", "\\prod",         # Product
+            "∐", "\\coprod",       # Coproduct
+            "∫", "\\int",          # Integral
+            "∬", "\\iint",         # Double integral
+            "∭", "\\iiint",        # Triple integral
+            "∮", "\\oint",         # Contour integral
+            "⋃", "\\bigcup",       # Union
+            "⋂", "\\bigcap",       # Intersection
+            "⋁", "\\bigvee",       # Logical OR
+            "⋀", "\\bigwedge",     # Logical AND
+            "⨁", "\\bigoplus",     # Direct sum
+            "⨂", "\\bigotimes",    # Tensor product
+            "⨄", "\\biguplus",     # Multiset union
+        ]
+
+        # Check direct <mo> or <mi> elements
+        if tag in ('mo', 'mi'):
+            base_text = _text_content(base_node).strip()
+            return base_text in large_ops
+
+        # Recursively search through wrapper elements (mstyle, mrow, mpadded, menclose)
+        # This handles Word's pattern: <munderover><mstyle><mrow><mo>∑</mo></mrow></mstyle>...
+        if tag in ('mstyle', 'mrow', 'mpadded', 'menclose'):
+            for child in base_node:
+                if self._is_large_operator(child):
+                    return True
+
+        return False
+
+    def _should_use_limits(self, base_node: ET.Element) -> bool:
+        """Check if operator should explicitly use \\limits."""
+        if _local(base_node.tag) != 'mo':
+            return False
+
+        base_text = _text_content(base_node).strip()
+
+        # Operators that need explicit \limits to display limits above/below
+        limits_ops = [
+            "lim", "\\lim",        # Limit
+            "sup", "\\sup",        # Supremum
+            "inf", "\\inf",        # Infimum
+            "max", "\\max",        # Maximum
+            "min", "\\min",        # Minimum
+            "limsup", "\\limsup",  # Limit superior
+            "liminf", "\\liminf",  # Limit inferior
+            "det", "\\det",        # Determinant
+            "gcd", "\\gcd",        # Greatest common divisor
+        ]
+
+        return base_text in limits_ops
+
+    def _brace(self, content: str) -> str:
+        """Wrap content in braces."""
+        return f"{{{content}}}"
+
+    def _get_xarrow_command(self, base_node: ET.Element) -> str:
+        """
+        Get extensible arrow command for the base element.
+
+        Returns command name (without backslash) if base is an arrow/equals,
+        otherwise returns empty string.
+
+        Supported arrows:
+        - = → xlongequal
+        - → → xrightarrow
+        - ← → xleftarrow
+        - ↔ → xleftrightarrow
+        - ⇌ → xrightleftharpoons
+        """
+        # Accept <mo> (operator), <mi> (identifier), and <mtext> (text) elements for arrows
+        # Word's XSLT sometimes produces <mi> for arrows instead of <mo>
+        if _local(base_node.tag) not in ('mo', 'mi', 'mtext'):
+            return ""
+
+        base_text = _text_content(base_node).strip()
+
+        # Map arrow symbols to xarrow commands
+        arrow_map = {
+            "=": "xlongequal",
+            "→": "xrightarrow",
+            "\\rightarrow": "xrightarrow",
+            "←": "xleftarrow",
+            "\\leftarrow": "xleftarrow",
+            "↔": "xleftrightarrow",
+            "\\leftrightarrow": "xleftrightarrow",
+            "⟷": "xleftrightarrow",  # U+27F7 long left-right arrow
+            "\\longleftrightarrow": "xleftrightarrow",
+            "⇌": "xrightleftharpoons",
+            "\\rightleftharpoons": "xrightleftharpoons",
+        }
+
+        return arrow_map.get(base_text, "")
+
+    def _clean_arrow_text(self, text: str) -> str:
+        """
+        Clean up text for use in arrow labels.
+
+        Removes:
+        - \\phantom{} wrappers (Word uses these for arrow labels)
+        - \\mathrm{} wrappers (with proper nested brace handling)
+        - \\text{} wrappers
+        - Extra spaces between characters
+        """
+        import re
+
+        # Helper function to remove LaTeX commands with balanced braces
+        def remove_command(text: str, command: str) -> str:
+            """Remove LaTeX command with proper brace balancing.
+
+            Args:
+                text: Input text with LaTeX commands
+                command: Command to remove (e.g., "\\mathrm" or "mathrm")
+            """
+            # Normalize command: ensure it starts with backslash
+            if not command.startswith('\\'):
+                command = '\\' + command
+
+            while command in text:
+                # Find the command
+                idx = text.find(command)
+                if idx == -1:
+                    break
+
+                # Find the opening brace (should be right after command)
+                brace_start = idx + len(command)
+                if brace_start >= len(text) or text[brace_start] != '{':
+                    break  # Malformed - no opening brace
+
+                # Match balanced braces
+                brace_count = 1
+                pos = brace_start + 1
+                while pos < len(text) and brace_count > 0:
+                    if text[pos] == '{' and (pos == 0 or text[pos-1] != '\\'):
+                        brace_count += 1
+                    elif text[pos] == '}' and (pos == 0 or text[pos-1] != '\\'):
+                        brace_count -= 1
+                    pos += 1
+
+                if brace_count == 0:
+                    # Successfully matched braces
+                    content = text[brace_start+1:pos-1]
+                    text = text[:idx] + content + text[pos:]
+                else:
+                    break  # Malformed braces
+
+            return text
+
+        # Remove \phantom{} wrappers (Word's equation editor uses these for arrow labels)
+        text = remove_command(text, '\\phantom')
+
+        # Remove \mathrm{} wrappers (with nested brace handling)
+        text = remove_command(text, '\\mathrm')
+
+        # Remove \text{} wrappers (but keep the content)
+        # For Chinese text, we want to preserve it as-is
+        text = remove_command(text, '\\text')
+
+        # Remove extra spaces between individual characters
+        # "高 压" → "高压", but preserve intentional spaces in phrases
+        text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])', '', text)
+
+        # For non-Chinese text with spaces between each char, remove spaces
+        # "a b c" → "abc", but "word1 word2" stays as-is
+        if len(text.replace(' ', '')) > 0:
+            # Check if it's all single chars separated by spaces
+            parts = text.split()
+            if all(len(p) == 1 for p in parts):
+                text = ''.join(parts)
+
+        return text.strip()
+
+    def can_handle(self, node: ET.Element) -> bool:
+        """Check if this visitor can handle the given node."""
+        return _local(node.tag) == 'munderover'
+
+    @property
+    def element_name(self) -> str:
+        """Get the element name this visitor handles."""
+        return 'munderover'
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"MunderoverVisitor(strategy={self.strategy.name})"
diff --git a/scripts/omml_mathml2latex/visitors/visitor_registry.py b/scripts/omml_mathml2latex/visitors/visitor_registry.py
new file mode 100644
index 0000000..4890d83
--- /dev/null
+++ b/scripts/omml_mathml2latex/visitors/visitor_registry.py
@@ -0,0 +1,148 @@
+"""
+Visitor registry/factory for MathML element visitors.
+
+This module provides a centralized registry for mapping MathML element
+names to their corresponding visitor classes.
+"""
+
+from typing import Dict, Type, Optional, List
+from ..core.interfaces import Visitor, Strategy, VisitorRegistry as IVisitorRegistry
+from ..core.context import ConversionContext
+
+
+class VisitorRegistry(IVisitorRegistry):
+    """
+    Registry for MathML element visitors.
+
+    This class maintains a mapping of element names (e.g., 'mi', 'mo', 'mn')
+    to their corresponding visitor classes. It provides visitor instances
+    on demand with the appropriate strategy and context injected.
+
+    Example:
+        >>> registry = VisitorRegistry()
+        >>> registry.register('mi', MiVisitor)
+        >>> registry.register('mo', MoVisitor)
+        >>> strategy = MathStrategy()
+        >>> context = ConversionContext(input_type='mathml')
+        >>> mi_visitor = registry.get_visitor('mi', strategy, context)
+    """
+
+    def __init__(self, context: Optional[ConversionContext] = None):
+        """
+        Initialize the registry with empty mappings.
+
+        Args:
+            context: Optional shared conversion context for all visitors
+        """
+        self._visitors: Dict[str, Type[Visitor]] = {}
+        self._default_visitor: Type[Visitor] | None = None
+        self.context = context
+
+    def register(self, element_name: str, visitor_class: type) -> None:
+        """
+        Register a visitor class for a specific element type.
+
+        Args:
+            element_name: MathML element name (e.g., 'mi', 'mo', 'mn')
+            visitor_class: The visitor class to handle this element
+
+        Raises:
+            TypeError: If visitor_class is not a subclass of Visitor
+        """
+        if not issubclass(visitor_class, Visitor):
+            raise TypeError(
+                f"visitor_class must be a subclass of Visitor, "
+                f"got {type(visitor_class)}"
+            )
+
+        self._visitors[element_name] = visitor_class
+
+    def get_visitor(self, element_name: str, strategy: Strategy, context: Optional[ConversionContext] = None) -> Visitor:
+        """
+        Get a visitor instance for the given element type.
+
+        Args:
+            element_name: MathML element name (e.g., 'mi', 'mo')
+            strategy: The conversion strategy to inject into the visitor
+            context: Optional conversion context (uses registry's context if not provided)
+
+        Returns:
+            Visitor instance configured with the strategy and context
+
+        Raises:
+            ValueError: If no visitor registered for element_name and no default set
+        """
+        visitor_class = self._visitors.get(element_name)
+
+        if visitor_class is None:
+            if self._default_visitor is not None:
+                visitor_class = self._default_visitor
+            else:
+                raise ValueError(
+                    f"No visitor registered for element '{element_name}' "
+                    f"and no default visitor configured"
+                )
+
+        # Use provided context or fall back to registry's context
+        ctx = context if context is not None else self.context
+
+        # Try to instantiate with context, fall back to strategy-only if needed
+        try:
+            return visitor_class(strategy, ctx)
+        except TypeError:
+            # Visitor doesn't accept context parameter yet
+            return visitor_class(strategy)
+
+    def has_visitor(self, element_name: str) -> bool:
+        """
+        Check if a visitor is registered for the element type.
+
+        Args:
+            element_name: MathML element name
+
+        Returns:
+            True if visitor is registered or default exists, False otherwise
+        """
+        return element_name in self._visitors or self._default_visitor is not None
+
+    def set_default_visitor(self, visitor_class: Type[Visitor]) -> None:
+        """
+        Set a default visitor for unregistered element types.
+
+        Args:
+            visitor_class: The visitor class to use as default
+
+        Raises:
+            TypeError: If visitor_class is not a subclass of Visitor
+        """
+        if not issubclass(visitor_class, Visitor):
+            raise TypeError(
+                f"visitor_class must be a subclass of Visitor, "
+                f"got {type(visitor_class)}"
+            )
+
+        self._default_visitor = visitor_class
+
+    def get_registered_elements(self) -> List[str]:
+        """
+        Get list of all registered element names.
+
+        Returns:
+            List of element names with registered visitors
+        """
+        return list(self._visitors.keys())
+
+    def clear(self) -> None:
+        """Clear all registered visitors."""
+        self._visitors.clear()
+        self._default_visitor = None
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        elements = ', '.join(self._visitors.keys()) if self._visitors else 'none'
+        default = f", default={self._default_visitor.__name__}" if self._default_visitor else ""
+        return f"VisitorRegistry(registered=[{elements}]{default})"
+
+    def __len__(self) -> int:
+        """Get number of registered visitors."""
+        return len(self._visitors)