@datagrok/helm 2.3.2 → 2.3.4

package/vendor/dojo-1.10.10/dojox/lang/functional/lambda.js.uncompressed.js

@@ -0,0 +1,132 @@
+define("dojox/lang/functional/lambda", ["../..", "dojo/_base/lang", "dojo/_base/array"], function(dojox, lang, arr){
+	var df = lang.getObject("lang.functional", true, dojox);
+
+// This module adds high-level functions and related constructs:
+//	- anonymous functions built from the string
+
+// Acknowledgements:
+//	- lambda() is based on work by Oliver Steele
+//		(http://osteele.com/sources/javascript/functional/functional.js)
+//		which was published under MIT License
+
+// Notes:
+//	- lambda() produces functions, which after the compilation step are
+//		as fast as regular JS functions (at least theoretically).
+
+// Lambda input values:
+//	- returns functions unchanged
+//	- converts strings to functions
+//	- converts arrays to a functional composition
+
+	var lcache = {};
+
+	// split() is augmented on IE6 to ensure the uniform behavior
+	var split = "ab".split(/a*/).length > 1 ? String.prototype.split :
+			function(sep){
+				 var r = this.split.call(this, sep),
+					 m = sep.exec(this);
+				 if(m && m.index == 0){ r.unshift(""); }
+				 return r;
+			};
+			
+	var lambda = function(/*String*/ s){
+		var args = [], sects = split.call(s, /\s*->\s*/m);
+		if(sects.length > 1){
+			while(sects.length){
+				s = sects.pop();
+				args = sects.pop().split(/\s*,\s*|\s+/m);
+				if(sects.length){ sects.push("(function(" + args.join(", ") + "){ return (" + s + "); })"); }
+			}
+		}else if(s.match(/\b_\b/)){
+			args = ["_"];
+		}else{
+			var l = s.match(/^\s*(?:[+*\/%&|\^\.=<>]|!=)/m),
+				r = s.match(/[+\-*\/%&|\^\.=<>!]\s*$/m);
+			if(l || r){
+				if(l){
+					args.push("$1");
+					s = "$1" + s;
+				}
+				if(r){
+					args.push("$2");
+					s = s + "$2";
+				}
+			}else{
+				// the point of the long regex below is to exclude all well-known
+				// lower-case words from the list of potential arguments
+				var vars = s.
+					replace(/(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|this|true|false|null|undefined|typeof|instanceof|in|delete|new|void|arguments|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|isFinite|isNaN|parseFloat|parseInt|unescape|dojo|dijit|dojox|window|document|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, "").
+					match(/([a-z_$][a-z_$\d]*)/gi) || [], t = {};
+				arr.forEach(vars, function(v){
+					if(!t.hasOwnProperty(v)){
+						args.push(v);
+						t[v] = 1;
+					}
+				});
+			}
+		}
+		return {args: args, body: s};	// Object
+	};
+
+	var compose = function(/*Array*/ a){
+		return a.length ?
+					function(){
+						var i = a.length - 1, x = df.lambda(a[i]).apply(this, arguments);
+						for(--i; i >= 0; --i){ x = df.lambda(a[i]).call(this, x); }
+						return x;
+					}
+				:
+					// identity
+					function(x){ return x; };
+	};
+
+	lang.mixin(df, {
+		// lambda
+		rawLambda: function(/*String*/ s){
+			// summary:
+			//		builds a function from a snippet, or array (composing),
+			//		returns an object describing the function; functions are
+			//		passed through unmodified.
+			// description:
+			//		This method is to normalize a functional representation (a
+			//		text snippet) to an object that contains an array of
+			//		arguments, and a body , which is used to calculate the
+			//		returning value.
+			return lambda(s);	// Object
+		},
+		buildLambda: function(/*String*/ s){
+			// summary:
+			//		builds a function from a snippet, returns a string, which
+			//		represents the function.
+			// description:
+			//		This method returns a textual representation of a function
+			//		built from the snippet. It is meant to be evaled in the
+			//		proper context, so local variables can be pulled from the
+			//		environment.
+			var l = lambda(s);
+			return "function(" + l.args.join(",") + "){return (" + l.body + ");}";	// String
+		},
+		lambda: function(/*Function|String|Array*/ s){
+			// summary:
+			//		builds a function from a snippet, or array (composing),
+			//		returns a function object; functions are passed through
+			//		unmodified.
+			// description:
+			//		This method is used to normalize a functional
+			//		representation (a text snippet, an array, or a function) to
+			//		a function object.
+			if(typeof s == "function"){ return s; }
+			if(s instanceof Array){ return compose(s); }
+			if(lcache.hasOwnProperty(s)){ return lcache[s]; }
+			var l = lambda(s);
+			return lcache[s] = new Function(l.args, "return (" + l.body + ");");	// Function
+		},
+		clearLambdaCache: function(){
+			// summary:
+			//		clears internal cache of lambdas
+			lcache = {};
+		}
+	});
+	
+	return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/object.js

@@ -0,0 +1,54 @@
+//>>built
+define("dojox/lang/functional/object",["dojo/_base/kernel","dojo/_base/lang","./lambda"],function(_1,_2,df){
+var _3={};
+_2.mixin(df,{keys:function(_4){
+var t=[];
+for(var i in _4){
+if(!(i in _3)){
+t.push(i);
+}
+}
+return t;
+},values:function(_5){
+var t=[];
+for(var i in _5){
+if(!(i in _3)){
+t.push(_5[i]);
+}
+}
+return t;
+},filterIn:function(_6,f,o){
+o=o||_1.global;
+f=df.lambda(f);
+var t={},v,i;
+for(i in _6){
+if(!(i in _3)){
+v=_6[i];
+if(f.call(o,v,i,_6)){
+t[i]=v;
+}
+}
+}
+return t;
+},forIn:function(_7,f,o){
+o=o||_1.global;
+f=df.lambda(f);
+for(var i in _7){
+if(!(i in _3)){
+f.call(o,_7[i],i,_7);
+}
+}
+return o;
+},mapIn:function(_8,f,o){
+o=o||_1.global;
+f=df.lambda(f);
+var t={},i;
+for(i in _8){
+if(!(i in _3)){
+t[i]=f.call(o,_8[i],i,_8);
+}
+}
+return t;
+}});
+return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/object.js.uncompressed.js

@@ -0,0 +1,78 @@
+define("dojox/lang/functional/object", ["dojo/_base/kernel", "dojo/_base/lang", "./lambda"], function(kernel, lang, df){
+
+// This module adds high-level functions and related constructs:
+//	- object/dictionary helpers
+
+// Defined methods:
+//	- take any valid lambda argument as the functional argument
+//	- skip all attributes that are present in the empty object
+//		(IE and/or 3rd-party libraries).
+
+	var empty = {};
+
+	lang.mixin(df, {
+		// object helpers
+		keys: function(/*Object*/ obj){
+			// summary:
+			//		returns an array of all keys in the object
+			var t = [];
+			for(var i in obj){
+				if(!(i in empty)){
+					t.push(i);
+				}
+			}
+			return	t; // Array
+		},
+		values: function(/*Object*/ obj){
+			// summary:
+			//		returns an array of all values in the object
+			var t = [];
+			for(var i in obj){
+				if(!(i in empty)){
+					t.push(obj[i]);
+				}
+			}
+			return	t; // Array
+		},
+		filterIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		creates new object with all attributes that pass the test
+			//		implemented by the provided function.
+			o = o || kernel.global; f = df.lambda(f);
+			var t = {}, v, i;
+			for(i in obj){
+				if(!(i in empty)){
+					v = obj[i];
+					if(f.call(o, v, i, obj)){ t[i] = v; }
+				}
+			}
+			return t;	// Object
+		},
+		forIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		iterates over all object attributes.
+			o = o || kernel.global; f = df.lambda(f);
+			for(var i in obj){
+				if(!(i in empty)){
+					f.call(o, obj[i], i, obj);
+				}
+			}
+			return o;	// Object
+		},
+		mapIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		creates new object with the results of calling
+			//		a provided function on every attribute in this object.
+			o = o || kernel.global; f = df.lambda(f);
+			var t = {}, i;
+			for(i in obj){
+				if(!(i in empty)){
+					t[i] = f.call(o, obj[i], i, obj);
+				}
+			}
+			return t;	// Object
+		}
+	});
+	
+	return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/reversed.js

@@ -0,0 +1,61 @@
+//>>built
+define("dojox/lang/functional/reversed",["dojo/_base/lang","dojo/_base/kernel","./lambda"],function(_1,_2,df){
+_1.mixin(df,{filterRev:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_2.global;
+f=df.lambda(f);
+var t=[],v,i=a.length-1;
+for(;i>=0;--i){
+v=a[i];
+if(f.call(o,v,i,a)){
+t.push(v);
+}
+}
+return t;
+},forEachRev:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_2.global;
+f=df.lambda(f);
+for(var i=a.length-1;i>=0;f.call(o,a[i],i,a),--i){
+}
+},mapRev:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_2.global;
+f=df.lambda(f);
+var n=a.length,t=new Array(n),i=n-1,j=0;
+for(;i>=0;t[j++]=f.call(o,a[i],i,a),--i){
+}
+return t;
+},everyRev:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_2.global;
+f=df.lambda(f);
+for(var i=a.length-1;i>=0;--i){
+if(!f.call(o,a[i],i,a)){
+return false;
+}
+}
+return true;
+},someRev:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_2.global;
+f=df.lambda(f);
+for(var i=a.length-1;i>=0;--i){
+if(f.call(o,a[i],i,a)){
+return true;
+}
+}
+return false;
+}});
+return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/reversed.js.uncompressed.js

@@ -0,0 +1,77 @@
+define("dojox/lang/functional/reversed", ["dojo/_base/lang", "dojo/_base/kernel" ,"./lambda"],
+	function(lang, kernel, df){
+// This module adds high-level functions and related constructs:
+//	- reversed versions of array-processing functions similar to standard JS functions
+
+// Notes:
+//	- this module provides reversed versions of standard array-processing functions:
+//		forEachRev, mapRev, filterRev
+
+// Defined methods:
+//	- take any valid lambda argument as the functional argument
+//	- operate on dense arrays
+//	- take a string as the array argument
+
+	lang.mixin(df, {
+		// JS 1.6 standard array functions, which can take a lambda as a parameter.
+		// Consider using dojo._base.array functions, if you don't need the lambda support.
+		filterRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		creates a new array with all elements that pass the test
+			//		implemented by the provided function.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var t = [], v, i = a.length - 1;
+			for(; i >= 0; --i){
+				v = a[i];
+				if(f.call(o, v, i, a)){ t.push(v); }
+			}
+			return t;	// Array
+		},
+		forEachRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		executes a provided function once per array element.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			for(var i = a.length - 1; i >= 0; f.call(o, a[i], i, a), --i);
+		},
+		mapRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		creates a new array with the results of calling
+			//		a provided function on every element in this array.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var n = a.length, t = new Array(n), i = n - 1, j = 0;
+			for(; i >= 0; t[j++] = f.call(o, a[i], i, a), --i);
+			return t;	// Array
+		},
+		everyRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		tests whether all elements in the array pass the test
+			//		implemented by the provided function.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			for(var i = a.length - 1; i >= 0; --i){
+				if(!f.call(o, a[i], i, a)){
+					return false;	// Boolean
+				}
+			}
+			return true;	// Boolean
+		},
+		someRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		tests whether some element in the array passes the test
+			//		implemented by the provided function.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			for(var i = a.length - 1; i >= 0; --i){
+				if(f.call(o, a[i], i, a)){
+					return true;	// Boolean
+				}
+			}
+			return false;	// Boolean
+		}
+	});
+	
+	return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/scan.js

