efront 3.14.0 → 3.14.9

package/coms/basic/Array2.js

@@ -0,0 +1,9 @@
+var setPrototypeOf = Object.setPrototypeOf || function (obj, proto) {
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    for (var p in proto) if (!hasOwnProperty.call(obj)) obj[p] = proto[p];
+    return obj;
+}
+function Array2() {
+    return setPrototypeOf(Array.apply(this, arguments), this.constructor.prototype);
+}
+Array2.prototype = Array.prototype;

package/coms/basic/Speed.js

@@ -0,0 +1,120 @@
+function inertia(gun) {
+    var _decreased = 0, spd = new Speed;
+    var _decrease = function () {
+        if (
+            decrease instanceof Function
+        ) {
+            if (!spd.length || !spd[0]) return;
+            var id = smooth_timer;
+            var res = decrease(_decreased++, spd);
+            if (smooth_timer !== id) return;
+            if (res === false || isEmpty(res)) {
+                spd.unset();
+                return;
+            }
+            smooth_timer = requestAnimationFrame(_decrease);
+        }
+    };
+    var _cancel = function () {
+        cancelAnimationFrame(smooth_timer);
+        _decreased = 0;
+        decrease = null;
+    }
+    var smooth = function () {
+        var args = spd.read();
+        if (decrease && args.filter(a => Math.abs(a) > .5).length === 0) {
+            spd.reset();
+            _decrease();
+            return;
+        }
+        if (args.filter(a => Math.abs(a) > .1).length === 0) {
+            spd.reset();
+            return;
+        }
+        var id = smooth_timer;
+        var res = gun.apply(that, args);
+        if (id !== smooth_timer) return;
+        if (false === res) {
+            spd.reset();
+            smooth_timer = requestAnimationFrame(_decrease);
+            return;
+        }
+        smooth_timer = requestAnimationFrame(smooth);
+    };
+    var spd, smooth_timer, that, decrease;
+    var train = function () {
+        _cancel();
+        var args = [].slice.call(arguments, 0, arguments.length);
+        spd.write(args);
+        gun.apply(this, args);
+        that = this;
+    };
+    train.smooth = function (d) {
+        _cancel();
+        decrease = d;
+        smooth_timer = requestAnimationFrame(smooth);
+    };
+    train.reset = function () {
+        _cancel();
+        spd.reset();
+    };
+    return train;
+
+}
+class Speed extends Array {
+    cache = [];
+    stamp = 0;
+    static now() {
+        return performance.now ? performance.now() : Date.now();
+    }
+    static inertia = inertia;
+    reset() {
+        this.cache.splice(0, this.cache.length, 0);
+    }
+    unset() {
+        this.splice(0, this.length), this.cache.splice(0, this.cache.length), this.stamp = 0;
+    }
+    write(values, stamp = Speed.now()) {
+        if (values.length !== this.length || this.length && this.cache.length < 2) this.unset();
+        this.cache.push(values, stamp);
+        if (this.cache.length > 20) this.cache.splice(0, 12);
+        var start = Math.max(this.cache.length - 6, 0);
+        var s = values.slice(0, values.length), t = this.cache[this.cache.length - 1] - this.cache[start + 1] + 12;
+        for (var cx = start, dx = this.cache.length - 2; cx < dx; cx++) {
+            var values = this.cache[cx++];
+            for (var cy = 0, dy = values.length; cy < dy; cy++) {
+                var v = values[cy];
+                if (!s[cy]) s[cy] = 0;
+                s[cy] += v;
+            }
+        }
+        for (var cx = 0, dx = s.length; cx < dx; cx++) {
+            this[cx] = s[cx] / t;
+        }
+    }
+    read(now = Speed.now()) {
+        var stamp = this.cache[this.cache.length - 1];
+        var values = this.slice(0);
+        var deltat = now - stamp;
+        var ratio;
+        if (this.stamp) ratio = now - this.stamp;
+        else ratio = deltat;
+        if (ratio > 160) ratio = 1e-3;
+        this.stamp = now;
+        var sum = 0;
+        for (var v of values) sum += v * v;
+        v = Math.sqrt(sum) * ratio;
+        if (v > 1) {
+            v = Math.sqrt(v * (v - 1)) / v;
+        }
+        else {
+            v = 1e-7;
+        }
+        var r = ratio * v;
+        for (var cx = 0, dx = values.length; cx < dx; cx++) {
+            values[cx] *= r;
+            this[cx] *= v;
+        }
+        return values;
+    }
+}

