efront 4.34.1 → 4.35.0

package/coms/basic/math.js

@@ -0,0 +1,321 @@
+var mo2 = (o, b) => `<mo>${o}</mo>${b}`;
+var mo3 = (o, args) => args.length === 1 ? args[0] + `<ms>${o}</ms>` : args.join(`<mo>${o}</mo>`);
+var ms = s => `<ms>${s}</ms>`;
+var mroot = (d, z) => `<mroot>${d}${z}</mroot>`;
+var msqrt = a => `<msqrt>${a}</msqrt>`;
+var mi = s => `<mi>${s}</mi>`;
+var mn = s => `<mn>${s}</mn>`;
+var mi2 = (s, a, n) => {
+    s = n ? `<msup><mi>${s}</mi>${n}</msup>` : `<mi>${s}</mi>`;
+    return s + `<ms>&thinsp;</ms>` + a;
+}
+var mrow = (a, quote, deep) => {
+    if (deep === 2) var tag = 'mtd';
+    else tag = 'mrow';
+    if (quote === true) a = `<${tag}><mi>(</mi>${a}<mi>)</mi></${tag}>`;
+    else if (quote === false) a = `<${tag}>${a}</${tag}>`;
+    else if (deep === 2) a = `<mtd>${a}</mtd>`;
+    return a;
+}
+var series =/*级数*/(通项, neq, to) =>
+    `<munderover><mo>∑</mo>${neq}${to}</munderover>${通项}`;
+var msub = (a, n) => `<msub>${a}${n}</msub>`;
+var qt = (t, a, args) => {
+    var b = args.shift();
+    a = t(a, b);
+    while (args.length) {
+        a = `<mrow><mo>(</mo>${a}<mo>)</mo></mrow>`;
+        b = args.shift();
+        a = t(a, b);
+    }
+    return a;
+}
+
+var 三角函数 = {
+    "sin"(a, n) {
+        return mi2("sin", a, n);
+    },
+    "cos"(a, n) {
+        return mi2("cos", a, n);
+    },
+    "tan"(a, n) {
+        return mi2("tan", a, n);
+    },
+    "cot"(a, n) {
+        return mi2("cot", a, n);
+    },
+    "sec"(a, n) {
+        return mi2("sec", a, n);
+    },
+    "csc"(a, n) {
+        return mi2("csc", a, n);
+    },
+};
+
+var funcmap = {
+    "+"(...args) {
+        return mo3("+", args);
+    },
+    "-"(...args) {
+        return mo3("–", args);
+    },
+    "*"(...args) {
+        return args.join("");
+    },
+    "vector"(name, ...args) {
+        name = `<mover>${name}<mo>→</mo></mover>`;
+        if (args.length) {
+            name += `<mrow><mi>(</mi>${args.join("<mo>,</mo>")}<mi>)</mi></mrow>`
+        }
+        return name;
+    },
+    "MUL"(...args) {
+        return args.join('');
+    },
+    mul(...args) {
+        return mo3("×", args);
+    },
+    Mul(...args) {
+        return mo3("·", args);
+    },
+    abs(a) {
+        return `<mo>|</mo>${a}<mo>|</mo>`;
+    },
+    "div"(...args) {
+        return mo3("÷", args);
+    },
+    "\\"(a, ...args) {
+        return qt((a, b) => `<msup>${a}<mn>-1</mn></msup>${b}`, a, args);
+    },
+    '.*'(...args) {
+        return args.join('<mo>·</mo>');
+    },
+    "="(...args) {
+        return mo3("=", args);
+    },
+    limit(a, x, n) {
+        return `<munder><ms>limit</ms><mrow>${x}<mo>→</mo>${n}</mrow></munder>${a}`
+    },
+    sigma: series,
+    series,
+    '!='(...args) {
+        return mo3("≉", args);
+    },
+    '!=='(...args) {
+        return mo3("≢", args);
+    },
+    "~="(...args) {
+        return mo3("≈", args);
+    },
+    "integral"(a, b = '', c = '') {
+        return `<msubsup><mo>∫</mo>${b}${c}</msubsup>${a}`;
+    },
+    "'"(...args) {
+        var b = args.pop();
+        if (!args.length) return `<msup>${b}<mo>'</mo></msup>`;// 转置
+        // 导数
+        return args.map((a) => `${a}<mo>'</mo>`).join('') + `<mi>(</mi>${b}<mi>)</mi>`;
+    },
+    "!"(...args) {
+        return args.map(a => a + `<mo>!</mo>`).join('');
+    }
+};
+var unary = (u, a) => `<ms>${u}</ms>${a}`;
+var unarymap = {
+    "+"(a) {
+        return unary("+", a);
+    },
+    "!"(a) {
+        return unary("!", a);
+    },
+    "-"(a) {
+        return unary("–", a);
+    },
+    "~"(a) {
+        return unary("~", a);
+    },
+};
+var puncmap = {
+    "**"(a, ...args) {
+        return qt((a, b) => `<msup>${a}${b}</msup>`, a, args);
+    },
+    "/"(a, ...args) {
+        while (args.length) {
+            var b = args.shift();
+            a = `<mfrac>${a}${b}</mfrac>`;
+        }
+        return a;
+    },
+    "sqrt"(a) {
+        return msqrt(a);
+    },
+    "root"(d, z) {
+        return mroot(d, z);
+    },
+    "√‌"(z, d) {
+        if (z) return mroot(d, z);
+        return msqrt(d);
+    },
+    "_"(a, ...args) {
+        return qt(msub, a, args);
+    },
+
+    // "积分": "∫",
+    // "summa": "∫",
+    // "sigma": "∑",
+    // "求和": "∑",
+    // "-+": "±",
+    // "pi": '∏',
+    // "直积": '∏',
+    // "any": "∀",
+    // "任意": "∀",
+    // "exist": "∃",
+    // "存在": "∃",
+    // "!<": "≮",
+    // "!>": "≯",
+    // ">=": "≥",
+    // "<=": '≤',
+};
+var pmap = {};
+
+[
+    '=,+=,-=,*=,/=,%=,|=,&=,^=,||=,&&=,??=,<<=,>>=,>>>=,**=,~=,:=,?,:,=>'/* 1 */,
+    '&&,||,^^,??'/* 3 */, '|,^'/* 4 */, '&'/*5*/,
+    'instanceof,in,==,>=,<=,>,<,!=,!==,===,!in,!instanceof'/* 6 */,
+    '>>,>>>,<<'/* 7 */, '+,-'/* 8 */, '*,/,%'/* 9 */, '**'/* 10 */,
+    '++,--'/* 11 */,
+    "typeof,await,yield,delete,void,..."/*12*/,
+    '!,~,#,new'/* 13 */,
+    "::,?.,->,."/*14*/,
+].forEach((pp, i) => {
+    pp.split(",").forEach(p => {
+        pmap[p] = i + 1;
+    })
+});
+
+var 希腊 = {
+    alpha: "α", Alpha: "Α",
+    beta: "β", Beta: "Β",
+    gamma: "γ", Gamma: "‌Γ",
+    delta: "δ‌", Delta: "Δ",
+    epsilon: "ε", Epsilon: "Ε",
+    zeta: "ζ‌", Zeta: "Ζ",
+    eta: "η‌", Eta: "Η",
+    theta: "θ", Theta: "Θ",
+    iota: "ι", Iota: "Ι",
+    kappa: 'κ', Kappa: 'Κ',
+    lambda: 'λ‌', Lambda: '‌Λ',
+    mu: 'μ', Mu: 'Μ',
+    nu: 'ν', Nu: 'Ν',
+    xi: 'ξ‌', Xi: '‌Ξ',
+    omicron: 'ο', Omicron: 'Ο',
+    pi: 'π‌', Pi: '‌Π',
+    rho: 'ρ', Rho: 'Ρ',
+    sigma: 'σ', Sigma: 'Σ',
+    tau: 'τ', Tau: 'Τ',
+    upsilon: 'υ', Upsilon: 'Υ',
+    phi: 'φ', Phi: 'Φ',
+    chi: 'χ‌', Chi: 'Χ',
+    psi: 'ψ', Psi: 'Ψ',
+    omega: 'ω', Omega: '‌Ω',
+};
+var lineBroken = false;
+var br = function () {
+    lineBroken = true;
+    return '</mtd></mtr><mtr><mtd>';
+};
+function toString(obj, p, deep) {
+    if (obj instanceof Array) {
+        deep++;
+        var args = obj.map(a => toString(a, deep > 1 ? 0 : p, deep));
+        deep--;
+        if (args instanceof Array) {
+            if (deep > 2) {
+                if (args.length > 1) args = `<mrow><mo>(</mo>${args.join('<mo>,</mo>')}<mo>)</mo></mrow>`;
+            }
+            else if (deep === 2) {
+                args = `<mtd>${args.join('</mtd><mtd>')}</mtd>`;
+            }
+            else if (deep === 1) {
+                args = `<mrow><mo>[</mo><mtable><mtr>${args.join("</mtr><mtr>")}</mtr></mtable><mo>]</mo></mrow>`;
+            }
+        }
+        return args;
+    }
+    var res;
+    if (obj instanceof Object) {
+        for (var k in obj) break;
+        if (!k) return '';
+        var origin = obj[k];
+        if (k in 三角函数) {
+            var args = origin.map(a => toString(a, pmap["*"], 0));
+            obj = 三角函数[k](...args);
+            return mrow(三角函数[k](...args), p >= pmap["**"], deep);
+        }
+        var args = toString(origin, pmap[k], 0);
+        var addqt = pmap[k] < p && p < pmap["**"];
+        if (args instanceof Array) {
+            var f = funcmap[k];
+            if (!f) {
+                addqt = -1;
+                f = puncmap[k];
+            }
+        }
+        else f = unarymap[k];
+        if (!f) {
+            return mrow(`<mi>${k}</mi>${mrow(args instanceof Array ? args.join('<mo>,</mo>') : args, true)}`, false, deep);
+        }
+        if (args instanceof Array) {
+            if (k === '*') {
+                var allnum = true;
+                var bx = 1;
+                var simple = true;
+                for (var cx = 0, dx = args.length; cx < dx; cx++) {
+                    if (typeof origin[cx] !== 'number') {
+                        allnum = false;
+                        if (cx > bx) {
+                            while (bx < cx) {
+                                args[bx] = args[bx] + "<mo>·</mo>";
+                                bx++;
+                            }
+                        }
+                        bx = cx;
+                    }
+                }
+                if (allnum) {
+                    return mrow(funcmap.mul(...args), false, deep);
+                }
+            }
+            return mrow(f(...args), addqt, deep);
+        }
+        return mrow(f(args), addqt, deep);
+    }
+    var isCap = /^[A-Z]/.test(obj);
+    obj = 希腊[obj] || obj;
+    if (typeof obj === "number") {
+        if (obj === Infinity) obj = '∞';
+        return mrow(mn(obj), -1, deep);
+    }
+    if (/^[\s,;]+$/.test(obj)) {
+        obj = obj.replace(/(\r\n|\r|\n)/g, br)
+        if (lineBroken) return obj;
+        obj = obj.replace(/\s/g, '&ensp;');
+        return `<mtext>${obj}</mtext>`;
+    }
+    if (isCap && obj.length === 1) return mrow(ms(obj), -1, deep);
+    obj = String(obj).replace(/\-/g, '–');
+    return mrow(obj ? mi(obj) : '', -1, deep);
+}
+function math(mathObj) {
+    if (mathObj.tagName) return mathObj;
+    lineBroken = false;
+    var res = [];
+    for (var a of arguments) {
+        res.push(toString(a, 0, 1));
+    }
+    res = res.join('');
+    if (lineBroken) {
+        res = `<mtable style="text-align:justify"><mtr><mtd>${res}</mtd></mtr></mtable>`;
+    }
+    return `<math>${res}</math>`;
+}

