tck-lambdas 0.1.5 → 0.1.6

data/lib/tck/lambdas/chistacojs/node_modules/cheerio/node_modules/css-select/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+module.exports = CSSselect;
+
+var Pseudos       = require("./lib/pseudos.js"),
+    DomUtils      = require("domutils"),
+    findOne       = DomUtils.findOne,
+    findAll       = DomUtils.findAll,
+    getChildren   = DomUtils.getChildren,
+    removeSubsets = DomUtils.removeSubsets,
+    falseFunc     = require("boolbase").falseFunc,
+    compile       = require("./lib/compile.js"),
+    compileUnsafe = compile.compileUnsafe,
+    compileToken  = compile.compileToken;
+
+function getSelectorFunc(searchFunc){
+	return function select(query, elems, options){
+        if(typeof query !== "function") query = compileUnsafe(query, options, elems);
+        if(!Array.isArray(elems)) elems = getChildren(elems);
+		else elems = removeSubsets(elems);
+		return searchFunc(query, elems);
+	};
+}
+
+var selectAll = getSelectorFunc(function selectAll(query, elems){
+	return (query === falseFunc || !elems || elems.length === 0) ? [] : findAll(query, elems);
+});
+
+var selectOne = getSelectorFunc(function selectOne(query, elems){
+	return (query === falseFunc || !elems || elems.length === 0) ? null : findOne(query, elems);
+});
+
+function is(elem, query, options){
+	return (typeof query === "function" ? query : compile(query, options))(elem);
+}
+
+/*
+	the exported interface
+*/
+function CSSselect(query, elems, options){
+	return selectAll(query, elems, options);
+}
+
+CSSselect.compile = compile;
+CSSselect.filters = Pseudos.filters;
+CSSselect.pseudos = Pseudos.pseudos;
+
+CSSselect.selectAll = selectAll;
+CSSselect.selectOne = selectOne;
+
+CSSselect.is = is;
+
+//legacy methods (might be removed)
+CSSselect.parse = compile;
+CSSselect.iterate = selectAll;
+
+//hooks
+CSSselect._compileUnsafe = compileUnsafe;
+CSSselect._compileToken = compileToken;

data/lib/tck/lambdas/chistacojs/node_modules/cheerio/node_modules/css-select/lib/attributes.js

@@ -0,0 +1,181 @@
+var DomUtils  = require("domutils"),
+    hasAttrib = DomUtils.hasAttrib,
+    getAttributeValue = DomUtils.getAttributeValue,
+    falseFunc = require("boolbase").falseFunc;
+
+//https://github.com/slevithan/XRegExp/blob/master/src/xregexp.js#L469
+var reChars = /[-[\]{}()*+?.,\\^$|#\s]/g;
+
+/*
+	attribute selectors
+*/
+
+var attributeRules = {
+	__proto__: null,
+	equals: function(next, data){
+		var name  = data.name,
+		    value = data.value;
+
+		if(data.ignoreCase){
+			value = value.toLowerCase();
+
+			return function equalsIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null && attr.toLowerCase() === value && next(elem);
+			};
+		}
+
+		return function equals(elem){
+			return getAttributeValue(elem, name) === value && next(elem);
+		};
+	},
+	hyphen: function(next, data){
+		var name  = data.name,
+		    value = data.value,
+		    len = value.length;
+
+		if(data.ignoreCase){
+			value = value.toLowerCase();
+
+			return function hyphenIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null &&
+						(attr.length === len || attr.charAt(len) === "-") &&
+						attr.substr(0, len).toLowerCase() === value &&
+						next(elem);
+			};
+		}
+
+		return function hyphen(elem){
+			var attr = getAttributeValue(elem, name);
+			return attr != null &&
+					attr.substr(0, len) === value &&
+					(attr.length === len || attr.charAt(len) === "-") &&
+					next(elem);
+		};
+	},
+	element: function(next, data){
+		var name = data.name,
+		    value = data.value;
+
+		if(/\s/.test(value)){
+			return falseFunc;
+		}
+
+		value = value.replace(reChars, "\\$&");
+
+		var pattern = "(?:^|\\s)" + value + "(?:$|\\s)",
+		    flags = data.ignoreCase ? "i" : "",
+		    regex = new RegExp(pattern, flags);
+
+		return function element(elem){
+			var attr = getAttributeValue(elem, name);
+			return attr != null && regex.test(attr) && next(elem);
+		};
+	},
+	exists: function(next, data){
+		var name = data.name;
+		return function exists(elem){
+			return hasAttrib(elem, name) && next(elem);
+		};
+	},
+	start: function(next, data){
+		var name  = data.name,
+		    value = data.value,
+		    len = value.length;
+
+		if(len === 0){
+			return falseFunc;
+		}
+		
+		if(data.ignoreCase){
+			value = value.toLowerCase();
+
+			return function startIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null && attr.substr(0, len).toLowerCase() === value && next(elem);
+			};
+		}
+
+		return function start(elem){
+			var attr = getAttributeValue(elem, name);
+			return attr != null && attr.substr(0, len) === value && next(elem);
+		};
+	},
+	end: function(next, data){
+		var name  = data.name,
+		    value = data.value,
+		    len   = -value.length;
+
+		if(len === 0){
+			return falseFunc;
+		}
+
+		if(data.ignoreCase){
+			value = value.toLowerCase();
+
+			return function endIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null && attr.substr(len).toLowerCase() === value && next(elem);
+			};
+		}
+
+		return function end(elem){
+			var attr = getAttributeValue(elem, name);
+			return attr != null && attr.substr(len) === value && next(elem);
+		};
+	},
+	any: function(next, data){
+		var name  = data.name,
+		    value = data.value;
+
+		if(value === ""){
+			return falseFunc;
+		}
+
+		if(data.ignoreCase){
+			var regex = new RegExp(value.replace(reChars, "\\$&"), "i");
+
+			return function anyIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null && regex.test(attr) && next(elem);
+			};
+		}
+
+		return function any(elem){
+			var attr = getAttributeValue(elem, name);
+			return attr != null && attr.indexOf(value) >= 0 && next(elem);
+		};
+	},
+	not: function(next, data){
+		var name  = data.name,
+		    value = data.value;
+
+		if(value === ""){
+			return function notEmpty(elem){
+				return !!getAttributeValue(elem, name) && next(elem);
+			};
+		} else if(data.ignoreCase){
+			value = value.toLowerCase();
+
+			return function notIC(elem){
+				var attr = getAttributeValue(elem, name);
+				return attr != null && attr.toLowerCase() !== value && next(elem);
+			};
+		}
+
+		return function not(elem){
+			return getAttributeValue(elem, name) !== value && next(elem);
+		};
+	}
+};
+
+module.exports = {
+	compile: function(next, data, options){
+		if(options && options.strict && (
+			data.ignoreCase || data.action === "not"
+		)) throw SyntaxError("Unsupported attribute selector");
+		return attributeRules[data.action](next, data);
+	},
+	rules: attributeRules
+};

