711             x = Q - q,
712             X = Math.pow(Math.abs(x), 1 / 3) * (x < 0 ? -1 : 1),
1055         var x = x1 - x2,
1057         if (!x && !y) {
1060         return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360;
1072     return this.x + S + this.y;
1075     return this.x + S + this.y + S + this.width + " \xd7 " + this.height;
1236 Snap.closestPoint = function (path, x, y) {
1238         var dx = p.x - x,
1275         x: best.x,
1872                     x1 = inver.x(0, 0);
1874                     x2 = inver.x(t[1], t[2]);
1883                     m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);
1886                         x2 = inver.x(t[2], t[3]);
1896                     m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);
1899                         x2 = inver.x(t[2], t[3]);
1907                         x2 = inver.x(t[3], t[4]);
1967         $(mgr, {x: -9e9, y: -9e9, width: 10, height: 10, "class": "svg---mgr", fill: "none"});
2590         x: left
2605 Snap.getElementByPoint = function (x, y) {
2608         target = glob.doc.elementFromPoint(x, y);
2612         sr.x = x - so.x;
3233     elproto.pattern = elproto.toPattern = function (x, y, width, height) {  argument
3235         if (x == null) {
3236             x = this.getBBox();
3238         if (is(x, "object") && "x" in x) {
3239             y = x.y;
3240             width = x.width;
3241             height = x.height;
3242             x = x.x;
3245             x: x,
3251             viewBox: [x, y, width, height].join(" ")
3275     elproto.marker = function (x, y, width, height, refX, refY) {  argument
3277         if (x == null) {
3278             x = this.getBBox();
3280         if (is(x, "object") && "x" in x) {
3281             y = x.y;
3282             width = x.width;
3283             height = x.height;
3284             refX = x.refX || x.cx;
3285             refY = x.refY || x.cy;
3286             x = x.x;
3289             viewBox: [x, y, width, height].join(" "),
3603                 x: +bb.x.toFixed(3),
3691                 x, y, z, res;
3697             for (x = 0; x < 3; x++) {
3701                         res += m[x][z] * matrix[z][y];
3703                     out[x][y] = res;
3723                 x = me.a * me.d - me.b * me.c;
3724 …return 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…
3744         matrixproto.translate = function (x, y) {  argument
3745             return this.add(1, 0, 0, 1, x, y);
3758         matrixproto.scale = function (x, y, cx, cy) {  argument
3759             y == null && (y = x);
3761             this.add(x, 0, 0, y, 0, 0);
3774         matrixproto.rotate = function (a, x, y) {  argument
3776             x = x || 0;
3780             this.add(cos, sin, -sin, cos, x, y);
3781             return this.add(1, 0, 0, 1, -x, -y);
3792         matrixproto.x = function (x, y) {  function
3793             return x * this.a + y * this.c + this.e;
3804         matrixproto.y = function (x, y) {  argument
3805             return x * this.b + y * this.d + this.f;
4120             vb = [value.x, value.y, value.width, value.height].join(" ");
4512             "+": function (x, y) {  argument
4513                     return x + y;
4515             "-": function (x, y) {  argument
4516                     return x - y;
4518             "/": function (x, y) {  argument
4519                     return x / y;
4521             "*": function (x, y) {  argument
4522                     return x * y;
4622     proto.rect = function (x, y, w, h, rx, ry) {  argument
4627         if (is(x, "object") && x == "[object Object]") {
4628             attr = x;
4629         } else if (x != null) {
4631                 x: x,  property in proto.rect.attr
4708     proto.image = function (src, x, y, width, height) {  argument
4717             if (x != null && y != null) {
4718                 set.x = x;
4857     proto.svg = function (x, y, width, height, vbx, vby, vbw, vbh) {  argument
4859         if (is(x, "object") && y == null) {
4860             attrs = x;
4862             if (x != null) {
4863                 attrs.x = x;
4916     proto.ptrn = function (x, y, width, height, vx, vy, vw, vh) {  argument
4917         if (is(x, "object")) {
4918             var attr = x;
4921             if (x) {
4922                 attr.x = x;
4936                 attr.viewBox = [x || 0, y || 0, width || 0, height || 0];
5009     proto.text = function (x, y, text) {  argument
5011         if (is(x, "object")) {
5012             attr = x;
5013         } else if (x != null) {
5015                 x: x,  property in proto.text.attr
5350     function box(x, y, width, height) {  argument
5351         if (x == null) {
5352             x = y = width = height = 0;
5355             y = x.y;
5356             width = x.width;
5357             height = x.height;
5358             x = x.x;
5361             x: x,
5367             x2: x + width,
5369             cx: x + width / 2,
5374             path: rectPath(x, y, width, height),
5375             vb: [x, y, width, height].join(" ")
5403             var x, y, p, l, sp = "", subpaths = {}, point,
5408                     x = +p[1];
5411                     l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
5414 …           point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
5416                                 "C" + O(point.start.x),
5418                                 O(point.m.x),
5420                                 O(point.x),
5426                                 "M" + O(point.x),
5427                                 O(point.y) + "C" + O(point.n.x),
5429                                 O(point.end.x),
5435                             x = +p[5];
5440 …           point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
5445                     x = +p[5];
5451 …point = istotal ? len : subpath ? subpaths : findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4],…
5464             x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
5477             x: x,
5479             m: {x: mx, y: my},
5480             n: {x: nx, y: ny},
5481             start: {x: ax, y: ay},
5482             end: {x: cx, y: cy},
5492             bbox.min.x,
5494             bbox.max.x - bbox.min.x,
5498     function isPointInsideBBox(bbox, x, y) {  argument
5499         return  x >= bbox.x &&
5500                 x <= bbox.x + bbox.width &&
5507         return isPointInsideBBox(bbox2, bbox1.x, bbox1.y)
5509             || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2)
5511             || isPointInsideBBox(bbox1, bbox2.x, bbox2.y)
5513             || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2)
5515             || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x
5516                 || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
5593         return {x: px, y: py};
5617             dots1.push({x: p.x, y: p.y, t: i / n1});
5621             dots2.push({x: p.x, y: p.y, t: i / n2});
5629                     ci = abs(di1.x - di.x) < .001 ? "y" : "x",
5630                     cj = abs(dj1.x - dj.x) < .001 ? "y" : "x",
5631                     is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);
5633                     if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {
5636                     xy[is.x.toFixed(4)] = is.y.toFixed(4);
5644                                 x: is.x,
5715     function isPointInsidePath(path, x, y) {  argument
5717         return isPointInsideBBox(bbox, x, y) &&
5718                interPathHelper(path, [["M", x, y], ["H", bbox.x2 + 10]], 1) % 2 == 1;
5729         var x = 0, 
5737                 x = p[1];
5739                 X.push(x);
5742                 var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
5743                 X = X.concat(dim.min.x, dim.max.x);
5745                 x = p[5];
5757     function rectPath(x, y, w, h, r) {  argument
5760                 ["M", +x + (+r), y],
5772         var res = [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
5776     function ellipsePath(x, y, rx, ry, a) {  argument
5780         x = +x;
5786                 x1 = x + rx * Math.cos(-ry * rad),
5787                 x2 = x + rx * Math.cos(-a * rad),
5793                 ["M", x, y],
5818             return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height, attr.rx, attr.ry);
5822             return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height);
5835             return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
5848             x = 0,
5854             x = pathArray[0][1];
5856             mx = x;
5859             res.push(["M", x, y]);
5873                         r[6] = +(pa[6] - x).toFixed(3);
5884                             r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
5890                     mx = pa[1] + x;
5900                     x = mx;
5904                     x += +res[i][len - 1];
5910                     x += +res[i][len - 2];
5930             x = 0,
5937             x = +pathArray[0][1];
5939             mx = x;
5942             res[0] = ["M", x, y];
5961                         r[6] = +pa[6] + x;
5968                         r[1] = +pa[1] + x;
5971                         var dots = [x, y].concat(pa.slice(1));
5973                             dots[j] = +dots[j] + x;
5981                         dots = ellipsePath(x, y, pa[1], pa[2]);
5987                         res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));
5991                         mx = +pa[1] + x;
5995                             r[j] = +pa[j] + ((j % 2) ? x : y);
5999                 dots = [x, y].concat(pa.slice(1));
6005                 dots = ellipsePath(x, y, pa[1], pa[2]);
6010                 res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));
6021                         x = +mx;
6025                         x = r[1];
6034                         x = r[r.length - 2];
6065             rotate = Snap._.cacher(function (x, y, rad) {  argument
6066                 var X = x * math.cos(rad) - y * math.sin(rad),
6067                     Y = x * math.sin(rad) + y * math.cos(rad);
6068                 return {x: X, y: Y};
6072             x1 = xy.x;
6075             x2 = xy.x;
6079                 x = (x1 - x2) / 2,
6081             var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
6090 …             math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
6092                 cy = k * -ry * x / rx + (y1 + y2) / 2,
6142 …         newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
6150             x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
6198         var x, y, j = tvalues.length,
6216           min: {x: mmin.apply(0, bounds[0]), y: mmin.apply(0, bounds[1])},
6217           max: {x: mmax.apply(0, bounds[0]), y: mmax.apply(0, bounds[1])}
6228             attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},  property in path2curve.attrs
6229             attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},  property in path2curve.attrs2
6233                     return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
6242                         path = ["C"].concat(a2c.apply(0, [d.x, d.y].concat(path.slice(1))));
6246                             nx = d.x * 2 - d.bx;          // And reflect the previous
6250                             nx = d.x;
6257                             d.qx = d.x * 2 - d.qx;        // And make a reflection similar
6261                             d.qx = d.x;
6264                         path = ["C"].concat(q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));
6269                         path = ["C"].concat(q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
6272                         path = ["C"].concat(l2c(d.x, d.y, path[1], path[2]));
6275                         path = ["C"].concat(l2c(d.x, d.y, path[1], d.y));
6278                         path = ["C"].concat(l2c(d.x, d.y, d.x, path[1]));
6281                         path = ["C"].concat(l2c(d.x, d.y, d.X, d.Y));
6301                     path2.splice(i, 0, ["M", a2.x, a2.y]);
6304                     a1.x = path1[i][1];
6349             attrs.x = seg[seglen - 2];
6351             attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
6353             attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);
6355             attrs2.x = p2 && seg2[seg2len - 2];
6367         var x, y, i, j, ii, jj, pathi;
6372                 x = matrix.x(pathi[j], pathi[j + 1]);
6374                 pathi[j] = x;
6386                         {x: +crp[i - 2], y: +crp[i - 1]},
6387                         {x: +crp[i],     y: +crp[i + 1]},
6388                         {x: +crp[i + 2], y: +crp[i + 3]},
6389                         {x: +crp[i + 4], y: +crp[i + 5]}
6393                     p[0] = {x: +crp[iLen - 2], y: +crp[iLen - 1]};  property in catmullRom2bezier.p
6395                     p[3] = {x: +crp[0], y: +crp[1]};  property in catmullRom2bezier.p
6397                     p[2] = {x: +crp[0], y: +crp[1]};  property in catmullRom2bezier.p
6398                     p[3] = {x: +crp[2], y: +crp[3]};  property in catmullRom2bezier.p
6404                     p[0] = {x: +crp[i], y: +crp[i + 1]};  property in catmullRom2bezier.p
6408                   (-p[0].x + 6 * p[1].x + p[2].x) / 6,
6410                   (p[1].x + 6 * p[2].x - p[3].x) / 6,
6412                   p[2].x,
6598     Snap.closest = function (x, y, X, Y) {  argument
6600             b = box(x - r / 2, y - r / 2, r, r),
6604                     x: X[i].x,
6609                     x: X[i],
6617                 if (isPointInsideBBox(b, xy.x, xy.y)) {
6625                 b = box(x - r / 2, y - r / 2, r, r)
6634             var l = Snap.len(x, y, inside[i].x, inside[i].y);
7030         var x = [],
7036             x.push(box.x);
7038             x2.push(box.x + box.width);
7041         x = mmin.apply(0, x);
7046             x: x,
7050             width: x2 - x,
7052             cx: x + (x2 - x) / 2,
7333                 var x = e.clientX + scrollX,
7335                 return fn.call(element, e, x, y);
7355         var x = e.clientX,
7369                         x = touch.clientX;
7389             x += scrollX;
7391 …g.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, …
7699         function start(e, x, y) {  argument
7701             el._drag.x = x;
7709             eve("snap.drag.start." + el.id, start_scope || move_scope || el, x, y, e);
7711         function init(e, x, y) {  argument
7712             eve("snap.draginit." + el.id, el, e, x, y);
7843     Snap.filter.blur = function (x, y) {  argument
7844         if (x == null) {
7845             x = 2;
7847         var def = y == null ? x : [x, y];
8135                 out.dx = bx.x - bb.x;