package/coms/basic/math.md

@@ -0,0 +1,265 @@
+# 数学公式生成工具
+使用方法有如下两种：
+1. 直接传入解析结构
+```javascript
+// 运算符或函数用大括号的对象表式层级，运算符或函数名放在对象的属性名位置，参数放在属性值的位置
+var obj={
+    "*":["左边","右边"],
+};
+// 勾股定理可以表示为如下形式
+var obj={
+    "=":[
+        {"+":[
+            {"**": ["a",2]},
+            {"**": ["b",2]}
+        ]},
+        {            "**":["c",2] }
+    ]
+};
+// 海伦-秦九韶公式可以表式为如下形式
+var obj = {
+    "=": [
+        "S",
+        {
+            "sqrt": {
+                "*": [
+                    "p",
+                    { "-": ["p", "a"] },
+                    { "-": ["p", "b"] },
+                    { "-": ["p", "c"] }
+                ]
+            }
+        }
+    ]
+}
+math(obj)
+```
+
+2. 以数学公式的js表达式做为模板直接生成
+```javascript
+// 勾股定理可以表示为如下形式
+math`a**2+b**2=c**2`
+// 海伦-秦九韶公式可以表式为如下形式
+math`S=sqrt(p*(p-a)*(p-b)*(p-c))`
+```
+这种方法经过efront编译后会自动转换成上一种方法中的解析形式
+
+## 常用语法及函数名如下
+* 加法
+```javascript
+    1+2
+```
+```math
+    1+2
+```
+* 减法
+```javascript
+    1-2
+```
+```math
+    1-2
+```
+* 乘法
+```javascript
+    1*2
+    a*b
+    2*a
+```
+```math
+    1*2
+    a*b
+    2*a
+```
+```javascript
+// 默认用`*`会自动转成`×`或`·`或省略
+// 如果自动生成的符号不符合预期
+// 可以使用`mul(a,b)`以强制生成`×`
+// `Mul(a,b)`生成`·`
+// `MUL(a,b)`不显示乘号
+mul(a,b),Mul(a,b),MUL(a,b)
+```
+```math
+mul(a,b),Mul(a,b),MUL(a,b)
+```
+* 分数
+```javascript
+ 分子/分母
+```
+```math
+    分子/分母
+```
+* 以除号表示除法
+```javascript
+    div(被除数,除数)
+```
+```math
+    div(被除数,除数)
+```
+* 绝对值
+```javascript
+    abs(a)
+```
+```math
+    abs(a)
+```
+* 阶乘： n!
+```javascript
+    n!
+```
+```math
+    n!
+```
+* 幂
+```javascript
+    底数 ** 指数
+```
+```math
+    底数 ** 指数
+```
+* 平方根
+```javascript
+    sqrt(底数)
+```
+```math
+    sqrt(底数)
+```
+* 高次根式
+```javascript
+  root(底数,指数)
+```
+```math
+  root(底数,指数)
+```
+* 函数
+```javascript
+    f(x)=x**2
+    f'(x)=2*x
+```
+```math
+    f(x)=x**2
+    f'(x)=2*x
+```
+
+* 三角函数
+```javascript
+sin(theta);
+sin(theta,2);
+sin(theta**2);
+sin(theta)**2;
+```
+```math
+sin(theta);
+sin(theta,2);
+sin(theta**2);
+sin(theta)**2;
+```
+
+* 向量
+```javascript
+    //vector(向量名,横坐标,纵坐标,竖坐标)
+    vector(A,x,y)
+    //坐标可以不传入
+    vector(A)
+```
+```math
+    vector(A,x,y)
+    vector(A)
+```
+* 下标
+```javascript
+    a[n]
+    a[n+1]
+    a_n
+    a_(n+1) 
+```
+```math
+    a[n]
+    a[n+1]
+    a_n
+    a_(n+1) 
+```
+* 极限
+```javascript
+    limit(公式主体,变量,目标)
+    // 可以用 Infinity表示无穷大
+    limit(1/n,n,+Infinity)
+```
+```math
+    limit(公式主体,变量,目标)
+    limit(1/n,n,+Infinity)
+```
+
+* 积分
+```javascript
+integral(表达式,下界,上界)
+```
+```math
+integral(表达式,下界,上界)
+```
+* 级数
+```javascript
+sigma(公式主体,n=1,+Infinity)
+series(公式主体,n=1,+Infinity)
+```
+```math
+sigma(公式主体,n=1,+Infinity)
+series(公式主体,n=1,+Infinity)
+```
+* 矩阵
+```javascript
+    [1,2;3,4]
+```
+```math
+    [1,2;3,4]
+```
+* 左除
+```javascript
+    [1,2;3,4] \ [5;6]
+```
+```math
+    [1,2;3,4]\[5;6]
+```
+* 转置
+```javascript
+    [1,2;3,4]'
+```
+```math
+    [1,2;3,4]'
+```
+* 离子
+```javascript
+    H[+], O[2-]
+```
+```math
+    H[+], O[2-]
+```
+
+## 希腊字母对照表如下
+
+```javascript
+    // 按此表中的英文单词命名的变量将自动转换为希腊字母
+    alpha: "α",    Alpha: "Α",
+    beta: "β",    Beta: "Β",
+    gamma: "γ",    Gamma: "‌Γ",
+    delta: "δ‌",    Delta: "Δ",
+    epsilon: "ε",    Epsilon: "Ε",
+    zeta: "ζ‌",    Zeta: "Ζ",
+    eta: "η‌",    Eta: "Η",
+    theta: "θ",    Theta: "Θ",
+    iota: "ι",    Iota: "Ι",
+    kappa: 'κ',    Kappa: 'Κ',
+    lambda: 'λ‌',    Lambda: '‌Λ',
+    mu: 'μ',    Mu: 'Μ',
+    nu: 'ν',    Nu: 'Ν',
+    xi: 'ξ‌',    Xi: '‌Ξ',
+    omicron: 'ο',    Omicron: 'Ο',
+    pi: 'π‌',    Pi: '‌Π',
+    rho: 'ρ',    Rho: 'Ρ',
+    sigma: 'σ',    Sigma: 'Σ',
+    tau: 'τ',    Tau: 'Τ',
+    upsilon: 'υ',    Upsilon: 'Υ',
+    phi: 'φ',    Phi: 'Φ',
+    chi: 'χ‌',    Chi: 'Χ',
+    psi: 'ψ',    Psi: 'Ψ',
+    omega: 'ω',    Omega: '‌Ω',
+```

