xmmath 1.0.4 → 1.0.6

package/src/main.ts

@@ -31,7 +31,7 @@ type vtype = "" | "str" | "v" | "f" | "blank" | "group";
 type tree = { type: vtype; value: string; children?: tree; esc?: boolean }[];
 
 function ast(str: string) {
-    let v = /[a-zA-Z.]/;
+    let v = /[a-zA-Z]/;
     let kh = /[\(\)]/;
     let blank = /[ \t\n\r]+/;
     let type: vtype = "";
@@ -74,15 +74,8 @@ function ast(str: string) {
         }
     }
 
-    let continue_c = 0;
-
-    let strl = splitter.splitGraphemes(str);
+    let strl = init_c.emoji ? splitter.splitGraphemes(str) : [...str];
     for (let i = 0; i < strl.length; i++) {
-        if (continue_c > 0) {
-            continue_c--;
-            continue;
-        }
-
         const t = strl[i];
         // 字符
         if (t == '"' && strl[i - 1] != "\\") {
@@ -249,7 +242,9 @@ for (let i in shorthand) {
     }
 }
 
-let f = {
+let f: {
+    [name: string]: (attr?: tree[], dic?: fdic, array?: tree[][], e?: fonts) => MathMLElement | DocumentFragment;
+} = {
     accent: (attr: tree[], dic: fdic) => {
         let base = createMath("mrow");
         base.append(render(attr[0]));
@@ -322,20 +317,30 @@ let f = {
         row.append(l, f, r);
         return row;
     },
-    cancel: (attr: tree[], dic: fdic) => {},
+    cancel: (attr: tree[], dic: fdic) => {
+        let r = createMath("mrow");
+        const bg = (x: boolean) =>
+            `linear-gradient(to ${
+                x ? "left" : "right"
+            } top, transparent 47.75%, currentColor 49.5%, currentColor 50.5%, transparent 52.25%)`;
+        let s = "";
+        if (is_true(dic.cross)) {
+            s = bg(true) + "," + bg(false);
+        } else if (is_true(dic.inverted)) {
+            s = bg(false);
+        } else {
+            s = bg(true);
+        }
+        r.style.backgroundImage = s;
+        r.append(render(attr[0]));
+        return r;
+    },
     cases: (attr: tree[], dic: fdic) => {
-        let f = createMath("mrow");
+        let r = createMath("mrow");
         let l = createMath("mo", dic?.delim?.[0]?.value || "{");
-        let t = createMath("mtable", null, { columnalign: "left" });
-        for (let i of attr) {
-            let tr = createMath("mtr");
-            let td = createMath("mtd");
-            td.append(render(i));
-            tr.append(td);
-            t.append(tr);
-        }
-        f.append(l, t);
-        return f;
+        let t = f.x_table(attr, { cases: [] });
+        r.append(l, t);
+        return r;
     },
     frac: (attr: tree[], dic: fdic) => {
         console.log(attr);
@@ -404,10 +409,26 @@ let f = {
     sqrt: (attr: tree[], dic: fdic) => {
         return f.root([[], attr[0]], null);
     },
-    display: (attr: tree[], dic: fdic) => {},
-    inline: (attr: tree[], dic: fdic) => {},
-    script: (attr: tree[], dic: fdic) => {},
-    sscript: (attr: tree[], dic: fdic) => {},
+    display: (attr: tree[], dic: fdic) => {
+        let m = createMath("mrow", null, { displaystyle: "true" });
+        m.append(render(attr[0]));
+        return m;
+    },
+    inline: (attr: tree[], dic: fdic) => {
+        let m = createMath("mrow", null, { displaystyle: "false", scriptlevel: "0" });
+        m.append(render(attr[0]));
+        return m;
+    },
+    script: (attr: tree[], dic: fdic) => {
+        let m = createMath("mrow", null, { displaystyle: "false", scriptlevel: "1" });
+        m.append(render(attr[0]));
+        return m;
+    },
+    sscript: (attr: tree[], dic: fdic) => {
+        let m = createMath("mrow", null, { displaystyle: "false", scriptlevel: "2" });
+        m.append(render(attr[0]));
+        return m;
+    },
     upright: (attr: tree[], dic: fdic) => {
         let r = createMath("mrow");
         r.append(render(attr[0]));
@@ -436,11 +457,10 @@ let f = {
         r.append(render(attr[0]));
         return r;
     },
-    op: (attr: tree[], dic: fdic) => {
+    op: (attr: tree[], dic: fdic, a, e) => {
         let f = createMath("mrow");
-        let str = createMath("ms", attr[0][0].value);
+        let str = createMath("ms", font(attr[0][0].value, e));
         f.append(str);
-        // TODO dic.limit
         return f;
     },
     underline: (attr: tree[], dic: fdic) => {
@@ -461,12 +481,24 @@ let f = {
     overbracket: (attr: tree[], dic: fdic) => {
         return underover_f("over", attr[0], "⎴", attr?.[1]);
     },
-    serif: (attr: tree[], dic: fdic) => {},
-    sans: (attr: tree[], dic: fdic) => {},
-    frak: (attr: tree[], dic: fdic) => {},
-    mono: (attr: tree[], dic: fdic) => {},
-    bb: (attr: tree[], dic: fdic) => {},
-    cal: (attr: tree[], dic: fdic) => {},
+    serif: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "serif");
+    },
+    sans: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "sans");
+    },
+    frak: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "frak");
+    },
+    mono: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "mono");
+    },
+    bb: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "bb");
+    },
+    cal: (attr: tree[], dic: fdic) => {
+        return render(attr[0], "cal");
+    },
     vec: (attr: tree[], dic: fdic) => {
         let d = dic?.delim?.[0]?.value || "(";
         let o = { "(": ["(", ")"], "[": ["[", "]"], "{": ["{", "}"], "|": ["|", "|"], "||": ["‖", "‖"] };
@@ -484,7 +516,8 @@ let f = {
     },
     // 额外
     //
-    x_table: (attr: tree[]) => {
+    x_table: (attr: tree[], dic: fdic) => {
+        let max = 0;
         let t = createMath("mtable");
         for (let i of attr) {
             let r = createMath("mtr");
@@ -506,6 +539,8 @@ let f = {
                 result.push(tmp_group);
             }
 
+            if (result.length > max) max = result.length;
+
             for (let i of result) {
                 let d = createMath("mtd");
                 r.append(d);
@@ -514,6 +549,21 @@ let f = {
 
             t.append(r);
         }
+        let al = [];
+        if (dic.cases) {
+            // cases
+            al.push("left");
+        } else {
+            // 其他换行对齐 交替
+            for (let i = 0; i < max; i++) {
+                if (i % 2 == 0) {
+                    al.push("right");
+                } else {
+                    al.push("left");
+                }
+            }
+        }
+        t.setAttribute("columnalign", al.join(" "));
         return t;
     },
 };
@@ -558,8 +608,8 @@ let opl: { id: string; str?: string; limits?: boolean }[] = [
 ];
 function op_f() {
     for (let i of opl) {
-        f[i.id] = (attr: tree[]) => {
-            let s = f.op([[{ type: "str", value: i.str || i.id }]], {});
+        f[i.id] = (attr: tree[], a, b, e) => {
+            let s = f.op([[{ type: "str", value: i.str || i.id }]], {}, null, e);
             if (attr) {
                 let f = document.createDocumentFragment();
                 f.append(s, kh(attr[0]));
@@ -695,6 +745,13 @@ 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";
             }
         }
         if (x.type == "v" && limits_sy.includes(x.value)) {
@@ -709,6 +766,10 @@ function is_f_mark(x: tree[0], str: string) {
     return x.value == str && x.type == "v" && !x.esc;
 }
 
+function is_dot(x: tree[0]) {
+    return x && x.type == "v" && x.value == ".";
+}
+
 let dh: tree[0] = { type: "v", value: "," };
 
 function v_f(str: string): tree[0] {
@@ -733,31 +794,36 @@ 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;
+            }
+        }
+    }
+    return false;
+}
+
 function ast2(tree: tree) {
     // 处理数字和小数
     {
         let t: tree = [];
         let num = /[0-9]/;
         let number = "";
-        for (let i in tree) {
-            let n = Number(i);
+        for (let n = 0; n < tree.length; n++) {
             let x = tree[n];
-            if (
-                x.value.match(num) ||
-                (tree[n - 1] &&
-                    tree[n - 1].value.match(num) &&
-                    x.value == "." &&
-                    tree[n + 1] &&
-                    tree[n + 1].value.match(num))
-            ) {
+            if (x.value.match(num) || (tree[n - 1]?.value.match(num) && is_dot(x) && tree[n + 1]?.value.match(num))) {
                 number += x.value;
             } else {
                 t.push(x);
             }
             if (
                 x.value.match(num) &&
-                (!tree[n + 1] || !tree[n + 1].value.match(/[0-9]/)) &&
-                !(tree[n + 1]?.value == "." && tree[n + 2]?.value.match(num))
+                (!tree[n + 1] || !tree[n + 1].value.match(num)) &&
+                !(is_dot(tree[n + 1]) && tree[n + 2]?.value.match(num))
             ) {
                 t.push({ type: "v", value: number });
                 number = "";
@@ -769,13 +835,7 @@ function ast2(tree: tree) {
     // 处理符号简写（shorthand）
     {
         let t: tree = [];
-        let continue_c = 0;
-        for (let i in tree) {
-            if (continue_c > 0) {
-                continue_c--;
-                continue;
-            }
-            let n = Number(i);
+        for (let n = 0; n < tree.length; n++) {
             let x = tree[n];
 
             if (tree?.[n - 1]?.value != "\\") {
@@ -795,7 +855,7 @@ function ast2(tree: tree) {
                         t.push(nx);
 
                         // 不处理已经后面连起来的字符
-                        continue_c = l.at(-1).length - 1;
+                        n += l.at(-1).length - 1;
                     } else {
                         t.push(x);
                     }
@@ -812,13 +872,7 @@ function ast2(tree: tree) {
     // 处理\转义
     {
         let t: tree = [];
-        let continue_c = 0;
-        for (let i in tree) {
-            if (continue_c > 0) {
-                continue_c--;
-                continue;
-            }
-            let n = Number(i);
+        for (let n = 0; n < tree.length; n++) {
             let x = tree[n];
 
             if (x.value == "\\" && x.type == "v") {
@@ -826,20 +880,20 @@ function ast2(tree: tree) {
                     let next = tree[n + 1];
                     if (next.value == "\\" && next.type == "v") {
                         t.push({ type: "v", value: "\\" });
-                        continue_c = 1;
+                        n++;
                     } else if (next.type == "blank") {
                         t.push({ type: "v", value: "br", esc: true });
-                        continue_c = 1;
+                        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) });
-                        continue_c = 1;
+                        n++;
                     } else {
                         let v = next;
                         v.esc = true;
                         t.push(v);
-                        continue_c = 1;
+                        n++;
                     }
                 }
             } else {
@@ -849,16 +903,52 @@ function ast2(tree: tree) {
         tree = t;
     }
 
-    // 处理f
+    // 处理字符与v之间空格
+    {
+        let t: tree = [];
+        for (let n = 0; n < tree.length; n++) {
+            let x = tree[n];
+
+            if (x.type == "v" && tree?.[n + 1]?.type == "blank" && tree?.[n + 2]?.type == "str") {
+                t.push(x);
+                t.push({ type: "f", value: "space" });
+            } else if (x.type == "str" && tree?.[n + 1]?.type == "blank" && tree?.[n + 2]?.type == "v") {
+                t.push(x);
+                t.push({ type: "f", value: "space" });
+            } else {
+                t.push(x);
+            }
+        }
+        tree = t;
+    }
+
+    // 处理带.的f
     {
         let t: tree = [];
-        let continue_c = 0;
-        for (let i in tree) {
-            if (continue_c > 0) {
-                continue_c--;
+        let f = "";
+        for (let n = 0; n < tree.length; n++) {
+            let x = tree[n];
+
+            if (x.type == "f" && is_dot(tree[n + 1])) {
+                f += x.value + ".";
+                n++;
                 continue;
+            } else if (f && x.type == "f") {
+                f += x.value;
+                if (!is_dot(tree[n + 1])) {
+                    t.push({ type: "f", value: f });
+                    f = "";
+                }
+            } else {
+                t.push(x);
             }
-            let n = Number(i);
+        }
+        tree = t;
+    }
+    // 处理f
+    {
+        let t: tree = [];
+        for (let n = 0; n < tree.length; n++) {
             let x = tree[n];
 
             // 带有括号（参数）的函数
@@ -874,7 +964,7 @@ function ast2(tree: tree) {
                 t.push(x);
 
                 // 不处理group
-                continue_c = 1;
+                n++;
                 continue;
             } else {
                 t.push(x);
@@ -918,24 +1008,11 @@ function ast2(tree: tree) {
         }
 
         let t: tree = [];
-        let continue_c = 0;
-        for (let i in tree) {
-            if (continue_c > 0) {
-                continue_c--;
-                continue;
-            }
-            let n = Number(i);
-
+        for (let n = 0; n < tree.length; n++) {
             if (n == index?.[0]?.[0]) {
                 {
-                    let continue_c = 0;
                     let tmp: tree[0] = tree[index[0][1]];
                     for (let i = index[0][1]; i >= index[0][0]; i--) {
-                        if (continue_c > 0) {
-                            continue_c--;
-                            continue;
-                        }
-
                         if (tree[i - 1]?.value == "^" && tree[i - 3]?.value == "_") {
                             let o = is_limit([tree[i - 4]])
                                 ? { t: out_kh(tmp), b: out_kh(tree[i - 2]) }
@@ -945,7 +1022,7 @@ function ast2(tree: tree) {
                                 value: "attach",
                                 children: [tree[i - 4], dh, ...dic_to_ast(o)],
                             };
-                            continue_c = 4 - 1;
+                            i -= 4 - 1;
                             continue;
                         }
                         if (tree[i - 1]?.value == "_" && tree[i - 3]?.value == "^") {
@@ -957,7 +1034,7 @@ function ast2(tree: tree) {
                                 value: "attach",
                                 children: [tree[i - 4], dh, ...dic_to_ast(o)],
                             };
-                            continue_c = 4 - 1;
+                            i -= 4 - 1;
                             continue;
                         }
                         if (tree[i - 1]?.value == "^") {
@@ -967,7 +1044,7 @@ function ast2(tree: tree) {
                                 value: "attach",
                                 children: [tree[i - 2], dh, ...dic_to_ast(o)],
                             };
-                            continue_c = 2 - 1;
+                            i -= 2 - 1;
                             continue;
                         }
                         if (tree[i - 1]?.value == "_") {
@@ -977,18 +1054,18 @@ function ast2(tree: tree) {
                                 value: "attach",
                                 children: [tree[i - 2], dh, ...dic_to_ast(o)],
                             };
-                            continue_c = 2 - 1;
+                            i -= 2 - 1;
                             continue;
                         }
                     }
                     t.push(tmp);
                 }
-                continue_c = index[0][1] - index[0][0];
+                n += index[0][1] - index[0][0];
                 index = index.slice(1);
                 continue;
             }
 
-            t.push(tree[i]);
+            t.push(tree[n]);
         }
         tree = t;
     }
@@ -1012,31 +1089,18 @@ function ast2(tree: tree) {
         }
 
         let t: tree = [];
-        let continue_c = 0;
-        for (let i in tree) {
-            if (continue_c > 0) {
-                continue_c--;
-                continue;
-            }
-            let n = Number(i);
-
+        for (let n = 0; n < tree.length; n++) {
             if (n == index?.[0]?.[0]) {
                 {
-                    let continue_c = 0;
                     let tmp: tree[0] = tree[index[0][0]];
                     for (let i = index[0][0]; i <= index[0][1]; i++) {
-                        if (continue_c > 0) {
-                            continue_c--;
-                            continue;
-                        }
-
                         if (tree[i + 1]?.value == "/") {
                             tmp = {
                                 type: "f",
                                 value: "frac",
                                 children: [...out_kh(tmp), dh, ...out_kh(tree[i + 2])],
                             };
-                            continue_c = 2 - 1;
+                            i += 2 - 1;
                             continue;
                         }
                     }
@@ -1044,19 +1108,133 @@ function ast2(tree: tree) {
 
                     t.push(tmp);
                 }
-                continue_c = index[0][1] - index[0][0];
+                n += index[0][1] - index[0][0];
                 index.splice(0, 1);
                 continue;
             }
 
-            t.push(tree[i]);
+            t.push(tree[n]);
         }
         tree = t;
     }
     return tree;
 }
 
-function render(tree: tree) {
+function f_attr(x: tree[0]) {
+    let type: "dic" | "array" | "attr" = "array";
+    let attr: tree[] = [];
+    let dicl: tree[] = [];
+    let array: tree[][] = [];
+    let l: tree = [];
+    for (let i in x.children) {
+        const t = x.children[i];
+        if (Number(i) + 1 == x.children.length) {
+            if (t.type == "blank" && x.children[Number(i) - 1].value.match(/[,;]/)) break;
+            if (!is_f_mark(t, ",") && !is_f_mark(t, ";")) l.push(t);
+            if (type == "dic") {
+                dicl.push(l);
+                l = [];
+            } else {
+                attr.push(l);
+            }
+            if (array.length) {
+                array.push(attr);
+                attr = [];
+            }
+            l = [];
+        } else {
+            if (is_f_mark(t, ",")) {
+                if (type == "dic") {
+                    dicl.push(l);
+                    type = "array";
+                } else {
+                    attr.push(l);
+                }
+                l = [];
+            } else if (is_f_mark(t, ";")) {
+                // 存在; 则存好的attr为array的一个子元素
+                type == "array";
+                attr.push(l);
+                l = [];
+                array.push(attr);
+                attr = [];
+            } else {
+                // 按,拆分成段
+                l.push(t);
+                // 段中有: 为dic
+                if (is_f_mark(t, ":")) {
+                    type = "dic";
+                }
+            }
+        }
+    }
+
+    // 将dicl的tree转为键对
+    let dic: fdic = {};
+    for (let i of dicl) {
+        let n = "";
+        let t: tree = [];
+        for (let el of i) {
+            if (!n) {
+                n = el.value;
+            } else {
+                if (el.value != ":") t.push(el);
+            }
+        }
+        dic[n] = t;
+    }
+    return { attr, dic, array };
+}
+
+type fonts = "serif" | "sans" | "frak" | "mono" | "bb" | "cal";
+function font(str: string, type: fonts = "serif") {
+    function index_c(c: string) {
+        const l = "abcdefghijklmnopqrstuvwxyz";
+        return l.indexOf(c.toLowerCase());
+    }
+    switch (type) {
+        case "serif":
+            return str;
+        case "sans":
+            const s0 = [..."𝟢𝟣𝟤𝟥𝟦𝟧𝟨𝟩𝟪𝟫"];
+            const s1 = [..."𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"];
+            const s2 = [..."𝖠𝖡𝖢𝖣𝖤𝖥𝖦𝖧𝖨𝖩𝖪𝖫𝖬𝖭𝖮𝖯𝖰𝖱𝖲𝖳𝖴𝖵𝖶𝖷𝖸𝖹"];
+            str = str.replace(/[0-9]+/g, (s) => s0[s]);
+            str = str.replace(/[a-z]/g, (s) => s1[index_c(s)]);
+            str = str.replace(/[A-Z]/g, (s) => s2[index_c(s)]);
+            return str;
+        case "frak":
+            const frak1 = [..."𝔞𝔟𝔠𝔡𝔢𝔣𝔤𝔥𝔦𝔧𝔨𝔩𝔪𝔫𝔬𝔭𝔮𝔯𝔰𝔱𝔲𝔳𝔴𝔵𝔶𝔷"];
+            const frak2 = [..."𝔄𝔅ℭ𝔇𝔈𝔉𝔊ℌℑ𝔍𝔎𝔏𝔐𝔑𝔒𝔓𝔔ℜ𝔖𝔗𝔘𝔙𝔚𝔛𝔜ℨ"];
+            str = str.replace(/[a-z]/g, (s) => frak1[index_c(s)]);
+            str = str.replace(/[A-Z]/g, (s) => frak2[index_c(s)]);
+            return str;
+        case "mono":
+            const m0 = [..."0𝟷𝟸𝟹𝟺𝟻𝟼𝟽𝟾𝟿"];
+            const m1 = [..."𝚊𝚋𝚌𝚍𝚎𝚏𝚐𝚑𝚒𝚓𝚔𝚕𝚖𝚗𝚘𝚙𝚚𝚛𝚜𝚝𝚞𝚟𝚠𝚡𝚢𝚣"];
+            const m2 = [..."𝙰𝙱𝙲𝙳𝙴𝙵𝙶𝙷𝙸𝙹𝙺𝙻𝙼𝙽𝙾𝙿𝚀𝚁𝚂𝚃𝚄𝚅𝚆𝚇𝚈𝚉"];
+            str = str.replace(/[0-9]+/g, (s) => m0[s]);
+            str = str.replace(/[a-z]/g, (s) => m1[index_c(s)]);
+            str = str.replace(/[A-Z]/g, (s) => m2[index_c(s)]);
+            return str;
+        case "bb":
+            const bb0 = [..."𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡"];
+            const bb1 = [..."𝕒𝕓𝕔𝕕𝕖𝕗𝕘𝕙𝕚𝕛𝕜𝕝𝕞𝕟𝕠𝕡𝕢𝕣𝕤𝕥𝕦𝕧𝕨𝕩𝕪𝕫"];
+            const bb2 = [..."𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ"];
+            str = str.replace(/[0-9]+/g, (s) => bb0[s]);
+            str = str.replace(/[a-z]/g, (s) => bb1[index_c(s)]);
+            str = str.replace(/[A-Z]/g, (s) => bb2[index_c(s)]);
+            return str;
+        case "cal":
+            const c1 = [..."𝒶𝒷𝒸𝒹ℯ𝒻ℊ𝒽𝒾𝒿𝓀𝓁𝓂𝓃ℴ𝓅𝓆𝓇𝓈𝓉𝓊𝓋𝓌𝓍𝓎𝓏"];
+            const c2 = [..."𝒜ℬ𝒞𝒟ℰℱ𝒢ℋℐ𝒥𝒦ℒℳ𝒩𝒪𝒫𝒬ℛ𝒮𝒯𝒰𝒱𝒲𝒳𝒴𝒵"];
+            str = str.replace(/[a-z]/g, (s) => c1[index_c(s)]);
+            str = str.replace(/[A-Z]/g, (s) => c2[index_c(s)]);
+            return str;
+    }
+}
+
+function render(tree: tree, e?: fonts) {
     let fragment = document.createDocumentFragment();
 
     tree = ast2(tree);
@@ -1104,86 +1282,29 @@ function render(tree: tree) {
             let t: tree = [];
             t.push({ type: "f", value: "x_table", children: tree });
             tree = t;
+        } else {
+            let t: tree = [];
+            for (let x of tree) {
+                // 移除&
+                if (!(x.type == "v" && x.value == "&" && !x.esc)) {
+                    t.push(x);
+                }
+            }
+            tree = t;
         }
     }
 
-    let continue_c = 0;
     for (let i in tree) {
-        if (continue_c > 0) {
-            continue_c--;
-            continue;
-        }
         let n = Number(i);
         let x = tree[n];
 
         // 带有括号（参数）的函数
         if (x.type == "f" && x.children) {
-            let type: "dic" | "array" | "attr" = "array";
-            let attr: tree[] = [];
-            let dicl: tree[] = [];
-            let array: tree[][] = [];
-            let l: tree = [];
-            for (let i in x.children) {
-                const t = x.children[i];
-                if (Number(i) + 1 == x.children.length) {
-                    if (t.type == "blank" && x.children[Number(i) - 1].value.match(/[,;]/)) break;
-                    if (!is_f_mark(t, ",") && !is_f_mark(t, ";")) l.push(t);
-                    if (type == "dic") {
-                        dicl.push(l);
-                        l = [];
-                    } else {
-                        attr.push(l);
-                    }
-                    if (array.length) {
-                        array.push(attr);
-                        attr = [];
-                    }
-                    l = [];
-                } else {
-                    if (is_f_mark(t, ",")) {
-                        if (type == "dic") {
-                            dicl.push(l);
-                            type = "array";
-                        } else {
-                            attr.push(l);
-                        }
-                        l = [];
-                    } else if (is_f_mark(t, ";")) {
-                        // 存在; 则存好的attr为array的一个子元素
-                        type == "array";
-                        attr.push(l);
-                        l = [];
-                        array.push(attr);
-                        attr = [];
-                    } else {
-                        // 按,拆分成段
-                        l.push(t);
-                        // 段中有: 为dic
-                        if (is_f_mark(t, ":")) {
-                            type = "dic";
-                        }
-                    }
-                }
-            }
-
-            // 将dicl的tree转为键对
-            let dic: fdic = {};
-            for (let i of dicl) {
-                let n = "";
-                let t: tree = [];
-                for (let el of i) {
-                    if (!n) {
-                        n = el.value;
-                    } else {
-                        if (el.value != ":") t.push(el);
-                    }
-                }
-                dic[n] = t;
-            }
+            let { attr, dic, array }: { attr: tree[]; dic: fdic; array: tree[][] } = f_attr(x);
 
             if (f[x.value]) {
                 console.log(attr, dic, array);
-                let el = f[x.value](attr, dic, array);
+                let el = f[x.value](attr, dic, array, e);
                 fragment.append(el);
             } else if (ss[x.value]) {
                 let el = createMath("mo", ss[x.value]);
@@ -1194,36 +1315,53 @@ function render(tree: tree) {
         if (x.type == "f" && !x.children) {
             if (ss[x.value]) {
                 let tag: keyof MathMLElementTagNameMap;
-                if (x.value.match(/[a-zA-Z\u0391-\u03C9]/)) {
+                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",
+                };
+                if (ss[x.value].match(/[a-zA-Z\u0391-\u03C9]/)) {
                     tag = "mi";
+                } else if (space_width[ss[x.value]]) {
+                    tag = "mspace";
+                    space_w = { width: space_width[ss[x.value]] };
                 } else {
                     tag = "mo";
                 }
-                let el = createMath(tag, ss[x.value]);
+                let el = createMath(tag, ss[x.value], space_w);
                 fragment.append(el);
             } else {
                 if (f[x.value]) {
-                    let el = f[x.value]();
+                    let el = f[x.value](null, null, null, e);
                     fragment.append(el);
                 }
             }
         }
 
         if (x.type == "str") {
-            let el = createMath("ms", x.value);
+            let el = createMath("ms", font(x.value, e));
             fragment.append(el);
         }
 
         if (x.type == "v") {
             let tag: keyof MathMLElementTagNameMap;
-            if (x.value.match(/[0-9]+/)) {
+            if (x.value.match(/[0-9.]+/)) {
                 tag = "mn";
             } else if (x.value.match(/[a-zA-Z\u0391-\u03C9]/)) {
                 tag = "mi";
             } else {
                 tag = "mo";
             }
-            let el = createMath(tag, x.value);
+            let el = createMath(tag, font(x.value, e));
             fragment.append(el);
         }
 
@@ -1235,6 +1373,16 @@ function render(tree: tree) {
     return fragment;
 }
 
+var init_c = {
+    emoji: false,
+};
+
+function init(p: { emoji: boolean }) {
+    for (let i in p) {
+        if (init_c[i]) init_c[i] = p[i];
+    }
+}
+
 function toMML(str: string) {
     let obj = ast(str);
     console.log(obj);
@@ -1250,4 +1398,4 @@ function toMMLHTML(str: string) {
     return toMML(str).outerHTML;
 }
 
-export { toMML, toMMLHTML };
+export { init, toMML, toMMLHTML };