@@ -0,0 +1,87 @@
+//>>built
+define("dojox/lang/functional/scan",["dojo/_base/kernel","dojo/_base/lang","./lambda"],function(_1,_2,df){
+var _3={};
+_2.mixin(df,{scanl:function(a,f,z,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_1.global;
+f=df.lambda(f);
+var t,n,i;
+if(_2.isArray(a)){
+t=new Array((n=a.length)+1);
+t[0]=z;
+for(i=0;i<n;z=f.call(o,z,a[i],i,a),t[++i]=z){
+}
+}else{
+if(typeof a.hasNext=="function"&&typeof a.next=="function"){
+t=[z];
+for(i=0;a.hasNext();t.push(z=f.call(o,z,a.next(),i++,a))){
+}
+}else{
+t=[z];
+for(i in a){
+if(!(i in _3)){
+t.push(z=f.call(o,z,a[i],i,a));
+}
+}
+}
+}
+return t;
+},scanl1:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_1.global;
+f=df.lambda(f);
+var t,n,z,_4=true;
+if(_2.isArray(a)){
+t=new Array(n=a.length);
+t[0]=z=a[0];
+for(var i=1;i<n;t[i]=z=f.call(o,z,a[i],i,a),++i){
+}
+}else{
+if(typeof a.hasNext=="function"&&typeof a.next=="function"){
+if(a.hasNext()){
+t=[z=a.next()];
+for(i=1;a.hasNext();t.push(z=f.call(o,z,a.next(),i++,a))){
+}
+}
+}else{
+for(i in a){
+if(!(i in _3)){
+if(_4){
+t=[z=a[i]];
+_4=false;
+}else{
+t.push(z=f.call(o,z,a[i],i,a));
+}
+}
+}
+}
+}
+return t;
+},scanr:function(a,f,z,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_1.global;
+f=df.lambda(f);
+var n=a.length,t=new Array(n+1),i=n;
+t[n]=z;
+for(;i>0;--i,z=f.call(o,z,a[i],i,a),t[i]=z){
+}
+return t;
+},scanr1:function(a,f,o){
+if(typeof a=="string"){
+a=a.split("");
+}
+o=o||_1.global;
+f=df.lambda(f);
+var n=a.length,t=new Array(n),z=a[n-1],i=n-1;
+t[i]=z;
+for(;i>0;--i,z=f.call(o,z,a[i],i,a),t[i]=z){
+}
+return t;
+}});
+});

