efront 3.34.11 → 3.35.0

package/coms/compile/downLevel_test.js

@@ -0,0 +1,111 @@
+var downLevel = require("./downLevel");
+// 声明及解构
+assert(downLevel(`const`), 'var');
+assert(downLevel(`let`), 'var');
+assert(downLevel(`var`), 'var');
+assert(downLevel(`const a,b,c`), 'var a, b, c');
+assert(downLevel(`let a,b,c`), 'var a, b, c');
+assert(downLevel(`var a;{let a,b,c}`), 'var a; { var a0 = undefined, b = undefined, c = undefined }');
+assert(downLevel(`var {a,b,c}`), 'var a, b, c');
+assert(downLevel(`let {a,b,c}`), 'var a, b, c');
+assert(downLevel(`const {a,b,c}`), 'var a, b, c');
+assert(downLevel(`var [a,b,c]`), 'var a, b, c');
+assert(downLevel(`var [a,b,c];`), 'var a, b, c;');
+assert(downLevel(`var [a,b,c],{d,e,f};`), 'var a, b, c, d, e, f;');
+assert(downLevel(`var {1:a}`), 'var a');
+assert(downLevel(`var {c:a}`), 'var a');
+assert(downLevel(`var {a}=b`), 'var a = b.a');
+assert(downLevel(`var {a}=1`), 'var a = 1 .a');
+assert(downLevel(`var {a}=1.1`), 'var a = 1.1 .a');
+assert(downLevel(`var {c:a}=b`), 'var a = b.c');
+assert(downLevel(`var {"c":a}=b`), 'var a = b["c"]');
+assert(downLevel(`var {1:a}=b`), 'var a = b[1]');
+assert(downLevel(`var [,a]=b`), 'var a = b[1]');
+assert(downLevel(`var {[c]:a}=b`), 'var a = b[c]');
+assert(downLevel(`var {1:a}=b`), 'var a = b[1]');
+assert(downLevel(`var {.1:a}=b`), 'var a = b[.1]');
+assert(downLevel(`var {a,[a]:c}=b`), 'var a = b.a, c = b[a]');
+assert(downLevel(`var {a}=a`), 'var a = a.a');
+assert(downLevel(`var {a,b}=a`), 'var _ = a, a = a.a, b = _.b');
+assert(downLevel(`var {a:{a:{a}}}=b`), 'var a = b.a.a.a');
+assert(downLevel(`var {a,[a]:c}={}`), 'var _ = {}, a = _.a, c = _[a]');
+assert(downLevel(`={a,[a]:c}={}`), '= _ = {}, a = _.a, c = _[a]');
+assert(downLevel(`function (){var [a]=a;}`), "function () { var a = a[0]; }")
+// 参数解构
+assert(downLevel(`function ([a]){}`), "function (arg) { var a = arg[0]; }")
+assert(downLevel(`function ([a],b){}`), "function (arg0, b) { var a = arg0[0]; }")
+assert(downLevel(`function ([a],{b}){}`), "function (arg0, arg1) { var a = arg0[0], b = arg1.b; }")
+assert(downLevel(`function (){var {a},{b};}`), "function () { var a, b; }")
+assert(downLevel(`function (){var {a}=a,{b}=a;}`), "function () { var a = a.a, b = a.b; }")
+assert(downLevel(`function (a=b){}`), "function (a) { if (a === undefined) a = b; }")
+assert(downLevel(`function (a=b,[c],d,e=f){}`), "function (a, arg1, d, e) { if (a === undefined) a = b; var c = arg1[0]; if (e === undefined) e = f; }")
+assert(downLevel(`function (arg1=b,[c],d,e=f){}`), "function (arg1, arg2, d, e) { if (arg1 === undefined) arg1 = b; var c = arg2[0]; if (e === undefined) e = f; }")
+// class降级
+assert(downLevel(`class a {}`), "function a() {}")
+assert(downLevel(`class a {a=1}`), "function a() { this.a = 1 }")
+assert(downLevel(`class a {a=1; b(){}}`), "function a() { this.a = 1; }; a.prototype.b = function () {}")
+assert(downLevel(`=class a {a=1; b(){}}`), "= function (a) { a.prototype.b = function () {}; return a }(function a() { this.a = 1; })")
+assert(downLevel(`class a {static b(){}}`), "function a() {}; a.b = function () {}")
+assert(downLevel(`class a extends b{}`), "function a() {}; extends_(a, b)");
+assert(downLevel(`class a extends class b{}{}`), "var a = function (b, a) { extends_(a, b); return a }(function b() {}, function a() {})");
+assert(downLevel(`class a {get a(){}}`), `function a() {}; Object.defineProperty(a.prototype, "a", { get: function () {} })`);
+assert(downLevel(`class a {set a(){}}`), `function a() {}; Object.defineProperty(a.prototype, "a", { set: function () {} })`);
+assert(downLevel(`class a {get a(){}; get b(){}; set a(){}}`), `function a() {}; Object.defineProperty(a.prototype, "a", { get: function () {}, set: function () {} }); Object.defineProperty(a.prototype, "b", { get: function () {} });`);
+assert(downLevel(`class a {set a(){}; get b(){}; set a(){}}`), `function a() {}; Object.defineProperty(a.prototype, "a", { set: function () {}, set: function () {} }); Object.defineProperty(a.prototype, "b", { get: function () {} });`);
+// 属性降级
+assert(downLevel(`={[a]:b}`), `= (_ = {}, _[a] = b, _)`);
+assert(downLevel(`={a:1,[a]:1}`), `= (_ = { a: 1 }, _[a] = 1, _)`);
+assert(downLevel(`={a,[a]:1}`), `= (_ = {}, _.a = a, _[a] = 1, _)`);
+assert(downLevel(`={[a]:{[b]:1}}`), `= (_ = {}, _[a] = (_0 = {}, _0[b] = 1, _0), _)`);
+assert(downLevel(`={[a]:{[b]:{[c]:1}}}`), `= (_ = {}, _[a] = (_0 = {}, _0[b] = (_1 = {}, _1[c] = 1, _1), _0), _)`);
+assert(downLevel(`={[a]:{[b]:{[c]:1}},[b]:{[a]:1})}`), `= (_ = {}, _[a] = (_0 = {}, _0[b] = (_1 = {}, _1[c] = 1, _1), _0), _[b] = (_0 = {}, _0[a] = 1, _0), _)`);
+// 对象展开
+assert(downLevel(`={...a}`), `= extend({}, a)`);
+assert(downLevel(`={...{a:1}}`), `= extend({}, { a: 1 })`);
+assert(downLevel(`={...a,...c}`), `= extend({}, a, c)`);
+assert(downLevel(`={...a,b}`), `= (_ = extend({}, a), _.b = b, _)`);
+assert(downLevel(`={...a,b,...c}`), `= (_ = extend({}, a), _.b = b, extend(_, c), _)`);
+assert(downLevel(`={...a,...c,b}`), `= (_ = extend({}, a, c), _.b = b, _)`);
+assert(downLevel(`={...{},...c,b}`), `= (_ = extend({}, {}, c), _.b = b, _)`);
+assert(downLevel(`={a(){},get c(){},b}`), `= (_ = {}, _.a = function () {}, Object.defineProperty(_, "c", { get: function () {} }), _.b = b, _)`);
+assert(downLevel(`=[...a]`), `= Array.prototype.slice.call(a)`)
+assert(downLevel(`=[...a,...b]`), `= (slice_ = Array.prototype.slice).call(a).concat(slice_.call(b))`)
+assert(downLevel(`=[a,...b]`), `= [a].concat(Array.prototype.slice.call(b))`)
+assert(downLevel(`=[a,...b,...c]`), `= [a].concat((slice_ = Array.prototype.slice).call(b), slice_.call(c))`)
+assert(downLevel(`=[a,b,...c]`), `= [a, b].concat(Array.prototype.slice.call(c))`)
+assert(downLevel(`=[a,b,...c,d]`), `= [a, b].concat(Array.prototype.slice.call(c), [d])`)
+assert(downLevel(`=[a,b,...c,d,e,f]`), `= [a, b].concat(Array.prototype.slice.call(c), [d, e, f])`)
+assert(downLevel(`=[a,b,...c,d,e,f,...g]`), `= [a, b].concat((slice_ = Array.prototype.slice).call(c), [d, e, f], slice_.call(g))`)
+assert(downLevel(`=[a,b,...c,d,...e]`), `= [a, b].concat((slice_ = Array.prototype.slice).call(c), [d], slice_.call(e))`)
+assert(downLevel(`a(...b)`), `a.apply(null, b)`)
+assert(downLevel(`a(...b,...c)`), `a.apply(null, (slice_ = Array.prototype.slice).call(b).concat(slice_.call(c)))`)
+assert(downLevel(`a(...b,c)`), `a.apply(null, Array.prototype.slice.call(b).concat([c]))`)
+assert(downLevel(`a(b,...c)`), `a.apply(null, [b].concat(Array.prototype.slice.call(c)))`)
+assert(downLevel(`a(a,b,...c,d,...e)`), `a.apply(null, [a, b].concat((slice_ = Array.prototype.slice).call(c), [d], slice_.call(e)))`)
+assert(downLevel(`a.call(a,b,...c,d,...e)`), `a.call.apply(a, [a, b].concat((slice_ = Array.prototype.slice).call(c), [d], slice_.call(e)))`)
+assert(downLevel(`a.b(a,b,...c,d,...e)`), `a.b.apply(a, [a, b].concat((slice_ = Array.prototype.slice).call(c), [d], slice_.call(e)))`)
+assert(downLevel(`[].b(a,b,...c,d,...e)`), `(_ = []).b.apply(_, [a, b].concat((slice_ = Array.prototype.slice).call(c), [d], slice_.call(e)))`)
+assert(downLevel(`a(...b).c(...d)`), `(_ = a.apply(null, b)).c.apply(_, d)`)
+assert(downLevel(`a(...b).c(...d).e(...f)`), `(_ = (_ = a.apply(null, b)).c.apply(_, d)).e.apply(_, f)`)
+// 对象收集
+assert(downLevel(`function (a,...b){}`), "function (a) { var b = Array.prototype.slice.call(arguments, 1); }")
+assert(downLevel(`function (a,...b,c){}`), "function (a, c) { var b = Array.prototype.slice.call(arguments, 1, -1); c = arguments.length > 1 ? arguments[arguments.length - 1] : undefined; }")
+assert(downLevel(`function (a,...,c){}`), "function (a, c) { c = arguments.length > 1 ? arguments[arguments.length - 1] : undefined; }")
+assert(downLevel(`function (a,...b,b){}`), "function (a, b) { b = arguments.length > 1 ? arguments[arguments.length - 1] : undefined; }")
+assert(downLevel(`(a)=>k`), "function (a) { return k }")
+assert(downLevel(`(...a) => k`), "function () { var a = Array.prototype.slice.call(arguments, 0); return k }")
+assert(downLevel(`for(var o of os)`), "for (var _ = 0; _ < os.length && (o = os[_], true); _++)")
+assert(downLevel(`for(var [a] of os)`), "for (var _ = 0; _ < os.length && (a = os[_][0], true); _++)")
+assert(downLevel(`for(var [a,b] of os)`), "for (var _ = 0; _ < os.length && (_0 = os[_], a = _0[0], b = _0[1], true); _++)")
+assert(downLevel(`[...a]=a`), "a = Array.prototype.slice.call(a, 0)")
+assert(downLevel(`[c,...a]=a`), "c = a[0], a = Array.prototype.slice.call(a, 1)")
+assert(downLevel(`[...a]=a`), "a = Array.prototype.slice.call(a, 0)")
+assert(downLevel(`[...a,c]=a`), "_ = a, a = Array.prototype.slice.call(a, 0, -1), c = _.length > 1 ? _[_.length - 1] : undefined")
+assert(downLevel(`{...a,c}=a`), `c = a.c, a = rest_(a, ["c"])`)
+assert(downLevel(`{c,...a}=a`), `c = a.c, a = rest_(a, ["c"])`)
+assert(downLevel(`{c,[c]:b,...a}=a`), `c = a.c, b = a[c], a = rest_(a, ["c", c])`)
+assert(downLevel(`async function(){}`), `function(){return Promise.resolve()}`)
+assert(downLevel(`async function(a){await a}`), `function(a){return Promise.resolve(a)}`)
+assert(downLevel(`async function(a){await a,await b}`), `function(a){return async_(function(){return a},function(){return b}})`)
+assert(downLevel(`async function(){await a,await b}`), `function(){return async_(function(){return a},function(){return b}})`)
+assert(downLevel(`async function(a){ if(c)await a}`), `function(){return Promise.resolve(a).then(b)}`)

