@datagrok/helm 2.3.2 → 2.3.4

package/vendor/dojo-1.10.10/dojox/gfx/fx.js.uncompressed.js

@@ -0,0 +1,350 @@
+define("dojox/gfx/fx", ["dojo/_base/lang", "./_base", "./matrix", "dojo/_base/Color", "dojo/_base/array", "dojo/_base/fx", "dojo/_base/connect", "dojo/sniff"], 
+  function(lang, g, m, Color, arr, fx, Hub, has){
+	var fxg = g.fx = {};
+
+	// Generic interpolators. Should they be moved to dojox.fx?
+
+	function InterpolNumber(start, end){
+		this.start = start, this.end = end;
+	}
+	InterpolNumber.prototype.getValue = function(r){
+		return (this.end - this.start) * r + this.start;
+	};
+
+	function InterpolUnit(start, end, units){
+		this.start = start, this.end = end;
+		this.units = units;
+	}
+	InterpolUnit.prototype.getValue = function(r){
+		return (this.end - this.start) * r + this.start + this.units;
+	};
+
+	function InterpolColor(start, end){
+		this.start = start, this.end = end;
+		this.temp = new Color();
+	}
+	InterpolColor.prototype.getValue = function(r){
+		return Color.blendColors(this.start, this.end, r, this.temp);
+	};
+
+	function InterpolValues(values){
+		this.values = values;
+		this.length = values.length;
+	}
+	InterpolValues.prototype.getValue = function(r){
+		return this.values[Math.min(Math.floor(r * this.length), this.length - 1)];
+	};
+
+	function InterpolObject(values, def){
+		this.values = values;
+		this.def = def ? def : {};
+	}
+	InterpolObject.prototype.getValue = function(r){
+		var ret = lang.clone(this.def);
+		for(var i in this.values){
+			ret[i] = this.values[i].getValue(r);
+		}
+		return ret;
+	};
+
+	function InterpolTransform(stack, original){
+		this.stack = stack;
+		this.original = original;
+	}
+	InterpolTransform.prototype.getValue = function(r){
+		var ret = [];
+		arr.forEach(this.stack, function(t){
+			if(t instanceof m.Matrix2D){
+				ret.push(t);
+				return;
+			}
+			if(t.name == "original" && this.original){
+				ret.push(this.original);
+				return;
+			}
+ 			// Adding support for custom matrices
+ 			if(t.name == "matrix"){
+ 				if((t.start instanceof m.Matrix2D) && (t.end instanceof m.Matrix2D)){
+ 					var transfMatrix = new m.Matrix2D();
+ 					for(var p in t.start) {
+ 						transfMatrix[p] = (t.end[p] - t.start[p])*r + t.start[p];
+ 					}
+ 					ret.push(transfMatrix);
+ 				}
+ 				return;
+ 			}
+			if(!(t.name in m)){ return; }
+			var f = m[t.name];
+			if(typeof f != "function"){
+				// constant
+				ret.push(f);
+				return;
+			}
+			var val = arr.map(t.start, function(v, i){
+							return (t.end[i] - v) * r + v;
+						}),
+				matrix = f.apply(m, val);
+			if(matrix instanceof m.Matrix2D){
+				ret.push(matrix);
+			}
+		}, this);
+		return ret;
+	};
+
+	var transparent = new Color(0, 0, 0, 0);
+
+	function getColorInterpol(prop, obj, name, def){
+		if(prop.values){
+			return new InterpolValues(prop.values);
+		}
+		var value, start, end;
+		if(prop.start){
+			start = g.normalizeColor(prop.start);
+		}else{
+			start = value = obj ? (name ? obj[name] : obj) : def;
+		}
+		if(prop.end){
+			end = g.normalizeColor(prop.end);
+		}else{
+			if(!value){
+				value = obj ? (name ? obj[name] : obj) : def;
+			}
+			end = value;
+		}
+		return new InterpolColor(start, end);
+	}
+
+	function getNumberInterpol(prop, obj, name, def){
+		if(prop.values){
+			return new InterpolValues(prop.values);
+		}
+		var value, start, end;
+		if(prop.start){
+			start = prop.start;
+		}else{
+			start = value = obj ? obj[name] : def;
+		}
+		if(prop.end){
+			end = prop.end;
+		}else{
+			if(typeof value != "number"){
+				value = obj ? obj[name] : def;
+			}
+			end = value;
+		}
+		return new InterpolNumber(start, end);
+	}
+
+	fxg.animateStroke = function(/*Object*/ args){
+		// summary:
+		//		Returns an animation which will change stroke properties over time.
+		// args:
+		//		an object defining the animation setting.
+		// example:
+		//	|	fxg.animateStroke{{
+		//	|		shape: shape,
+		//	|		duration: 500,
+		//	|		color: {start: "red", end: "green"},
+		//	|		width: {end: 15},
+		//	|		join:  {values: ["miter", "bevel", "round"]}
+		//	|	}).play();
+		if(!args.easing){ args.easing = fx._defaultEasing; }
+		var anim = new fx.Animation(args), shape = args.shape, stroke;
+		Hub.connect(anim, "beforeBegin", anim, function(){
+			stroke = shape.getStroke();
+			var prop = args.color, values = {}, value, start, end;
+			if(prop){
+				values.color = getColorInterpol(prop, stroke, "color", transparent);
+			}
+			prop = args.style;
+			if(prop && prop.values){
+				values.style = new InterpolValues(prop.values);
+			}
+			prop = args.width;
+			if(prop){
+				values.width = getNumberInterpol(prop, stroke, "width", 1);
+			}
+			prop = args.cap;
+			if(prop && prop.values){
+				values.cap = new InterpolValues(prop.values);
+			}
+			prop = args.join;
+			if(prop){
+				if(prop.values){
+					values.join = new InterpolValues(prop.values);
+				}else{
+					start = prop.start ? prop.start : (stroke && stroke.join || 0);
+					end = prop.end ? prop.end : (stroke && stroke.join || 0);
+					if(typeof start == "number" && typeof end == "number"){
+						values.join = new InterpolNumber(start, end);
+					}
+				}
+			}
+			this.curve = new InterpolObject(values, stroke);
+		});
+		Hub.connect(anim, "onAnimate", shape, "setStroke");
+		return anim; // dojo.Animation
+	};
+
+	fxg.animateFill = function(/*Object*/ args){
+		// summary:
+		//		Returns an animation which will change fill color over time.
+		//		Only solid fill color is supported at the moment
+		// args:
+		//		an object defining the animation setting.
+		// example:
+		//	|	gfx.animateFill{{
+		//	|		shape: shape,
+		//	|		duration: 500,
+		//	|		color: {start: "red", end: "green"}
+		//	|	}).play();
+		if(!args.easing){ args.easing = fx._defaultEasing; }
+		var anim = new fx.Animation(args), shape = args.shape, fill;
+		Hub.connect(anim, "beforeBegin", anim, function(){
+			fill = shape.getFill();
+			var prop = args.color, values = {};
+			if(prop){
+				this.curve = getColorInterpol(prop, fill, "", transparent);
+			}
+		});
+		Hub.connect(anim, "onAnimate", shape, "setFill");
+		return anim; // dojo.Animation
+	};
+
+	fxg.animateFont = function(/*Object*/ args){
+		// summary:
+		//		Returns an animation which will change font properties over time.
+		// args:
+		//		an object defining the animation setting.
+		// example:
+		//	|	gfx.animateFont{{
+		//	|		shape: shape,
+		//	|		duration: 500,
+		//	|		variant: {values: ["normal", "small-caps"]},
+		//	|		size:  {end: 10, units: "pt"}
+		//	|	}).play();
+		if(!args.easing){ args.easing = fx._defaultEasing; }
+		var anim = new fx.Animation(args), shape = args.shape, font;
+		Hub.connect(anim, "beforeBegin", anim, function(){
+			font = shape.getFont();
+			var prop = args.style, values = {}, value, start, end;
+			if(prop && prop.values){
+				values.style = new InterpolValues(prop.values);
+			}
+			prop = args.variant;
+			if(prop && prop.values){
+				values.variant = new InterpolValues(prop.values);
+			}
+			prop = args.weight;
+			if(prop && prop.values){
+				values.weight = new InterpolValues(prop.values);
+			}
+			prop = args.family;
+			if(prop && prop.values){
+				values.family = new InterpolValues(prop.values);
+			}
+			prop = args.size;
+			if(prop && prop.units){
+				start = parseFloat(prop.start ? prop.start : (shape.font && shape.font.size || "0"));
+				end = parseFloat(prop.end ? prop.end : (shape.font && shape.font.size || "0"));
+				values.size = new InterpolUnit(start, end, prop.units);
+			}
+			this.curve = new InterpolObject(values, font);
+		});
+		Hub.connect(anim, "onAnimate", shape, "setFont");
+		return anim; // dojo.Animation
+	};
+
+	fxg.animateTransform = function(/*Object*/ args){
+		// summary:
+		//		Returns an animation which will change transformation over time.
+		// args:
+		//		an object defining the animation setting.
+		// example:
+		//	|	gfx.animateTransform{{
+		//	|		shape: shape,
+		//	|		duration: 500,
+		//	|		transform: [
+		//	|			{name: "translate", start: [0, 0], end: [200, 200]},
+		//	|			{name: "original"}
+		//	|		]
+		//	|	}).play();
+		if(!args.easing){ args.easing = fx._defaultEasing; }
+		var anim = new fx.Animation(args), shape = args.shape, original;
+		Hub.connect(anim, "beforeBegin", anim, function(){
+			original = shape.getTransform();
+			this.curve = new InterpolTransform(args.transform, original);
+		});
+		Hub.connect(anim, "onAnimate", shape, "setTransform");
+		if(g.renderer === "svg" && (has("ie") >= 9 || has("ff"))){
+			// fix http://bugs.dojotoolkit.org/ticket/16879
+			var handlers = [
+					Hub.connect(anim, "onBegin", anim, function(){
+						var parent = shape.getParent();
+						while(parent && parent.getParent){
+							parent = parent.getParent();
+						}
+						if(parent){
+							shape.__svgContainer = parent.rawNode.parentNode;
+							shape.__svgRoot = parent.rawNode;
+							if(shape.__svgRoot && shape.__svgRoot.getAttribute){
+								shape.__svgWidth = parseInt(shape.__svgRoot.getAttribute("width"), 10);
+								if(isNaN(shape.__svgWidth)){
+									delete shape.__svgWidth;
+								}
+							}
+						}
+					}),
+					Hub.connect(anim, "onAnimate", anim, function(){
+						try{
+							if(shape.__svgContainer){
+								var ov = shape.__svgContainer.style.visibility;
+								shape.__svgContainer.style.visibility = "visible";
+								var pokeNode = shape.__svgContainer.offsetHeight;
+								shape.__svgContainer.style.visibility = ov;
+								var width = shape.__svgWidth;
+								if(!isNaN(width)){
+									try{
+										shape.__svgRoot.setAttribute("width", width  - 0.000005);
+										shape.__svgRoot.setAttribute("width", width);
+									}catch(ignore){}
+								}
+							}
+						}catch(e){}
+					}),
+					Hub.connect(anim, "onEnd", anim, function(){
+						arr.forEach(handlers, Hub.disconnect);
+						if(shape.__svgContainer){
+							var sn = shape.__svgContainer;
+							if(sn.getAttribute("__gotVis") == null){
+								sn.setAttribute("__gotVis", true);
+								var ov = shape.__svgContainer.style.visibility;
+								var root = shape.__svgRoot;
+								var width = shape.__svgWidth;
+								sn.style.visibility = "visible";
+								setTimeout(function(){
+									try{
+										sn.style.visibility = ov;
+										sn.removeAttribute("__gotVis");
+										sn = null;
+										try{
+											if(!isNaN(width)){
+												root.setAttribute("width", width - 0.000005);
+												root.setAttribute("width", width);
+											}
+										}catch(ignore){}
+									}catch(e){}
+								},100);
+							}
+						}
+						delete shape.__svgContainer;
+						delete shape.__svgRoot;
+						delete shape.__svgWidth;
+					})
+				];
+		}
+		return anim; // dojo.Animation
+	};
+	
+	return fxg;
+});

