@fiduswriter/document 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/importer/docx/omml2mathml.js

@@ -6,8 +6,6 @@ const MATH_NS = "http://www.w3.org/1998/Math/MathML";
 const oprx = /[\+\-\*\/\^\&\|\!\~\<\>\=\:\u2208\u2209\u220B\u220C\u2218\u2219\u221D\u2223\u2224\u2225\u2226\u2227\u2228\u2229\u222A\u222B\u222C\u222D\u2234\u2235\u2236\u2237\u2238\u2239\u223A\u223B\u223C\u223D\u223E\u223F\u2240\u2241\u2242\u2243\u2244\u2245\u2246\u2247\u2248\u2249\u224A\u224B\u224C\u224D\u224E\u224F\u2250\u2251\u2252\u2253\u2254\u2255\u2256\u2257\u2258\u2259\u225A\u225B\u225C\u225D\u225E\u225F\u2260\u2261\u2262\u2263\u2264\u2265\u2266\u2267\u2268\u2269\u226A\u226B\u226C\u226D\u226E\u226F\u2270\u2271\u2272\u2273\u2274\u2275\u2276\u2277\u2278\u2279\u227A\u227B\u227C\u227D\u227E\u227F\u2280\u2281\u2282\u2283\u2284\u2285\u2286\u2287\u2288\u2289\u228A\u228B\u228C\u228D\u228E\u228F\u2290\u2291\u2292\u2293\u2294\u2295\u2296\u2297\u2298\u2299\u229A\u229B\u229C\u229D\u229E\u229F\u22A0\u22A1\u22A2\u22A3\u22A4\u22A5\u22A6\u22A7\u22A8\u22A9\u22AA\u22AB\u22AC\u22AD\u22AE\u22AF\u22B0\u22B1\u22B2\u22B3\u22B4\u22B5\u22B6\u22B7\u22B8\u22B9\u22BA\u22BB\u22BC\u22BD\u22C0\u22C1\u22C2\u22C3\u22C4\u22C5\u22C6\u22C7\u22C8\u22C9\u22CA\u22CB\u22CC\u22CD\u22CE\u22CF\u22D0\u22D1\u22D2\u22D3\u22D4\u22D5\u22D6\u22D7\u22D8\u22D9\u22DA\u22DB\u22DC\u22DD\u22DE\u22DF\u22E0\u22E1\u22E2\u22E3\u22E4\u22E5\u22E6\u22E7\u22E8\u22E9\u22EA\u22EB\u22EC\u22ED\u22EE\u22EF\u22F0\u22F1\u22F2\u22F3\u22F4\u22F5\u22F6\u22F7\u22F8\u22F9\u22FA\u22FB\u22FC\u22FD\u22FE\u22FF]/;
 /**
  * Converts OMML to MathML
- * @param {XMLElement} omml - OMML XML element
- * @return {string} MathML XML string
  */
 export function omml2mathml(omml) {
     // Create the root math element
@@ -18,14 +16,12 @@ export function omml2mathml(omml) {
 }
 /**
  * Process the OMML document and convert to MathML
- * @param {XMLElement} omml - The OMML element to process
- * @param {XMLElement} math - The parent MathML element
  */
 function processOMML(omml, math) {
     // Handle different OMML elements
     if (omml.tagName === "m:oMathPara") {
         math.setAttribute("display", "block");
-        omml.queryAll("m:oMath").forEach(omath => {
+        omml.queryAll("m:oMath").forEach((omath) => {
             processOMML(omath, math);
         });
     }
@@ -39,8 +35,6 @@ function processOMML(omml, math) {
 }
 /**
  * Process an OMML element and create corresponding MathML
- * @param {XMLElement} element - The OMML element to process
- * @param {XMLElement} parent - The parent MathML element
  */
 function processElement(element, parent) {
     if (!element || !element.tagName) {
@@ -119,14 +113,12 @@ function processElement(element, parent) {
 }
 /**
  * Process all children of an element
- * @param {XMLElement} element - The element whose children to process
- * @param {XMLElement} parent - The parent MathML element
  */
 function processChildren(element, parent) {
     if (!element || !element.children) {
         return;
     }
-    element.children.forEach(child => {
+    element.children.forEach((child) => {
         if (typeof child === "object") {
             processElement(child, parent);
         }
@@ -134,10 +126,6 @@ function processChildren(element, parent) {
 }
 /**
  * Create a MathML element with specified attributes
- * @param {string} tag - The MathML tag name
- * @param {Object} attrs - The attributes to set
- * @param {XMLElement} parent - The parent element
- * @return {XMLElement} The created element
  */
 function createMathElement(tag, attrs = {}, parent = null) {
     const elem = xmlDOM(`<${tag}></${tag}>`);
@@ -154,8 +142,6 @@ function createMathElement(tag, attrs = {}, parent = null) {
 }
 /**
  * Process a fraction element
- * @param {XMLElement} element - The OMML fraction element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processFraction(element, parent) {
     const type = getAttr(element, "m:fPr/m:type", "m:val") || "";
@@ -191,8 +177,6 @@ function processFraction(element, parent) {
 }
 /**
  * Process a run of text
- * @param {XMLElement} element - The OMML run element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processRun(element, parent) {
     const nor = forceFalse(getAttr(element, "m:rPr/m:nor", "m:val") || "false");
@@ -200,12 +184,12 @@ function processRun(element, parent) {
         const mtext = createMathElement("mtext", {}, parent);
         const textContent = element
             .queryAll("m:t")
-            .map(t => t.textContent)
+            .map((t) => t.textContent)
             .join("");
         mtext.textContent = nbsp(textContent);
     }
     else {
-        element.queryAll("m:t").forEach(t => {
+        element.queryAll("m:t").forEach((t) => {
             const toParse = t.textContent;
             const scr = getAttr(element, "m:rPr/m:scr", "m:val");
             const sty = getAttr(element, "m:rPr/m:sty", "m:val");
@@ -220,8 +204,6 @@ function processRun(element, parent) {
 }
 /**
  * Process a lower limit element
- * @param {XMLElement} element - The OMML limLow element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processLimLow(element, parent) {
     const munder = createMathElement("munder", {}, parent);
@@ -238,8 +220,6 @@ function processLimLow(element, parent) {
 }
 /**
  * Process an upper limit element
- * @param {XMLElement} element - The OMML limUpp element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processLimUpp(element, parent) {
     const mover = createMathElement("mover", {}, parent);
@@ -256,8 +236,6 @@ function processLimUpp(element, parent) {
 }
 /**
  * Process a subscript element
- * @param {XMLElement} element - The OMML sSub element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processSubscript(element, parent) {
     const msub = createMathElement("msub", {}, parent);
@@ -274,8 +252,6 @@ function processSubscript(element, parent) {
 }
 /**
  * Process a superscript element
- * @param {XMLElement} element - The OMML sSup element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processSuperscript(element, parent) {
     const msup = createMathElement("msup", {}, parent);
@@ -292,8 +268,6 @@ function processSuperscript(element, parent) {
 }
 /**
  * Process a subscript-superscript element
- * @param {XMLElement} element - The OMML sSubSup element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processSubSuperscript(element, parent) {
     const msubsup = createMathElement("msubsup", {}, parent);
@@ -315,8 +289,6 @@ function processSubSuperscript(element, parent) {
 }
 /**
  * Process a prescripted element
- * @param {XMLElement} element - The OMML sPre element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processPreScript(element, parent) {
     const mmultiscripts = createMathElement("mmultiscripts", {}, parent);
@@ -333,8 +305,6 @@ function processPreScript(element, parent) {
 }
 /**
  * Process a matrix element
- * @param {XMLElement} element - The OMML matrix element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processMatrix(element, parent) {
     const mcjc = getAttr(element, "m:mPr/m:mcs/m:mc/m:mcPr/m:mcJc", "m:val");
@@ -343,9 +313,9 @@ function processMatrix(element, parent) {
         attrs.columnalign = mcjc.toLowerCase();
     }
     const mtable = createMathElement("mtable", attrs, parent);
-    element.queryAll("m:mr").forEach(mr => {
+    element.queryAll("m:mr").forEach((mr) => {
         const mtr = createMathElement("mtr", {}, mtable);
-        mr.queryAll("m:e").forEach(me => {
+        mr.queryAll("m:e").forEach((me) => {
             const mtd = createMathElement("mtd", {}, mtr);
             processElement(me, mtd);
         });
@@ -353,8 +323,6 @@ function processMatrix(element, parent) {
 }
 /**
  * Process a radical element
- * @param {XMLElement} element - The OMML radical element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processRadical(element, parent) {
     const degHide = forceFalse(getAttr(element, "m:radPr/m:degHide", "m:val") || "false");
@@ -381,8 +349,6 @@ function processRadical(element, parent) {
 }
 /**
  * Process an n-ary operator element
- * @param {XMLElement} element - The OMML nary element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processNary(element, parent) {
     const subHide = forceFalse(getAttr(element, "m:naryPr/m:subHide", "m:val") || "false");
@@ -436,8 +402,6 @@ function processNary(element, parent) {
 }
 /**
  * Process a delimiter element
- * @param {XMLElement} element - The OMML delimiter element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processDelimiter(element, parent) {
     const begChr = getAttr(element, "m:dPr/m:begChr", "m:val");
@@ -454,19 +418,17 @@ function processDelimiter(element, parent) {
         attr.separators = sepChr;
     }
     const mfenced = createMathElement("mfenced", attr, parent);
-    element.queryAll("m:e").forEach(me => {
+    element.queryAll("m:e").forEach((me) => {
         const row = createMathElement("mrow", {}, mfenced);
         processElement(me, row);
     });
 }
 /**
  * Process an equation array element
- * @param {XMLElement} element - The OMML eqArr element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processEqArr(element, parent) {
     const mtable = createMathElement("mtable", {}, parent);
-    element.queryAll("m:e").forEach(me => {
+    element.queryAll("m:e").forEach((me) => {
         const mtr = createMathElement("mtr", {}, mtable);
         const mtd = createMathElement("mtd", {}, mtr);
         const scrLvl = getAttr(me, "m:argPr/m:scrLvl", "m:val");
@@ -482,13 +444,11 @@ function processEqArr(element, parent) {
 }
 /**
  * Process a function element
- * @param {XMLElement} element - The OMML function element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processFunction(element, parent) {
     const outer = createMathElement("mrow", {}, parent);
     const row1 = createMathElement("mrow", {}, outer);
-    element.queryAll("m:fName").forEach(fn => {
+    element.queryAll("m:fName").forEach((fn) => {
         processElement(fn, row1);
     });
     const mo = createMathElement("mo", {}, outer);
@@ -501,8 +461,6 @@ function processFunction(element, parent) {
 }
 /**
  * Process an accent element
- * @param {XMLElement} element - The OMML accent element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processAccent(element, parent) {
     const mover = createMathElement("mover", { accent: "true" }, parent);
@@ -528,8 +486,6 @@ function processAccent(element, parent) {
 }
 /**
  * Process a group character element
- * @param {XMLElement} element - The OMML groupChr element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processGroupChar(element, parent) {
     const lastGroupChrPr = element.query("m:groupChrPr");
@@ -539,16 +495,16 @@ function processGroupChar(element, parent) {
     const pos = (getAttr(lastGroupChrPr, "m:pos", "m:val") || "").toLowerCase();
     const vertJc = (getAttr(lastGroupChrPr, "m:vertJc", "m:val") || "").toLowerCase();
     const chr = getAttr(lastGroupChrPr, "m:chr", "m:val") || "\u23DF";
-    const mkMrow = parent => {
-        const mrow = createMathElement("mrow", {}, parent);
+    const mkMrow = (p) => {
+        const mrow = createMathElement("mrow", {}, p);
         const e = element.query("m:e");
         if (e) {
             processElement(e, mrow);
         }
         return mrow;
     };
-    const mkMo = parent => {
-        const mo = createMathElement("mo", {}, parent);
+    const mkMo = (p) => {
+        const mo = createMathElement("mo", {}, p);
         mo.textContent = chr.substr(0, 1);
         return mo;
     };
@@ -579,8 +535,6 @@ function processGroupChar(element, parent) {
 }
 /**
  * Process a border box element
- * @param {XMLElement} element - The OMML borderBox element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processBorderBox(element, parent) {
     const hideTop = forceTrue(getAttr(element, "m:borderBoxPr/m:hideTop", "m:val") || "false");
@@ -622,8 +576,6 @@ function processBorderBox(element, parent) {
 }
 /**
  * Process a bar element
- * @param {XMLElement} element - The OMML bar element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processBar(element, parent) {
     const pos = (getAttr(element, "m:barPr/m:pos", "m:val") || "").toLowerCase();
@@ -650,8 +602,6 @@ function processBar(element, parent) {
 }
 /**
  * Process a phantom element
- * @param {XMLElement} element - The OMML phantom element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processPhantom(element, parent) {
     const zeroWid = forceFalse(getAttr(element, "m:phantPr/m:zeroWid", "m:val") || "false");
@@ -677,8 +627,6 @@ function processPhantom(element, parent) {
 }
 /**
  * Process an argument element
- * @param {XMLElement} element - The OMML argument element
- * @param {XMLElement} parent - The parent MathML element
  */
 function processArgument(element, parent) {
     const scriptlevel = getAttr(element, "m:argPr/m:scrLvl", "m:val");
@@ -692,10 +640,6 @@ function processArgument(element, parent) {
 }
 /**
  * Get attribute value from an element using a simplified XPath-like path
- * @param {XMLElement} element - The element to query
- * @param {string} path - The simplified path to the attribute
- * @param {string} attrName - The attribute name
- * @return {string} The attribute value or empty string
  */
 function getAttr(element, path, attrName) {
     if (!element) {
@@ -729,12 +673,10 @@ function getAttr(element, path, attrName) {
             current = current.query(part) || null;
         }
     }
-    return current ? current.getAttribute(attrName) || "" : "";
+    return current ? String(current.getAttribute(attrName) || "") : "";
 }
 /**
  * Output a script element, or "none" if not provided
- * @param {XMLElement} parent - The parent element
- * @param {XMLElement} element - The script element to output
  */
 function outputScript(parent, element) {
     if (element) {
@@ -747,9 +689,6 @@ function outputScript(parent, element) {
 }
 /**
  * Output an n-ary operator
- * @param {XMLElement} element - The OMML nary element
- * @param {XMLElement} parent - The parent MathML element
- * @param {boolean} grow - Whether the operator should stretch
  */
 function outputNAryMO(element, parent, grow = false) {
     const mo = createMathElement("mo", { stretchy: grow ? "true" : "false" }, parent);
@@ -758,10 +697,6 @@ function outputNAryMO(element, parent, grow = false) {
 }
 /**
  * Create an equation array row
- * @param {XMLElement} parent - The parent MathML element
- * @param {XMLElement} src - The source OMML element
- * @param {XMLElement} cur - The current OMML element
- * @param {number} align - Alignment indicator
  */
 function createEqArrRow(parent, src, cur, align) {
     if (!cur) {
@@ -770,7 +705,7 @@ function createEqArrRow(parent, src, cur, align) {
     if (cur.tagName === "m:r") {
         const allMt = cur
             .queryAll("m:t")
-            .map(t => t.textContent)
+            .map((t) => t.textContent)
             .join("");
         const nor = forceFalse(getAttr(cur, "m:rPr/m:nor", "m:val") || "false");
         parseEqArrMr(parent, {
@@ -791,7 +726,7 @@ function createEqArrRow(parent, src, cur, align) {
     if (nextSibling) {
         const allMt = cur
             .queryAll("m:t")
-            .map(t => t.textContent)
+            .map((t) => t.textContent)
             .join("");
         const amp = countAmp(allMt);
         createEqArrRow(parent, src, nextSibling, (align + (amp % 2)) % 2);
@@ -799,8 +734,6 @@ function createEqArrRow(parent, src, cur, align) {
 }
 /**
  * Parse equation array run text
- * @param {XMLElement} parent - The parent MathML element
- * @param {Object} options - Parsing options
  */
 function parseEqArrMr(parent, { toParse = "", scr, sty, nor, align }) {
     if (!toParse.length) {
@@ -810,7 +743,7 @@ function parseEqArrMr(parent, { toParse = "", scr, sty, nor, align }) {
         createMathElement(align ? "malignmark" : "maligngroup", {}, parent);
         parseEqArrMr(parent, {
             toParse: toParse.substr(1),
-            align: !align,
+            align: align ? 0 : 1,
             scr,
             sty,
             nor
@@ -892,9 +825,6 @@ function parseEqArrMr(parent, { toParse = "", scr, sty, nor, align }) {
 }
 /**
  * Parse math text
- * @param {XMLElement} ctx - The context OMML element
- * @param {XMLElement} parent - The parent MathML element
- * @param {Object} options - Parsing options
  */
 function parseMT(ctx, parent, { toParse = "", scr, sty, nor }) {
     if (!toParse.length) {
@@ -964,9 +894,6 @@ function parseMT(ctx, parent, { toParse = "", scr, sty, nor }) {
 }
 /**
  * Find the index of a regex match in a string
- * @param {string} str - The string to search
- * @param {RegExp} rx - The regex to match
- * @return {number} The match index + 1, or 0 if no match
  */
 function rxIndexOf(str, rx) {
     const re = rx.exec(str);
@@ -977,8 +904,6 @@ function rxIndexOf(str, rx) {
 }
 /**
  * Get the start of a number in a string
- * @param {string} str - The string to check
- * @return {string} The number at the start of the string
  */
 function numStart(str) {
     if (!str) {
@@ -989,16 +914,12 @@ function numStart(str) {
 }
 /**
  * Count ampersands in a string
- * @param {string} str - The string to check
- * @return {number} The number of ampersands
  */
 function countAmp(str) {
     return ((str || "").match(/&/g) || []).length;
 }
 /**
  * Convert a combining character to its non-combining equivalent
- * @param {string} ch - The character to convert
- * @return {string} The non-combining equivalent
  */
 function toNonCombining(ch) {
     const combiMap = {
@@ -1032,10 +953,9 @@ function toNonCombining(ch) {
 }
 /**
  * Create MathML token attributes based on token settings
- * @param {Object} options - Token options
- * @return {Object} Attribute object
  */
-function tokenAttributes({ scr, sty, nor, charToPrint = 0, tokenType }) {
+function tokenAttributes(options) {
+    const { scr, sty, nor, charToPrint = 0, tokenType } = options;
     const attr = {};
     if (nor) {
         attr.mathvariant = "normal";
@@ -1120,8 +1040,6 @@ function tokenAttributes({ scr, sty, nor, charToPrint = 0, tokenType }) {
 }
 /**
  * Create menclose notation attribute value
- * @param {Object} options - Notation options
- * @return {Object} The notation attributes
  */
 function createMEnclodeNotation({ hideTop, hideBot, hideLeft, hideRight, strikeH, strikeV, strikeBLTR, strikeTLBR }) {
     const notation = [];
@@ -1158,8 +1076,6 @@ function createMEnclodeNotation({ hideTop, hideBot, hideLeft, hideRight, strikeH
 }
 /**
  * Create mpadded attributes
- * @param {Object} options - Padding options
- * @return {Object} The padding attributes
  */
 function createMPaddedAttr({ zeroWid, zeroAsc, zeroDesc }) {
     const attr = {};
@@ -1176,8 +1092,6 @@ function createMPaddedAttr({ zeroWid, zeroAsc, zeroDesc }) {
 }
 /**
  * Get fraction properties
- * @param {string} type - Fraction type
- * @return {Object} Fraction attributes
  */
 function getFracProps(type) {
     if (type === "skw" || type === "lin") {
@@ -1190,8 +1104,6 @@ function getFracProps(type) {
 }
 /**
  * Replace spaces with non-breaking spaces
- * @param {string} str - The string to process
- * @return {string} String with non-breaking spaces
  */
 function nbsp(str) {
     if (!str) {
@@ -1201,25 +1113,22 @@ function nbsp(str) {
 }
 /**
  * Parse a boolean value
- * @param {string} str - The string to parse
- * @return {boolean|undefined} The parsed boolean or undefined
  */
 function tf(str) {
     if (str == null) {
         return;
     }
-    str = str.toLowerCase();
-    if (str === "on" || str === "1" || str === "true") {
+    const lower = String(str).toLowerCase();
+    if (lower === "on" || lower === "1" || lower === "true") {
         return true;
     }
-    if (str === "off" || str === "0" || str === "false") {
+    if (lower === "off" || lower === "0" || lower === "false") {
         return false;
     }
+    return undefined;
 }
 /**
  * Force a value to be true unless explicitly false
- * @param {string} str - The string to parse
- * @return {boolean} True unless the string is explicitly false
  */
 function forceFalse(str) {
     const res = tf(str);
@@ -1230,8 +1139,6 @@ function forceFalse(str) {
 }
 /**
  * Force a value to be false unless explicitly true
- * @param {string} str - The string to parse
- * @return {boolean} False unless the string is explicitly true
  */
 function forceTrue(str) {
     return tf(str) || false;