xmmath 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xmmath",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "",
     "main": "./dist/xmmath.umd.js",
     "module": "./dist/xmmath.es.js",
@@ -23,5 +23,8 @@
     "devDependencies": {
         "typescript": "^5.1.3",
         "vite": "^4.3.9"
+    },
+    "dependencies": {
+        "grapheme-splitter": "^1.0.4"
     }
 }

package/src/main.ts

@@ -50,8 +50,11 @@ function createMath(tagname: mathtag, innerText?: string, attr?: { [name: string
 
 const mathvariant = "mathvariant";
 
+import GraphemeSplitter from "grapheme-splitter";
+var splitter = new GraphemeSplitter();
+
 type vtype = "" | "str" | "v" | "f" | "blank" | "group";
-type tree = { type: vtype; value: string; children?: tree }[];
+type tree = { type: vtype; value: string; children?: tree; esc?: boolean }[];
 
 function ast(str: string) {
     let v = /[a-zA-Z.]/;
@@ -63,6 +66,11 @@ function ast(str: string) {
     let now_tree = o;
     let tmp_str = "";
 
+    str = str.replace(/(\\u\{[\dA-Fa-f]+\})/g, (v) => {
+        const codePoint = parseInt(v.slice(3, -1), 16);
+        return String.fromCodePoint(codePoint);
+    });
+
     let lkh_stack: number[] = [];
     let rkh_stack: number[] = [];
     for (let i = 0; i < str.length; i++) {
@@ -87,22 +95,23 @@ function ast(str: string) {
             if (lkh_stack.length == 0) {
                 rkh_stack.push(i);
             } else {
-                lkh_stack.pop();
+                if (str[i - 1] != "\\") lkh_stack.pop();
             }
         }
     }
 
     let continue_c = 0;
 
-    for (let i = 0; i < str.length; i++) {
+    let strl = splitter.splitGraphemes(str);
+    for (let i = 0; i < strl.length; i++) {
         if (continue_c > 0) {
             continue_c--;
             continue;
         }
 
-        const t = str[i];
+        const t = strl[i];
         // 字符
-        if (t == '"' && str[i - 1] != "\\") {
+        if (t == '"' && strl[i - 1] != "\\") {
             if (type != "str") {
                 type = "str";
             } else {
@@ -126,19 +135,11 @@ function ast(str: string) {
             type = "";
         }
 
-        if (t == "\\") {
-            if (str[i + 1] == "\\") {
-                continue_c = 1;
-                now_tree.push({ type: "v", value: t });
-            }
-            continue;
-        }
-
         // 原始值（字母变量、数字、符号）
         if (
             type == "" &&
-            (!str[i - 1] || !str[i - 1].match(v)) &&
-            (!str[i + 1] || !str[i + 1].match(v)) &&
+            (!strl[i - 1] || !strl[i - 1].match(v)) &&
+            (!strl[i + 1] || !strl[i + 1].match(v)) &&
             !t.match(kh)
         ) {
             now_tree.push({ type: "v", value: t });
@@ -150,20 +151,20 @@ function ast(str: string) {
         }
 
         // 函数名
-        if (((str[i - 1] && str[i - 1].match(v)) || (str[i + 1] && str[i + 1].match(v))) && t.match(v)) {
+        if (((strl[i - 1] && strl[i - 1].match(v)) || (strl[i + 1] && strl[i + 1].match(v))) && t.match(v)) {
             type = "f";
         }
         if (type == "f") {
             tmp_str += t;
         }
-        if (type == "f" && (!str[i + 1] || !str[i + 1].match(v))) {
+        if (type == "f" && (!strl[i + 1] || !strl[i + 1].match(v))) {
             now_tree.push({ type, value: tmp_str });
             type = "";
             tmp_str = "";
         }
 
         if (t == "(") {
-            if (lkh_stack.includes(i)) {
+            if (lkh_stack.includes(i) || strl[i - 1] == "\\") {
                 now_tree.push({ type: "v", value: t });
             } else {
                 p_tree.push({ tree: now_tree, close: false });
@@ -194,6 +195,86 @@ import symbols from "./symbols.json?raw";
 /** @see https://github.com/typst/typst/blob/6c542ea1a4a0ee85069dad6974ff331851eff406/library/src/symbols/sym.rs */
 let s = JSON.parse(symbols);
 
+// symbols路径简写
+let ss: { [id: string]: string } = {};
+for (let i in s) {
+    if (typeof s[i] == "string") {
+        ss[i] = s[i];
+    } else {
+        for (let objOrStr of s[i]) {
+            // 第二层的array
+            if (typeof objOrStr == "string") {
+                ss[i] = objOrStr;
+            } else {
+                if (!ss[i]) ss[i] = objOrStr[Object.keys(objOrStr)[0]];
+                for (let j in objOrStr) {
+                    // 第三层的obj
+                    ss[`${i}.${j}`] = objOrStr[j];
+                    // 允许部分索引，但要保证唯一
+                    let l = j.split(".");
+                    for (let n = 1; n < l.length; n++) {
+                        let shotKey = l.slice(0, n).join(".");
+                        if (!objOrStr[shotKey]) {
+                            ss[`${i}.${shotKey}`] = objOrStr[j];
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+let shorthand = {
+    "->": "arrow.r",
+    "|->": "arrow.r.bar",
+    "=>": "arrow.r.double",
+    "|=>": "arrow.r.double.bar",
+    "==>": "arrow.r.double.long",
+    "-->": "arrow.r.long",
+    "~~>": "arrow.r.long.squiggly",
+    "~>": "arrow.r.squiggly",
+    ">->": "arrow.r.tail",
+    "->>": "arrow.r.twohead",
+    "<-": "arrow.l",
+    "<==": "arrow.l.double.long",
+    "<--": "arrow.l.long",
+    "<~~": "arrow.l.long.squiggly",
+    "<~": "arrow.l.squiggly",
+    "<-<": "arrow.l.tail",
+    "<<-": "arrow.l.twohead",
+    "<->": "arrow.l.r",
+    "<=>": "arrow.l.r.double",
+    "<==>": "arrow.l.r.double.long",
+    "<-->": "arrow.l.r.long",
+    "*": "convolve",
+    "||": "bar.v.double",
+    "[|": "bracket.l.double",
+    "|]": "bracket.r.double",
+    ":=": "colon.eq",
+    "::=": "colon.double.eq",
+    "--": "dash.en",
+    "---": "dash.em",
+    "...": "dots.h",
+    "=:": "eq.colon",
+    "!=": "eq.not",
+    ">>": "gt.double",
+    ">=": "gt.eq",
+    ">>>": "gt.triple",
+    "-?": "hyph.soft",
+    "<<": "lt.double",
+    "<=": "lt.eq",
+    "<<<": "lt.triple",
+    "-": "minus",
+    "'": "prime",
+    "~": "space.nobreak",
+};
+let max_shorthand_len = 0;
+for (let i in shorthand) {
+    if (i.length > max_shorthand_len) {
+        max_shorthand_len = i.length;
+    }
+}
+
 let f = {
     accent: (attr: tree[], dic: fdic) => {
         let base = createMath("mrow");
@@ -380,22 +461,22 @@ let f = {
         return f;
     },
     underline: (attr: tree[], dic: fdic) => {
-        return underover_f("under", attr[0], "_", attr?.[1]?.[0]?.value);
+        return underover_f("under", attr[0], "_", attr?.[1]);
     },
     overline: (attr: tree[], dic: fdic) => {
-        return underover_f("over", attr[0], "‾", attr?.[1]?.[0]?.value);
+        return underover_f("over", attr[0], "‾", attr?.[1]);
     },
     underbrace: (attr: tree[], dic: fdic) => {
-        return underover_f("under", attr[0], "⏟", attr?.[1]?.[0]?.value);
+        return underover_f("under", attr[0], "⏟", attr?.[1]);
     },
     overbrace: (attr: tree[], dic: fdic) => {
-        return underover_f("over", attr[0], "⏞", attr?.[1]?.[0]?.value);
+        return underover_f("over", attr[0], "⏞", attr?.[1]);
     },
     underbracket: (attr: tree[], dic: fdic) => {
-        return underover_f("under", attr[0], "⎵", attr?.[1]?.[0]?.value);
+        return underover_f("under", attr[0], "⎵", attr?.[1]);
     },
     overbracket: (attr: tree[], dic: fdic) => {
-        return underover_f("over", attr[0], "⎴", attr?.[1]?.[0]?.value);
+        return underover_f("over", attr[0], "⎴", attr?.[1]);
     },
     serif: (attr: tree[], dic: fdic) => {},
     sans: (attr: tree[], dic: fdic) => {},
@@ -420,6 +501,15 @@ let f = {
     },
     // 额外
     //
+    x_table: (attr: tree[]) => {
+        let t = createMath("mtable");
+        for (let i of attr) {
+            let r = createMath("mtr");
+            r.append(render(i));
+            t.append(r);
+        }
+        return t;
+    },
 };
 
 let opl: { id: string; str?: string; limits?: boolean }[] = [
@@ -476,6 +566,16 @@ function op_f() {
 }
 op_f();
 
+let limits_f = [];
+let limits_sy = ["∏", "∐", "∑", "⋀", "⋁", "⋂", "⋃", "⨀", "⨁", "⨂", "⨃", "⨄", "⨅", "⨆"];
+for (let i in ss) {
+    for (let j of limits_sy) {
+        if (ss[i] == j) {
+            limits_f.push(i);
+        }
+    }
+}
+
 function accent_f() {
     const l = [
         "grave",
@@ -520,31 +620,33 @@ function lr_f() {
 }
 lr_f();
 
-function underover_f(type: "under" | "over", tree: tree, x: string, str?: string) {
+function underover_f(type: "under" | "over", tree: tree, x: string, str?: tree) {
     let m =
         type == "under"
             ? createMath("munder", null, { accentunder: "true" })
             : createMath("mover", null, { accent: "true" });
     let base = createMath("mrow");
     base.append(render(tree));
-    let xx = createMath("mo", x);
-    m.append(base, xx);
     if (str) {
-        let s = createMath("ms", str);
-
+        let s = createMath("mrow");
+        s.append(render(str));
         let mm = type == "under" ? createMath("munder") : createMath("mover");
-        mm.append(m, s);
-        return mm;
+        let xx = createMath("mo", x);
+        mm.append(xx, s);
+        m.append(base, mm);
+    } else {
+        let xx = createMath("mo", x);
+        m.append(base, xx);
     }
     return m;
 }
 
 function kh(tree: tree) {
-    let f = document.createDocumentFragment();
-    let l = createMath("ms");
+    let f = createMath("mrow");
+    let l = createMath("mo");
     l.innerText = "(";
     let c = render(tree);
-    let r = createMath("ms");
+    let r = createMath("mo");
     r.innerText = ")";
     f.append(l, c, r);
     return f;
@@ -558,11 +660,26 @@ function out_kh(x: tree[0]) {
     }
 }
 
+function in_kh(x: tree) {
+    let k: tree = [{ type: "group", value: "", children: x }];
+    return k;
+}
+
+function is_frac(x: tree[0]) {
+    if (!x) return false;
+    return x.value == "/" && !x.esc;
+}
+
+function is_br(x: tree[0]) {
+    if (!x) return false;
+    return x.value == "br" && x.esc;
+}
+
 function is_limit(tree: tree) {
     if (tree.length == 1) {
         let x = tree[0];
         if (x.type == "f") {
-            if (x.value == "sum" || x.value == "limits") {
+            if (limits_f.includes(x.value)) {
                 return true;
             }
             for (let i of opl) {
@@ -574,11 +691,18 @@ function is_limit(tree: tree) {
             if (x.value == "op") {
             }
         }
+        if (x.type == "v" && limits_sy.includes(x.value)) {
+            return true;
+        }
     } else {
         return false;
     }
 }
 
+function is_f_mark(x: tree[0], str: string) {
+    return x.value == str && x.type == "v" && !x.esc;
+}
+
 let dh: tree[0] = { type: "v", value: "," };
 
 function v_f(str: string): tree[0] {
@@ -600,9 +724,7 @@ function dic_to_ast(dic: { [id: string]: tree }) {
     return l;
 }
 
-function render(tree: tree) {
-    let fragment = document.createDocumentFragment();
-
+function ast2(tree: tree) {
     // 处理数字和小数
     {
         let t: tree = [];
@@ -635,6 +757,89 @@ function render(tree: tree) {
         tree = t;
     }
 
+    // 处理符号简写（shorthand）
+    {
+        let t: tree = [];
+        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 (tree?.[n - 1]?.value != "\\") {
+                if (x.type == "v") {
+                    let nn = n;
+                    let shortkey = x.value;
+                    let l = [];
+                    if (shorthand[shortkey]) l.push(shortkey);
+                    // 连起来的字符
+                    while (tree?.[nn + 1]?.type == "v" && shortkey.length <= max_shorthand_len) {
+                        shortkey += tree[nn + 1].value;
+                        if (shorthand[shortkey]) l.push(shortkey);
+                        nn++;
+                    }
+                    if (l.length) {
+                        let nx: tree[0] = { type: "f", value: shorthand[l[l.length - 1]] };
+                        t.push(nx);
+
+                        // 不处理已经后面连起来的字符
+                        continue_c = l[l.length - 1].length - 1;
+                    } else {
+                        t.push(x);
+                    }
+                } else {
+                    t.push(x);
+                }
+            } else {
+                t.push(x);
+            }
+        }
+        tree = t;
+    }
+
+    // 处理\转义
+    {
+        let t: tree = [];
+        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.value == "\\" && x.type == "v") {
+                if (tree?.[n + 1]) {
+                    let next = tree[n + 1];
+                    if (next.value == "\\" && next.type == "v") {
+                        t.push({ type: "v", value: "\\" });
+                        continue_c = 1;
+                    } else if (next.type == "blank") {
+                        t.push({ type: "v", value: "br", esc: true });
+                        continue_c = 1;
+                    } 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;
+                    } else {
+                        let v = next;
+                        v.esc = true;
+                        t.push(v);
+                        continue_c = 1;
+                    }
+                }
+            } else {
+                t.push(x);
+            }
+        }
+        tree = t;
+    }
+
     // 处理f
     {
         let t: tree = [];
@@ -650,6 +855,13 @@ function render(tree: tree) {
             // 带有括号（参数）的函数
             if (x.type == "f" && tree[n + 1] && 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;
+                        }
+                    }
+                }
                 t.push(x);
 
                 // 不处理group
@@ -763,6 +975,7 @@ function render(tree: tree) {
                     t.push(tmp);
                 }
                 continue_c = index[0][1] - index[0][0];
+                index = index.slice(1);
                 continue;
             }
 
@@ -778,11 +991,11 @@ function render(tree: tree) {
         let start = NaN;
         for (let n = 0; n < tree.length; n++) {
             const x = tree[n];
-            if (x.value != "/") {
-                if (tree[n + 1]?.value == "/" && !(tree[n - 1]?.value == "/")) {
+            if (!is_frac(x)) {
+                if (is_frac(tree[n + 1]) && !is_frac(tree[n - 1])) {
                     if (!start) start = n;
                 }
-                if (tree[n - 1]?.value == "/" && !(tree[n + 1]?.value == "/")) {
+                if (is_frac(tree[n - 1]) && !is_frac(tree[n + 1])) {
                     index.push([start, n]);
                     start = NaN;
                 }
@@ -831,6 +1044,59 @@ function render(tree: tree) {
         }
         tree = t;
     }
+    return tree;
+}
+
+function render(tree: tree) {
+    let fragment = document.createDocumentFragment();
+
+    tree = ast2(tree);
+
+    // 处理\ 换行
+    {
+        let xx = false;
+        let w = (tree: tree) => {
+            for (let i of tree) {
+                if (is_br(i)) {
+                    xx = true;
+                    return;
+                }
+                if (i.type == "group") {
+                    w(i.children);
+                }
+            }
+        };
+        w(tree);
+        if (xx) {
+            // 移除group
+            {
+                let t: tree = [];
+                for (let i in tree) {
+                    let x = tree[i];
+                    // 不作为group，只是数学上显示的括号对
+                    if (x.type == "group") {
+                        t.push(v_f("("));
+                        t.push(...ast2(x.children));
+                        t.push(v_f(")"));
+                    } else {
+                        t.push(x);
+                    }
+                }
+                tree = t;
+            }
+            // 将换行替换成逗号传入函数
+            for (let n = 0; n < tree.length; n++) {
+                const x = tree[n];
+                if (is_br(x)) {
+                    tree[n] = dh;
+                }
+            }
+
+            let t: tree = [];
+            t.push({ type: "f", value: "x_table", children: tree });
+            tree = t;
+        }
+    }
 
     let continue_c = 0;
     for (let i in tree) {
@@ -852,7 +1118,7 @@ function render(tree: tree) {
                 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 (t.value != "," && t.value != ";") l.push(t);
+                    if (!is_f_mark(t, ",") && !is_f_mark(t, ";")) l.push(t);
                     if (type == "dic") {
                         dicl.push(l);
                         l = [];
@@ -865,7 +1131,7 @@ function render(tree: tree) {
                     }
                     l = [];
                 } else {
-                    if (t.value == ",") {
+                    if (is_f_mark(t, ",")) {
                         if (type == "dic") {
                             dicl.push(l);
                             l = [];
@@ -873,7 +1139,7 @@ function render(tree: tree) {
                             attr.push(l);
                         }
                         l = [];
-                    } else if (t.value == ";") {
+                    } else if (is_f_mark(t, ";")) {
                         // 存在; 则存好的attr为array的一个子元素
                         type == "array";
                         attr.push(l);
@@ -884,7 +1150,7 @@ function render(tree: tree) {
                         // 按,拆分成段
                         l.push(t);
                         // 段中有: 为dic
-                        if (t.value == ":") {
+                        if (is_f_mark(t, ":")) {
                             type = "dic";
                         }
                     }
@@ -910,47 +1176,15 @@ function render(tree: tree) {
                 console.log(attr, dic, array);
                 let el = f[x.value](attr, dic, array);
                 fragment.append(el);
+            } else if (ss[x.value]) {
+                let el = createMath("mo", ss[x.value]);
+                fragment.append(el, render(in_kh(x.children)));
             }
         }
 
         if (x.type == "f" && !x.children) {
-            let l = x.value.split(".");
-            if (s[l[0]]) {
-                let v = "";
-                if (l.length == 1) {
-                    if (typeof s[l[0]] == "string") {
-                        v = s[l[0]];
-                    } else {
-                        // 获取第一个元素值
-                        let o = s[l[0]][0];
-                        if (typeof o == "string") {
-                            v = o;
-                        } else {
-                            v = Object.values(o)[0] as string;
-                        }
-                    }
-                } else {
-                    let p = l.slice(1).join(".");
-                    for (let i of s[l[0]]) {
-                        if (typeof i == "object") {
-                            l: for (let k of Object.keys(i)) {
-                                if (k == p) {
-                                    v = i[k];
-                                    break l;
-                                } else {
-                                    let ll = k.split(".");
-                                    for (let n = 1; n < ll.length; n++) {
-                                        if (p == ll.slice(0, n).join(".")) {
-                                            v = i[k];
-                                            break l;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                let el = createMath("mo", v);
+            if (ss[x.value]) {
+                let el = createMath("mo", ss[x.value]);
                 fragment.append(el);
             } else {
                 if (f[x.value]) {

package/test/text.html

@@ -11,18 +11,21 @@
 
     <script src="../dist/xmmath.umd.js"></script>
     <script>
-        let l = ['a', '"a"', "sin(theta)", "()()(())(", "))", "1^2_3_4^5_6_7", "attach(Pi, t: alpha, b: beta,tl: 1, tr: 2+3, bl: 4+5, br: 6,)"]
-        for (let i of l) {
-            let div = document.createElement('div')
-            div.innerHTML = xmmath.toMMLHTML(i)
-            document.body.append(div)
-        }
         let text = document.querySelector('textarea')
         let div = document.createElement('div')
         document.body.append(div)
         text.oninput = () => {
             div.innerHTML = xmmath.toMMLHTML(text.value)
         }
+        let l = ['x^2y^2', 'attach(F,bl:2,br:3)', "(x+y^2)/(k+1)", "x+y^(2/(k+1))", 'a/(b\\/2)', "a_0+1/(a_1+1/(a_2+1/(a_3+1/a_4)))", "attach(Pi, t: alpha, b: beta,tl: 1, tr: 2+3, bl: 4+5, br: 6,)", `binom(n,k\\/2)`, `binom(p,2)x^2y^(p-2)-1/(1-x) 1/(1-x^2)`, `sum_(0<=i<=m\\ 0<j<n) P(i,j)`, `x^(2y)`, `sum^p_(i=1)sum^q_(j=1)sum^r_(k=1) a_(i j)b_(j k)c_(k i)`, 'sqrt(1+sqrt(1+sqrt(1+sqrt(1+sqrt(1+sqrt(1+sqrt(1+x)))))))', '(diff^2/(diff x^2)+diff^2/(diff y^2))abs(phi (x+"i" y))^2=0', '2^2^2^x', 'integral^x_1(d t)/t', 'integral integral_D d x d y', 'f(x)=cases(1 \\/ 3 "if" 0<= x <=1";",2\\/3 "if"3<=x<=4";")', 'overbrace(x+dots+x,k"times")', 'sum_(p"prime")f(p)=integral_(t>1)f(t)d Pi(t)', '{underbrace(overbrace(a\\,dots\\,a),overbrace(b\\,dots\\,b))}', 'mat(mat(a,b;c,d),mat(e,f;g,h);0,mat(i,j;k,l))', 'det mat(delim:"|",c_0,c_1,c_2,dots,c_n;c_1)>0', 'y_x_2', 'x^31415_92+Pi', 'x^(z^c_d)_(y^a_b)', "y^(''')_3", 'lim_(n->+oo)sqrt(2Pi n)/(n!)(n/e)^n=1', 'det(A)=sum_(sigma in S_n)epsilon.alt(sigma)product^n_(i=1)a_(i,sigma_i)']
+        for (let i of l) {
+            let div = document.createElement('div')
+            let p = document.createElement('pre')
+            p.innerText = i
+            div.append(p)
+            div.insertAdjacentHTML('beforeend', xmmath.toMMLHTML(i))
+            document.body.append(div)
+        }
     </script>
 </body>