package/coms/basic/math_test.xht

@@ -0,0 +1,56 @@
+<p>
+    <h2>
+        秦九韶-海伦公式
+    </h2>
+    <div>
+        ${math`S=sqrt(p*(p-a)*(p-b)*(p-c))`}
+    </div>
+</p>
+<p>
+    <h2>
+        勾股定理
+    </h2>
+    <div>
+        ${math`a**2+b**2=c**2`}
+    </div>
+</p>
+<p>
+    <h2>
+        约分
+    </h2>
+    <div>
+        ${
+        math`(a/b/c)*(b/d)=a/(c*d)`
+        }
+    </div>
+</p>
+<p>
+    <h2>
+        极限
+    </h2>
+    <div>
+        ${
+        math`limit(a**-n,n,+Infinity)`
+        }
+    </div>
+</p>
+<p>
+    ${
+        math`cos(theta,2)*E+(1 - cos(theta))*K'*K+sin(theta)*[0,-K_2,K_1;K_2,0,-K_0;-K_1,K_0,0]`
+    }
+
+</p>
+<style>
+    &{
+        height: 360px;
+        overflow: auto;
+        display: block;
+    }
+    div {
+        display: block;
+        padding: 10px 20px;
+    }
+</style>
+<script>
+
+</script>

package/coms/basic/pinyin.js