data/lib/tck/lambdas/chistacojs/node_modules/cheerio/node_modules/css-select/lib/compile.js

@@ -0,0 +1,192 @@
+/*
+	compiles a selector to an executable function
+*/
+
+module.exports = compile;
+module.exports.compileUnsafe = compileUnsafe;
+module.exports.compileToken = compileToken;
+
+var parse       = require("css-what"),
+    DomUtils    = require("domutils"),
+    isTag       = DomUtils.isTag,
+    Rules       = require("./general.js"),
+    sortRules   = require("./sort.js"),
+    BaseFuncs   = require("boolbase"),
+    trueFunc    = BaseFuncs.trueFunc,
+    falseFunc   = BaseFuncs.falseFunc,
+    procedure   = require("./procedure.json");
+
+function compile(selector, options, context){
+	var next = compileUnsafe(selector, options, context);
+	return wrap(next);
+}
+
+function wrap(next){
+	return function base(elem){
+		return isTag(elem) && next(elem);
+	};
+}
+
+function compileUnsafe(selector, options, context){
+	var token = parse(selector, options);
+	return compileToken(token, options, context);
+}
+
+function includesScopePseudo(t){
+    return t.type === "pseudo" && (
+        t.name === "scope" || (
+            Array.isArray(t.data) &&
+            t.data.some(function(data){
+                return data.some(includesScopePseudo);
+            })
+        )
+    );
+}
+
+var DESCENDANT_TOKEN = {type: "descendant"},
+    SCOPE_TOKEN = {type: "pseudo", name: "scope"},
+    PLACEHOLDER_ELEMENT = {},
+    getParent = DomUtils.getParent;
+
+//CSS 4 Spec (Draft): 3.3.1. Absolutizing a Scope-relative Selector
+//http://www.w3.org/TR/selectors4/#absolutizing
+function absolutize(token, context){
+    //TODO better check if context is document
+    var hasContext = !!context && !!context.length && context.every(function(e){
+        return e === PLACEHOLDER_ELEMENT || !!getParent(e);
+    });
+
+
+    token.forEach(function(t){
+        if(t.length > 0 && isTraversal(t[0]) && t[0].type !== "descendant"){
+            //don't return in else branch
+        } else if(hasContext && !includesScopePseudo(t)){
+            t.unshift(DESCENDANT_TOKEN);
+        } else {
+            return;
+        }
+
+        t.unshift(SCOPE_TOKEN);
+    });
+}
+
+function compileToken(token, options, context){
+    token = token.filter(function(t){ return t.length > 0; });
+
+	token.forEach(sortRules);
+
+	var isArrayContext = Array.isArray(context);
+
+    context = (options && options.context) || context;
+
+    if(context && !isArrayContext) context = [context];
+
+    absolutize(token, context);
+
+	return token
+		.map(function(rules){ return compileRules(rules, options, context, isArrayContext); })
+		.reduce(reduceRules, falseFunc);
+}
+
+function isTraversal(t){
+	return procedure[t.type] < 0;
+}
+
+function compileRules(rules, options, context, isArrayContext){
+	var acceptSelf = (isArrayContext && rules[0].name === "scope" && rules[1].type === "descendant");
+	return rules.reduce(function(func, rule, index){
+		if(func === falseFunc) return func;
+		return Rules[rule.type](func, rule, options, context, acceptSelf && index === 1);
+	}, options && options.rootFunc || trueFunc);
+}
+
+function reduceRules(a, b){
+	if(b === falseFunc || a === trueFunc){
+		return a;
+	}
+	if(a === falseFunc || b === trueFunc){
+		return b;
+	}
+
+	return function combine(elem){
+		return a(elem) || b(elem);
+	};
+}
+
+//:not, :has and :matches have to compile selectors
+//doing this in lib/pseudos.js would lead to circular dependencies,
+//so we add them here
+
+var Pseudos     = require("./pseudos.js"),
+    filters     = Pseudos.filters,
+    existsOne   = DomUtils.existsOne,
+    isTag       = DomUtils.isTag,
+    getChildren = DomUtils.getChildren;
+
+
+function containsTraversal(t){
+	return t.some(isTraversal);
+}
+
+filters.not = function(next, token, options, context){
+	var opts = {
+	    	xmlMode: !!(options && options.xmlMode),
+	    	strict: !!(options && options.strict)
+	    };
+
+	if(opts.strict){
+		if(token.length > 1 || token.some(containsTraversal)){
+			throw new SyntaxError("complex selectors in :not aren't allowed in strict mode");
+		}
+	}
+
+    var func = compileToken(token, opts, context);
+
+	if(func === falseFunc) return next;
+	if(func === trueFunc)  return falseFunc;
+
+	return function(elem){
+		return !func(elem) && next(elem);
+	};
+};
+
+filters.has = function(next, token, options){
+	var opts = {
+		xmlMode: !!(options && options.xmlMode),
+		strict: !!(options && options.strict)
+	};
+
+    //FIXME: Uses an array as a pointer to the current element (side effects)
+    var context = token.some(containsTraversal) ? [PLACEHOLDER_ELEMENT] : null;
+
+	var func = compileToken(token, opts, context);
+
+	if(func === falseFunc) return falseFunc;
+	if(func === trueFunc)  return function(elem){
+			return getChildren(elem).some(isTag) && next(elem);
+		};
+
+	func = wrap(func);
+
+    if(context){
+        return function has(elem){
+		return next(elem) && (
+                (context[0] = elem), existsOne(func, getChildren(elem))
+            );
+	};
+    }
+
+    return function has(elem){
+		return next(elem) && existsOne(func, getChildren(elem));
+	};
+};
+
+filters.matches = function(next, token, options, context){
+	var opts = {
+		xmlMode: !!(options && options.xmlMode),
+		strict: !!(options && options.strict),
+		rootFunc: next
+	};
+
+	return compileToken(token, opts, context);
+};