package/coms/compile/formatcode.js

@@ -0,0 +1,57 @@
+var {
+    SCOPED,
+    STAMP,
+    STRAP,
+    SPACE,
+    relink,
+} = require("./common");
+var { createExpressList } = require("./washcode")
+function format(code, step) {
+    if (!code.length) return;
+    var rest = ["\r\n", code];
+    while (rest.length > 0) {
+        var code = rest.pop();
+        var lowspace = rest.pop();
+        var cp = code.prev;
+        var cpp = cp && cp.prev;
+        if(cpp && cpp.type === STRAP && cpp.text==="switch"){
+            lowspace += step;
+        }
+        var space = lowspace + step;
+        if (code.length === 0) continue;
+        var explist = createExpressList(code);
+        var breakline = explist.length > 1 && (code.isObject || !code.entry || code.entry === "{");
+        code.splice(0, code.length);
+        if (breakline) code.push({ type: SPACE, text: space });
+        if (breakline) var deepspace = space + step;
+        else var deepspace = space, space = lowspace;
+        var hasCommaBefore = false;
+        for (var exp of explist) {
+            for (var e of exp) {
+                if (breakline && e.type === STRAP) {
+                    if (/^(else|catch|finally)/.test(e.text)) {
+                        code.push({ type: SPACE, text: space });
+                    }
+                    else if (/^(case|default)$/.test(e.text)) {
+                        if (code[code.length - 1].type === SPACE) code.pop();
+                        code.push({ type: SPACE, text: lowspace });
+                    }
+                }
+                code.push(e);
+                if (e.type === SCOPED) rest.push(space, e);
+            }
+            if (breakline && (e.type === STAMP && /^[,;]$/.test(e.text) || !code.isClass && !code.isObject)) hasCommaBefore = !code.isObject && e.text === ',', code.push({ type: SPACE, text: hasCommaBefore ? deepspace: space });
+        }
+        if (breakline) {
+            var hasspaceend = code[code.length - 1].type === SPACE;
+            code.splice(code.length - hasspaceend, +hasspaceend, { type: SPACE, text: lowspace });
+        }
+        relink(code);
+    }
+}
+module.exports = function (code, tabSize) {
+    format(code, new Array(tabSize + 1).join(" "));
+    code.keepspace = true;
+    code.helpcode = true;
+    return code;
+};

