execonvert 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -9,6 +9,28 @@ Categorías usadas: **Añadido**, **Cambiado**, **Corregido**, **Eliminado**.
 
 ## [Unreleased]
 
+## [0.5.3] - 2026-09-05
+
+### Corregido
+- Los `.elpx` generados desde `.docx` y `.md` se escribían sin comprimir, de
+  modo que ocupaban unas cuatro veces más de lo debido: un proyecto que
+  eXeLearning guarda en 2,4 MB salía de 10,3 MB. El empaquetado usa ahora el
+  mismo nivel de compresión habitual del formato, sin coste apreciable de
+  tiempo. Los archivos anteriores siguen abriéndose con normalidad.
+
+## [0.5.2] - 2026-09-05
+
+### Corregido
+- Las fórmulas de los `.docx` se perdían al convertir desde la línea de órdenes:
+  el documento se recorría buscando los nodos `m:oMath` por espacio de nombres,
+  algo que el navegador resuelve pero linkedom —el DOM que usa la CLI— no, de
+  modo que no encontraba ninguna y las fórmulas desaparecían sin aviso. Ahora la
+  búsqueda funciona en ambos entornos y el fragmento OMML se reinterpreta con
+  `@xmldom/xmldom` antes de convertirlo, que es lo que el conversor entiende.
+  La versión web no estaba afectada. Se añade una prueba de regresión
+  (`npm run test:docx`) que comprueba que una fórmula llega a `content.xml`
+  convertida en LaTeX.
+
 ## [0.5.1] - 2026-09-05
 
 ### Cambiado

package/dist/cli/cli/execonvert.js

@@ -10,9 +10,9 @@ import { convertElpToElpx } from '../src/legacy-elp.js';
 import { convertMarkdownToElpx } from '../src/markdown-import.js';
 import { installCliRuntime } from './runtime.js';
 import { automaticCheck, autoCheckAllowed, runUpdate, updateText } from './updates.js';
-const CLI_VERSION = '0.5.1'.startsWith('__')
+const CLI_VERSION = '0.5.3'.startsWith('__')
     ? String(JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version)