@@ -422,6 +422,45 @@ var source = {
     ";": "；",
     " ": "　 \t\r\n"
 };
+var 注音 = {
+    "ㄅ": "b",
+    "ㄆ": "p",
+    "ㄇ": "m",
+    "ㄈ": "f",
+    "ㄉ": "d",
+    "ㄊ": "t",
+    "ㄋ": "n",
+    "ㄌ": "l",
+    "ㄍ": "g",
+    "ㄎ": "k",
+    "ㄏ": "h",
+    "ㄐ": "j",
+    "ㄑ": "q",
+    "ㄒ": "x",
+    "ㄓ": "zh",
+    "ㄔ": "ch",
+    "ㄕ": "sh",
+    "ㄖ": "r",
+    "ㄗ": "z",
+    "ㄘ": "c",
+    "ㄙ": "s",
+    "ㄧ": "i",
+    "ㄨ": "u",
+    "ㄩ": "v",
+    "ㄚ": "a",
+    "ㄛ": "o",
+    "ㄜ": "e", // 鹅
+    "ㄞ": "ai",
+    "ㄟ": "ei",
+    "ㄠ": "ao",
+    "ㄡ": "ou",
+    "ㄢ": "an",
+    "ㄣ": "en",
+    "ㄤ": "ang",
+    "ㄥ": "eng",
+    "ㄦ": "er",
+    "ㄝ": "e", // ye üe ue ie
+};
 var PY = {};
 var PinYin = {};
 for (var k in source) {
@@ -446,6 +485,7 @@ var startWith = function (p, s) {
     return true;
 }
 var py = function (char) {
+    char = 注音[char] || char;
     return PY[char] || (char || "").toLowerCase();
 };
 var pinyin = function (char) {