package/vendor/dojo-1.10.10/dojox/lang/functional/scan.js.uncompressed.js

@@ -0,0 +1,107 @@
+define("dojox/lang/functional/scan", ["dojo/_base/kernel", "dojo/_base/lang", "./lambda"], function(kernel, lang, df){
+
+// This module adds high-level functions and related constructs:
+//	- "scan" family of functions
+
+// Notes:
+//	- missing high-level functions are provided with the compatible API:
+//		scanl, scanl1, scanr, scanr1
+
+// Defined methods:
+//	- take any valid lambda argument as the functional argument
+//	- operate on dense arrays
+//	- take a string as the array argument
+//	- take an iterator objects as the array argument (only scanl, and scanl1)
+
+	var empty = {};
+
+	lang.mixin(df, {
+		// classic reduce-class functions
+		scanl: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
+			// summary:
+			//		repeatedly applies a binary function to an array from left
+			//		to right using a seed value as a starting point; returns an array
+			//		of values produced by foldl() at that point.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var t, n, i;
+			if(lang.isArray(a)){
+				// array
+				t = new Array((n = a.length) + 1);
+				t[0] = z;
+				for(i = 0; i < n; z = f.call(o, z, a[i], i, a), t[++i] = z);
+			}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
+				// iterator
+				t = [z];
+				for(i = 0; a.hasNext(); t.push(z = f.call(o, z, a.next(), i++, a)));
+			}else{
+				// object/dictionary
+				t = [z];
+				for(i in a){
+					if(!(i in empty)){
+						t.push(z = f.call(o, z, a[i], i, a));
+					}
+				}
+			}
+			return t;	// Array
+		},
+		scanl1: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		repeatedly applies a binary function to an array from left
+			//		to right; returns an array of values produced by foldl1() at that
+			//		point.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var t, n, z, first = true;
+			if(lang.isArray(a)){
+				// array
+				t = new Array(n = a.length);
+				t[0] = z = a[0];
+				for(var i = 1; i < n; t[i] = z = f.call(o, z, a[i], i, a), ++i);
+			}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
+				// iterator
+				if(a.hasNext()){
+					t = [z = a.next()];
+					for(i = 1; a.hasNext(); t.push(z = f.call(o, z, a.next(), i++, a)));
+				}
+			}else{
+				// object/dictionary
+				for(i in a){
+					if(!(i in empty)){
+						if(first){
+							t = [z = a[i]];
+							first = false;
+						}else{
+							t.push(z = f.call(o, z, a[i], i, a));
+						}
+					}
+				}
+			}
+			return t;	// Array
+		},
+		scanr: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
+			// summary:
+			//		repeatedly applies a binary function to an array from right
+			//		to left using a seed value as a starting point; returns an array
+			//		of values produced by foldr() at that point.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var n = a.length, t = new Array(n + 1), i = n;
+			t[n] = z;
+			for(; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
+			return t;	// Array
+		},
+		scanr1: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
+			// summary:
+			//		repeatedly applies a binary function to an array from right
+			//		to left; returns an array of values produced by foldr1() at that
+			//		point.
+			if(typeof a == "string"){ a = a.split(""); }
+			o = o || kernel.global; f = df.lambda(f);
+			var n = a.length, t = new Array(n), z = a[n - 1], i = n - 1;
+			t[i] = z;
+			for(; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
+			return t;	// Array
+		}
+	});
+});