package/vendor/dojo-1.10.10/dojox/gfx/gradutils.js

@@ -0,0 +1,63 @@
+//>>built
+define("dojox/gfx/gradutils",["./_base","dojo/_base/lang","./matrix","dojo/_base/Color"],function(g,_1,m,_2){
+var _3=g.gradutils={};
+function _4(o,c){
+if(o<=0){
+return c[0].color;
+}
+var _5=c.length;
+if(o>=1){
+return c[_5-1].color;
+}
+for(var i=0;i<_5;++i){
+var _6=c[i];
+if(_6.offset>=o){
+if(i){
+var _7=c[i-1];
+return _2.blendColors(new _2(_7.color),new _2(_6.color),(o-_7.offset)/(_6.offset-_7.offset));
+}
+return _6.color;
+}
+}
+return c[_5-1].color;
+};
+_3.getColor=function(_8,pt){
+var o;
+if(_8){
+switch(_8.type){
+case "linear":
+var _9=Math.atan2(_8.y2-_8.y1,_8.x2-_8.x1),_a=m.rotate(-_9),_b=m.project(_8.x2-_8.x1,_8.y2-_8.y1),p=m.multiplyPoint(_b,pt),_c=m.multiplyPoint(_b,_8.x1,_8.y1),_d=m.multiplyPoint(_b,_8.x2,_8.y2),_e=m.multiplyPoint(_a,_d.x-_c.x,_d.y-_c.y).x;
+o=m.multiplyPoint(_a,p.x-_c.x,p.y-_c.y).x/_e;
+break;
+case "radial":
+var dx=pt.x-_8.cx,dy=pt.y-_8.cy;
+o=Math.sqrt(dx*dx+dy*dy)/_8.r;
+break;
+}
+return _4(o,_8.colors);
+}
+return new _2(_8||[0,0,0,0]);
+};
+_3.reverse=function(_f){
+if(_f){
+switch(_f.type){
+case "linear":
+case "radial":
+_f=_1.delegate(_f);
+if(_f.colors){
+var c=_f.colors,l=c.length,i=0,_10,n=_f.colors=new Array(c.length);
+for(;i<l;++i){
+_10=c[i];
+n[i]={offset:1-_10.offset,color:_10.color};
+}
+n.sort(function(a,b){
+return a.offset-b.offset;
+});
+}
+break;
+}
+}
+return _f;
+};
+return _3;
+});