package/coms/compile/iso8859.js

@@ -0,0 +1,9 @@
+"use ../../data/iso8859_1.txt";
+var iso8859_map = Object.create(null);
+if (typeof iso8859_1 === 'string') for (let r of iso8859_1.split(/[\r\n]+/)) {
+    r = r.split(/\t+/);
+    var c = r.pop();
+    var d = r.pop();
+    iso8859_map[d] = String.fromCharCode(+c.slice(2, -1));
+}
+module.exports = iso8859_map;

package/coms/compile/iso8859_test.js

@@ -0,0 +1,2 @@
+var iso = require("./iso8859");
+console.log(iso);

package/coms/compile/keywords.js

@@ -0,0 +1,6 @@
+var keyword = `NaN Infinity break do in typeof case else instanceof var let catch export new void class extends return while const finally super with continue for switch yield debugger function this default if throw delete import try enum await null true false arguments eval`;
+var keywords = {};
+keyword.split(/\s+/g).forEach(function (key) {
+    keywords[key] = true;
+});
+module.exports = keywords;

package/coms/compile/namelist.js

@@ -0,0 +1,154 @@
+var js_keywords = `
+if,in,do,
+var,for,new,try,let,
+this,else,case,void,with,enum,elif,from,
+async,while,break,catch,throw,const,yield,class,await
+return,typeof,delete,switch,export,import,
+default,finally,extends,
+function,continue,debugger,Infinity,abstract,nonlocal,
+null|true|false|NaN|Infinity|undefined|arguments
+instanceof,implements
+`;
+var c_java_go_python = `
+go,or,as,is,
+len,map,int,and,
+make,func,goto,chan,type,sync,byte,char,long,auto,pass,open
+label,purge,stack,
+defer,range,final,float,short,super,union,model,
+global,assert,except,lambda,
+inline,select,struct,public,native,static,strict,throws,double,extern,signed,sizeof
+package,private,boolean,
+typedef
+interface,transient,
+fullthrough
+synchronized
+_Bool,_Complex,_Imaginary
+_Alignas,_Alignof,_Atomic,_Static_assert,_Noreturn,_Thread_local,_Generic
+False,None,True
+strictfp,volatile,unsigned,restrict,
+`
+
+var others = `
+fi,md,rd,rm,cd,ls
+rem,
+ren,
+clc,cld,cli,chs,cls,dir,
+cmp
+ins,
+dec,inc,pop,ptr,
+seg,set,
+lea
+shl,shr
+cat
+popa,popf,fstp,fist,fadd,fsub,fmul,fdiv,fild
+endp,ends,proc,idiv,imul,
+call,chcp,
+code,data,even,
+loop,push,
+test,find,
+open,
+exit,
+move,
+copy,
+echo,
+help,
+type,
+popd,
+more,
+wmic,
+setx
+clear,print,
+pushd,
+assoc,ftype,mkdir,xcopy,
+enter,bound,cupid,group,raise,start,local
+subst,
+title,
+fistp,fiadd,fisub,fimul,fidiv,
+rename,
+assume,offset,
+segment,startup,
+template
+`;
+var keywords = [js_keywords, c_java_go_python, others].join("|").trim().split(/[,\r\n\s\|]+/).join("|");
+keywords = new RegExp(`^(${keywords})$`, 'i');
+var source = `abcdefghijklmnopqrstuvwxyz`;
+source += source.toUpperCase() + "_$";
+var number = source + '0123456789';
+// source += "ªµºΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρςστυφχψω";
+source += function () {
+    var reg = /\xAA\xB5\xBA\xC0-\xD5\xD8-\xF2\xF8-\u02af\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA/;
+    var dist = [];
+    reg.source.replace(/\\[xu]([0-9a-f]+)(?:\-\\[xu]([0-9a-f]+))?/ig, function (_, a, b) {
+        a = parseInt(a, 16);
+        if (!b) {
+            dist.push(a);
+            return;
+        }
+        b = parseInt(b, 16);
+        while (a <= b) dist.push(a++);
+    });
+    return String.fromCharCode.apply(String, dist);
+}();
+var source_length = source.length;
+var counts = [
+    source_length,
+    source_length * 64,
+    source_length * 64 * 64,
+    source_length * 64 * 64 * 64,
+    source_length * 64 * 64 * 64 * 64
+];
+function create(n, length) {
+    var rest = [];
+    while (length > 0) {
+        rest[length] = (number[n & 0b111111]);
+        length--;
+        n = n >>> 6;
+    }
+    rest[0] = source[n];
+    return rest.join("");
+}
+var preventList = function (k) {
+    for (var i = this.length - 1; i >= 0; i--) {
+        if (k in this[i]) return true;
+    }
+    return false;
+};
+var preventObject = function (k) {
+    return k in this;
+};
+var preventNull = function () { return false };
+function namelist(count, prevent, skip) {
+    var dist = [];
+    if (!prevent) prevent = preventNull;
+    else if (prevent instanceof Array) prevent = preventList.bind(prevent);
+    else prevent = preventObject.bind(prevent);
+    var skip0 = skip;
+    for (var cy = 0, dy = counts.length; cy < dy; cy++) {
+        if (count <= 0) break;
+        var limit = counts[cy];
+        if (skip >= limit) {
+            skip -= limit;
+            continue;
+        }
+        if (skip) count += skip;
+        count -= limit;
+        for (var cx = skip | 0, dx = count < 0 ? limit + count : limit; cx < dx; cx++) {
+            var a = create(cx, cy);
+            if (keywords.test(a) || prevent(a)) {
+                if (dx < limit) {
+                    dx++;
+                    count++;
+                } else {
+                    count++;
+                }
+            } else {
+                dist.push(a);
+            }
+        }
+        skip0 += dx - skip;
+        skip = 0;
+    }
+    dist.skip = skip0;
+    return dist;
+}
+module.exports = namelist;