package/vendor/dojo-1.10.10/dojox/lang/functional.js

@@ -0,0 +1,4 @@
+//>>built
+define("dojox/lang/functional",["./functional/lambda","./functional/array","./functional/object"],function(df){
+return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/functional.js.uncompressed.js

@@ -0,0 +1,3 @@
+define("dojox/lang/functional", ["./functional/lambda", "./functional/array", "./functional/object"], function(df){
+	return df;
+});

package/vendor/dojo-1.10.10/dojox/lang/utils.js

@@ -0,0 +1,86 @@
+//>>built
+define("dojox/lang/utils",["..","dojo/_base/lang"],function(_1,_2){
+var du=_2.getObject("lang.utils",true,_1);
+var _3={},_4=Object.prototype.toString;
+var _5=function(o){
+if(o){
+switch(_4.call(o)){
+case "[object Array]":
+return o.slice(0);
+case "[object Object]":
+return _2.delegate(o);
+}
+}
+return o;
+};
+_2.mixin(du,{coerceType:function(_6,_7){
+switch(typeof _6){
+case "number":
+return Number(eval("("+_7+")"));
+case "string":
+return String(_7);
+case "boolean":
+return Boolean(eval("("+_7+")"));
+}
+return eval("("+_7+")");
+},updateWithObject:function(_8,_9,_a){
+if(!_9){
+return _8;
+}
+for(var x in _8){
+if(x in _9&&!(x in _3)){
+var t=_8[x];
+if(t&&typeof t=="object"){
+du.updateWithObject(t,_9[x],_a);
+}else{
+_8[x]=_a?du.coerceType(t,_9[x]):_5(_9[x]);
+}
+}
+}
+return _8;
+},updateWithPattern:function(_b,_c,_d,_e){
+if(!_c||!_d){
+return _b;
+}
+for(var x in _d){
+if(x in _c&&!(x in _3)){
+_b[x]=_e?du.coerceType(_d[x],_c[x]):_5(_c[x]);
+}
+}
+return _b;
+},merge:function(_f,_10){
+if(_10){
+var _11=_4.call(_f),_12=_4.call(_10),t,i,l,m;
+switch(_12){
+case "[object Array]":
+if(_12==_11){
+t=new Array(Math.max(_f.length,_10.length));
+for(i=0,l=t.length;i<l;++i){
+t[i]=du.merge(_f[i],_10[i]);
+}
+return t;
+}
+return _10.slice(0);
+case "[object Object]":
+if(_12==_11&&_f){
+t=_2.delegate(_f);
+for(i in _10){
+if(i in _f){
+l=_f[i];
+m=_10[i];
+if(m!==l){
+t[i]=du.merge(l,m);
+}
+}else{
+t[i]=_2.clone(_10[i]);
+}
+}
+return t;
+}
+return _2.clone(_10);
+}
+}
+return _10;
+}});
+return du;
+});