package/vendor/dojo-1.10.10/dojox/gfx/gradutils.js.uncompressed.js

@@ -0,0 +1,91 @@
+// Various generic utilities to deal with a linear gradient
+
+define("dojox/gfx/gradutils", ["./_base", "dojo/_base/lang", "./matrix", "dojo/_base/Color"], 
+  function(g, lang, m, Color){
+  
+	var gradutils = g.gradutils = {};
+
+	function findColor(o, c){
+		if(o <= 0){
+			return c[0].color;
+		}
+		var len = c.length;
+		if(o >= 1){
+			return c[len - 1].color;
+		}
+		//TODO: use binary search
+		for(var i = 0; i < len; ++i){
+			var stop = c[i];
+			if(stop.offset >= o){
+				if(i){
+					var prev = c[i - 1];
+					return Color.blendColors(new Color(prev.color), new Color(stop.color),
+						(o - prev.offset) / (stop.offset - prev.offset));
+				}
+				return stop.color;
+			}
+		}
+		return c[len - 1].color;
+	}
+
+	gradutils.getColor = function(fill, pt){
+		// summary:
+		//		sample a color from a gradient using a point
+		// fill: Object
+		//		fill object
+		// pt: dojox/gfx.Point
+		//		point where to sample a color
+		var o;
+		if(fill){
+			switch(fill.type){
+				case "linear":
+					var angle = Math.atan2(fill.y2 - fill.y1, fill.x2 - fill.x1),
+						rotation = m.rotate(-angle),
+						projection = m.project(fill.x2 - fill.x1, fill.y2 - fill.y1),
+						p = m.multiplyPoint(projection, pt),
+						pf1 = m.multiplyPoint(projection, fill.x1, fill.y1),
+						pf2 = m.multiplyPoint(projection, fill.x2, fill.y2),
+						scale = m.multiplyPoint(rotation, pf2.x - pf1.x, pf2.y - pf1.y).x;
+					o = m.multiplyPoint(rotation, p.x - pf1.x, p.y - pf1.y).x / scale;
+					break;
+				case "radial":
+					var dx = pt.x - fill.cx, dy = pt.y - fill.cy;
+					o = Math.sqrt(dx * dx + dy * dy) / fill.r;
+					break;
+			}
+			return findColor(o, fill.colors);	// dojo/_base/Color
+		}
+		// simple color
+		return new Color(fill || [0, 0, 0, 0]);	// dojo/_base/Color
+	};
+
+	gradutils.reverse = function(fill){
+		// summary:
+		//		reverses a gradient
+		// fill: Object
+		//		fill object
+		if(fill){
+			switch(fill.type){
+				case "linear":
+				case "radial":
+					fill = lang.delegate(fill);
+					if(fill.colors){
+						var c = fill.colors, l = c.length, i = 0, stop,
+							n = fill.colors = new Array(c.length);
+						for(; i < l; ++i){
+							stop = c[i];
+							n[i] = {
+								offset: 1 - stop.offset,
+								color:  stop.color
+							};
+						}
+						n.sort(function(a, b){ return a.offset - b.offset; });
+					}
+					break;
+			}
+		}
+		return fill;	// Object
+	};
+
+	return gradutils;
+});

