45         numsort = function (a, b) {  argument
46             return a - b;
464     isArray = Array.isArray || function (a) {
465         return a instanceof Array ||  class
466             Object.prototype.toString.call(a) == "[object Array]";  argument
473     diff = function (a, b, A, B) {
474         if (isArray(a)) {
476             for (var i = 0, ii = a.length; i < ii; i++) {
477                 res[i] = diff(a[i], b, A[i], B);
481         var dif = (A - a) / (B - b);
483             return a + dif * (bb - b);
490         var a = this;
492             return a.s;
494         var ds = a.s - val;
495         a.b += a.dur * ds;
496         a.B += a.dur * ds;
497         a.s = val;
500         var a = this;
502             return a.spd;
504         a.spd = val;
507         var a = this;
509             return a.dur;
511         a.s = a.s * val / a.dur;
512         a.dur = val;
515         var a = this;
516         delete animations[a.id];
517         a.update();
518         eve("mina.stop." + a.id, a);
521         var a = this;
522         if (a.pdif) {
525         delete animations[a.id];
526         a.update();
527         a.pdif = a.get() - a.b;
530         var a = this;
531         if (!a.pdif) {
534         a.b = a.get() - a.pdif;
535         delete a.pdif;
536         animations[a.id] = a;
539         var a = this,
541         if (isArray(a.start)) {
543             for (var j = 0, jj = a.start.length; j < jj; j++) {
544                 res[j] = +a.start[j] +
545                     (a.end[j] - a.start[j]) * a.easing(a.s);
548             res = +a.start + (a.end - a.start) * a.easing(a.s);
550         a.set(res);
555             var a = animations[i],
556                 b = a.get(),
559             a.s = (b - a.b) / (a.dur / a.spd);
560             if (a.s >= 1) {
562                 a.s = 1;
564                 (function (a) {
566                         eve("mina.finish." + a.id, a);
568                 }(a));
570             a.update();
608     mina = function (a, A, b, B, get, set, easing) {
611             start: a,
1757 …  var paramCounts = {a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0},
1763         Str(pathString).replace(pathCommand, function (a, b, c) {
1766             c.replace(pathValues, function (a, b) {
1811         Str(TString).replace(tCommand, function (a, b, c) {
1814             c.replace(pathValues, function (a, b) {
1924     function (a, b) {
1925         var adown = a.nodeType == 9 ? a.documentElement : a,
1927             return a == bup || !!(bup && bup.nodeType == 1 && (
1930                     a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
1933     function (a, b) {
1937                 if (b == a) {
3355             (function (a) {
3357                     anim: new Animation(a._attrs, a.dur, a.easing, a._callback),
3358                     mina: a,
3359                     curStatus: a.status(),
3361                         return a.status(val);
3364                         a.stop();
3646     function Matrix(a, b, c, d, e, f) {  argument
3647         if (b == null && objectToString.call(a) == "[object SVGMatrix]") {
3648             this.a = a.a;
3649             this.b = a.b;
3650             this.c = a.c;
3651             this.d = a.d;
3652             this.e = a.e;
3653             this.f = a.f;
3656         if (a != null) {
3657             this.a = +a;
3664             this.a = 1;
3687         matrixproto.add = function (a, b, c, d, e, f) {  argument
3689                 m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]],
3690                 matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
3693             if (a && a instanceof Matrix) {
3694                 matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]];
3706             this.a = out[0][0];
3723                 x = me.a * me.d - me.b * me.c;
3724 … new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.…
3734             return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f);
3774         matrixproto.rotate = function (a, x, y) {  argument
3775             a = Snap.rad(a);
3778             var cos = +math.cos(a).toFixed(9),
3779                 sin = +math.sin(a).toFixed(9);
3793             return x * this.a + y * this.c + this.e;
3816         function norm(a) {  argument
3817             return a[0] * a[0] + a[1] * a[1];
3819         function normalize(a) {  argument
3820             var mag = math.sqrt(norm(a));
3821             a[0] && (a[0] /= mag);
3822             a[1] && (a[1] /= mag);
3832             return this.a * this.d - this.b * this.c;
3855             var row = [[this.a, this.c], [this.b, this.d]];
3933     Snap.matrix = function (a, b, c, d, e, f) {  argument
3934         return new Matrix(a, b, c, d, e, f);
4541                 a = this.attr(name),
4545                 aUnit = a.match(reUnit),
4548                 val = op(parseFloat(a), +plus[2]);
4550                 a = this.asPX(name);
4553             if (isNaN(a) || isNaN(val)) {
4561         var A, B, a = Str(this.attr(name) || ""),
4567                 aUnit = a.match(reUnit),
4571                     from: parseFloat(a),
4572                     to: op(parseFloat(a), +bplus[2]),
4576                 a = this.asPX(name);
4578                     from: a,
4579                     to: op(a, this.asPX(name, bplus[2] + unit)),
5776     function ellipsePath(x, y, rx, ry, a) {  argument
5777         if (a == null && ry == null) {
5784         if (a != null) {
5787                 x2 = x + rx * Math.cos(-a * rad),
5789                 y2 = y + rx * Math.sin(-a * rad),
5790                 res = [["M", x1, y1], ["A", rx, rx, 0, +(a - ry > 180), 0, x2, y2]];
6162             a, b, c, t, t1, t2, b2ac, sqrtb2ac;
6166                 a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
6170                 a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
6173             if (abs(a) < 1e-12) {
6183             b2ac = b * b - 4 * c * a;
6188             t1 = (-b + sqrtb2ac) / (2 * a);
6192             t2 = (-b - sqrtb2ac) / (2 * a);
6467         var a = getSubpathsAtLength(path, to, 1);
6468         return from ? getSubpathsAtLength(a, from).end : a;
6931     setproto.bind = function (attr, a, b) {  argument
6933         if (typeof a == "function") {
6934             this.bindings[attr] = a;
6939                 a.attr(data);
7133                     from = [["m", t1.a, t1.b, t1.c, t1.d, t1.e, t1.f]];
7134                     to = [["m", t2.a, t2.b, t2.c, t2.d, t2.e, t2.f]];
7165         var k = 0, i, ii, j, jj, out, a, b = [];
7168             a = ['"' + path[i][0] + '"'];
7170                 a[j] = "val[" + (k++) + "]";
7172             out += a + "]";
7199         var A, B, a = Str(this.attr(name) || ""),
7201         if (isNumeric(a) && isNumeric(b)) {
7203                 from: parseFloat(a),
7209             A = Snap.color(a);
7233             return equaliseTransform(a, b, function () {
7238             A = Snap.path.toCubic(a, b);
7246             A = Str(a).split(Snap._.separator);
7254         var aUnit = a.match(reUnit),
7258                 from: parseFloat(a),
7932             a: 0.2126 + 0.7874 * (1 - amount),
7959             a: 0.393 + 0.607 * (1 - amount),