package/coms/basic/assert.js

@@ -1,4 +1,8 @@
-var assert = function (result, expect, log = console.error) {
+var dump = function (a) {
+    if (a instanceof Object) console.error('对象的属性不符合'), console.log("  ", a);
+    else console.error(a);
+};
+var assert = function (result, expect, log = dump) {
     var errors = {}, hasCollect;
     var collect = function (k, args) {
         hasCollect = true;
@@ -19,7 +23,12 @@ var assert = function (result, expect, log = console.error) {
     var res = false;
     if (result === expect) {
         res = true;
-    } else if (expect instanceof Date) {
+    }
+    else if (typeof result === "number" && typeof expect === "number") {
+        var e = (result - expect) * (result - expect) / Math.sqrt(result * result + expect * expect);
+        if (e < 1e-14) res = true;
+    }
+    else if (expect instanceof Date) {
         if (result instanceof Date)
             res = assert(+expect, +result, collect());
     } else if (expect instanceof Array) {

package/coms/basic/matrix.js

@@ -0,0 +1,283 @@
+// 空间变换算法
+// function [dots]=xrs(dots,wyh)
+// % 转动，缩放，平移，依次进行
+// % wyh.mid为变换中心
+// % wyh.ppt为转动轴的方向
+// % wyh.alph为转动角度
+// % wyh.scrl为缩放系数，反射可设轴向系数为-1
+// % wyh.drag为平移向量
+// wyh.alph=pi*wyh.alph/180;
+// if size(dots,2)==3
+//     if numel(wyh.ppt) == 2 
+//         theta = pi*wyh.ppt(1)/180;
+//         phi = pi*wyh.ppt(2)/180;
+//         rot_u = [cos(phi)*cos(theta); cos(phi)*sin(theta); sin(phi)];
+//     elseif numel(wyh.ppt) == 3 
+//         rot_u = wyh.ppt(:)/norm(wyh.ppt);
+//     end
+//     x_u = rot_u(1);
+//     y_u = rot_u(2);
+//     z_u = rot_u(3);
+//     cosa = cos(wyh.alph);
+//     sina = sin(wyh.alph);
+//     vera = 1 - cosa;
+//     rot = [cosa+x_u^2*vera x_u*y_u*vera-z_u*sina x_u*z_u*vera+y_u*sina; ...
+//         x_u*y_u*vera+z_u*sina cosa+y_u^2*vera y_u*z_u*vera-x_u*sina; ...
+//         x_u*z_u*vera-y_u*sina y_u*z_u*vera+x_u*sina cosa+z_u^2*vera]';
+// else
+//     rot=[cos(wyh.alph),-sin(wyh.alph);sin(wyh.alph),cos(wyh.alph)];
+// end
+// for cx=1:size(dots,1)
+//     dots(cx,:)=(dots(cx,:)-wyh.mid).*wyh.scrl*rot+wyh.mid+wyh.drag;
+// end
+// end
+"use strict";
+
+var notMatchLength = new Error("矩阵长度不一致");
+function transform(dots, B) {
+    var dimention = Math.sqrt(B.length - 1) | 0;
+    if (dots.length % dimention !== 0) throw notMatchLength;
+    if (dots === B) B = B.slice(0);
+    var ds = dots.slice(0);
+    var dim2 = B.length % dimention !== 0 ? dimention + 1 : dimention;
+    for (var cx = 0, dx = dots.length; cx < dx; cx += dimention) {
+        for (var cy = 0, dy = dimention; cy < dy; cy++) {
+            var sum = 0;
+            for (var ct = 0, dt = dimention; ct < dt; ct++) {
+                sum += ds[cx + ct] * B[ct * dim2 + cy];
+            }
+            sum += B[dimention * dim2 + cy];
+            dots[cx + cy] = sum;
+        }
+    }
+    return dots;
+};
+
+function translate(A, delta) {
+    var [dim2, dim] = size(A);
+    var inc = 0;
+    for (var cx = dim * dim2, dx = cx + dim; cx < dx; cx++) {
+        A[cx] = (A[cx] || 0) + delta[inc++];
+    }
+    return A;
+}
+
+
+function 负(a) {
+    return -a;
+}
+
+function multiply(A, B) {
+    if (A.length !== B.length) throw notMatchLength;
+    var dim = Math.sqrt(A.length) | 0;
+    if (dim * dim !== A.length) throw notMatchLength;
+    var X = A.slice(0);
+    for (var cx = 0, dx = A.length; cx < dx; cx += dim) {
+        for (var cy = 0, dy = dim; cy < dy; cy++) {
+            var sum = 0;
+            for (var ct = 0, dt = dim; ct < dt; ct++) {
+                sum += X[cx + ct] * B[ct * dim + cy];
+            }
+            A[cx + cy] = sum;
+        }
+    }
+    return A;
+}
+
+function inner(vec1, vec2) {
+    if (vec1.length !== vec2.length) throw notMatchLength;
+    var sum = 0;
+    for (var cx = 0, dx = vec1.length; cx < dx; cx++) {
+        sum += vec1[cx] * vec2[cx];
+    }
+    return sum;
+}
+function cross(vec1, vec2) {
+    if (vec1.length !== vec2.length) throw notMatchLength;
+    var c = new Array(vec1.length);
+    for (var cx = 0, dx = vec1.length; cx < dx; cx++) {
+        var s = 0, f = 1;
+        for (var cy = 1, dy = dx; cy < dy; cy++) {
+            var c1 = cx + cy;
+            var c2 = c1 + f;
+            if (c1 >= dx) c1 -= dx;
+            if (c2 >= dx) c2 -= dx;
+            f = 0 - f;
+            s += vec1[c1] * vec2[c2];
+        }
+        c[cx] = s;
+    }
+    return c;
+}
+function times(vector, factor) {
+    for (var cx = 0, dx = vector.length; cx < dx; cx++) {
+        vector[cx] *= factor;
+    }
+    return vector;
+}
+
+function olinde(v, vector) {
+    // 罗德里格旋转公式
+    // https://baike.baidu.com/item/%E7%BD%97%E5%BE%B7%E9%87%8C%E6%A0%BC%E6%97%8B%E8%BD%AC%E5%85%AC%E5%BC%8F/18878562
+    // https://www.cnblogs.com/flyinggod/p/8144100.html 旋转矩阵、欧拉角、四元数理论及其转换关系
+    var theta = norm(vector);
+    var k = times(vector.slice(0), 1 / theta);
+    var cosa = Math.cos(theta);
+    var sina = Math.sin(theta);
+    var inna = inner(k, v);
+    var aa = inna * (1 - cosa);
+    var kv = cross(k, v);
+    for (var cx = 0, dx = k.length; cx < dx; cx++) {
+        v[cx] = v[cx] * cosa + aa * k[cx] + sina * kv[cx];
+    }
+    return v;
+}
+function matrix2d(theta) {
+    var cosa = Math.cos(theta);
+    var sina = Math.sin(theta);
+    return new Matrix(
+        cosa, sina, 0,
+        -sina, cosa, 0,
+        0, 0, 1
+    );
+};
+function matrix3d(factor) {
+    var theta = norm(factor);
+    var vec = times(factor, 1 / theta);
+    var cosa = Math.cos(theta);
+    var sina = Math.sin(theta);
+    var vera = 1 - cosa;
+    var [x_u, y_u, z_u] = factor ? [0, 0, 1] : vec;
+
+    return new Matrix(
+        cosa + x_u * x_u * vera, x_u * y_u * vera - z_u * sina, x_u * z_u * vera + y_u * sina, 0,
+        x_u * y_u * vera + z_u * sina, cosa + y_u * y_u * vera, y_u * z_u * vera - x_u * sina, 0,
+        x_u * z_u * vera - y_u * sina, y_u * z_u * vera + x_u * sina, cosa + z_u * z_u * vera, 0,
+        0, 0, 0, 1
+    );
+}
+var norm = function (vector) {
+    var sum = 0;
+    for (var cx = 0, dx = vector.length; cx < dx; cx++) {
+        sum += vector[cx] * vector[cx];
+    }
+    return Math.sqrt(sum);
+};
+
+var 逆 = function (A) {
+    var dim = Math.sqrt(A.length) | 0;
+    if (dim * dim !== A.length) throw notMatchLength;
+    var E = new Array(A.length).fill(0);
+    for (var cx = 0, dx = dim; cx < dx; cx++)E[cx * dim + cx] = 1;
+    var X = A.splice(0, A.length);
+    A.push.apply(A, E);
+    for (var cx = 0, dx = dim; cx < dx; cx++) {
+        var start = cx * dim + cx;
+        for (var ct = start, dt = X.length; ct < dt; ct += dim) {
+            if (X[ct] !== 0) break;
+        }
+        if (ct !== start) {
+            var delta = ct - start;
+            var ratio = 1 / X[ct];
+            for (var cy = cx * dim, dy = cy + dim; cy < dy; cy++) {
+                X[cy] += X[cy + delta] * ratio;
+                A[cy] += A[cy + delta] * ratio;
+            }
+        }
+        if (X[start] !== 1) {
+            var delta = ct - start;
+            var ratio = 1 / X[start];
+            for (var cy = cx * dim, dy = cy + dim; cy < dy; cy++) {
+                X[cy] *= ratio;
+                A[cy] *= ratio;
+            }
+        }
+        for (var ct = start + dim, dt = X.length; ct < dt; ct += dim) {
+            if (X[ct] === 0) continue;
+            var ratio = -X[ct];
+            var delta = start - ct;
+            for (var cy = ct - cx, dy = cy + dim; cy < dy; cy++) {
+                X[cy] += X[cy + delta] * ratio;
+                A[cy] += A[cy + delta] * ratio;
+            }
+        }
+    }
+    for (var cx = dim - 2; cx >= 0; cx--) {
+        var start = cx * dim + cx + 1;
+        for (var ct = start; ct >= 0; ct -= dim) {
+            if (X[ct] === 0) continue;
+            var ratio = -X[ct];
+            var delta = dim + start - ct;
+            for (var cy = cx * dim, dy = cy + dim; cy < dy; cy++) {
+                X[cy] += X[cy + delta] * ratio;
+                A[cy] += A[cy + delta] * ratio;
+            }
+        }
+    }
+    return A;
+};
+
+function size(A) {
+    var dim = Math.sqrt(A.length - 1) | 0;
+    var dim2 = dim;
+    if (A.length % dim !== 0) {
+        dim2++;
+    }
+    if ((dim + 1) * dim2 !== A.length) throw notMatchLength;
+    return [dim2, dim];
+}
+
+class Matrix extends Array {
+    static create2d(theta = 0) {
+        return matrix2d(theta);
+    }
+    static create3d(factor = [0, 0, 0]) {
+        return matrix3d(factor);
+    }
+    size() {
+        return size(this);
+    }
+    dirty() {
+        this._invert = null;
+    }
+    _invert = null;
+    get invert() {
+        if (this._invert) return this._invert;
+        return this._invert = this.slice().inverse();
+    }
+    inverse() {
+        this.dirty();
+        return 逆(this);
+    }
+    rotate(factor, center) {
+        this.dirty();
+        if (center) this.translate(center.map(负));
+        if (factor.length) {
+            this.multiply(matrix3d(factor));
+        }
+        else {
+            this.multiply(matrix2d(factor));
+        }
+        if (center) this.translate(center);
+        return this;
+    }
+    translate(vector) {
+        this.dirty();
+        return translate(this, vector);
+    }
+    scale(ratio) {
+        this.dirty();
+        times(this, ratio);
+        this[this.length - 1] = 1;
+        return this;
+    }
+    multiply(a) {
+        this.dirty();
+        return multiply(this, a);
+    }
+    transform(dots) {
+        if (dots instanceof Array) return transform(dots, this);
+        if (isFinite(dots)) return dots * this[this.length - 1];
+        return dots;
+    }
+}

package/coms/basic/parseYML.js

@@ -75,7 +75,8 @@ var scan = function (text) {
             }
             data += row.slice(0, index + +!!jsonlikes.length);
             row = row.slice(index + 1)
-            unshift(spacesize, row);
+            if (!row) push();
+            else unshift(spacesize, row);
             rowtype = 0;
             continue;
         }
@@ -187,15 +188,16 @@ var scan = function (text) {
             continue;
         }
         else {
-            var match = /^([\s\S]*?)\:(|\s+[\s\S]*)$/.exec(row);
+            var match = /^([\s\S]+)?\:(|\s+[\s\S]*)$/.exec(row);
             if (match) {
-                if (data || prop && span >= spacesize) push();
+                if (data && !!match[1] || prop && span >= spacesize) push();
                 if (prop) {
                     var obj = {};
                     push(obj);
                     parents[spacesize] = obj;
                 }
                 var [_, prop, value] = match;
+                if (!prop) prop = data, data = '';
                 value = value.trim();
                 if (value) {
                     unshift(spacesize + 1, value);

package/coms/compile/common.js

@@ -122,6 +122,7 @@ var createScoped = function (parsed, wash) {
             var isArrow = false;
             var isDeclare = false;
             var isYield = false;
+            var isClass = false;
             switch (o.type) {
                 case QUOTED:
                     if (o.length) {
@@ -215,8 +216,9 @@ var createScoped = function (parsed, wash) {
                                 o = o.next;
                             }
                         case "catch":
-                            isCatch = true;
+                            if (s === 'catch') isCatch = true;
                         case "class":
+                            if (s === 'class') isClass = true;
                             if (!o.isExpress) {
                                 o = o.next;
 
@@ -225,7 +227,6 @@ var createScoped = function (parsed, wash) {
                                     isDeclare = true;
                                     o.kind = isFunction ? 'function' : 'class';
                                     saveTo(used, o.text, o);
-
                                     o = o.next;
                                 }
                             }
@@ -286,6 +287,9 @@ var createScoped = function (parsed, wash) {
                     vars = _vars;
                     scoped.lets = lets;
                     scoped.used = used;
+                    if (isClass) {
+                        lets.super = true;
+                    }
                 }
                 if (isArrow);
                 else if (o.isExpress && o.type !== SCOPED && !isDeclare) {

package/coms/kugou/buildScroll.less

@@ -9,6 +9,10 @@
 }
 &+.titlebar>back{
     height: 44px;
+    pointer-events: all;
+}
+&+.titlebar{
+    pointer-events: none;
 }
 
 >png {

package/coms/zimoli/autodragchildren.js

@@ -216,8 +216,8 @@ var hooka = function (matcher, move, event, targetChild, isMovingSource) {
             var dstElement = children[dst + delta];
             src = bindTarget(src, srcElement);
             dst = bindTarget(dst, dstElement);
-            isFunction(move) && move(src, dst, dst + delta, appendSibling, targetBox);
-            if (srcElement === children[src] && dstElement === children[dst + delta] && srcElement && dstElement) appendSibling(dstElement, srcElement);
+            var needFire = !isFunction(move) || move(src, dst, dst + delta, appendSibling, targetBox) !== false;
+            if (needFire && srcElement === children[src] && dstElement === children[dst + delta] && srcElement && dstElement) appendSibling(dstElement, srcElement);
         } else if (isMovingSource === false) {
             move(previousElements.length, previousElements.length, previousElements.length, null, targetBox);
         }

package/coms/zimoli/confirm.js

@@ -123,9 +123,6 @@ function confirm() {
         onclick(btn, clickbtn);
         return btn;
     });
-    onclick(element, function () {
-        css(this, { zIndex: zIndex() });
-    });
     preventOverflowScrolling(element);
     appendChild(option, buttons);
     if (!target) element.initialStyle = "transform:scale(0.96);opacity:0;transition:transform .3s,opacity .2s ease-out";

package/coms/zimoli/data.js

@@ -314,10 +314,12 @@ function parseConfig(api) {
 var isWorseIE = /msie\s+[2-9]/i.test(navigator.userAgent);
 var parseData = function (sourceText) {
     if (/^\s*<[^\s\'\"\`]/i.test(sourceText)) {
+        if (!isWorseIE && window.DOMParser) {
+            return new window.DOMParser().parseFromString(sourceText, "text/html");
+        }
         // XML 格式
         var doc = document.implementation.createHTMLDocument('');
         if (isWorseIE) {
-
             sourceText = sourceText
                 .replace(/<!--[\s\S]*?-->|<\[CDATA\[[\s\S]*?\]\]>/ig, '')
                 .replace(/^[\s\S]*?<html>([\s\S]*)<\/html>[\s\S]*?$/i, '$1')

package/coms/zimoli/drag.js

@@ -13,6 +13,22 @@ var getOffset = function (e) {
     if (isFinite(e.screenLeft)) return [e.screenLeft, e.screenTop];
     if (isFinite(e.screenX)) return [e.screenX, e.screenY];
 };
+var z;
+var addZIndex = function (clone) {
+    if (clone.style) clone.style.zIndex = z + (+clone.style.zIndex || 0);
+};
+var setZIndex = function () {
+    var target = this;
+    if (!isElement(target)) return;
+    var computed = getComputedStyle(target);
+    var z0 = zIndex(0);
+    if (!z || computed.zIndex < z0) {
+        z = zIndex();
+        if (/^(absolute|fixed)$/i.test(computed.position)) {
+            css(target, { zIndex: z });
+        }
+    }
+};
 function drag(target, initialEvent, preventOverflow, isMovingSource) {
     if (/^(?:select|input|textarea)$/i.test(initialEvent.target.tagName)) return;
     if (target.dragable === false) return;
@@ -36,7 +52,6 @@ function drag(target, initialEvent, preventOverflow, isMovingSource) {
         var saved_height = target.outerHeight;
     }
     var extraClones;
-
     var mousemove = function (event) {
         if (event.moveLocked) return;
         if (/resize/i.test(getComputedStyle(document.body).cursor)) return;
@@ -50,21 +65,20 @@ function drag(target, initialEvent, preventOverflow, isMovingSource) {
             dispatch("dragstart", target);
             if (isElement(target) && !/absolute|fixed/.test(getComputedStyle(target).position)) {
                 clone = toCloneTarget(target, isMovingSource);
+                z = zIndex(0) + 1;
+                addZIndex(clone);
                 appendChild(document.body, clone);
             } else {
                 clone = target;
                 extraTargets = [];
+                if (target.style) css(target, { zIndex: z });
             }
             var [clone_left, clone_top] = getOffset(clone);
             extraClones = extraTargets.map(toCloneTarget);
+            extraClones.forEach(addZIndex);
             extraClones.map(c => document.body.appendChild(c));
             saved_delta.x += clone_left - target_left;
             saved_delta.y += clone_top - target_top;
-            if (clone.style) {
-                var z = zIndex();
-                clone.style.zIndex = z + (+clone.style.zIndex || 0);
-                extraClones.map(e => e.style.zIndex = z + (+e.style.zIndex || 0));
-            }
         }
         drag.target = clone;
         var offsetLeft = saved_delta.x + event.screenX;
@@ -125,6 +139,9 @@ drag.on = function (target, actionTarget = target.dragTarget) {
         var _mousedrag = mousedrag;
         var _touchdrag = touchdrag;
     }
+    onmousedown(actionTarget || target, setZIndex);
+    ontouchstart(actionTarget || target, setZIndex);
+    on("drop")(actionTarget || target, setZIndex);
     onmousedown(target, _mousedrag);
     ontouchstart(target, _touchdrag);
     move.bindPosition(actionTarget || target);

package/coms/zimoli/inertia.js

@@ -1,70 +1 @@
-var { abs, sign = (a) => { if (a > 0) return 1; if (a < 0) return -1; return 0; }, sqrt } = Math;
-function main(gun, is_delta = true) {
-    var smooth = function () {
-        var currentTime = +new Date;
-        var delta_time = currentTime - savedTime;
-
-        savedTime = currentTime;
-        if (delta_time > 6) {
-            var abs_speed = 0;
-            var args = speeds.map(function (_speed, i) {
-                var __speed = _speed() * delta_time;
-                var abs_spd = abs(__speed);
-                if (abs_spd <= 1) {
-                    return _speed(0);
-                }
-                abs_speed = Math.max(abs_speed, abs_spd);
-                __speed = __speed - sign(__speed) * (abs_spd - sqrt(abs_spd) * sqrt(abs_spd - 1));
-                _speed(__speed);
-                return __speed;
-            });
-            run(args);
-            if (!(abs_speed >= 1)) {
-                if (
-                    decrease instanceof Function
-                ) decrease();
-                return;
-            }
-        }
-        smooth_timer = requestAnimationFrame(smooth);
-    };
-    var run = function (args) {
-        if (false === gun.apply(that, args)) {
-            speeds.forEach(a => a(0));
-        }
-    };
-    var saved_args, speeds, smooth_timer, savedTime = 0, that, decrease;
-    var trans = function () {
-        cancelAnimationFrame(smooth_timer);
-        var args = arguments;
-        if (!saved_args) {
-            saved_args = args;
-            speeds = [].map.call(saved_args, a => speed());
-            speeds.forEach(a => a(0));
-            savedTime = +new Date;
-        } else if (args.length !== saved_args.length) {
-            saved_args = null;
-            // throw new Error("前后传入的参数的个数应该相同！");
-        } else {
-            if (!is_delta) {
-                args = [].map.call(args, (a, i) => a - saved_args[i]);
-            }
-            that = this;
-            run(args);
-            args = speeds.map((a, i) => a(args[i]));
-            savedTime = +new Date;
-        }
-    };
-    trans.smooth = function (d) {
-        decrease = d;
-        if (speeds) smooth_timer = requestAnimationFrame(smooth, 20);
-        else decrease();
-    };
-    trans.reset = function () {
-        cancelAnimationFrame(smooth_timer);
-        saved_args = null;
-        speeds = null;
-        decrease = null;
-    };
-    return trans;
-}
+Speed.inertia;