package/vendor/dojo-1.10.10/dojox/gfx/matrix.js

@@ -0,0 +1,170 @@
+//>>built
+define("dojox/gfx/matrix",["./_base","dojo/_base/lang"],function(g,_1){
+var m=g.matrix={};
+var _2={};
+m._degToRad=function(_3){
+return _2[_3]||(_2[_3]=(Math.PI*_3/180));
+};
+m._radToDeg=function(_4){
+return _4/Math.PI*180;
+};
+m.Matrix2D=function(_5){
+if(_5){
+if(typeof _5=="number"){
+this.xx=this.yy=_5;
+}else{
+if(_5 instanceof Array){
+if(_5.length>0){
+var _6=m.normalize(_5[0]);
+for(var i=1;i<_5.length;++i){
+var l=_6,r=m.normalize(_5[i]);
+_6=new m.Matrix2D();
+_6.xx=l.xx*r.xx+l.xy*r.yx;
+_6.xy=l.xx*r.xy+l.xy*r.yy;
+_6.yx=l.yx*r.xx+l.yy*r.yx;
+_6.yy=l.yx*r.xy+l.yy*r.yy;
+_6.dx=l.xx*r.dx+l.xy*r.dy+l.dx;
+_6.dy=l.yx*r.dx+l.yy*r.dy+l.dy;
+}
+_1.mixin(this,_6);
+}
+}else{
+_1.mixin(this,_5);
+}
+}
+}
+};
+_1.extend(m.Matrix2D,{xx:1,xy:0,yx:0,yy:1,dx:0,dy:0});
+_1.mixin(m,{identity:new m.Matrix2D(),flipX:new m.Matrix2D({xx:-1}),flipY:new m.Matrix2D({yy:-1}),flipXY:new m.Matrix2D({xx:-1,yy:-1}),translate:function(a,b){
+if(arguments.length>1){
+return new m.Matrix2D({dx:a,dy:b});
+}
+return new m.Matrix2D({dx:a.x,dy:a.y});
+},scale:function(a,b){
+if(arguments.length>1){
+return new m.Matrix2D({xx:a,yy:b});
+}
+if(typeof a=="number"){
+return new m.Matrix2D({xx:a,yy:a});
+}
+return new m.Matrix2D({xx:a.x,yy:a.y});
+},rotate:function(_7){
+var c=Math.cos(_7);
+var s=Math.sin(_7);
+return new m.Matrix2D({xx:c,xy:-s,yx:s,yy:c});
+},rotateg:function(_8){
+return m.rotate(m._degToRad(_8));
+},skewX:function(_9){
+return new m.Matrix2D({xy:Math.tan(_9)});
+},skewXg:function(_a){
+return m.skewX(m._degToRad(_a));
+},skewY:function(_b){
+return new m.Matrix2D({yx:Math.tan(_b)});
+},skewYg:function(_c){
+return m.skewY(m._degToRad(_c));
+},reflect:function(a,b){
+if(arguments.length==1){
+b=a.y;
+a=a.x;
+}
+var a2=a*a,b2=b*b,n2=a2+b2,xy=2*a*b/n2;
+return new m.Matrix2D({xx:2*a2/n2-1,xy:xy,yx:xy,yy:2*b2/n2-1});
+},project:function(a,b){
+if(arguments.length==1){
+b=a.y;
+a=a.x;
+}
+var a2=a*a,b2=b*b,n2=a2+b2,xy=a*b/n2;
+return new m.Matrix2D({xx:a2/n2,xy:xy,yx:xy,yy:b2/n2});
+},normalize:function(_d){
+return (_d instanceof m.Matrix2D)?_d:new m.Matrix2D(_d);
+},isIdentity:function(_e){
+return _e.xx==1&&_e.xy==0&&_e.yx==0&&_e.yy==1&&_e.dx==0&&_e.dy==0;
+},clone:function(_f){
+var obj=new m.Matrix2D();
+for(var i in _f){
+if(typeof (_f[i])=="number"&&typeof (obj[i])=="number"&&obj[i]!=_f[i]){
+obj[i]=_f[i];
+}
+}
+return obj;
+},invert:function(_10){
+var M=m.normalize(_10),D=M.xx*M.yy-M.xy*M.yx;
+M=new m.Matrix2D({xx:M.yy/D,xy:-M.xy/D,yx:-M.yx/D,yy:M.xx/D,dx:(M.xy*M.dy-M.yy*M.dx)/D,dy:(M.yx*M.dx-M.xx*M.dy)/D});
+return M;
+},_multiplyPoint:function(_11,x,y){
+return {x:_11.xx*x+_11.xy*y+_11.dx,y:_11.yx*x+_11.yy*y+_11.dy};
+},multiplyPoint:function(_12,a,b){
+var M=m.normalize(_12);
+if(typeof a=="number"&&typeof b=="number"){
+return m._multiplyPoint(M,a,b);
+}
+return m._multiplyPoint(M,a.x,a.y);
+},multiplyRectangle:function(_13,_14){
+var M=m.normalize(_13);
+_14=_14||{x:0,y:0,width:0,height:0};
+if(m.isIdentity(M)){
+return {x:_14.x,y:_14.y,width:_14.width,height:_14.height};
+}
+var p0=m.multiplyPoint(M,_14.x,_14.y),p1=m.multiplyPoint(M,_14.x,_14.y+_14.height),p2=m.multiplyPoint(M,_14.x+_14.width,_14.y),p3=m.multiplyPoint(M,_14.x+_14.width,_14.y+_14.height),_15=Math.min(p0.x,p1.x,p2.x,p3.x),_16=Math.min(p0.y,p1.y,p2.y,p3.y),_17=Math.max(p0.x,p1.x,p2.x,p3.x),_18=Math.max(p0.y,p1.y,p2.y,p3.y);
+return {x:_15,y:_16,width:_17-_15,height:_18-_16};
+},multiply:function(_19){
+var M=m.normalize(_19);
+for(var i=1;i<arguments.length;++i){
+var l=M,r=m.normalize(arguments[i]);
+M=new m.Matrix2D();
+M.xx=l.xx*r.xx+l.xy*r.yx;
+M.xy=l.xx*r.xy+l.xy*r.yy;
+M.yx=l.yx*r.xx+l.yy*r.yx;
+M.yy=l.yx*r.xy+l.yy*r.yy;
+M.dx=l.xx*r.dx+l.xy*r.dy+l.dx;
+M.dy=l.yx*r.dx+l.yy*r.dy+l.dy;
+}
+return M;
+},_sandwich:function(_1a,x,y){
+return m.multiply(m.translate(x,y),_1a,m.translate(-x,-y));
+},scaleAt:function(a,b,c,d){
+switch(arguments.length){
+case 4:
+return m._sandwich(m.scale(a,b),c,d);
+case 3:
+if(typeof c=="number"){
+return m._sandwich(m.scale(a),b,c);
+}
+return m._sandwich(m.scale(a,b),c.x,c.y);
+}
+return m._sandwich(m.scale(a),b.x,b.y);
+},rotateAt:function(_1b,a,b){
+if(arguments.length>2){
+return m._sandwich(m.rotate(_1b),a,b);
+}
+return m._sandwich(m.rotate(_1b),a.x,a.y);
+},rotategAt:function(_1c,a,b){
+if(arguments.length>2){
+return m._sandwich(m.rotateg(_1c),a,b);
+}
+return m._sandwich(m.rotateg(_1c),a.x,a.y);
+},skewXAt:function(_1d,a,b){
+if(arguments.length>2){
+return m._sandwich(m.skewX(_1d),a,b);
+}
+return m._sandwich(m.skewX(_1d),a.x,a.y);
+},skewXgAt:function(_1e,a,b){
+if(arguments.length>2){
+return m._sandwich(m.skewXg(_1e),a,b);
+}
+return m._sandwich(m.skewXg(_1e),a.x,a.y);
+},skewYAt:function(_1f,a,b){
+if(arguments.length>2){
+return m._sandwich(m.skewY(_1f),a,b);
+}
+return m._sandwich(m.skewY(_1f),a.x,a.y);
+},skewYgAt:function(_20,a,b){
+if(arguments.length>2){
+return m._sandwich(m.skewYg(_20),a,b);
+}
+return m._sandwich(m.skewYg(_20),a.x,a.y);
+}});
+g.Matrix2D=m.Matrix2D;
+return m;
+});