data/lib/tck/lambdas/chistacojs/node_modules/cheerio/node_modules/css-select/lib/general.js

@@ -0,0 +1,89 @@
+var DomUtils    = require("domutils"),
+    isTag       = DomUtils.isTag,
+    getParent   = DomUtils.getParent,
+    getChildren = DomUtils.getChildren,
+    getSiblings = DomUtils.getSiblings,
+    getName     = DomUtils.getName;
+
+/*
+	all available rules
+*/
+module.exports = {
+	__proto__: null,
+
+	attribute: require("./attributes.js").compile,
+	pseudo: require("./pseudos.js").compile,
+
+	//tags
+	tag: function(next, data){
+		var name = data.name;
+		return function tag(elem){
+			return getName(elem) === name && next(elem);
+		};
+	},
+
+	//traversal
+	descendant: function(next, rule, options, context, acceptSelf){
+		return function descendant(elem){
+
+			if (acceptSelf && next(elem)) return true;
+
+			var found = false;
+
+			while(!found && (elem = getParent(elem))){
+				found = next(elem);
+			}
+
+			return found;
+		};
+	},
+	parent: function(next, data, options){
+		if(options && options.strict) throw SyntaxError("Parent selector isn't part of CSS3");
+
+		return function parent(elem){
+			return getChildren(elem).some(test);
+		};
+
+		function test(elem){
+			return isTag(elem) && next(elem);
+		}
+	},
+	child: function(next){
+		return function child(elem){
+			var parent = getParent(elem);
+			return !!parent && next(parent);
+		};
+	},
+	sibling: function(next){
+		return function sibling(elem){
+			var siblings = getSiblings(elem);
+
+			for(var i = 0; i < siblings.length; i++){
+				if(isTag(siblings[i])){
+					if(siblings[i] === elem) break;
+					if(next(siblings[i])) return true;
+				}
+			}
+
+			return false;
+		};
+	},
+	adjacent: function(next){
+		return function adjacent(elem){
+			var siblings = getSiblings(elem),
+			    lastElement;
+
+			for(var i = 0; i < siblings.length; i++){
+				if(isTag(siblings[i])){
+					if(siblings[i] === elem) break;
+					lastElement = siblings[i];
+				}
+			}
+
+			return !!lastElement && next(lastElement);
+		};
+	},
+	universal: function(next){
+		return next;
+	}
+};