You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cmda.apache.org by xi...@apache.org on 2015/10/17 01:11:51 UTC
[17/51] [partial] incubator-cmda git commit: Update ApacheCMDA_1.0
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/browser.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/browser.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/browser.js
new file mode 100644
index 0000000..7bdb359
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/browser.js
@@ -0,0 +1,662 @@
+//
+// browser.js - client-side engine
+//
+/*global less, window, document, XMLHttpRequest, location */
+
+var isFileProtocol = /^(file|chrome(-extension)?|resource|qrc|app):/.test(location.protocol);
+
+less.env = less.env || (location.hostname == '127.0.0.1' ||
+ location.hostname == '0.0.0.0' ||
+ location.hostname == 'localhost' ||
+ (location.port &&
+ location.port.length > 0) ||
+ isFileProtocol ? 'development'
+ : 'production');
+
+var logLevel = {
+ info: 2,
+ errors: 1,
+ none: 0
+};
+
+// The amount of logging in the javascript console.
+// 2 - Information and errors
+// 1 - Errors
+// 0 - None
+// Defaults to 2
+less.logLevel = typeof(less.logLevel) != 'undefined' ? less.logLevel : logLevel.info;
+
+// Load styles asynchronously (default: false)
+//
+// This is set to `false` by default, so that the body
+// doesn't start loading before the stylesheets are parsed.
+// Setting this to `true` can result in flickering.
+//
+less.async = less.async || false;
+less.fileAsync = less.fileAsync || false;
+
+// Interval between watch polls
+less.poll = less.poll || (isFileProtocol ? 1000 : 1500);
+
+//Setup user functions
+if (less.functions) {
+ for(var func in less.functions) {
+ less.tree.functions[func] = less.functions[func];
+ }
+}
+
+var dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(location.hash);
+if (dumpLineNumbers) {
+ less.dumpLineNumbers = dumpLineNumbers[1];
+}
+
+var typePattern = /^text\/(x-)?less$/;
+var cache = null;
+var fileCache = {};
+
+function log(str, level) {
+ if (less.env == 'development' && typeof(console) !== 'undefined' && less.logLevel >= level) {
+ console.log('less: ' + str);
+ }
+}
+
+function extractId(href) {
+ return href.replace(/^[a-z-]+:\/+?[^\/]+/, '' ) // Remove protocol & domain
+ .replace(/^\//, '' ) // Remove root /
+ .replace(/\.[a-zA-Z]+$/, '' ) // Remove simple extension
+ .replace(/[^\.\w-]+/g, '-') // Replace illegal characters
+ .replace(/\./g, ':'); // Replace dots with colons(for valid id)
+}
+
+function errorConsole(e, rootHref) {
+ var template = '{line} {content}';
+ var filename = e.filename || rootHref;
+ var errors = [];
+ var content = (e.type || "Syntax") + "Error: " + (e.message || 'There is an error in your .less file') +
+ " in " + filename + " ";
+
+ var errorline = function (e, i, classname) {
+ if (e.extract[i] !== undefined) {
+ errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
+ .replace(/\{class\}/, classname)
+ .replace(/\{content\}/, e.extract[i]));
+ }
+ };
+
+ if (e.extract) {
+ errorline(e, 0, '');
+ errorline(e, 1, 'line');
+ errorline(e, 2, '');
+ content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':\n' +
+ errors.join('\n');
+ } else if (e.stack) {
+ content += e.stack;
+ }
+ log(content, logLevel.errors);
+}
+
+function createCSS(styles, sheet, lastModified) {
+ // Strip the query-string
+ var href = sheet.href || '';
+
+ // If there is no title set, use the filename, minus the extension
+ var id = 'less:' + (sheet.title || extractId(href));
+
+ // If this has already been inserted into the DOM, we may need to replace it
+ var oldCss = document.getElementById(id);
+ var keepOldCss = false;
+
+ // Create a new stylesheet node for insertion or (if necessary) replacement
+ var css = document.createElement('style');
+ css.setAttribute('type', 'text/css');
+ if (sheet.media) {
+ css.setAttribute('media', sheet.media);
+ }
+ css.id = id;
+
+ if (css.styleSheet) { // IE
+ try {
+ css.styleSheet.cssText = styles;
+ } catch (e) {
+ throw new(Error)("Couldn't reassign styleSheet.cssText.");
+ }
+ } else {
+ css.appendChild(document.createTextNode(styles));
+
+ // If new contents match contents of oldCss, don't replace oldCss
+ keepOldCss = (oldCss !== null && oldCss.childNodes.length > 0 && css.childNodes.length > 0 &&
+ oldCss.firstChild.nodeValue === css.firstChild.nodeValue);
+ }
+
+ var head = document.getElementsByTagName('head')[0];
+
+ // If there is no oldCss, just append; otherwise, only append if we need
+ // to replace oldCss with an updated stylesheet
+ if (oldCss === null || keepOldCss === false) {
+ var nextEl = sheet && sheet.nextSibling || null;
+ if (nextEl) {
+ nextEl.parentNode.insertBefore(css, nextEl);
+ } else {
+ head.appendChild(css);
+ }
+ }
+ if (oldCss && keepOldCss === false) {
+ oldCss.parentNode.removeChild(oldCss);
+ }
+
+ // Don't update the local store if the file wasn't modified
+ if (lastModified && cache) {
+ log('saving ' + href + ' to cache.', logLevel.info);
+ try {
+ cache.setItem(href, styles);
+ cache.setItem(href + ':timestamp', lastModified);
+ } catch(e) {
+ //TODO - could do with adding more robust error handling
+ log('failed to save', logLevel.errors);
+ }
+ }
+}
+
+function errorHTML(e, rootHref) {
+ var id = 'less-error-message:' + extractId(rootHref || "");
+ var template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
+ var elem = document.createElement('div'), timer, content, errors = [];
+ var filename = e.filename || rootHref;
+ var filenameNoPath = filename.match(/([^\/]+(\?.*)?)$/)[1];
+
+ elem.id = id;
+ elem.className = "less-error-message";
+
+ content = '<h3>' + (e.type || "Syntax") + "Error: " + (e.message || 'There is an error in your .less file') +
+ '</h3>' + '<p>in <a href="' + filename + '">' + filenameNoPath + "</a> ";
+
+ var errorline = function (e, i, classname) {
+ if (e.extract[i] !== undefined) {
+ errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
+ .replace(/\{class\}/, classname)
+ .replace(/\{content\}/, e.extract[i]));
+ }
+ };
+
+ if (e.extract) {
+ errorline(e, 0, '');
+ errorline(e, 1, 'line');
+ errorline(e, 2, '');
+ content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':</p>' +
+ '<ul>' + errors.join('') + '</ul>';
+ } else if (e.stack) {
+ content += '<br/>' + e.stack.split('\n').slice(1).join('<br/>');
+ }
+ elem.innerHTML = content;
+
+ // CSS for error messages
+ createCSS([
+ '.less-error-message ul, .less-error-message li {',
+ 'list-style-type: none;',
+ 'margin-right: 15px;',
+ 'padding: 4px 0;',
+ 'margin: 0;',
+ '}',
+ '.less-error-message label {',
+ 'font-size: 12px;',
+ 'margin-right: 15px;',
+ 'padding: 4px 0;',
+ 'color: #cc7777;',
+ '}',
+ '.less-error-message pre {',
+ 'color: #dd6666;',
+ 'padding: 4px 0;',
+ 'margin: 0;',
+ 'display: inline-block;',
+ '}',
+ '.less-error-message pre.line {',
+ 'color: #ff0000;',
+ '}',
+ '.less-error-message h3 {',
+ 'font-size: 20px;',
+ 'font-weight: bold;',
+ 'padding: 15px 0 5px 0;',
+ 'margin: 0;',
+ '}',
+ '.less-error-message a {',
+ 'color: #10a',
+ '}',
+ '.less-error-message .error {',
+ 'color: red;',
+ 'font-weight: bold;',
+ 'padding-bottom: 2px;',
+ 'border-bottom: 1px dashed red;',
+ '}'
+ ].join('\n'), { title: 'error-message' });
+
+ elem.style.cssText = [
+ "font-family: Arial, sans-serif",
+ "border: 1px solid #e00",
+ "background-color: #eee",
+ "border-radius: 5px",
+ "-webkit-border-radius: 5px",
+ "-moz-border-radius: 5px",
+ "color: #e00",
+ "padding: 15px",
+ "margin-bottom: 15px"
+ ].join(';');
+
+ if (less.env == 'development') {
+ timer = setInterval(function () {
+ if (document.body) {
+ if (document.getElementById(id)) {
+ document.body.replaceChild(elem, document.getElementById(id));
+ } else {
+ document.body.insertBefore(elem, document.body.firstChild);
+ }
+ clearInterval(timer);
+ }
+ }, 10);
+ }
+}
+
+function error(e, rootHref) {
+ if (!less.errorReporting || less.errorReporting === "html") {
+ errorHTML(e, rootHref);
+ } else if (less.errorReporting === "console") {
+ errorConsole(e, rootHref);
+ } else if (typeof less.errorReporting === 'function') {
+ less.errorReporting("add", e, rootHref);
+ }
+}
+
+function removeErrorHTML(path) {
+ var node = document.getElementById('less-error-message:' + extractId(path));
+ if (node) {
+ node.parentNode.removeChild(node);
+ }
+}
+
+function removeErrorConsole(path) {
+ //no action
+}
+
+function removeError(path) {
+ if (!less.errorReporting || less.errorReporting === "html") {
+ removeErrorHTML(path);
+ } else if (less.errorReporting === "console") {
+ removeErrorConsole(path);
+ } else if (typeof less.errorReporting === 'function') {
+ less.errorReporting("remove", path);
+ }
+}
+
+function loadStyles(modifyVars) {
+ var styles = document.getElementsByTagName('style'),
+ style;
+ for (var i = 0; i < styles.length; i++) {
+ style = styles[i];
+ if (style.type.match(typePattern)) {
+ var env = new less.tree.parseEnv(less),
+ lessText = style.innerHTML || '';
+ env.filename = document.location.href.replace(/#.*$/, '');
+
+ if (modifyVars || less.globalVars) {
+ env.useFileCache = true;
+ }
+
+ /*jshint loopfunc:true */
+ // use closure to store current value of i
+ var callback = (function(style) {
+ return function (e, cssAST) {
+ if (e) {
+ return error(e, "inline");
+ }
+ var css = cssAST.toCSS(less);
+ style.type = 'text/css';
+ if (style.styleSheet) {
+ style.styleSheet.cssText = css;
+ } else {
+ style.innerHTML = css;
+ }
+ };
+ })(style);
+ new(less.Parser)(env).parse(lessText, callback, {globalVars: less.globalVars, modifyVars: modifyVars});
+ }
+ }
+}
+
+function extractUrlParts(url, baseUrl) {
+ // urlParts[1] = protocol&hostname || /
+ // urlParts[2] = / if path relative to host base
+ // urlParts[3] = directories
+ // urlParts[4] = filename
+ // urlParts[5] = parameters
+
+ var urlPartsRegex = /^((?:[a-z-]+:)?\/+?(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i,
+ urlParts = url.match(urlPartsRegex),
+ returner = {}, directories = [], i, baseUrlParts;
+
+ if (!urlParts) {
+ throw new Error("Could not parse sheet href - '"+url+"'");
+ }
+
+ // Stylesheets in IE don't always return the full path
+ if (!urlParts[1] || urlParts[2]) {
+ baseUrlParts = baseUrl.match(urlPartsRegex);
+ if (!baseUrlParts) {
+ throw new Error("Could not parse page url - '"+baseUrl+"'");
+ }
+ urlParts[1] = urlParts[1] || baseUrlParts[1] || "";
+ if (!urlParts[2]) {
+ urlParts[3] = baseUrlParts[3] + urlParts[3];
+ }
+ }
+
+ if (urlParts[3]) {
+ directories = urlParts[3].replace(/\\/g, "/").split("/");
+
+ // extract out . before .. so .. doesn't absorb a non-directory
+ for(i = 0; i < directories.length; i++) {
+ if (directories[i] === ".") {
+ directories.splice(i, 1);
+ i -= 1;
+ }
+ }
+
+ for(i = 0; i < directories.length; i++) {
+ if (directories[i] === ".." && i > 0) {
+ directories.splice(i-1, 2);
+ i -= 2;
+ }
+ }
+ }
+
+ returner.hostPart = urlParts[1];
+ returner.directories = directories;
+ returner.path = urlParts[1] + directories.join("/");
+ returner.fileUrl = returner.path + (urlParts[4] || "");
+ returner.url = returner.fileUrl + (urlParts[5] || "");
+ return returner;
+}
+
+function pathDiff(url, baseUrl) {
+ // diff between two paths to create a relative path
+
+ var urlParts = extractUrlParts(url),
+ baseUrlParts = extractUrlParts(baseUrl),
+ i, max, urlDirectories, baseUrlDirectories, diff = "";
+ if (urlParts.hostPart !== baseUrlParts.hostPart) {
+ return "";
+ }
+ max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
+ for(i = 0; i < max; i++) {
+ if (baseUrlParts.directories[i] !== urlParts.directories[i]) { break; }
+ }
+ baseUrlDirectories = baseUrlParts.directories.slice(i);
+ urlDirectories = urlParts.directories.slice(i);
+ for(i = 0; i < baseUrlDirectories.length-1; i++) {
+ diff += "../";
+ }
+ for(i = 0; i < urlDirectories.length-1; i++) {
+ diff += urlDirectories[i] + "/";
+ }
+ return diff;
+}
+
+function getXMLHttpRequest() {
+ if (window.XMLHttpRequest) {
+ return new XMLHttpRequest();
+ } else {
+ try {
+ /*global ActiveXObject */
+ return new ActiveXObject("MSXML2.XMLHTTP.3.0");
+ } catch (e) {
+ log("browser doesn't support AJAX.", logLevel.errors);
+ return null;
+ }
+ }
+}
+
+function doXHR(url, type, callback, errback) {
+ var xhr = getXMLHttpRequest();
+ var async = isFileProtocol ? less.fileAsync : less.async;
+
+ if (typeof(xhr.overrideMimeType) === 'function') {
+ xhr.overrideMimeType('text/css');
+ }
+ log("XHR: Getting '" + url + "'", logLevel.info);
+ xhr.open('GET', url, async);
+ xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
+ xhr.send(null);
+
+ function handleResponse(xhr, callback, errback) {
+ if (xhr.status >= 200 && xhr.status < 300) {
+ callback(xhr.responseText,
+ xhr.getResponseHeader("Last-Modified"));
+ } else if (typeof(errback) === 'function') {
+ errback(xhr.status, url);
+ }
+ }
+
+ if (isFileProtocol && !less.fileAsync) {
+ if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
+ callback(xhr.responseText);
+ } else {
+ errback(xhr.status, url);
+ }
+ } else if (async) {
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState == 4) {
+ handleResponse(xhr, callback, errback);
+ }
+ };
+ } else {
+ handleResponse(xhr, callback, errback);
+ }
+}
+
+function loadFile(originalHref, currentFileInfo, callback, env, modifyVars) {
+
+ if (currentFileInfo && currentFileInfo.currentDirectory && !/^([a-z-]+:)?\//.test(originalHref)) {
+ originalHref = currentFileInfo.currentDirectory + originalHref;
+ }
+
+ // sheet may be set to the stylesheet for the initial load or a collection of properties including
+ // some env variables for imports
+ var hrefParts = extractUrlParts(originalHref, window.location.href);
+ var href = hrefParts.url;
+ var newFileInfo = {
+ currentDirectory: hrefParts.path,
+ filename: href
+ };
+
+ if (currentFileInfo) {
+ newFileInfo.entryPath = currentFileInfo.entryPath;
+ newFileInfo.rootpath = currentFileInfo.rootpath;
+ newFileInfo.rootFilename = currentFileInfo.rootFilename;
+ newFileInfo.relativeUrls = currentFileInfo.relativeUrls;
+ } else {
+ newFileInfo.entryPath = hrefParts.path;
+ newFileInfo.rootpath = less.rootpath || hrefParts.path;
+ newFileInfo.rootFilename = href;
+ newFileInfo.relativeUrls = env.relativeUrls;
+ }
+
+ if (newFileInfo.relativeUrls) {
+ if (env.rootpath) {
+ newFileInfo.rootpath = extractUrlParts(env.rootpath + pathDiff(hrefParts.path, newFileInfo.entryPath)).path;
+ } else {
+ newFileInfo.rootpath = hrefParts.path;
+ }
+ }
+
+ if (env.useFileCache && fileCache[href]) {
+ try {
+ var lessText = fileCache[href];
+ callback(null, lessText, href, newFileInfo, { lastModified: new Date() });
+ } catch (e) {
+ callback(e, null, href);
+ }
+ return;
+ }
+
+ doXHR(href, env.mime, function (data, lastModified) {
+ // per file cache
+ fileCache[href] = data;
+
+ // Use remote copy (re-parse)
+ try {
+ callback(null, data, href, newFileInfo, { lastModified: lastModified });
+ } catch (e) {
+ callback(e, null, href);
+ }
+ }, function (status, url) {
+ callback({ type: 'File', message: "'" + url + "' wasn't found (" + status + ")" }, null, href);
+ });
+}
+
+function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
+
+ var env = new less.tree.parseEnv(less);
+ env.mime = sheet.type;
+
+ if (modifyVars || less.globalVars) {
+ env.useFileCache = true;
+ }
+
+ loadFile(sheet.href, null, function(e, data, path, newFileInfo, webInfo) {
+
+ if (webInfo) {
+ webInfo.remaining = remaining;
+
+ var css = cache && cache.getItem(path),
+ timestamp = cache && cache.getItem(path + ':timestamp');
+
+ if (!reload && timestamp && webInfo.lastModified &&
+ (new(Date)(webInfo.lastModified).valueOf() ===
+ new(Date)(timestamp).valueOf())) {
+ // Use local copy
+ createCSS(css, sheet);
+ webInfo.local = true;
+ callback(null, null, data, sheet, webInfo, path);
+ return;
+ }
+ }
+
+ //TODO add tests around how this behaves when reloading
+ removeError(path);
+
+ if (data) {
+ env.currentFileInfo = newFileInfo;
+ new(less.Parser)(env).parse(data, function (e, root) {
+ if (e) { return callback(e, null, null, sheet); }
+ try {
+ callback(e, root, data, sheet, webInfo, path);
+ } catch (e) {
+ callback(e, null, null, sheet);
+ }
+ }, {modifyVars: modifyVars, globalVars: less.globalVars});
+ } else {
+ callback(e, null, null, sheet, webInfo, path);
+ }
+ }, env, modifyVars);
+}
+
+function loadStyleSheets(callback, reload, modifyVars) {
+ for (var i = 0; i < less.sheets.length; i++) {
+ loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
+ }
+}
+
+function initRunningMode(){
+ if (less.env === 'development') {
+ less.optimization = 0;
+ less.watchTimer = setInterval(function () {
+ if (less.watchMode) {
+ loadStyleSheets(function (e, root, _, sheet, env) {
+ if (e) {
+ error(e, sheet.href);
+ } else if (root) {
+ createCSS(root.toCSS(less), sheet, env.lastModified);
+ }
+ });
+ }
+ }, less.poll);
+ } else {
+ less.optimization = 3;
+ }
+}
+
+
+
+//
+// Watch mode
+//
+less.watch = function () {
+ if (!less.watchMode ){
+ less.env = 'development';
+ initRunningMode();
+ }
+ this.watchMode = true;
+ return true;
+};
+
+less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
+
+if (/!watch/.test(location.hash)) {
+ less.watch();
+}
+
+if (less.env != 'development') {
+ try {
+ cache = (typeof(window.localStorage) === 'undefined') ? null : window.localStorage;
+ } catch (_) {}
+}
+
+//
+// Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
+//
+var links = document.getElementsByTagName('link');
+
+less.sheets = [];
+
+for (var i = 0; i < links.length; i++) {
+ if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
+ (links[i].type.match(typePattern)))) {
+ less.sheets.push(links[i]);
+ }
+}
+
+//
+// With this function, it's possible to alter variables and re-render
+// CSS without reloading less-files
+//
+less.modifyVars = function(record) {
+ less.refresh(false, record);
+};
+
+less.refresh = function (reload, modifyVars) {
+ var startTime, endTime;
+ startTime = endTime = new Date();
+
+ loadStyleSheets(function (e, root, _, sheet, env) {
+ if (e) {
+ return error(e, sheet.href);
+ }
+ if (env.local) {
+ log("loading " + sheet.href + " from cache.", logLevel.info);
+ } else {
+ log("parsed " + sheet.href + " successfully.", logLevel.info);
+ createCSS(root.toCSS(less), sheet, env.lastModified);
+ }
+ log("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms', logLevel.info);
+ if (env.remaining === 0) {
+ log("css generated in " + (new Date() - startTime) + 'ms', logLevel.info);
+ }
+ endTime = new Date();
+ }, reload, modifyVars);
+
+ loadStyles(modifyVars);
+};
+
+less.refreshStyles = loadStyles;
+
+less.Parser.fileLoader = loadFile;
+
+less.refresh(less.env === 'development');
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/colors.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/colors.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/colors.js
new file mode 100644
index 0000000..e509b60
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/colors.js
@@ -0,0 +1,151 @@
+(function (tree) {
+ tree.colors = {
+ 'aliceblue':'#f0f8ff',
+ 'antiquewhite':'#faebd7',
+ 'aqua':'#00ffff',
+ 'aquamarine':'#7fffd4',
+ 'azure':'#f0ffff',
+ 'beige':'#f5f5dc',
+ 'bisque':'#ffe4c4',
+ 'black':'#000000',
+ 'blanchedalmond':'#ffebcd',
+ 'blue':'#0000ff',
+ 'blueviolet':'#8a2be2',
+ 'brown':'#a52a2a',
+ 'burlywood':'#deb887',
+ 'cadetblue':'#5f9ea0',
+ 'chartreuse':'#7fff00',
+ 'chocolate':'#d2691e',
+ 'coral':'#ff7f50',
+ 'cornflowerblue':'#6495ed',
+ 'cornsilk':'#fff8dc',
+ 'crimson':'#dc143c',
+ 'cyan':'#00ffff',
+ 'darkblue':'#00008b',
+ 'darkcyan':'#008b8b',
+ 'darkgoldenrod':'#b8860b',
+ 'darkgray':'#a9a9a9',
+ 'darkgrey':'#a9a9a9',
+ 'darkgreen':'#006400',
+ 'darkkhaki':'#bdb76b',
+ 'darkmagenta':'#8b008b',
+ 'darkolivegreen':'#556b2f',
+ 'darkorange':'#ff8c00',
+ 'darkorchid':'#9932cc',
+ 'darkred':'#8b0000',
+ 'darksalmon':'#e9967a',
+ 'darkseagreen':'#8fbc8f',
+ 'darkslateblue':'#483d8b',
+ 'darkslategray':'#2f4f4f',
+ 'darkslategrey':'#2f4f4f',
+ 'darkturquoise':'#00ced1',
+ 'darkviolet':'#9400d3',
+ 'deeppink':'#ff1493',
+ 'deepskyblue':'#00bfff',
+ 'dimgray':'#696969',
+ 'dimgrey':'#696969',
+ 'dodgerblue':'#1e90ff',
+ 'firebrick':'#b22222',
+ 'floralwhite':'#fffaf0',
+ 'forestgreen':'#228b22',
+ 'fuchsia':'#ff00ff',
+ 'gainsboro':'#dcdcdc',
+ 'ghostwhite':'#f8f8ff',
+ 'gold':'#ffd700',
+ 'goldenrod':'#daa520',
+ 'gray':'#808080',
+ 'grey':'#808080',
+ 'green':'#008000',
+ 'greenyellow':'#adff2f',
+ 'honeydew':'#f0fff0',
+ 'hotpink':'#ff69b4',
+ 'indianred':'#cd5c5c',
+ 'indigo':'#4b0082',
+ 'ivory':'#fffff0',
+ 'khaki':'#f0e68c',
+ 'lavender':'#e6e6fa',
+ 'lavenderblush':'#fff0f5',
+ 'lawngreen':'#7cfc00',
+ 'lemonchiffon':'#fffacd',
+ 'lightblue':'#add8e6',
+ 'lightcoral':'#f08080',
+ 'lightcyan':'#e0ffff',
+ 'lightgoldenrodyellow':'#fafad2',
+ 'lightgray':'#d3d3d3',
+ 'lightgrey':'#d3d3d3',
+ 'lightgreen':'#90ee90',
+ 'lightpink':'#ffb6c1',
+ 'lightsalmon':'#ffa07a',
+ 'lightseagreen':'#20b2aa',
+ 'lightskyblue':'#87cefa',
+ 'lightslategray':'#778899',
+ 'lightslategrey':'#778899',
+ 'lightsteelblue':'#b0c4de',
+ 'lightyellow':'#ffffe0',
+ 'lime':'#00ff00',
+ 'limegreen':'#32cd32',
+ 'linen':'#faf0e6',
+ 'magenta':'#ff00ff',
+ 'maroon':'#800000',
+ 'mediumaquamarine':'#66cdaa',
+ 'mediumblue':'#0000cd',
+ 'mediumorchid':'#ba55d3',
+ 'mediumpurple':'#9370d8',
+ 'mediumseagreen':'#3cb371',
+ 'mediumslateblue':'#7b68ee',
+ 'mediumspringgreen':'#00fa9a',
+ 'mediumturquoise':'#48d1cc',
+ 'mediumvioletred':'#c71585',
+ 'midnightblue':'#191970',
+ 'mintcream':'#f5fffa',
+ 'mistyrose':'#ffe4e1',
+ 'moccasin':'#ffe4b5',
+ 'navajowhite':'#ffdead',
+ 'navy':'#000080',
+ 'oldlace':'#fdf5e6',
+ 'olive':'#808000',
+ 'olivedrab':'#6b8e23',
+ 'orange':'#ffa500',
+ 'orangered':'#ff4500',
+ 'orchid':'#da70d6',
+ 'palegoldenrod':'#eee8aa',
+ 'palegreen':'#98fb98',
+ 'paleturquoise':'#afeeee',
+ 'palevioletred':'#d87093',
+ 'papayawhip':'#ffefd5',
+ 'peachpuff':'#ffdab9',
+ 'peru':'#cd853f',
+ 'pink':'#ffc0cb',
+ 'plum':'#dda0dd',
+ 'powderblue':'#b0e0e6',
+ 'purple':'#800080',
+ 'red':'#ff0000',
+ 'rosybrown':'#bc8f8f',
+ 'royalblue':'#4169e1',
+ 'saddlebrown':'#8b4513',
+ 'salmon':'#fa8072',
+ 'sandybrown':'#f4a460',
+ 'seagreen':'#2e8b57',
+ 'seashell':'#fff5ee',
+ 'sienna':'#a0522d',
+ 'silver':'#c0c0c0',
+ 'skyblue':'#87ceeb',
+ 'slateblue':'#6a5acd',
+ 'slategray':'#708090',
+ 'slategrey':'#708090',
+ 'snow':'#fffafa',
+ 'springgreen':'#00ff7f',
+ 'steelblue':'#4682b4',
+ 'tan':'#d2b48c',
+ 'teal':'#008080',
+ 'thistle':'#d8bfd8',
+ 'tomato':'#ff6347',
+ 'turquoise':'#40e0d0',
+ 'violet':'#ee82ee',
+ 'wheat':'#f5deb3',
+ 'white':'#ffffff',
+ 'whitesmoke':'#f5f5f5',
+ 'yellow':'#ffff00',
+ 'yellowgreen':'#9acd32'
+ };
+})(require('./tree'));
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/env.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/env.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/env.js
new file mode 100644
index 0000000..4f11c6a
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/env.js
@@ -0,0 +1,135 @@
+(function (tree) {
+
+ var parseCopyProperties = [
+ 'paths', // option - unmodified - paths to search for imports on
+ 'optimization', // option - optimization level (for the chunker)
+ 'files', // list of files that have been imported, used for import-once
+ 'contents', // map - filename to contents of all the files
+ 'contentsIgnoredChars', // map - filename to lines at the begining of each file to ignore
+ 'relativeUrls', // option - whether to adjust URL's to be relative
+ 'rootpath', // option - rootpath to append to URL's
+ 'strictImports', // option -
+ 'insecure', // option - whether to allow imports from insecure ssl hosts
+ 'dumpLineNumbers', // option - whether to dump line numbers
+ 'compress', // option - whether to compress
+ 'processImports', // option - whether to process imports. if false then imports will not be imported
+ 'syncImport', // option - whether to import synchronously
+ 'javascriptEnabled',// option - whether JavaScript is enabled. if undefined, defaults to true
+ 'mime', // browser only - mime type for sheet import
+ 'useFileCache', // browser only - whether to use the per file session cache
+ 'currentFileInfo' // information about the current file - for error reporting and importing and making urls relative etc.
+ ];
+
+ //currentFileInfo = {
+ // 'relativeUrls' - option - whether to adjust URL's to be relative
+ // 'filename' - full resolved filename of current file
+ // 'rootpath' - path to append to normal URLs for this node
+ // 'currentDirectory' - path to the current file, absolute
+ // 'rootFilename' - filename of the base file
+ // 'entryPath' - absolute path to the entry file
+ // 'reference' - whether the file should not be output and only output parts that are referenced
+
+ tree.parseEnv = function(options) {
+ copyFromOriginal(options, this, parseCopyProperties);
+
+ if (!this.contents) { this.contents = {}; }
+ if (!this.contentsIgnoredChars) { this.contentsIgnoredChars = {}; }
+ if (!this.files) { this.files = {}; }
+
+ if (!this.currentFileInfo) {
+ var filename = (options && options.filename) || "input";
+ var entryPath = filename.replace(/[^\/\\]*$/, "");
+ if (options) {
+ options.filename = null;
+ }
+ this.currentFileInfo = {
+ filename: filename,
+ relativeUrls: this.relativeUrls,
+ rootpath: (options && options.rootpath) || "",
+ currentDirectory: entryPath,
+ entryPath: entryPath,
+ rootFilename: filename
+ };
+ }
+ };
+
+ var evalCopyProperties = [
+ 'silent', // whether to swallow errors and warnings
+ 'verbose', // whether to log more activity
+ 'compress', // whether to compress
+ 'yuicompress', // whether to compress with the outside tool yui compressor
+ 'ieCompat', // whether to enforce IE compatibility (IE8 data-uri)
+ 'strictMath', // whether math has to be within parenthesis
+ 'strictUnits', // whether units need to evaluate correctly
+ 'cleancss', // whether to compress with clean-css
+ 'sourceMap', // whether to output a source map
+ 'importMultiple'// whether we are currently importing multiple copies
+ ];
+
+ tree.evalEnv = function(options, frames) {
+ copyFromOriginal(options, this, evalCopyProperties);
+
+ this.frames = frames || [];
+ };
+
+ tree.evalEnv.prototype.inParenthesis = function () {
+ if (!this.parensStack) {
+ this.parensStack = [];
+ }
+ this.parensStack.push(true);
+ };
+
+ tree.evalEnv.prototype.outOfParenthesis = function () {
+ this.parensStack.pop();
+ };
+
+ tree.evalEnv.prototype.isMathOn = function () {
+ return this.strictMath ? (this.parensStack && this.parensStack.length) : true;
+ };
+
+ tree.evalEnv.prototype.isPathRelative = function (path) {
+ return !/^(?:[a-z-]+:|\/)/.test(path);
+ };
+
+ tree.evalEnv.prototype.normalizePath = function( path ) {
+ var
+ segments = path.split("/").reverse(),
+ segment;
+
+ path = [];
+ while (segments.length !== 0 ) {
+ segment = segments.pop();
+ switch( segment ) {
+ case ".":
+ break;
+ case "..":
+ if ((path.length === 0) || (path[path.length - 1] === "..")) {
+ path.push( segment );
+ } else {
+ path.pop();
+ }
+ break;
+ default:
+ path.push( segment );
+ break;
+ }
+ }
+
+ return path.join("/");
+ };
+
+ //todo - do the same for the toCSS env
+ //tree.toCSSEnv = function (options) {
+ //};
+
+ var copyFromOriginal = function(original, destination, propertiesToCopy) {
+ if (!original) { return; }
+
+ for(var i = 0; i < propertiesToCopy.length; i++) {
+ if (original.hasOwnProperty(propertiesToCopy[i])) {
+ destination[propertiesToCopy[i]] = original[propertiesToCopy[i]];
+ }
+ }
+ };
+
+})(require('./tree'));
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/extend-visitor.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/extend-visitor.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/extend-visitor.js
new file mode 100644
index 0000000..4b397a9
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/extend-visitor.js
@@ -0,0 +1,416 @@
+(function (tree) {
+ /*jshint loopfunc:true */
+
+ tree.extendFinderVisitor = function() {
+ this._visitor = new tree.visitor(this);
+ this.contexts = [];
+ this.allExtendsStack = [[]];
+ };
+
+ tree.extendFinderVisitor.prototype = {
+ run: function (root) {
+ root = this._visitor.visit(root);
+ root.allExtends = this.allExtendsStack[0];
+ return root;
+ },
+ visitRule: function (ruleNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ },
+ visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ },
+ visitRuleset: function (rulesetNode, visitArgs) {
+ if (rulesetNode.root) {
+ return;
+ }
+
+ var i, j, extend, allSelectorsExtendList = [], extendList;
+
+ // get &:extend(.a); rules which apply to all selectors in this ruleset
+ var rules = rulesetNode.rules, ruleCnt = rules ? rules.length : 0;
+ for(i = 0; i < ruleCnt; i++) {
+ if (rulesetNode.rules[i] instanceof tree.Extend) {
+ allSelectorsExtendList.push(rules[i]);
+ rulesetNode.extendOnEveryPath = true;
+ }
+ }
+
+ // now find every selector and apply the extends that apply to all extends
+ // and the ones which apply to an individual extend
+ var paths = rulesetNode.paths;
+ for(i = 0; i < paths.length; i++) {
+ var selectorPath = paths[i],
+ selector = selectorPath[selectorPath.length - 1],
+ selExtendList = selector.extendList;
+
+ extendList = selExtendList ? selExtendList.slice(0).concat(allSelectorsExtendList)
+ : allSelectorsExtendList;
+
+ if (extendList) {
+ extendList = extendList.map(function(allSelectorsExtend) {
+ return allSelectorsExtend.clone();
+ });
+ }
+
+ for(j = 0; j < extendList.length; j++) {
+ this.foundExtends = true;
+ extend = extendList[j];
+ extend.findSelfSelectors(selectorPath);
+ extend.ruleset = rulesetNode;
+ if (j === 0) { extend.firstExtendOnThisSelectorPath = true; }
+ this.allExtendsStack[this.allExtendsStack.length-1].push(extend);
+ }
+ }
+
+ this.contexts.push(rulesetNode.selectors);
+ },
+ visitRulesetOut: function (rulesetNode) {
+ if (!rulesetNode.root) {
+ this.contexts.length = this.contexts.length - 1;
+ }
+ },
+ visitMedia: function (mediaNode, visitArgs) {
+ mediaNode.allExtends = [];
+ this.allExtendsStack.push(mediaNode.allExtends);
+ },
+ visitMediaOut: function (mediaNode) {
+ this.allExtendsStack.length = this.allExtendsStack.length - 1;
+ },
+ visitDirective: function (directiveNode, visitArgs) {
+ directiveNode.allExtends = [];
+ this.allExtendsStack.push(directiveNode.allExtends);
+ },
+ visitDirectiveOut: function (directiveNode) {
+ this.allExtendsStack.length = this.allExtendsStack.length - 1;
+ }
+ };
+
+ tree.processExtendsVisitor = function() {
+ this._visitor = new tree.visitor(this);
+ };
+
+ tree.processExtendsVisitor.prototype = {
+ run: function(root) {
+ var extendFinder = new tree.extendFinderVisitor();
+ extendFinder.run(root);
+ if (!extendFinder.foundExtends) { return root; }
+ root.allExtends = root.allExtends.concat(this.doExtendChaining(root.allExtends, root.allExtends));
+ this.allExtendsStack = [root.allExtends];
+ return this._visitor.visit(root);
+ },
+ doExtendChaining: function (extendsList, extendsListTarget, iterationCount) {
+ //
+ // chaining is different from normal extension.. if we extend an extend then we are not just copying, altering and pasting
+ // the selector we would do normally, but we are also adding an extend with the same target selector
+ // this means this new extend can then go and alter other extends
+ //
+ // this method deals with all the chaining work - without it, extend is flat and doesn't work on other extend selectors
+ // this is also the most expensive.. and a match on one selector can cause an extension of a selector we had already processed if
+ // we look at each selector at a time, as is done in visitRuleset
+
+ var extendIndex, targetExtendIndex, matches, extendsToAdd = [], newSelector, extendVisitor = this, selectorPath, extend, targetExtend, newExtend;
+
+ iterationCount = iterationCount || 0;
+
+ //loop through comparing every extend with every target extend.
+ // a target extend is the one on the ruleset we are looking at copy/edit/pasting in place
+ // e.g. .a:extend(.b) {} and .b:extend(.c) {} then the first extend extends the second one
+ // and the second is the target.
+ // the seperation into two lists allows us to process a subset of chains with a bigger set, as is the
+ // case when processing media queries
+ for(extendIndex = 0; extendIndex < extendsList.length; extendIndex++){
+ for(targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++){
+
+ extend = extendsList[extendIndex];
+ targetExtend = extendsListTarget[targetExtendIndex];
+
+ // look for circular references
+ if( extend.parent_ids.indexOf( targetExtend.object_id ) >= 0 ){ continue; }
+
+ // find a match in the target extends self selector (the bit before :extend)
+ selectorPath = [targetExtend.selfSelectors[0]];
+ matches = extendVisitor.findMatch(extend, selectorPath);
+
+ if (matches.length) {
+
+ // we found a match, so for each self selector..
+ extend.selfSelectors.forEach(function(selfSelector) {
+
+ // process the extend as usual
+ newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector);
+
+ // but now we create a new extend from it
+ newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0);
+ newExtend.selfSelectors = newSelector;
+
+ // add the extend onto the list of extends for that selector
+ newSelector[newSelector.length-1].extendList = [newExtend];
+
+ // record that we need to add it.
+ extendsToAdd.push(newExtend);
+ newExtend.ruleset = targetExtend.ruleset;
+
+ //remember its parents for circular references
+ newExtend.parent_ids = newExtend.parent_ids.concat(targetExtend.parent_ids, extend.parent_ids);
+
+ // only process the selector once.. if we have :extend(.a,.b) then multiple
+ // extends will look at the same selector path, so when extending
+ // we know that any others will be duplicates in terms of what is added to the css
+ if (targetExtend.firstExtendOnThisSelectorPath) {
+ newExtend.firstExtendOnThisSelectorPath = true;
+ targetExtend.ruleset.paths.push(newSelector);
+ }
+ });
+ }
+ }
+ }
+
+ if (extendsToAdd.length) {
+ // try to detect circular references to stop a stack overflow.
+ // may no longer be needed.
+ this.extendChainCount++;
+ if (iterationCount > 100) {
+ var selectorOne = "{unable to calculate}";
+ var selectorTwo = "{unable to calculate}";
+ try
+ {
+ selectorOne = extendsToAdd[0].selfSelectors[0].toCSS();
+ selectorTwo = extendsToAdd[0].selector.toCSS();
+ }
+ catch(e) {}
+ throw {message: "extend circular reference detected. One of the circular extends is currently:"+selectorOne+":extend(" + selectorTwo+")"};
+ }
+
+ // now process the new extends on the existing rules so that we can handle a extending b extending c ectending d extending e...
+ return extendsToAdd.concat(extendVisitor.doExtendChaining(extendsToAdd, extendsListTarget, iterationCount+1));
+ } else {
+ return extendsToAdd;
+ }
+ },
+ visitRule: function (ruleNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ },
+ visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ },
+ visitSelector: function (selectorNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ },
+ visitRuleset: function (rulesetNode, visitArgs) {
+ if (rulesetNode.root) {
+ return;
+ }
+ var matches, pathIndex, extendIndex, allExtends = this.allExtendsStack[this.allExtendsStack.length-1], selectorsToAdd = [], extendVisitor = this, selectorPath;
+
+ // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
+
+ for(extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
+ for(pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
+ selectorPath = rulesetNode.paths[pathIndex];
+
+ // extending extends happens initially, before the main pass
+ if (rulesetNode.extendOnEveryPath) { continue; }
+ var extendList = selectorPath[selectorPath.length-1].extendList;
+ if (extendList && extendList.length) { continue; }
+
+ matches = this.findMatch(allExtends[extendIndex], selectorPath);
+
+ if (matches.length) {
+
+ allExtends[extendIndex].selfSelectors.forEach(function(selfSelector) {
+ selectorsToAdd.push(extendVisitor.extendSelector(matches, selectorPath, selfSelector));
+ });
+ }
+ }
+ }
+ rulesetNode.paths = rulesetNode.paths.concat(selectorsToAdd);
+ },
+ findMatch: function (extend, haystackSelectorPath) {
+ //
+ // look through the haystack selector path to try and find the needle - extend.selector
+ // returns an array of selector matches that can then be replaced
+ //
+ var haystackSelectorIndex, hackstackSelector, hackstackElementIndex, haystackElement,
+ targetCombinator, i,
+ extendVisitor = this,
+ needleElements = extend.selector.elements,
+ potentialMatches = [], potentialMatch, matches = [];
+
+ // loop through the haystack elements
+ for(haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
+ hackstackSelector = haystackSelectorPath[haystackSelectorIndex];
+
+ for(hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
+
+ haystackElement = hackstackSelector.elements[hackstackElementIndex];
+
+ // if we allow elements before our match we can add a potential match every time. otherwise only at the first element.
+ if (extend.allowBefore || (haystackSelectorIndex === 0 && hackstackElementIndex === 0)) {
+ potentialMatches.push({pathIndex: haystackSelectorIndex, index: hackstackElementIndex, matched: 0, initialCombinator: haystackElement.combinator});
+ }
+
+ for(i = 0; i < potentialMatches.length; i++) {
+ potentialMatch = potentialMatches[i];
+
+ // selectors add " " onto the first element. When we use & it joins the selectors together, but if we don't
+ // then each selector in haystackSelectorPath has a space before it added in the toCSS phase. so we need to work out
+ // what the resulting combinator will be
+ targetCombinator = haystackElement.combinator.value;
+ if (targetCombinator === '' && hackstackElementIndex === 0) {
+ targetCombinator = ' ';
+ }
+
+ // if we don't match, null our match to indicate failure
+ if (!extendVisitor.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) ||
+ (potentialMatch.matched > 0 && needleElements[potentialMatch.matched].combinator.value !== targetCombinator)) {
+ potentialMatch = null;
+ } else {
+ potentialMatch.matched++;
+ }
+
+ // if we are still valid and have finished, test whether we have elements after and whether these are allowed
+ if (potentialMatch) {
+ potentialMatch.finished = potentialMatch.matched === needleElements.length;
+ if (potentialMatch.finished &&
+ (!extend.allowAfter && (hackstackElementIndex+1 < hackstackSelector.elements.length || haystackSelectorIndex+1 < haystackSelectorPath.length))) {
+ potentialMatch = null;
+ }
+ }
+ // if null we remove, if not, we are still valid, so either push as a valid match or continue
+ if (potentialMatch) {
+ if (potentialMatch.finished) {
+ potentialMatch.length = needleElements.length;
+ potentialMatch.endPathIndex = haystackSelectorIndex;
+ potentialMatch.endPathElementIndex = hackstackElementIndex + 1; // index after end of match
+ potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again
+ matches.push(potentialMatch);
+ }
+ } else {
+ potentialMatches.splice(i, 1);
+ i--;
+ }
+ }
+ }
+ }
+ return matches;
+ },
+ isElementValuesEqual: function(elementValue1, elementValue2) {
+ if (typeof elementValue1 === "string" || typeof elementValue2 === "string") {
+ return elementValue1 === elementValue2;
+ }
+ if (elementValue1 instanceof tree.Attribute) {
+ if (elementValue1.op !== elementValue2.op || elementValue1.key !== elementValue2.key) {
+ return false;
+ }
+ if (!elementValue1.value || !elementValue2.value) {
+ if (elementValue1.value || elementValue2.value) {
+ return false;
+ }
+ return true;
+ }
+ elementValue1 = elementValue1.value.value || elementValue1.value;
+ elementValue2 = elementValue2.value.value || elementValue2.value;
+ return elementValue1 === elementValue2;
+ }
+ elementValue1 = elementValue1.value;
+ elementValue2 = elementValue2.value;
+ if (elementValue1 instanceof tree.Selector) {
+ if (!(elementValue2 instanceof tree.Selector) || elementValue1.elements.length !== elementValue2.elements.length) {
+ return false;
+ }
+ for(var i = 0; i <elementValue1.elements.length; i++) {
+ if (elementValue1.elements[i].combinator.value !== elementValue2.elements[i].combinator.value) {
+ if (i !== 0 || (elementValue1.elements[i].combinator.value || ' ') !== (elementValue2.elements[i].combinator.value || ' ')) {
+ return false;
+ }
+ }
+ if (!this.isElementValuesEqual(elementValue1.elements[i].value, elementValue2.elements[i].value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ },
+ extendSelector:function (matches, selectorPath, replacementSelector) {
+
+ //for a set of matches, replace each match with the replacement selector
+
+ var currentSelectorPathIndex = 0,
+ currentSelectorPathElementIndex = 0,
+ path = [],
+ matchIndex,
+ selector,
+ firstElement,
+ match,
+ newElements;
+
+ for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {
+ match = matches[matchIndex];
+ selector = selectorPath[match.pathIndex];
+ firstElement = new tree.Element(
+ match.initialCombinator,
+ replacementSelector.elements[0].value,
+ replacementSelector.elements[0].index,
+ replacementSelector.elements[0].currentFileInfo
+ );
+
+ if (match.pathIndex > currentSelectorPathIndex && currentSelectorPathElementIndex > 0) {
+ path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
+ currentSelectorPathElementIndex = 0;
+ currentSelectorPathIndex++;
+ }
+
+ newElements = selector.elements
+ .slice(currentSelectorPathElementIndex, match.index)
+ .concat([firstElement])
+ .concat(replacementSelector.elements.slice(1));
+
+ if (currentSelectorPathIndex === match.pathIndex && matchIndex > 0) {
+ path[path.length - 1].elements =
+ path[path.length - 1].elements.concat(newElements);
+ } else {
+ path = path.concat(selectorPath.slice(currentSelectorPathIndex, match.pathIndex));
+
+ path.push(new tree.Selector(
+ newElements
+ ));
+ }
+ currentSelectorPathIndex = match.endPathIndex;
+ currentSelectorPathElementIndex = match.endPathElementIndex;
+ if (currentSelectorPathElementIndex >= selectorPath[currentSelectorPathIndex].elements.length) {
+ currentSelectorPathElementIndex = 0;
+ currentSelectorPathIndex++;
+ }
+ }
+
+ if (currentSelectorPathIndex < selectorPath.length && currentSelectorPathElementIndex > 0) {
+ path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
+ currentSelectorPathIndex++;
+ }
+
+ path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
+
+ return path;
+ },
+ visitRulesetOut: function (rulesetNode) {
+ },
+ visitMedia: function (mediaNode, visitArgs) {
+ var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
+ newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
+ this.allExtendsStack.push(newAllExtends);
+ },
+ visitMediaOut: function (mediaNode) {
+ this.allExtendsStack.length = this.allExtendsStack.length - 1;
+ },
+ visitDirective: function (directiveNode, visitArgs) {
+ var newAllExtends = directiveNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
+ newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, directiveNode.allExtends));
+ this.allExtendsStack.push(newAllExtends);
+ },
+ visitDirectiveOut: function (directiveNode) {
+ this.allExtendsStack.length = this.allExtendsStack.length - 1;
+ }
+ };
+
+})(require('./tree'));
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/functions.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/functions.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/functions.js
new file mode 100644
index 0000000..5fbf9c2
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/functions.js
@@ -0,0 +1,724 @@
+(function (tree) {
+
+tree.functions = {
+ rgb: function (r, g, b) {
+ return this.rgba(r, g, b, 1.0);
+ },
+ rgba: function (r, g, b, a) {
+ var rgb = [r, g, b].map(function (c) { return scaled(c, 255); });
+ a = number(a);
+ return new(tree.Color)(rgb, a);
+ },
+ hsl: function (h, s, l) {
+ return this.hsla(h, s, l, 1.0);
+ },
+ hsla: function (h, s, l, a) {
+ function hue(h) {
+ h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
+ if (h * 6 < 1) { return m1 + (m2 - m1) * h * 6; }
+ else if (h * 2 < 1) { return m2; }
+ else if (h * 3 < 2) { return m1 + (m2 - m1) * (2/3 - h) * 6; }
+ else { return m1; }
+ }
+
+ h = (number(h) % 360) / 360;
+ s = clamp(number(s)); l = clamp(number(l)); a = clamp(number(a));
+
+ var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
+ var m1 = l * 2 - m2;
+
+ return this.rgba(hue(h + 1/3) * 255,
+ hue(h) * 255,
+ hue(h - 1/3) * 255,
+ a);
+ },
+
+ hsv: function(h, s, v) {
+ return this.hsva(h, s, v, 1.0);
+ },
+
+ hsva: function(h, s, v, a) {
+ h = ((number(h) % 360) / 360) * 360;
+ s = number(s); v = number(v); a = number(a);
+
+ var i, f;
+ i = Math.floor((h / 60) % 6);
+ f = (h / 60) - i;
+
+ var vs = [v,
+ v * (1 - s),
+ v * (1 - f * s),
+ v * (1 - (1 - f) * s)];
+ var perm = [[0, 3, 1],
+ [2, 0, 1],
+ [1, 0, 3],
+ [1, 2, 0],
+ [3, 1, 0],
+ [0, 1, 2]];
+
+ return this.rgba(vs[perm[i][0]] * 255,
+ vs[perm[i][1]] * 255,
+ vs[perm[i][2]] * 255,
+ a);
+ },
+
+ hue: function (color) {
+ return new(tree.Dimension)(Math.round(color.toHSL().h));
+ },
+ saturation: function (color) {
+ return new(tree.Dimension)(Math.round(color.toHSL().s * 100), '%');
+ },
+ lightness: function (color) {
+ return new(tree.Dimension)(Math.round(color.toHSL().l * 100), '%');
+ },
+ hsvhue: function(color) {
+ return new(tree.Dimension)(Math.round(color.toHSV().h));
+ },
+ hsvsaturation: function (color) {
+ return new(tree.Dimension)(Math.round(color.toHSV().s * 100), '%');
+ },
+ hsvvalue: function (color) {
+ return new(tree.Dimension)(Math.round(color.toHSV().v * 100), '%');
+ },
+ red: function (color) {
+ return new(tree.Dimension)(color.rgb[0]);
+ },
+ green: function (color) {
+ return new(tree.Dimension)(color.rgb[1]);
+ },
+ blue: function (color) {
+ return new(tree.Dimension)(color.rgb[2]);
+ },
+ alpha: function (color) {
+ return new(tree.Dimension)(color.toHSL().a);
+ },
+ luma: function (color) {
+ return new(tree.Dimension)(Math.round(color.luma() * color.alpha * 100), '%');
+ },
+ saturate: function (color, amount) {
+ // filter: saturate(3.2);
+ // should be kept as is, so check for color
+ if (!color.rgb) {
+ return null;
+ }
+ var hsl = color.toHSL();
+
+ hsl.s += amount.value / 100;
+ hsl.s = clamp(hsl.s);
+ return hsla(hsl);
+ },
+ desaturate: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.s -= amount.value / 100;
+ hsl.s = clamp(hsl.s);
+ return hsla(hsl);
+ },
+ lighten: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.l += amount.value / 100;
+ hsl.l = clamp(hsl.l);
+ return hsla(hsl);
+ },
+ darken: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.l -= amount.value / 100;
+ hsl.l = clamp(hsl.l);
+ return hsla(hsl);
+ },
+ fadein: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.a += amount.value / 100;
+ hsl.a = clamp(hsl.a);
+ return hsla(hsl);
+ },
+ fadeout: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.a -= amount.value / 100;
+ hsl.a = clamp(hsl.a);
+ return hsla(hsl);
+ },
+ fade: function (color, amount) {
+ var hsl = color.toHSL();
+
+ hsl.a = amount.value / 100;
+ hsl.a = clamp(hsl.a);
+ return hsla(hsl);
+ },
+ spin: function (color, amount) {
+ var hsl = color.toHSL();
+ var hue = (hsl.h + amount.value) % 360;
+
+ hsl.h = hue < 0 ? 360 + hue : hue;
+
+ return hsla(hsl);
+ },
+ //
+ // Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein
+ // http://sass-lang.com
+ //
+ mix: function (color1, color2, weight) {
+ if (!weight) {
+ weight = new(tree.Dimension)(50);
+ }
+ var p = weight.value / 100.0;
+ var w = p * 2 - 1;
+ var a = color1.toHSL().a - color2.toHSL().a;
+
+ var w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+ var w2 = 1 - w1;
+
+ var rgb = [color1.rgb[0] * w1 + color2.rgb[0] * w2,
+ color1.rgb[1] * w1 + color2.rgb[1] * w2,
+ color1.rgb[2] * w1 + color2.rgb[2] * w2];
+
+ var alpha = color1.alpha * p + color2.alpha * (1 - p);
+
+ return new(tree.Color)(rgb, alpha);
+ },
+ greyscale: function (color) {
+ return this.desaturate(color, new(tree.Dimension)(100));
+ },
+ contrast: function (color, dark, light, threshold) {
+ // filter: contrast(3.2);
+ // should be kept as is, so check for color
+ if (!color.rgb) {
+ return null;
+ }
+ if (typeof light === 'undefined') {
+ light = this.rgba(255, 255, 255, 1.0);
+ }
+ if (typeof dark === 'undefined') {
+ dark = this.rgba(0, 0, 0, 1.0);
+ }
+ //Figure out which is actually light and dark!
+ if (dark.luma() > light.luma()) {
+ var t = light;
+ light = dark;
+ dark = t;
+ }
+ if (typeof threshold === 'undefined') {
+ threshold = 0.43;
+ } else {
+ threshold = number(threshold);
+ }
+ if (color.luma() < threshold) {
+ return light;
+ } else {
+ return dark;
+ }
+ },
+ e: function (str) {
+ return new(tree.Anonymous)(str instanceof tree.JavaScript ? str.evaluated : str);
+ },
+ escape: function (str) {
+ return new(tree.Anonymous)(encodeURI(str.value).replace(/=/g, "%3D").replace(/:/g, "%3A").replace(/#/g, "%23").replace(/;/g, "%3B").replace(/\(/g, "%28").replace(/\)/g, "%29"));
+ },
+ '%': function (quoted /* arg, arg, ...*/) {
+ var args = Array.prototype.slice.call(arguments, 1),
+ str = quoted.value;
+
+ for (var i = 0; i < args.length; i++) {
+ /*jshint loopfunc:true */
+ str = str.replace(/%[sda]/i, function(token) {
+ var value = token.match(/s/i) ? args[i].value : args[i].toCSS();
+ return token.match(/[A-Z]$/) ? encodeURIComponent(value) : value;
+ });
+ }
+ str = str.replace(/%%/g, '%');
+ return new(tree.Quoted)('"' + str + '"', str);
+ },
+ unit: function (val, unit) {
+ if(!(val instanceof tree.Dimension)) {
+ throw { type: "Argument", message: "the first argument to unit must be a number" + (val instanceof tree.Operation ? ". Have you forgotten parenthesis?" : "") };
+ }
+ return new(tree.Dimension)(val.value, unit ? unit.toCSS() : "");
+ },
+ convert: function (val, unit) {
+ return val.convertTo(unit.value);
+ },
+ round: function (n, f) {
+ var fraction = typeof(f) === "undefined" ? 0 : f.value;
+ return _math(function(num) { return num.toFixed(fraction); }, null, n);
+ },
+ pi: function () {
+ return new(tree.Dimension)(Math.PI);
+ },
+ mod: function(a, b) {
+ return new(tree.Dimension)(a.value % b.value, a.unit);
+ },
+ pow: function(x, y) {
+ if (typeof x === "number" && typeof y === "number") {
+ x = new(tree.Dimension)(x);
+ y = new(tree.Dimension)(y);
+ } else if (!(x instanceof tree.Dimension) || !(y instanceof tree.Dimension)) {
+ throw { type: "Argument", message: "arguments must be numbers" };
+ }
+
+ return new(tree.Dimension)(Math.pow(x.value, y.value), x.unit);
+ },
+ _minmax: function (isMin, args) {
+ args = Array.prototype.slice.call(args);
+ switch(args.length) {
+ case 0: throw { type: "Argument", message: "one or more arguments required" };
+ case 1: return args[0];
+ }
+ var i, j, current, currentUnified, referenceUnified, unit,
+ order = [], // elems only contains original argument values.
+ values = {}; // key is the unit.toString() for unified tree.Dimension values,
+ // value is the index into the order array.
+ for (i = 0; i < args.length; i++) {
+ current = args[i];
+ if (!(current instanceof tree.Dimension)) {
+ order.push(current);
+ continue;
+ }
+ currentUnified = current.unify();
+ unit = currentUnified.unit.toString();
+ j = values[unit];
+ if (j === undefined) {
+ values[unit] = order.length;
+ order.push(current);
+ continue;
+ }
+ referenceUnified = order[j].unify();
+ if ( isMin && currentUnified.value < referenceUnified.value ||
+ !isMin && currentUnified.value > referenceUnified.value) {
+ order[j] = current;
+ }
+ }
+ if (order.length == 1) {
+ return order[0];
+ }
+ args = order.map(function (a) { return a.toCSS(this.env); })
+ .join(this.env.compress ? "," : ", ");
+ return new(tree.Anonymous)((isMin ? "min" : "max") + "(" + args + ")");
+ },
+ min: function () {
+ return this._minmax(true, arguments);
+ },
+ max: function () {
+ return this._minmax(false, arguments);
+ },
+ argb: function (color) {
+ return new(tree.Anonymous)(color.toARGB());
+ },
+ percentage: function (n) {
+ return new(tree.Dimension)(n.value * 100, '%');
+ },
+ color: function (n) {
+ if (n instanceof tree.Quoted) {
+ var colorCandidate = n.value,
+ returnColor;
+ returnColor = tree.Color.fromKeyword(colorCandidate);
+ if (returnColor) {
+ return returnColor;
+ }
+ if (/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/.test(colorCandidate)) {
+ return new(tree.Color)(colorCandidate.slice(1));
+ }
+ throw { type: "Argument", message: "argument must be a color keyword or 3/6 digit hex e.g. #FFF" };
+ } else {
+ throw { type: "Argument", message: "argument must be a string" };
+ }
+ },
+ iscolor: function (n) {
+ return this._isa(n, tree.Color);
+ },
+ isnumber: function (n) {
+ return this._isa(n, tree.Dimension);
+ },
+ isstring: function (n) {
+ return this._isa(n, tree.Quoted);
+ },
+ iskeyword: function (n) {
+ return this._isa(n, tree.Keyword);
+ },
+ isurl: function (n) {
+ return this._isa(n, tree.URL);
+ },
+ ispixel: function (n) {
+ return this.isunit(n, 'px');
+ },
+ ispercentage: function (n) {
+ return this.isunit(n, '%');
+ },
+ isem: function (n) {
+ return this.isunit(n, 'em');
+ },
+ isunit: function (n, unit) {
+ return (n instanceof tree.Dimension) && n.unit.is(unit.value || unit) ? tree.True : tree.False;
+ },
+ _isa: function (n, Type) {
+ return (n instanceof Type) ? tree.True : tree.False;
+ },
+ tint: function(color, amount) {
+ return this.mix(this.rgb(255,255,255), color, amount);
+ },
+ shade: function(color, amount) {
+ return this.mix(this.rgb(0, 0, 0), color, amount);
+ },
+ extract: function(values, index) {
+ index = index.value - 1; // (1-based index)
+ // handle non-array values as an array of length 1
+ // return 'undefined' if index is invalid
+ return Array.isArray(values.value)
+ ? values.value[index] : Array(values)[index];
+ },
+ length: function(values) {
+ var n = Array.isArray(values.value) ? values.value.length : 1;
+ return new tree.Dimension(n);
+ },
+
+ "data-uri": function(mimetypeNode, filePathNode) {
+
+ if (typeof window !== 'undefined') {
+ return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
+ }
+
+ var mimetype = mimetypeNode.value;
+ var filePath = (filePathNode && filePathNode.value);
+
+ var fs = require("fs"),
+ path = require("path"),
+ useBase64 = false;
+
+ if (arguments.length < 2) {
+ filePath = mimetype;
+ }
+
+ if (this.env.isPathRelative(filePath)) {
+ if (this.currentFileInfo.relativeUrls) {
+ filePath = path.join(this.currentFileInfo.currentDirectory, filePath);
+ } else {
+ filePath = path.join(this.currentFileInfo.entryPath, filePath);
+ }
+ }
+
+ // detect the mimetype if not given
+ if (arguments.length < 2) {
+ var mime;
+ try {
+ mime = require('mime');
+ } catch (ex) {
+ mime = tree._mime;
+ }
+
+ mimetype = mime.lookup(filePath);
+
+ // use base 64 unless it's an ASCII or UTF-8 format
+ var charset = mime.charsets.lookup(mimetype);
+ useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0;
+ if (useBase64) { mimetype += ';base64'; }
+ }
+ else {
+ useBase64 = /;base64$/.test(mimetype);
+ }
+
+ var buf = fs.readFileSync(filePath);
+
+ // IE8 cannot handle a data-uri larger than 32KB. If this is exceeded
+ // and the --ieCompat flag is enabled, return a normal url() instead.
+ var DATA_URI_MAX_KB = 32,
+ fileSizeInKB = parseInt((buf.length / 1024), 10);
+ if (fileSizeInKB >= DATA_URI_MAX_KB) {
+
+ if (this.env.ieCompat !== false) {
+ if (!this.env.silent) {
+ console.warn("Skipped data-uri embedding of %s because its size (%dKB) exceeds IE8-safe %dKB!", filePath, fileSizeInKB, DATA_URI_MAX_KB);
+ }
+
+ return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
+ }
+ }
+
+ buf = useBase64 ? buf.toString('base64')
+ : encodeURIComponent(buf);
+
+ var uri = "'data:" + mimetype + ',' + buf + "'";
+ return new(tree.URL)(new(tree.Anonymous)(uri));
+ },
+
+ "svg-gradient": function(direction) {
+
+ function throwArgumentDescriptor() {
+ throw { type: "Argument", message: "svg-gradient expects direction, start_color [start_position], [color position,]..., end_color [end_position]" };
+ }
+
+ if (arguments.length < 3) {
+ throwArgumentDescriptor();
+ }
+ var stops = Array.prototype.slice.call(arguments, 1),
+ gradientDirectionSvg,
+ gradientType = "linear",
+ rectangleDimension = 'x="0" y="0" width="1" height="1"',
+ useBase64 = true,
+ renderEnv = {compress: false},
+ returner,
+ directionValue = direction.toCSS(renderEnv),
+ i, color, position, positionValue, alpha;
+
+ switch (directionValue) {
+ case "to bottom":
+ gradientDirectionSvg = 'x1="0%" y1="0%" x2="0%" y2="100%"';
+ break;
+ case "to right":
+ gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="0%"';
+ break;
+ case "to bottom right":
+ gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="100%"';
+ break;
+ case "to top right":
+ gradientDirectionSvg = 'x1="0%" y1="100%" x2="100%" y2="0%"';
+ break;
+ case "ellipse":
+ case "ellipse at center":
+ gradientType = "radial";
+ gradientDirectionSvg = 'cx="50%" cy="50%" r="75%"';
+ rectangleDimension = 'x="-50" y="-50" width="101" height="101"';
+ break;
+ default:
+ throw { type: "Argument", message: "svg-gradient direction must be 'to bottom', 'to right', 'to bottom right', 'to top right' or 'ellipse at center'" };
+ }
+ returner = '<?xml version="1.0" ?>' +
+ '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" viewBox="0 0 1 1" preserveAspectRatio="none">' +
+ '<' + gradientType + 'Gradient id="gradient" gradientUnits="userSpaceOnUse" ' + gradientDirectionSvg + '>';
+
+ for (i = 0; i < stops.length; i+= 1) {
+ if (stops[i].value) {
+ color = stops[i].value[0];
+ position = stops[i].value[1];
+ } else {
+ color = stops[i];
+ position = undefined;
+ }
+
+ if (!(color instanceof tree.Color) || (!((i === 0 || i+1 === stops.length) && position === undefined) && !(position instanceof tree.Dimension))) {
+ throwArgumentDescriptor();
+ }
+ positionValue = position ? position.toCSS(renderEnv) : i === 0 ? "0%" : "100%";
+ alpha = color.alpha;
+ returner += '<stop offset="' + positionValue + '" stop-color="' + color.toRGB() + '"' + (alpha < 1 ? ' stop-opacity="' + alpha + '"' : '') + '/>';
+ }
+ returner += '</' + gradientType + 'Gradient>' +
+ '<rect ' + rectangleDimension + ' fill="url(#gradient)" /></svg>';
+
+ if (useBase64) {
+ // only works in node, needs interface to what is supported in environment
+ try {
+ returner = new Buffer(returner).toString('base64');
+ } catch(e) {
+ useBase64 = false;
+ }
+ }
+
+ returner = "'data:image/svg+xml" + (useBase64 ? ";base64" : "") + "," + returner + "'";
+ return new(tree.URL)(new(tree.Anonymous)(returner));
+ }
+};
+
+// these static methods are used as a fallback when the optional 'mime' dependency is missing
+tree._mime = {
+ // this map is intentionally incomplete
+ // if you want more, install 'mime' dep
+ _types: {
+ '.htm' : 'text/html',
+ '.html': 'text/html',
+ '.gif' : 'image/gif',
+ '.jpg' : 'image/jpeg',
+ '.jpeg': 'image/jpeg',
+ '.png' : 'image/png'
+ },
+ lookup: function (filepath) {
+ var ext = require('path').extname(filepath),
+ type = tree._mime._types[ext];
+ if (type === undefined) {
+ throw new Error('Optional dependency "mime" is required for ' + ext);
+ }
+ return type;
+ },
+ charsets: {
+ lookup: function (type) {
+ // assumes all text types are UTF-8
+ return type && (/^text\//).test(type) ? 'UTF-8' : '';
+ }
+ }
+};
+
+// Math
+
+var mathFunctions = {
+ // name, unit
+ ceil: null,
+ floor: null,
+ sqrt: null,
+ abs: null,
+ tan: "",
+ sin: "",
+ cos: "",
+ atan: "rad",
+ asin: "rad",
+ acos: "rad"
+};
+
+function _math(fn, unit, n) {
+ if (!(n instanceof tree.Dimension)) {
+ throw { type: "Argument", message: "argument must be a number" };
+ }
+ if (unit == null) {
+ unit = n.unit;
+ } else {
+ n = n.unify();
+ }
+ return new(tree.Dimension)(fn(parseFloat(n.value)), unit);
+}
+
+// ~ End of Math
+
+// Color Blending
+// ref: http://www.w3.org/TR/compositing-1
+
+function colorBlend(mode, color1, color2) {
+ var ab = color1.alpha, cb, // backdrop
+ as = color2.alpha, cs, // source
+ ar, cr, r = []; // result
+
+ ar = as + ab * (1 - as);
+ for (var i = 0; i < 3; i++) {
+ cb = color1.rgb[i] / 255;
+ cs = color2.rgb[i] / 255;
+ cr = mode(cb, cs);
+ if (ar) {
+ cr = (as * cs + ab * (cb
+ - as * (cb + cs - cr))) / ar;
+ }
+ r[i] = cr * 255;
+ }
+
+ return new(tree.Color)(r, ar);
+}
+
+var colorBlendMode = {
+ multiply: function(cb, cs) {
+ return cb * cs;
+ },
+ screen: function(cb, cs) {
+ return cb + cs - cb * cs;
+ },
+ overlay: function(cb, cs) {
+ cb *= 2;
+ return (cb <= 1)
+ ? colorBlendMode.multiply(cb, cs)
+ : colorBlendMode.screen(cb - 1, cs);
+ },
+ softlight: function(cb, cs) {
+ var d = 1, e = cb;
+ if (cs > 0.5) {
+ e = 1;
+ d = (cb > 0.25) ? Math.sqrt(cb)
+ : ((16 * cb - 12) * cb + 4) * cb;
+ }
+ return cb - (1 - 2 * cs) * e * (d - cb);
+ },
+ hardlight: function(cb, cs) {
+ return colorBlendMode.overlay(cs, cb);
+ },
+ difference: function(cb, cs) {
+ return Math.abs(cb - cs);
+ },
+ exclusion: function(cb, cs) {
+ return cb + cs - 2 * cb * cs;
+ },
+
+ // non-w3c functions:
+ average: function(cb, cs) {
+ return (cb + cs) / 2;
+ },
+ negation: function(cb, cs) {
+ return 1 - Math.abs(cb + cs - 1);
+ }
+};
+
+// ~ End of Color Blending
+
+tree.defaultFunc = {
+ eval: function () {
+ var v = this.value_, e = this.error_;
+ if (e) {
+ throw e;
+ }
+ if (v != null) {
+ return v ? tree.True : tree.False;
+ }
+ },
+ value: function (v) {
+ this.value_ = v;
+ },
+ error: function (e) {
+ this.error_ = e;
+ },
+ reset: function () {
+ this.value_ = this.error_ = null;
+ }
+};
+
+function initFunctions() {
+ var f, tf = tree.functions;
+
+ // math
+ for (f in mathFunctions) {
+ tf[f] = _math.bind(null, Math[f], mathFunctions[f]);
+ }
+
+ // color blending
+ for (f in colorBlendMode) {
+ tf[f] = colorBlend.bind(null, colorBlendMode[f]);
+ }
+
+ // default
+ f = tree.defaultFunc;
+ tf.default = f.eval.bind(f);
+
+} initFunctions();
+
+function hsla(color) {
+ return tree.functions.hsla(color.h, color.s, color.l, color.a);
+}
+
+function scaled(n, size) {
+ if (n instanceof tree.Dimension && n.unit.is('%')) {
+ return parseFloat(n.value * size / 100);
+ } else {
+ return number(n);
+ }
+}
+
+function number(n) {
+ if (n instanceof tree.Dimension) {
+ return parseFloat(n.unit.is('%') ? n.value / 100 : n.value);
+ } else if (typeof(n) === 'number') {
+ return n;
+ } else {
+ throw {
+ error: "RuntimeError",
+ message: "color functions take numbers as parameters"
+ };
+ }
+}
+
+function clamp(val) {
+ return Math.min(1, Math.max(0, val));
+}
+
+tree.functionCall = function(env, currentFileInfo) {
+ this.env = env;
+ this.currentFileInfo = currentFileInfo;
+};
+
+tree.functionCall.prototype = tree.functions;
+
+})(require('./tree'));
http://git-wip-us.apache.org/repos/asf/incubator-cmda/blob/a9a83675/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/import-visitor.js
----------------------------------------------------------------------
diff --git a/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/import-visitor.js b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/import-visitor.js
new file mode 100644
index 0000000..6a3aaed
--- /dev/null
+++ b/ApacheCMDA_Backend_1.0/project/target/node-modules/webjars/less/lib/less/import-visitor.js
@@ -0,0 +1,118 @@
+(function (tree) {
+ tree.importVisitor = function(importer, finish, evalEnv) {
+ this._visitor = new tree.visitor(this);
+ this._importer = importer;
+ this._finish = finish;
+ this.env = evalEnv || new tree.evalEnv();
+ this.importCount = 0;
+ };
+
+ tree.importVisitor.prototype = {
+ isReplacing: true,
+ run: function (root) {
+ var error;
+ try {
+ // process the contents
+ this._visitor.visit(root);
+ }
+ catch(e) {
+ error = e;
+ }
+
+ this.isFinished = true;
+
+ if (this.importCount === 0) {
+ this._finish(error);
+ }
+ },
+ visitImport: function (importNode, visitArgs) {
+ var importVisitor = this,
+ evaldImportNode,
+ inlineCSS = importNode.options.inline;
+
+ if (!importNode.css || inlineCSS) {
+
+ try {
+ evaldImportNode = importNode.evalForImport(this.env);
+ } catch(e){
+ if (!e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+ // attempt to eval properly and treat as css
+ importNode.css = true;
+ // if that fails, this error will be thrown
+ importNode.error = e;
+ }
+
+ if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
+ importNode = evaldImportNode;
+ this.importCount++;
+ var env = new tree.evalEnv(this.env, this.env.frames.slice(0));
+
+ if (importNode.options.multiple) {
+ env.importMultiple = true;
+ }
+
+ this._importer.push(importNode.getPath(), importNode.currentFileInfo, importNode.options, function (e, root, imported, fullPath) {
+ if (e && !e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+
+ if (imported && !env.importMultiple) { importNode.skip = imported; }
+
+ var subFinish = function(e) {
+ importVisitor.importCount--;
+
+ if (importVisitor.importCount === 0 && importVisitor.isFinished) {
+ importVisitor._finish(e);
+ }
+ };
+
+ if (root) {
+ importNode.root = root;
+ importNode.importedFilename = fullPath;
+ if (!inlineCSS && !importNode.skip) {
+ new(tree.importVisitor)(importVisitor._importer, subFinish, env)
+ .run(root);
+ return;
+ }
+ }
+
+ subFinish();
+ });
+ }
+ }
+ visitArgs.visitDeeper = false;
+ return importNode;
+ },
+ visitRule: function (ruleNode, visitArgs) {
+ visitArgs.visitDeeper = false;
+ return ruleNode;
+ },
+ visitDirective: function (directiveNode, visitArgs) {
+ this.env.frames.unshift(directiveNode);
+ return directiveNode;
+ },
+ visitDirectiveOut: function (directiveNode) {
+ this.env.frames.shift();
+ },
+ visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+ this.env.frames.unshift(mixinDefinitionNode);
+ return mixinDefinitionNode;
+ },
+ visitMixinDefinitionOut: function (mixinDefinitionNode) {
+ this.env.frames.shift();
+ },
+ visitRuleset: function (rulesetNode, visitArgs) {
+ this.env.frames.unshift(rulesetNode);
+ return rulesetNode;
+ },
+ visitRulesetOut: function (rulesetNode) {
+ this.env.frames.shift();
+ },
+ visitMedia: function (mediaNode, visitArgs) {
+ this.env.frames.unshift(mediaNode.ruleset);
+ return mediaNode;
+ },
+ visitMediaOut: function (mediaNode) {
+ this.env.frames.shift();
+ }
+ };
+
+})(require('./tree'));
\ No newline at end of file