-    : '0.5.1';
+    : '0.5.3';
 const cliMessages = {
     es: {
         'help.title': 'CLI de eXeConvert',

package/dist/cli/src/docx-import.js

@@ -1,7 +1,7 @@
 import { unzipSync, zipSync } from 'fflate';
 import mammoth from 'mammoth';
 import { MathMLToLaTeX } from 'mathml-to-latex';
-import { XMLSerializer as XmldomSerializer } from '@xmldom/xmldom';
+import { DOMParser as XmldomParser, XMLSerializer as XmldomSerializer } from '@xmldom/xmldom';
 // @ts-expect-error the vendored omml2mathml ships no TypeScript declarations.
 import omml2mathml from './vendor/omml2mathml/index.js';
 import temml from 'temml';
@@ -197,16 +197,16 @@ async function preprocessDocxMath(inputBuffer) {
     const document = parseXml(documentXml, 'No se ha podido interpretar word/document.xml.');
     const formulas = new Map();
     let formulaIndex = 1;
-    const blockMathNodes = Array.from(document.getElementsByTagNameNS(M_NS, 'oMathPara'));
+    const blockMathNodes = findOmmlNodes(document, 'oMathPara');
     for (const mathNode of blockMathNodes) {
         const placeholder = createMathPlaceholder(formulaIndex++);
         const latex = await convertOmmlElementToLatex(mathNode);
         formulas.set(placeholder, `\\[${latex}\\]`);
         replaceMathNodeWithPlaceholder(document, mathNode, placeholder);
     }
-    const inlineMathNodes = Array.from(document.getElementsByTagNameNS(M_NS, 'oMath'));
+    const inlineMathNodes = findOmmlNodes(document, 'oMath');
     for (const mathNode of inlineMathNodes) {
-        if (mathNode.parentElement?.namespaceURI === M_NS && mathNode.parentElement.localName === 'oMathPara') {
+        if (isOmmlElement(mathNode.parentElement, 'oMathPara')) {
             continue;
         }
         const placeholder = createMathPlaceholder(formulaIndex++);
@@ -221,9 +221,57 @@ async function preprocessDocxMath(inputBuffer) {
     const patchedBuffer = patchedBytes.buffer.slice(patchedBytes.byteOffset, patchedBytes.byteOffset + patchedBytes.byteLength);
     return { arrayBuffer: patchedBuffer, formulas };
 }
+// Word writes formulas as <m:oMath>. Looking them up by namespace is the correct
+// way and works in the browser, but linkedom -- the DOM the CLI runs on -- does
+// not resolve namespaces in XML documents and finds nothing, which silently
+// dropped every formula from .docx files converted from the command line.
+// So: namespace first, qualified name as a fallback.
+function findOmmlNodes(document, localName) {
+    const byNamespace = Array.from(document.getElementsByTagNameNS(M_NS, localName));
+    if (byNamespace.length > 0) {
+        return byNamespace;
+    }
+    // Not even getElementsByTagName('*') is usable there: on an XML document it
+    // returns nothing. Walking the tree by hand is what survives both DOMs.
+    const found = [];
+    const visit = (node) => {
+        for (const child of Array.from(node.childNodes)) {
+            if (child.nodeType !== 1) {
+                continue;
+            }
+            const element = child;
+            if (isOmmlElement(element, localName)) {
+                found.push(element);
+            }
+            visit(element);
+        }
+    };
+    visit(document);
+    return found;
+}
+function isOmmlElement(element, localName) {
+    if (!element) {
+        return false;
+    }
+    // linkedom keeps the prefix inside localName and reports the wrong namespace,
+    // so compare the name with any prefix stripped, in both DOMs.
+    const name = (element.localName ?? element.tagName ?? '').replace(/^[^:]*:/, '');
+    if (name !== localName) {
+        return false;
+    }
+    return element.namespaceURI === M_NS || (element.tagName ?? '').startsWith('m:');
+}
 async function convertOmmlElementToLatex(element) {
     try {
-        const mathElement = omml2mathml(element);
+        // omml2mathml returns null when fed linkedom nodes, so the fragment is
+        // reparsed with the same DOM it builds its output on. Serializing it detaches
+        // it from the namespace declarations on <w:document>, so they are restated on
+        // a wrapper; without them the fragment is not well-formed XML.
+        const ommlSource = new XMLSerializer().serializeToString(element);
+        const wrapped = `<w:wrapper xmlns:w="${W_NS}" xmlns:m="${M_NS}">${ommlSource}</w:wrapper>`;
+        const ommlDocument = new XmldomParser().parseFromString(wrapped, 'text/xml');
+        const ommlRoot = ommlDocument.documentElement?.firstChild;
+        const mathElement = omml2mathml(ommlRoot);
         // El árbol MathML lo construye @xmldom/xmldom, así que lo serializa el suyo:
         // el XMLSerializer global es el del entorno (linkedom en la CLI) y no
         // entiende esos nodos.
@@ -392,7 +440,10 @@ function buildElpxFromTemplate(template, project) {
     const { entries } = template;
     entries['content.xml'] = new TextEncoder().encode(generateContentXml(project));
     addPreviewHtmlEntries(entries, project);
-    return zipSync(entries, { level: 0 });
+    // Stored entries made a .elpx four times bigger than the one eXeLearning
+    // writes for the same project. Level 6 is what the format is usually packed
+    // with, and the bundled runtime compresses well.
+    return zipSync(entries, { level: 6 });
 }
 function buildStandalonePreviewPages(project, entries, previewOptions = {}) {
     const pages = getPreviewPages(project);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "execonvert",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "private": false,
   "repository": {
     "type": "git",
@@ -38,7 +38,8 @@
     "prepack": "npm run build:cli",
     "test:updates": "node --import tsx --test tests/updates.test.ts",
     "test:runtime": "node scripts/test-runtime.mjs",
-    "test:cli": "node --test tests/cli-update.test.mjs"
+    "test:cli": "node --test tests/cli-update.test.mjs",
+    "test:docx": "node --test tests/docx-omml.test.mjs"
   },
   "dependencies": {
     "@resvg/resvg-js": "^2.6.2",