package/coms/compile/namelist_test.js

@@ -0,0 +1,7 @@
+var namelist = require("./namelist");
+var start = new Date;
+namelist(1000000, {});
+var a = namelist(600, {});
+var a = namelist(60, { A: true, _: true,  a: 1, s: 1, b: 1, m: 1, aa: 1, a_: 1 });
+console.log(a);
+console.log("生成1百万个变量名，耗时",new Date - start);

package/coms/compile/polyfill.js

@@ -0,0 +1,31 @@
+var { SCOPED } = require("./common");
+var backEach = require("../basic/backEach");
+
+var polyfills = Object.assign(Object.create(null), {
+    "Object.assign": 'extend'
+});
+var polyfill = function (o, i, used) {
+    var v = o.text;
+    if (v in polyfills) {
+        var p = polyfills[v];
+        var n = o.next;
+        if (n && n.type === SCOPED && n.entry === '(') {
+            if (!this.used[p]) {
+                this.used[p] = [];
+                this.envs[p] = true;
+            }
+            o.text = p;
+            this.used[p].push(o);
+            used.splice(i, 1);
+        }
+    }
+};
+
+module.exports = function (body) {
+    var envs = body.envs;
+    if (envs.Object) {
+        backEach(body.used.Object, polyfill, body);
+        if (!body.used.Object.length) delete body.used.Object, delete body.envs.Object;
+    }
+    return body;
+}

