xmmath 1.0.7 → 1.0.8

package/src/main.ts

@@ -24,10 +24,10 @@ function createMath<K extends keyof MathMLElementTagNameMap>(
 
 const mathvariant = "mathvariant";
 
-import GraphemeSplitter from "grapheme-splitter";
-var splitter = new GraphemeSplitter();
+const Segmenter = Intl.Segmenter;
+const segmenter = new Segmenter("emoji", { granularity: "grapheme" });
 
-type vtype = "" | "str" | "v" | "f" | "blank" | "group" | "group1"; // group1组合基本类型，提高优先级
+type vtype = "" | "str" | "v" | "f" | "blank" | "group" | "group1" | "sharp"; // group1组合基本类型，提高优先级
 type tree = { type: vtype; value: string; children?: tree; esc?: boolean }[];
 
 function ast(str: string) {
@@ -74,7 +74,11 @@ function ast(str: string) {
         }
     }
 
-    let strl = init_c.emoji ? splitter.splitGraphemes(str) : [...str];
+    let strl = init_c.emoji
+        ? typeof init_c.emoji === "boolean"
+            ? Array.from(segmenter.segment(str)).map((w) => w.segment)
+            : init_c.emoji(str)
+        : [...str];
     for (let i = 0; i < strl.length; i++) {
         const t = strl[i];
         // 字符
@@ -102,6 +106,11 @@ function ast(str: string) {
             type = "";
         }
 
+        if (t === "#") {
+            now_tree.push({ type: "sharp", value: t });
+            continue;
+        }
+
         // 原始值（字母变量、数字、符号）
         if (
             type == "" &&
@@ -159,7 +168,7 @@ function ast(str: string) {
 }
 
 import symbols from "./symbols.json?raw";
-/** @see https://github.com/typst/typst/blob/v0.6.0/library/src/symbols/sym.rs */
+/** @see https://github.com/typst/typst/blob/v0.11.1/crates/typst/src/symbols/sym.rs */
 let s = JSON.parse(symbols);
 
 // symbols路径简写
@@ -242,6 +251,8 @@ for (let i in shorthand) {
     }
 }
 
+const delimPair = { "(": ["(", ")"], "[": ["[", "]"], "{": ["{", "}"], "|": ["|", "|"], "||": ["‖", "‖"] };
+
 let f: {
     [name: string]: (attr?: tree[], dic?: fdic, array?: tree[][], e?: fonts) => MathMLElement | DocumentFragment;
 } = {
@@ -309,7 +320,9 @@ let f: {
         let a = createMath("mrow");
         a.append(render(attr[0]));
         let b = createMath("mrow");
-        b.append(render(attr[1]));
+        const s: tree = [];
+        for (let x of attr.slice(1)) s.push(...x, dh);
+        b.append(render(s.slice(0, -1)));
         let f = createMath("mfrac", null, { linethickness: "0" });
         f.append(a, b);
         let l = createMath("mo", "(");
@@ -337,9 +350,17 @@ let f: {
     },
     cases: (attr: tree[], dic: fdic) => {
         let r = createMath("mrow");
-        let l = createMath("mo", dic?.delim?.[0]?.value || "{");
-        let t = f.x_table(attr, { cases: [] });
-        r.append(l, t);
+        const d = dic?.delim?.[0]?.value || "{";
+        let t = f.x_table(attr, { cases: [] }) as MathMLElement;
+        const gap = dic?.gap?.[0]?.value || "0.5em";
+        t.setAttribute("rowspacing", gap);
+        if (is_true(dic?.reverse)) {
+            const l = createMath("mo", delimPair[d][1]);
+            r.append(t, l);
+        } else {
+            const l = createMath("mo", d);
+            r.append(l, t);
+        }
         return r;
     },
     frac: (attr: tree[], dic: fdic) => {
@@ -368,16 +389,26 @@ let f: {
             end = { c: [el], n: i };
             break;
         }
-        let l = document.createDocumentFragment();
-        l.append(render(start.c));
-        let r = document.createDocumentFragment();
-        r.append(render(end.c));
-        let c = document.createDocumentFragment();
-        c.append(render(list.slice(start.n + 1, end.n)));
-        let row = createMath("mrow");
+        const size = dic?.size?.[0]?.value;
+        const l = render(start.c);
+        const r = render(end.c);
+        if (size && size != "auto") {
+            const lm = l.querySelector("mo");
+            const rm = r.querySelector("mo");
+            lm.setAttribute("maxsize", size);
+            lm.setAttribute("minsize", size);
+            rm.setAttribute("maxsize", size);
+            rm.setAttribute("minsize", size);
+        }
+        const c = render(list.slice(start.n + 1, end.n));
+        const row = createMath("mrow");
         row.append(l, c, r);
         return row;
     },
+    mid: (attr: tree[], dic: fdic) => {
+        const o = createMath("mo", attr?.[0]?.[0]?.value, { stretchy: "true" });
+        return o;
+    },
     mat: (attr: tree[], dic: fdic, array: tree[][]) => {
         let d = dic?.delim?.[0]?.value || "(";
         let o = { "(": ["(", ")"], "[": ["[", "]"], "{": ["{", "}"], "|": ["|", "|"], "||": ["‖", "‖"] };
@@ -385,8 +416,38 @@ let f: {
         let l = createMath("mo", o[d][0]);
         let r = createMath("mo", o[d][1]);
         let t = createMath("mtable");
+        let augment = lan_dic(dic?.augment?.[0].children);
+        if (augment) {
+            let xa = NaN;
+            let ya = NaN;
+            if (Array.isArray(augment)) {
+                xa = Number((augment as tree).map((i) => i.value).join(""));
+            } else {
+                ya = Number((augment["hline"] as tree).map((i) => i.value).join(""));
+            }
+            if (xa < 0) xa = array[0].length + xa;
+            if (ya < 0) ya = array.length + ya;
+
+            if (ya) {
+                let l: boolean[] = [];
+                for (let i = 1; i < array.length; i++) l.push(i === ya);
+                t.setAttribute("rowlines", l.map((i) => (i ? "solid" : "none")).join(" "));
+            }
+            if (xa) {
+                let l: boolean[] = [];
+                for (let i = 1; i < array[0].length; i++) l.push(i === xa);
+                t.setAttribute("columnlines", l.map((i) => (i ? "solid" : "none")).join(" "));
+            }
+        }
+        const gap = dic?.gap?.[0]?.value;
+        const rowgap = dic?.["row-gap"]?.[0]?.value;
+        const colgap = dic?.["column-gap"]?.[0]?.value;
+        t.setAttribute("columnspacing", colgap || gap || "0.5em");
+        t.setAttribute("rowspacing", rowgap || gap || "0.5em");
+
         for (let i of array) {
             let tr = createMath("mtr");
+            if (!i.length) continue;
             for (let j of i) {
                 let td = createMath("mtd");
                 td.append(render(j));
@@ -459,7 +520,8 @@ let f: {
     },
     op: (attr: tree[], dic: fdic, a, e) => {
         let f = createMath("mrow");
-        let str = createMath("ms", font(attr[0][0].value, e));
+        let str = createMath("ms");
+        str.append(render(attr[0], e));
         f.append(str);
         return f;
     },
@@ -501,11 +563,13 @@ let f: {
     },
     vec: (attr: tree[], dic: fdic) => {
         let d = dic?.delim?.[0]?.value || "(";
-        let o = { "(": ["(", ")"], "[": ["[", "]"], "{": ["{", "}"], "|": ["|", "|"], "||": ["‖", "‖"] };
+        let o = delimPair;
         let row = createMath("mrow");
         let l = createMath("mo", o[d][0]);
         let r = createMath("mo", o[d][1]);
         let t = createMath("mtable");
+        const gap = dic?.gap?.[0]?.value || "0.5em";
+        t.setAttribute("rowspacing", gap);
         for (let i of attr) {
             let tr = createMath("mtr");
             tr.append(render(i));
@@ -514,6 +578,9 @@ let f: {
         row.append(l, t, r);
         return row;
     },
+    h: (attr: tree[], dic: fdic) => {
+        return createMath("mspace", "", { width: attr[0][0].value });
+    },
     // 额外
     //
     x_table: (attr: tree[], dic: fdic) => {
@@ -579,6 +646,7 @@ let opl: { id: string; str?: string; limits?: boolean }[] = [
     { id: "ctg" },
     { id: "coth" },
     { id: "csc" },
+    { id: "csch" },
     { id: "deg" },
     { id: "det", limits: true },
     { id: "dim" },
@@ -586,6 +654,8 @@ let opl: { id: string; str?: string; limits?: boolean }[] = [
     { id: "gcd", limits: true },
     { id: "hom" },
     { id: "mod" },
+    { id: "id" },
+    { id: "im" },
     { id: "inf", limits: true },
     { id: "ker" },
     { id: "lg" },
@@ -596,12 +666,14 @@ let opl: { id: string; str?: string; limits?: boolean }[] = [
     { id: "min", limits: true },
     { id: "Pr", limits: true },
     { id: "sec" },
+    { id: "sech" },
     { id: "sin" },
     { id: "sinc" },
     { id: "sinh" },
     { id: "sup", limits: true },
     { id: "tan" },
     { id: "tg" },
+    { id: "tr" },
     { id: "tanh" },
     { id: "liminf", str: "lim inf", limits: true },
     { id: "limsup", str: "lim sup", limits: true },
@@ -622,6 +694,20 @@ function op_f() {
 }
 op_f();
 
+const spaceConst = {
+    quad: "1em",
+    med: "0.222em",
+    thin: "0.17em",
+    thick: "0.28em",
+    wide: "2em",
+};
+
+for (let i in spaceConst) {
+    f[i] = () => {
+        return f.h([[{ type: "str", value: spaceConst[i] }]]);
+    };
+}
+
 let limits_f = [];
 let limits_sy = ["∏", "∐", "∑", "⋀", "⋁", "⋂", "⋃", "⨀", "⨁", "⨂", "⨃", "⨄", "⨅", "⨆"];
 for (let i in ss) {
@@ -648,7 +734,13 @@ function accent_f() {
         "diaer",
         "circle",
         "arrow",
+        "arrow.r",
         "arrow.l",
+        "arrow.l.r",
+        "caron",
+        "harpoon",
+        "harpoon.rt",
+        "harpoon.lt",
     ];
     for (let i of l) {
         f[i] = (attr: tree[]) => {
@@ -668,8 +760,8 @@ function lr_f() {
         { name: "round", l: v_f("⌊"), r: v_f("⌉") },
     ];
     for (let i of l) {
-        f[i.name] = (attr: tree[]) => {
-            let s = f.lr([[i.l, ...attr[0], i.r]], {});
+        f[i.name] = (attr: tree[], dic) => {
+            let s = f.lr([[i.l, ...attr[0], i.r]], dic);
             return s;
         };
     }
@@ -722,15 +814,15 @@ function in_kh(x: tree) {
 }
 
 function is_sup(x: tree[0]) {
-    return x && x.type == "v" && x.value == "^" && !x.esc;
+    return eqq(x, { type: "v", value: "^" });
 }
 
 function is_sub(x: tree[0]) {
-    return x && x.type == "v" && x.value == "_" && !x.esc;
+    return eqq(x, { type: "v", value: "_" });
 }
 
 function is_frac(x: tree[0]) {
-    return x && x.type == "v" && x.value == "/" && !x.esc;
+    return eqq(x, { type: "v", value: "/" });
 }
 
 function is_br(x: tree[0]) {
@@ -744,6 +836,7 @@ function is_limit(tree: tree) {
             if (limits_f.includes(x.value)) {
                 return true;
             }
+            if (x.value.split(".").at(0) === "arrow") return true;
             for (let i of opl) {
                 if (i.limits && x.value == i.id) {
                     return true;
@@ -752,12 +845,7 @@ function is_limit(tree: tree) {
             if (x.value == "scripts") return false;
             if (x.value == "op") {
                 let { dic } = f_attr(x);
-                let t = "";
-                if (dic.limits)
-                    for (let i of dic.limits) {
-                        t += i.value;
-                    }
-                return t == "#true";
+                return is_true(dic.limits);
             }
         }
         if (x.type == "v" && limits_sy.includes(x.value)) {
@@ -773,7 +861,7 @@ function is_f_mark(x: tree[0], str: string) {
 }
 
 function is_dot(x: tree[0]) {
-    return x && x.type == "v" && x.value == ".";
+    return eq(x, { type: "v", value: "." });
 }
 
 function is_dot_f(x: tree[0]) {
@@ -790,6 +878,27 @@ function v_f(str: string): tree[0] {
     return { type: "v", value: str };
 }
 
+function eq(x0: tree[0], x1: tree[0]) {
+    if (!x0 || !x1) return false;
+    return x0.type === x1.type && x0.value === x1.value;
+}
+
+function eqq(x0: tree[0], x1: tree[0]) {
+    if (!x0 || !x1) return false;
+    return x0.type === x1.type && x0.value === x1.value && x0?.esc === x1?.esc;
+}
+
+function trim(tree: tree) {
+    if (!tree) return [];
+    while (tree.length > 0 && tree[0].type === "blank") {
+        tree.shift();
+    }
+    while (tree.length > 0 && tree.at(-1).type === "blank") {
+        tree.pop();
+    }
+    return tree;
+}
+
 type fdic = { [id: string]: tree };
 
 function dic_to_ast(dic: { [id: string]: tree }) {
@@ -798,7 +907,7 @@ function dic_to_ast(dic: { [id: string]: tree }) {
         l.push({ type: "f", value: i });
         l.push({ type: "v", value: ":" });
         for (let x of dic[i]) {
-            if (x.type == "v" && x.value == ",") x.esc = true;
+            if (eq(x, dh)) x.esc = true;
         }
         l.push(...dic[i]);
         if (Number(i) + 1 != Object.keys(dic).length) {
@@ -808,17 +917,35 @@ function dic_to_ast(dic: { [id: string]: tree }) {
     return l;
 }
 
-function is_true(t: tree) {
-    let n = 0;
-    if (t) {
-        if (t[0].type == "blank") n++;
-        if (t[n] && t[n].type == "v" && t[n].value == "#") {
-            if (t[n + 1] && t[n + 1].type == "f" && t[n + 1].value == "true") {
-                return true;
+function lan_dic(tree: tree) {
+    tree = trim(tree);
+    if (!tree.find((v) => eqq(v, v_f(":")))) return tree;
+    const o = new Object();
+    let key = "";
+    let value: tree = [];
+    tree.push(dh);
+    for (let i = 0; i < tree.length; i++) {
+        if (!key && tree[i].type != "blank") {
+            key = tree[i].value;
+        } else {
+            if (value.length) {
+                if (eqq(tree[i], dh)) {
+                    o[key] = trim(value);
+                    key = "";
+                    value = [];
+                } else value.push(tree[i]);
+            } else {
+                if (eqq(tree[i], v_f(":"))) {
+                    value.push(tree[i + 1]);
+                }
             }
         }
     }
-    return false;
+    return o;
+}
+
+function is_true(t: tree) {
+    return eqq(trim(t)?.[0], { type: "sharp", value: "true" });
 }
 
 function ast2(tree: tree) {
@@ -846,13 +973,88 @@ function ast2(tree: tree) {
         tree = t;
     }
 
+    // 处理\转义
+    {
+        let t: tree = [];
+        for (let n = 0; n < tree.length; n++) {
+            let x = tree[n];
+
+            if (x.value == "\\" && x.type == "v") {
+                if (tree?.[n + 1]) {
+                    let next = tree[n + 1];
+                    if (next.value == "\\" && next.type == "v") {
+                        t.push({ type: "v", value: "\\" });
+                        n++;
+                    } else if (next.type == "blank") {
+                        t.push({ type: "v", value: "br", esc: true });
+                        n++;
+                    } else if (next.type == "f") {
+                        let v = next.value;
+                        t.push({ type: "v", value: v[0] });
+                        t.push({ type: v.length == 2 ? "v" : "f", value: v.slice(1) });
+                        n++;
+                    } else if (next.type === "sharp") {
+                        t.push({ type: "v", value: "#" });
+                        n++;
+                    } else {
+                        let v = next;
+                        v.esc = true;
+                        t.push(v);
+                        n++;
+                    }
+                }
+            } else {
+                t.push(x);
+            }
+        }
+        tree = t;
+    }
+
+    // 处理#
+    {
+        const t: tree = [];
+        for (let n = 0; n < tree.length; n++) {
+            const x = tree[n];
+            if (x.type === "sharp") {
+                if (tree[n + 1]?.type === "group") {
+                    x.children = tree[n + 1].children;
+                    for (let i in x.children) {
+                        if (x.children[i].value === "\\" && x.children[i].type === "v") {
+                            if (x.children[Number(i) + 1]) {
+                                x.children[Number(i) + 1]["esc"] = true;
+                            }
+                        }
+                    }
+                    const v = x.children.map((i) => i.value).join("");
+                    if (v.match(/^[0-9\+\-\*\/()]+$/)) {
+                        x.value = v; // todo 数学运算
+                    } else {
+                        x.value = v;
+                    }
+                } else {
+                    x.value = tree[n + 1]?.value;
+                    if (tree[n + 2]?.type === "f") {
+                        x.value += tree[n + 2].value;
+                        n++;
+                    }
+                }
+                t.push(x);
+                n++;
+                continue;
+            } else {
+                t.push(x);
+            }
+        }
+        tree = t;
+    }
+
     // 处理符号简写（shorthand）
     {
         let t: tree = [];
         for (let n = 0; n < tree.length; n++) {
             let x = tree[n];
 
-            if (tree?.[n - 1]?.value != "\\") {
+            if (!x.esc) {
                 if (x.type == "v") {
                     let nn = n;
                     let shortkey = x.value;
@@ -883,40 +1085,6 @@ function ast2(tree: tree) {
         tree = t;
     }
 
-    // 处理\转义
-    {
-        let t: tree = [];
-        for (let n = 0; n < tree.length; n++) {
-            let x = tree[n];
-
-            if (x.value == "\\" && x.type == "v") {
-                if (tree?.[n + 1]) {
-                    let next = tree[n + 1];
-                    if (next.value == "\\" && next.type == "v") {
-                        t.push({ type: "v", value: "\\" });
-                        n++;
-                    } else if (next.type == "blank") {
-                        t.push({ type: "v", value: "br", esc: true });
-                        n++;
-                    } else if (next.type == "f") {
-                        let v = next.value;
-                        t.push({ type: "v", value: v[0] });
-                        t.push({ type: v.length == 2 ? "v" : "f", value: v.slice(1) });
-                        n++;
-                    } else {
-                        let v = next;
-                        v.esc = true;
-                        t.push(v);
-                        n++;
-                    }
-                }
-            } else {
-                t.push(x);
-            }
-        }
-        tree = t;
-    }
-
     // 处理字符与v之间空格
     {
         let t: tree = [];
@@ -1014,6 +1182,35 @@ function ast2(tree: tree) {
         tree = t;
     }
 
+    // '->^'
+    {
+        let t: tree = [];
+        for (let n = 0; n < tree.length; n++) {
+            let x = tree[n];
+            let nn = n;
+            if (eqq(x, { type: "f", value: "prime" })) {
+                while (tree[nn] && eqq(tree[nn], { type: "f", value: "prime" })) {
+                    nn++;
+                }
+                const primes = nn - n;
+                if (
+                    tree[n - 1] &&
+                    !is_sup(tree[n - 1]) &&
+                    !is_sub(tree[n - 1]) &&
+                    !eq(tree[n - 1], { type: "f", value: "prime" }) &&
+                    tree[n - 1].type != "blank"
+                ) {
+                    t.push({ type: "v", value: "^" });
+                }
+                t.push({ type: "v", value: "'".repeat(primes), children: [{ type: "v", value: String(primes) }] });
+                n += primes - 1;
+                continue;
+            }
+            t.push(x);
+        }
+        tree = t;
+    }
+
     // 移除blank
     {
         let t: tree = [];
@@ -1207,16 +1404,21 @@ function f_attr(x: tree[0]) {
     // 将dicl的tree转为键对
     let dic: fdic = {};
     for (let i of dicl) {
+        let x = false;
         let n = "";
         let t: tree = [];
         for (let el of i) {
-            if (!n) {
-                n = el.value;
+            if (el.value === ":") {
+                x = true;
+                continue;
+            }
+            if (!x) {
+                n += el.value;
             } else {
-                if (el.value != ":") t.push(el);
+                t.push(el);
             }
         }
-        dic[n] = t;
+        dic[n] = ast2(t);
     }
     return { attr, dic, array };
 }
@@ -1355,7 +1557,7 @@ function render(tree: tree, e?: fonts) {
                 let el = f[x.value](attr, dic, array, e);
                 fragment.append(el);
             } else if (ss[x.value]) {
-                let el = createMath("mo", ss[x.value]);
+                let el = createMath("mi", ss[x.value]);
                 fragment.append(el, render(in_kh(x.children)));
             }
         }
@@ -1366,16 +1568,16 @@ function render(tree: tree, e?: fonts) {
                 let space_w = null;
                 const space_width = {
                     " ": "0.36em",
-                    " ": "0.5em",
-                    " ": "3.75em",
-                    " ": "0.333em",
-                    " ": "0.25em",
-                    " ": "0.166em",
-                    " ": "0.222em",
-                    " ": "1ch",
-                    " ": "0.27em",
-                    " ": "0.2em",
-                    " ": "0.09em",
+                    "\u2002": "0.5em",
+                    "\u2003": "1em",
+                    "\u2004": "0.333em",
+                    "\u2005": "0.25em",
+                    "\u2006": "0.166em",
+                    "\u205f": "0.222em",
+                    "\u2007": "1ch",
+                    "\u2008": "0.27em",
+                    "\u2009": "0.17em",
+                    "\u200a": "0.09em",
                 };
                 if (ss[x.value].match(/[a-zA-Z\u0391-\u03C9]/)) {
                     tag = "mi";
@@ -1400,12 +1602,15 @@ function render(tree: tree, e?: fonts) {
             fragment.append(el);
         }
 
-        if (x.type == "v") {
+        if (x.type === "v" || x.type === "sharp") {
             let tag: keyof MathMLElementTagNameMap;
             if (x.value.match(/[0-9.]+/)) {
                 tag = "mn";
             } else if (x.value.match(/[a-zA-Z\u0391-\u03C9]/)) {
                 tag = "mi";
+            } else if (x.value.match(/^'+$/)) {
+                if (x.value.length > 1) x.value = x.value.replaceAll("'", ss["prime"]);
+                tag = "mo";
             } else {
                 tag = "mo";
             }
@@ -1421,7 +1626,7 @@ function render(tree: tree, e?: fonts) {
     return fragment;
 }
 
-var init_c = {
+var init_c: { emoji: boolean | ((str: string) => string) } = {
     emoji: false,
 };
 
@@ -1446,4 +1651,9 @@ function toMMLHTML(str: string) {
     return toMML(str).outerHTML;
 }
 
-export { init, toMML, toMMLHTML };
+const version = {
+    lan: "0.11.1",
+    symbol: "0.11.1",
+};
+
+export { init, toMML, toMMLHTML, version };