package/coms/compile/required.js

@@ -0,0 +1,20 @@
+"use strict";
+var scanner2 = require("../compile/scanner2");
+var strings = require("../basic/strings");
+function getRequired(data) {
+    var code = scanner2(data);
+    var { used, envs } = code;
+    if (envs.require) var require = used.require;
+    if (require instanceof Array) require.map(r => {
+        if (r.next && r.next.type === code.SCOPED) {
+            var s = r.next;
+            var f = s.first;
+            if (f && f.type === code.QUOTED && !f.length && /^[`'"]/.test(f.text)) {
+                return strings.decode(f.text);
+            }
+        }
+    })
+    else require = [];
+    return require;
+}
+module.exports = getRequired;

package/coms/compile/richcss.js

@@ -0,0 +1,237 @@
+var { STAMP, PROPERTY, SCOPED, VALUE, EXPRESS, QUOTED, createString } = require("./common");
+class Richcss extends Program {
+    straps = [];
+    stamps = `;:`.split("");
+    quotes = this.quotes.slice(0, 2);
+    scopes = [["{", "}"]]
+}
+Richcss.prototype.setType = function (o) {
+    var p = o.prev;
+    if (o.type !== SCOPED) {
+        if (!p || p.type === STAMP && p.text === ";" || p.type === SCOPED) {
+            o.type = PROPERTY;
+            return;
+        }
+    }
+    if (!p) return;
+    var q = o.queue;
+    if (o.type === SCOPED && o.entry === "{") {
+        if (p.type & (PROPERTY | EXPRESS) && /@$/.test(p.text)) {
+            return false;
+        }
+        var pps = [];
+        while (p && !(p.type === STAMP && p.text === ';' || p.type === SCOPED)) {
+            pps.push(p);
+            p = p.prev;
+        }
+        if (pps.length > 1) {
+            var i = q.lastIndexOf(p = pps.pop());
+            q.splice(i + 1, q.length, o);
+            p.next = o;
+            p.type = PROPERTY;
+            p.end = pps[0].end;
+            o.prev = p;
+            q.last = o;
+            return false;
+        }
+    }
+    if (!q.entry && o.type !== SCOPED) {
+        if (o.type !== STAMP || o.text !== ";") return false;
+    }
+};
+Richcss.prototype.createScoped = function (code) {
+    var run = function (o) {
+        var props = Object.create(null);
+        var values = null;
+        loop: while (o) {
+            switch (o.type) {
+                case PROPERTY:
+                    var p = [];
+                    while (o && !(o.type & (STAMP | SCOPED))) {
+                        p.push(o.text);
+                        o = o.next;
+                    }
+                    props[p.join(" ")] = values = [];
+                    if (!o) break loop;
+                    if (o.type === STAMP) break;
+                    continue;
+                case STAMP:
+                    if (o.text === ';') break;
+                case EXPRESS:
+                case VALUE:
+                case QUOTED:
+                    values.push(o.text);
+                    break;
+                case SCOPED:
+                    var s = run(o.first);
+                    var vars = null, used = null;
+                    for (var k in s) {
+                        var v = s[k];
+                        if (/^\-\-/.test(k)) {
+                            if (!vars) vars = {};
+                            vars[k] = v.join(" ");
+                        }
+                        else {
+                            if (!used) used = [];
+                            used[k] = v;
+                        }
+                    }
+                    values.used = used;
+                    values.vars = vars;
+
+            }
+            o = o.next;
+        }
+        return props;
+    };
+    return run(code.first);
+};
+Richcss.prototype.createString = createString;
+var getFromScopeList = function (name, varsList, value) {
+    for (var cx = varsList.length - 1; cx >= 0; cx--) {
+        var o = varsList[cx];
+        if (name in o) return o[name];
+    }
+    return value;
+}
+var fixBase = function (b, a) {
+    return a.split(/,\s*/).map(a => {
+        var replaced = false;
+        a = a.replace(/(:scope|&)/g, function (match) {
+            replaced = true;
+            return b;
+        });
+        if (!replaced) {
+            if (/^[>~+]/.test(a)) {
+                a = b + a;
+            }
+            else a = b + " " + a;
+        }
+        return a;
+    }).join(",");
+}
+function evalscoped(scoped, scopeNames, base = '') {
+    var root = scoped[":root"], scope = scoped[":scope"];
+    var vars = Object.create(null);
+    if (root) extend(vars, root.vars);
+    if (scope) extend(vars, scope.vars);
+    scopeNames.forEach(s => {
+        var ss = scoped[s];
+        if (ss) extend(vars, ss.vars), ss.rooted = true;
+    });
+    var vlist = [vars];
+    var mlist = [];
+    var initvars = function (vars) {
+        var queue = [];
+        for (var k in vars) {
+            var v = vars[k];
+            while (/^\-\-/.test(v)) {
+                if (queue.indexOf(v) >= 0) throw `变量环形引用，无法初始化：${queue}`;
+                queue.push(v);
+                v = getFromScopeList(v, vlist);
+            }
+            vars[k] = v;
+        }
+    };
+    initvars(vars);
+    var eval2 = function (props) {
+        var rest = [];
+        var result = [];
+        var methods = {};
+        mlist.push(methods);
+        var evalthis = function (p) {
+            if (p.vars) vlist.push(p.vars);
+            initvars(p.vars);
+            var temp = base;
+            base = p.base;
+            var res = eval2(p.used);
+            base = temp;
+            if (p.vars) vlist.pop();
+            return res;
+        };
+        var calcvars = function (v) {
+            return v.replace(/(^|\s|[\]\)\(\[\-\+\*\/])(?:var\s*\(([\s\S]*?)\)|(--[^\s]+))/g, function (m, q, a, b) {
+                return q + getFromScopeList(b || a.trim(), vlist, m.slice(q.length));
+            });
+        };
+        for (var k in props) {
+            var p = props[k];
+            if (p.used) {
+                var match = /^(@[^\s,]+)\s*\(\s*(@[^\s,]+\s*(?:,\s*@[^\s,]+\s*)*)?\)/.exec(k);
+                if (!match) continue;
+                p.base = base;
+                var [, name, args] = match;
+                args = args.split(",").map(a => a.trim());
+                p.args = args;
+                p.reg = new RegExp(args.join("|"), 'g');
+                methods[name] = function () {
+                    var body = evalthis(this);
+                    var valueMap = {};
+                    this.args.forEach((a, i) => {
+                        valueMap[a] = arguments[i];
+                    })
+                    var replace = text => text.replace(this.reg, function (name) {
+                        if (name in valueMap) return valueMap[name];
+                        return name;
+                    });
+                    var rest = body.rest.map(a => a.map(replace));
+                    var body = body.map(replace);
+                    body.rest = rest;
+                    return body;
+                }.bind(p);
+                delete props[k];
+            }
+        }
+        for (var k in props) {
+            var p = props[k];
+            if (p.used) {
+                if (base && !p.rooted) p.base = fixBase(base, k);
+                else p.base = k;
+                var value = evalthis(p);
+                if (value.rest.length) rest = rest.concat(value.rest);
+                if (value.length) rest.push([p.base, '{', value.join(""), "}"]);
+            }
+            else if (p.length) {
+                result.push(k, ":", calcvars(p.join(" ")), ';');
+            }
+            else {
+                k = calcvars(k);
+                var match = /^(@\S+)\s*\(([\s\S]*)\)$/.exec(k);
+                if (!match) continue;
+                var [, name, params] = match;
+                params = params.split(",").map(a => a.trim());
+                var method = getFromScopeList(name, mlist);
+                if (!isFunction(method)) throw `函数未定义：${name}`;
+                var res = method.apply(null, params);
+                if (res.rest.length) rest = rest.concat(res.rest);
+                if (res.length) result = result.concat(res);
+            }
+        }
+        mlist.pop();
+        result.rest = rest;
+        return result;
+    }
+    var result = eval2(scoped, [vars]);
+    return result;
+}
+var rcss = null;
+function richcss(text, scopeName, compress) {
+    if (!rcss) rcss = new Richcss;
+    var code = scanner2(text, rcss);
+    var scopeNames = [];
+    if (scopeName) code.forEach(c => {
+        if (c.type === PROPERTY) {
+            var replaced = false;
+            c.text = c.text.replace(/\:(scope|root)/g, function () {
+                replaced = true;
+                return scopeName;
+            });
+            if (replaced) {
+                scopeNames.push(c.text);
+            }
+        }
+    })
+    var { scoped } = code;
+    var result = evalscoped(scoped, scopeNames, scopeName);
+    return result.rest.map(a => a.join("")).concat(result).join(compress ? "" : "\r\n");
+}

package/coms/compile/richcss_test.js

@@ -0,0 +1,7 @@
+var test = function (data, expect) {
+    assert(richcss(data), expect);
+};
+test(`:scope{--a:1}a{opacity:--a}`, `a{opacity:1;}`);
+test(`:scope{--b:--a;--a:1;}a{opacity:--b}`, `a{opacity:1;}`);
+test(`@a(@p,@b){@p{opacity:@b}}@a(a,1);`, `a{opacity:1;}`);
+test(`@a(a,1);@a(@p,@b){@p{opacity:@b}}`, `a{opacity:1;}`);