Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Readding bin dir which was mistakenly deleted.

Change-Id: Ia8989da47a55f7c932115a976b6d799714b8dc56
  • Loading branch information...
commit 6f990c9ce4fe716b2ca9d136c65de9fad46bc7bb 1 parent cb8e7c1
@gabrielhurley gabrielhurley authored
Showing with 4,100 additions and 0 deletions.
  1. +139 −0 bin/less/lessc
  2. +380 −0 bin/lib/less/browser.js
  3. +152 −0 bin/lib/less/colors.js
  4. +355 −0 bin/lib/less/cssmin.js
  5. +228 −0 bin/lib/less/functions.js
  6. +148 −0 bin/lib/less/index.js
  7. +1,334 −0 bin/lib/less/parser.js
  8. +62 −0 bin/lib/less/rhino.js
  9. +17 −0 bin/lib/less/tree.js
  10. +17 −0 bin/lib/less/tree/alpha.js
  11. +13 −0 bin/lib/less/tree/anonymous.js
  12. +17 −0 bin/lib/less/tree/assignment.js
  13. +48 −0 bin/lib/less/tree/call.js
  14. +101 −0 bin/lib/less/tree/color.js
  15. +14 −0 bin/lib/less/tree/comment.js
  16. +42 −0 bin/lib/less/tree/condition.js
  17. +49 −0 bin/lib/less/tree/dimension.js
  18. +35 −0 bin/lib/less/tree/directive.js
  19. +52 −0 bin/lib/less/tree/element.js
  20. +23 −0 bin/lib/less/tree/expression.js
  21. +83 −0 bin/lib/less/tree/import.js
  22. +51 −0 bin/lib/less/tree/javascript.js
  23. +19 −0 bin/lib/less/tree/keyword.js
  24. +114 −0 bin/lib/less/tree/media.js
  25. +146 −0 bin/lib/less/tree/mixin.js
  26. +32 −0 bin/lib/less/tree/operation.js
  27. +16 −0 bin/lib/less/tree/paren.js
  28. +29 −0 bin/lib/less/tree/quoted.js
  29. +42 −0 bin/lib/less/tree/rule.js
  30. +225 −0 bin/lib/less/tree/ruleset.js
  31. +42 −0 bin/lib/less/tree/selector.js
  32. +25 −0 bin/lib/less/tree/url.js
  33. +24 −0 bin/lib/less/tree/value.js
  34. +26 −0 bin/lib/less/tree/variable.js
View
139 bin/less/lessc
@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+var path = require('path'),
+ fs = require('fs'),
+ sys = require('util'),
+ os = require('os');
+
+var less = require('../lib/less');
+var args = process.argv.slice(1);
+var options = {
+ compress: false,
+ yuicompress: false,
+ optimization: 1,
+ silent: false,
+ paths: [],
+ color: true,
+ strictImports: false
+};
+
+args = args.filter(function (arg) {
+ var match;
+
+ if (match = arg.match(/^-I(.+)$/)) {
+ options.paths.push(match[1]);
+ return false;
+ }
+
+ if (match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=([^\s]+))?$/i)) { arg = match[1] }
+ else { return arg }
+
+ switch (arg) {
+ case 'v':
+ case 'version':
+ sys.puts("lessc " + less.version.join('.') + " (LESS Compiler) [JavaScript]");
+ process.exit(0);
+ case 'verbose':
+ options.verbose = true;
+ break;
+ case 's':
+ case 'silent':
+ options.silent = true;
+ break;
+ case 'strict-imports':
+ options.strictImports = true;
+ break;
+ case 'h':
+ case 'help':
+ sys.puts("usage: lessc source [destination]");
+ process.exit(0);
+ case 'x':
+ case 'compress':
+ options.compress = true;
+ break;
+ case 'yui-compress':
+ options.yuicompress = true;
+ break;
+ case 'no-color':
+ options.color = false;
+ break;
+ case 'include-path':
+ options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':')
+ .map(function(p) {
+ if (p) {
+ return path.resolve(process.cwd(), p);
+ }
+ });
+ break;
+ case 'O0': options.optimization = 0; break;
+ case 'O1': options.optimization = 1; break;
+ case 'O2': options.optimization = 2; break;
+ }
+});
+
+var input = args[1];
+if (input && input != '-') {
+ input = path.resolve(process.cwd(), input);
+}
+var output = args[2];
+if (output) {
+ output = path.resolve(process.cwd(), output);
+}
+
+var css, fd, tree;
+
+if (! input) {
+ sys.puts("lessc: no input files");
+ process.exit(1);
+}
+
+var parseLessFile = function (e, data) {
+ if (e) {
+ sys.puts("lessc: " + e.message);
+ process.exit(1);
+ }
+
+ new(less.Parser)({
+ paths: [path.dirname(input)].concat(options.paths),
+ optimization: options.optimization,
+ filename: input,
+ strictImports: options.strictImports
+ }).parse(data, function (err, tree) {
+ if (err) {
+ less.writeError(err, options);
+ process.exit(1);
+ } else {
+ try {
+ css = tree.toCSS({
+ compress: options.compress,
+ yuicompress: options.yuicompress
+ });
+ if (output) {
+ fd = fs.openSync(output, "w");
+ fs.writeSync(fd, css, 0, "utf8");
+ } else {
+ sys.print(css);
+ }
+ } catch (e) {
+ less.writeError(e, options);
+ process.exit(2);
+ }
+ }
+ });
+};
+
+if (input != '-') {
+ fs.readFile(input, 'utf-8', parseLessFile);
+} else {
+ process.stdin.resume();
+ process.stdin.setEncoding('utf8');
+
+ var buffer = '';
+ process.stdin.on('data', function(data) {
+ buffer += data;
+ });
+
+ process.stdin.on('end', function() {
+ parseLessFile(false, buffer);
+ });
+}
View
380 bin/lib/less/browser.js
@@ -0,0 +1,380 @@
+//
+// browser.js - client-side engine
+//
+
+var isFileProtocol = (location.protocol === 'file:' ||
+ location.protocol === 'chrome:' ||
+ location.protocol === 'chrome-extension:' ||
+ location.protocol === 'resource:');
+
+less.env = less.env || (location.hostname == '127.0.0.1' ||
+ location.hostname == '0.0.0.0' ||
+ location.hostname == 'localhost' ||
+ location.port.length > 0 ||
+ isFileProtocol ? 'development'
+ : 'production');
+
+// 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 = false;
+
+// Interval between watch polls
+less.poll = less.poll || (isFileProtocol ? 1000 : 1500);
+
+//
+// Watch mode
+//
+less.watch = function () { return this.watchMode = true };
+less.unwatch = function () { return this.watchMode = false };
+
+if (less.env === 'development') {
+ less.optimization = 0;
+
+ if (/!watch/.test(location.hash)) {
+ less.watch();
+ }
+ less.watchTimer = setInterval(function () {
+ if (less.watchMode) {
+ loadStyleSheets(function (e, root, _, sheet, env) {
+ if (root) {
+ createCSS(root.toCSS(), sheet, env.lastModified);
+ }
+ });
+ }
+ }, less.poll);
+} else {
+ less.optimization = 3;
+}
+
+var cache;
+
+try {
+ cache = (typeof(window.localStorage) === 'undefined') ? null : window.localStorage;
+} catch (_) {
+ cache = null;
+}
+
+//
+// Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
+//
+var links = document.getElementsByTagName('link');
+var typePattern = /^text\/(x-)?less$/;
+
+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]);
+ }
+}
+
+
+less.refresh = function (reload) {
+ var startTime, endTime;
+ startTime = endTime = new(Date);
+
+ loadStyleSheets(function (e, root, _, sheet, env) {
+ if (env.local) {
+ log("loading " + sheet.href + " from cache.");
+ } else {
+ log("parsed " + sheet.href + " successfully.");
+ createCSS(root.toCSS(), sheet, env.lastModified);
+ }
+ log("css for " + sheet.href + " generated in " + (new(Date) - endTime) + 'ms');
+ (env.remaining === 0) && log("css generated in " + (new(Date) - startTime) + 'ms');
+ endTime = new(Date);
+ }, reload);
+
+ loadStyles();
+};
+less.refreshStyles = loadStyles;
+
+less.refresh(less.env === 'development');
+
+function loadStyles() {
+ var styles = document.getElementsByTagName('style');
+ for (var i = 0; i < styles.length; i++) {
+ if (styles[i].type.match(typePattern)) {
+ new(less.Parser)().parse(styles[i].innerHTML || '', function (e, tree) {
+ var css = tree.toCSS();
+ var style = styles[i];
+ style.type = 'text/css';
+ if (style.styleSheet) {
+ style.styleSheet.cssText = css;
+ } else {
+ style.innerHTML = css;
+ }
+ });
+ }
+ }
+}
+
+function loadStyleSheets(callback, reload) {
+ for (var i = 0; i < less.sheets.length; i++) {
+ loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1));
+ }
+}
+
+function loadStyleSheet(sheet, callback, reload, remaining) {
+ var url = window.location.href.replace(/[#?].*$/, '');
+ var href = sheet.href.replace(/\?.*$/, '');
+ var css = cache && cache.getItem(href);
+ var timestamp = cache && cache.getItem(href + ':timestamp');
+ var styles = { css: css, timestamp: timestamp };
+
+ // Stylesheets in IE don't always return the full path
+ if (! /^(https?|file):/.test(href)) {
+ if (href.charAt(0) == "/") {
+ href = window.location.protocol + "//" + window.location.host + href;
+ } else {
+ href = url.slice(0, url.lastIndexOf('/') + 1) + href;
+ }
+ }
+ var filename = href.match(/([^\/]+)$/)[1];
+
+ xhr(sheet.href, sheet.type, function (data, lastModified) {
+ if (!reload && styles && lastModified &&
+ (new(Date)(lastModified).valueOf() ===
+ new(Date)(styles.timestamp).valueOf())) {
+ // Use local copy
+ createCSS(styles.css, sheet);
+ callback(null, null, data, sheet, { local: true, remaining: remaining });
+ } else {
+ // Use remote copy (re-parse)
+ try {
+ new(less.Parser)({
+ optimization: less.optimization,
+ paths: [href.replace(/[\w\.-]+$/, '')],
+ mime: sheet.type,
+ filename: filename
+ }).parse(data, function (e, root) {
+ if (e) { return error(e, href) }
+ try {
+ callback(e, root, data, sheet, { local: false, lastModified: lastModified, remaining: remaining });
+ removeNode(document.getElementById('less-error-message:' + extractId(href)));
+ } catch (e) {
+ error(e, href);
+ }
+ });
+ } catch (e) {
+ error(e, href);
+ }
+ }
+ }, function (status, url) {
+ throw new(Error)("Couldn't load " + url + " (" + status + ")");
+ });
+}
+
+function extractId(href) {
+ return href.replace(/^[a-z]+:\/\/?[^\/]+/, '' ) // Remove protocol & domain
+ .replace(/^\//, '' ) // Remove root /
+ .replace(/\?.*$/, '' ) // Remove query
+ .replace(/\.[^\.\/]+$/, '' ) // Remove file extension
+ .replace(/[^\.\w-]+/g, '-') // Replace illegal characters
+ .replace(/\./g, ':'); // Replace dots with colons(for valid id)
+}
+
+function createCSS(styles, sheet, lastModified) {
+ var css;
+
+ // Strip the query-string
+ var href = sheet.href ? sheet.href.replace(/\?.*$/, '') : '';
+
+ // If there is no title set, use the filename, minus the extension
+ var id = 'less:' + (sheet.title || extractId(href));
+
+ // If the stylesheet doesn't exist, create a new node
+ if ((css = document.getElementById(id)) === null) {
+ css = document.createElement('style');
+ css.type = 'text/css';
+ css.media = sheet.media || 'screen';
+ css.id = id;
+ document.getElementsByTagName('head')[0].appendChild(css);
+ }
+
+ if (css.styleSheet) { // IE
+ try {
+ css.styleSheet.cssText = styles;
+ } catch (e) {
+ throw new(Error)("Couldn't reassign styleSheet.cssText.");
+ }
+ } else {
+ (function (node) {
+ if (css.childNodes.length > 0) {
+ if (css.firstChild.nodeValue !== node.nodeValue) {
+ css.replaceChild(node, css.firstChild);
+ }
+ } else {
+ css.appendChild(node);
+ }
+ })(document.createTextNode(styles));
+ }
+
+ // Don't update the local store if the file wasn't modified
+ if (lastModified && cache) {
+ log('saving ' + href + ' to cache.');
+ cache.setItem(href, styles);
+ cache.setItem(href + ':timestamp', lastModified);
+ }
+}
+
+function xhr(url, type, callback, errback) {
+ var xhr = getXMLHttpRequest();
+ var async = isFileProtocol ? false : less.async;
+
+ if (typeof(xhr.overrideMimeType) === 'function') {
+ xhr.overrideMimeType('text/css');
+ }
+ xhr.open('GET', url, async);
+ xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
+ xhr.send(null);
+
+ if (isFileProtocol) {
+ 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 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);
+ }
+ }
+}
+
+function getXMLHttpRequest() {
+ if (window.XMLHttpRequest) {
+ return new(XMLHttpRequest);
+ } else {
+ try {
+ return new(ActiveXObject)("MSXML2.XMLHTTP.3.0");
+ } catch (e) {
+ log("browser doesn't support AJAX.");
+ return null;
+ }
+ }
+}
+
+function removeNode(node) {
+ return node && node.parentNode.removeChild(node);
+}
+
+function log(str) {
+ if (less.env == 'development' && typeof(console) !== "undefined") { console.log('less: ' + str) }
+}
+
+function error(e, href) {
+ var id = 'less-error-message:' + extractId(href);
+ var template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
+ var elem = document.createElement('div'), timer, content, error = [];
+ var filename = e.filename || href;
+
+ elem.id = id;
+ elem.className = "less-error-message";
+
+ content = '<h3>' + (e.message || 'There is an error in your .less file') +
+ '</h3>' + '<p>in <a href="' + filename + '">' + filename + "</a> ";
+
+ var errorline = function (e, i, classname) {
+ if (e.extract[i]) {
+ error.push(template.replace(/\{line\}/, parseInt(e.line) + (i - 1))
+ .replace(/\{class\}/, classname)
+ .replace(/\{content\}/, e.extract[i]));
+ }
+ };
+
+ if (e.stack) {
+ content += '<br/>' + e.stack.split('\n').slice(1).join('<br/>');
+ } else if (e.extract) {
+ errorline(e, 0, '');
+ errorline(e, 1, 'line');
+ errorline(e, 2, '');
+ content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':</p>' +
+ '<ul>' + error.join('') + '</ul>';
+ }
+ 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);
+ }
+}
+
View
152 bin/lib/less/colors.js
@@ -0,0 +1,152 @@
+(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',
+ 'transparent':'rgba(0,0,0,0)',
+ 'turquoise':'#40e0d0',
+ 'violet':'#ee82ee',
+ 'wheat':'#f5deb3',
+ 'white':'#ffffff',
+ 'whitesmoke':'#f5f5f5',
+ 'yellow':'#ffff00',
+ 'yellowgreen':'#9acd32'
+ };
+})(require('./tree'));
View
355 bin/lib/less/cssmin.js
@@ -0,0 +1,355 @@
+/**
+ * cssmin.js
+ * Author: Stoyan Stefanov - http://phpied.com/
+ * This is a JavaScript port of the CSS minification tool
+ * distributed with YUICompressor, itself a port
+ * of the cssmin utility by Isaac Schlueter - http://foohack.com/
+ * Permission is hereby granted to use the JavaScript version under the same
+ * conditions as the YUICompressor (original YUICompressor note below).
+ */
+
+/*
+* YUI Compressor
+* http://developer.yahoo.com/yui/compressor/
+* Author: Julien Lecomte - http://www.julienlecomte.net/
+* Copyright (c) 2011 Yahoo! Inc. All rights reserved.
+* The copyrights embodied in the content of this file are licensed
+* by Yahoo! Inc. under the BSD (revised) open source license.
+*/
+var YAHOO = YAHOO || {};
+YAHOO.compressor = YAHOO.compressor || {};
+
+/**
+ * Utility method to replace all data urls with tokens before we start
+ * compressing, to avoid performance issues running some of the subsequent
+ * regexes against large strings chunks.
+ *
+ * @private
+ * @method _extractDataUrls
+ * @param {String} css The input css
+ * @param {Array} The global array of tokens to preserve
+ * @returns String The processed css
+ */
+YAHOO.compressor._extractDataUrls = function (css, preservedTokens) {
+
+ // Leave data urls alone to increase parse performance.
+ var maxIndex = css.length - 1,
+ appendIndex = 0,
+ startIndex,
+ endIndex,
+ terminator,
+ foundTerminator,
+ sb = [],
+ m,
+ preserver,
+ token,
+ pattern = /url\(\s*(["']?)data\:/g;
+
+ // Since we need to account for non-base64 data urls, we need to handle
+ // ' and ) being part of the data string. Hence switching to indexOf,
+ // to determine whether or not we have matching string terminators and
+ // handling sb appends directly, instead of using matcher.append* methods.
+
+ while ((m = pattern.exec(css)) !== null) {
+
+ startIndex = m.index + 4; // "url(".length()
+ terminator = m[1]; // ', " or empty (not quoted)
+
+ if (terminator.length === 0) {
+ terminator = ")";
+ }
+
+ foundTerminator = false;
+
+ endIndex = pattern.lastIndex - 1;
+
+ while(foundTerminator === false && endIndex+1 <= maxIndex) {
+ endIndex = css.indexOf(terminator, endIndex + 1);
+
+ // endIndex == 0 doesn't really apply here
+ if ((endIndex > 0) && (css.charAt(endIndex - 1) !== '\\')) {
+ foundTerminator = true;
+ if (")" != terminator) {
+ endIndex = css.indexOf(")", endIndex);
+ }
+ }
+ }
+
+ // Enough searching, start moving stuff over to the buffer
+ sb.push(css.substring(appendIndex, m.index));
+
+ if (foundTerminator) {
+ token = css.substring(startIndex, endIndex);
+ token = token.replace(/\s+/g, "");
+ preservedTokens.push(token);
+
+ preserver = "url(___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___)";
+ sb.push(preserver);
+
+ appendIndex = endIndex + 1;
+ } else {
+ // No end terminator found, re-add the whole match. Should we throw/warn here?
+ sb.push(css.substring(m.index, pattern.lastIndex));
+ appendIndex = pattern.lastIndex;
+ }
+ }
+
+ sb.push(css.substring(appendIndex));
+
+ return sb.join("");
+};
+
+/**
+ * Utility method to compress hex color values of the form #AABBCC to #ABC.
+ *
+ * DOES NOT compress CSS ID selectors which match the above pattern (which would break things).
+ * e.g. #AddressForm { ... }
+ *
+ * DOES NOT compress IE filters, which have hex color values (which would break things).
+ * e.g. filter: chroma(color="#FFFFFF");
+ *
+ * DOES NOT compress invalid hex values.
+ * e.g. background-color: #aabbccdd
+ *
+ * @private
+ * @method _compressHexColors
+ * @param {String} css The input css
+ * @returns String The processed css
+ */
+YAHOO.compressor._compressHexColors = function(css) {
+
+ // Look for hex colors inside { ... } (to avoid IDs) and which don't have a =, or a " in front of them (to avoid filters)
+ var pattern = /(\=\s*?["']?)?#([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])(\}|[^0-9a-f{][^{]*?\})/gi,
+ m,
+ index = 0,
+ isFilter,
+ sb = [];
+
+ while ((m = pattern.exec(css)) !== null) {
+
+ sb.push(css.substring(index, m.index));
+
+ isFilter = m[1];
+
+ if (isFilter) {
+ // Restore, maintain case, otherwise filter will break
+ sb.push(m[1] + "#" + (m[2] + m[3] + m[4] + m[5] + m[6] + m[7]));
+ } else {
+ if (m[2].toLowerCase() == m[3].toLowerCase() &&
+ m[4].toLowerCase() == m[5].toLowerCase() &&
+ m[6].toLowerCase() == m[7].toLowerCase()) {
+
+ // Compress.
+ sb.push("#" + (m[3] + m[5] + m[7]).toLowerCase());
+ } else {
+ // Non compressible color, restore but lower case.
+ sb.push("#" + (m[2] + m[3] + m[4] + m[5] + m[6] + m[7]).toLowerCase());
+ }
+ }
+
+ index = pattern.lastIndex = pattern.lastIndex - m[8].length;
+ }
+
+ sb.push(css.substring(index));
+
+ return sb.join("");
+};
+
+YAHOO.compressor.cssmin = function (css, linebreakpos) {
+
+ var startIndex = 0,
+ endIndex = 0,
+ i = 0, max = 0,
+ preservedTokens = [],
+ comments = [],
+ token = '',
+ totallen = css.length,
+ placeholder = '';
+
+ css = this._extractDataUrls(css, preservedTokens);
+
+ // collect all comment blocks...
+ while ((startIndex = css.indexOf("/*", startIndex)) >= 0) {
+ endIndex = css.indexOf("*/", startIndex + 2);
+ if (endIndex < 0) {
+ endIndex = totallen;
+ }
+ token = css.slice(startIndex + 2, endIndex);
+ comments.push(token);
+ css = css.slice(0, startIndex + 2) + "___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + (comments.length - 1) + "___" + css.slice(endIndex);
+ startIndex += 2;
+ }
+
+ // preserve strings so their content doesn't get accidentally minified
+ css = css.replace(/("([^\\"]|\\.|\\)*")|('([^\\']|\\.|\\)*')/g, function (match) {
+ var i, max, quote = match.substring(0, 1);
+
+ match = match.slice(1, -1);
+
+ // maybe the string contains a comment-like substring?
+ // one, maybe more? put'em back then
+ if (match.indexOf("___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_") >= 0) {
+ for (i = 0, max = comments.length; i < max; i = i + 1) {
+ match = match.replace("___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + i + "___", comments[i]);
+ }
+ }
+
+ // minify alpha opacity in filter strings
+ match = match.replace(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/gi, "alpha(opacity=");
+
+ preservedTokens.push(match);
+ return quote + "___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___" + quote;
+ });
+
+ // strings are safe, now wrestle the comments
+ for (i = 0, max = comments.length; i < max; i = i + 1) {
+
+ token = comments[i];
+ placeholder = "___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + i + "___";
+
+ // ! in the first position of the comment means preserve
+ // so push to the preserved tokens keeping the !
+ if (token.charAt(0) === "!") {
+ preservedTokens.push(token);
+ css = css.replace(placeholder, "___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___");
+ continue;
+ }
+
+ // \ in the last position looks like hack for Mac/IE5
+ // shorten that to /*\*/ and the next one to /**/
+ if (token.charAt(token.length - 1) === "\\") {
+ preservedTokens.push("\\");
+ css = css.replace(placeholder, "___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___");
+ i = i + 1; // attn: advancing the loop
+ preservedTokens.push("");
+ css = css.replace("___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + i + "___", "___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___");
+ continue;
+ }
+
+ // keep empty comments after child selectors (IE7 hack)
+ // e.g. html >/**/ body
+ if (token.length === 0) {
+ startIndex = css.indexOf(placeholder);
+ if (startIndex > 2) {
+ if (css.charAt(startIndex - 3) === '>') {
+ preservedTokens.push("");
+ css = css.replace(placeholder, "___YUICSSMIN_PRESERVED_TOKEN_" + (preservedTokens.length - 1) + "___");
+ }
+ }
+ }
+
+ // in all other cases kill the comment
+ css = css.replace("/*" + placeholder + "*/", "");
+ }
+
+
+ // Normalize all whitespace strings to single spaces. Easier to work with that way.
+ css = css.replace(/\s+/g, " ");
+
+ // Remove the spaces before the things that should not have spaces before them.
+ // But, be careful not to turn "p :link {...}" into "p:link{...}"
+ // Swap out any pseudo-class colons with the token, and then swap back.
+ css = css.replace(/(^|\})(([^\{:])+:)+([^\{]*\{)/g, function (m) {
+ return m.replace(":", "___YUICSSMIN_PSEUDOCLASSCOLON___");
+ });
+ css = css.replace(/\s+([!{};:>+\(\)\],])/g, '$1');
+ css = css.replace(/___YUICSSMIN_PSEUDOCLASSCOLON___/g, ":");
+
+ // retain space for special IE6 cases
+ css = css.replace(/:first-(line|letter)(\{|,)/g, ":first-$1 $2");
+
+ // no space after the end of a preserved comment
+ css = css.replace(/\*\/ /g, '*/');
+
+
+ // If there is a @charset, then only allow one, and push to the top of the file.
+ css = css.replace(/^(.*)(@charset "[^"]*";)/gi, '$2$1');
+ css = css.replace(/^(\s*@charset [^;]+;\s*)+/gi, '$1');
+
+ // Put the space back in some cases, to support stuff like
+ // @media screen and (-webkit-min-device-pixel-ratio:0){
+ css = css.replace(/\band\(/gi, "and (");
+
+
+ // Remove the spaces after the things that should not have spaces after them.
+ css = css.replace(/([!{}:;>+\(\[,])\s+/g, '$1');
+
+ // remove unnecessary semicolons
+ css = css.replace(/;+\}/g, "}");
+
+ // Replace 0(px,em,%) with 0.
+ css = css.replace(/([\s:])(0)(px|em|%|in|cm|mm|pc|pt|ex)/gi, "$1$2");
+
+ // Replace 0 0 0 0; with 0.
+ css = css.replace(/:0 0 0 0(;|\})/g, ":0$1");
+ css = css.replace(/:0 0 0(;|\})/g, ":0$1");
+ css = css.replace(/:0 0(;|\})/g, ":0$1");
+
+ // Replace background-position:0; with background-position:0 0;
+ // same for transform-origin
+ css = css.replace(/(background-position|transform-origin|webkit-transform-origin|moz-transform-origin|o-transform-origin|ms-transform-origin):0(;|\})/gi, function(all, prop, tail) {
+ return prop.toLowerCase() + ":0 0" + tail;
+ });
+
+ // Replace 0.6 to .6, but only when preceded by : or a white-space
+ css = css.replace(/(:|\s)0+\.(\d+)/g, "$1.$2");
+
+ // Shorten colors from rgb(51,102,153) to #336699
+ // This makes it more likely that it'll get further compressed in the next step.
+ css = css.replace(/rgb\s*\(\s*([0-9,\s]+)\s*\)/gi, function () {
+ var i, rgbcolors = arguments[1].split(',');
+ for (i = 0; i < rgbcolors.length; i = i + 1) {
+ rgbcolors[i] = parseInt(rgbcolors[i], 10).toString(16);
+ if (rgbcolors[i].length === 1) {
+ rgbcolors[i] = '0' + rgbcolors[i];
+ }
+ }
+ return '#' + rgbcolors.join('');
+ });
+
+ // Shorten colors from #AABBCC to #ABC.
+ css = this._compressHexColors(css);
+
+ // border: none -> border:0
+ css = css.replace(/(border|border-top|border-right|border-bottom|border-right|outline|background):none(;|\})/gi, function(all, prop, tail) {
+ return prop.toLowerCase() + ":0" + tail;
+ });
+
+ // shorter opacity IE filter
+ css = css.replace(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/gi, "alpha(opacity=");
+
+ // Remove empty rules.
+ css = css.replace(/[^\};\{\/]+\{\}/g, "");
+
+ if (linebreakpos >= 0) {
+ // Some source control tools don't like it when files containing lines longer
+ // than, say 8000 characters, are checked in. The linebreak option is used in
+ // that case to split long lines after a specific column.
+ startIndex = 0;
+ i = 0;
+ while (i < css.length) {
+ i = i + 1;
+ if (css[i - 1] === '}' && i - startIndex > linebreakpos) {
+ css = css.slice(0, i) + '\n' + css.slice(i);
+ startIndex = i;
+ }
+ }
+ }
+
+ // Replace multiple semi-colons in a row by a single one
+ // See SF bug #1980989
+ css = css.replace(/;;+/g, ";");
+
+ // restore preserved comments and strings
+ for (i = 0, max = preservedTokens.length; i < max; i = i + 1) {
+ css = css.replace("___YUICSSMIN_PRESERVED_TOKEN_" + i + "___", preservedTokens[i]);
+ }
+
+ // Trim the final string (for any leading or trailing white spaces)
+ css = css.replace(/^\s+|\s+$/g, "");
+
+ return css;
+
+};
+
+exports.compressor = YAHOO.compressor;
View
228 bin/lib/less/functions.js
@@ -0,0 +1,228 @@
+(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 number(c) }),
+ 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) {
+ h = (number(h) % 360) / 360;
+ s = number(s); l = number(l); a = 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);
+
+ 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;
+ }
+ },
+ 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), '%');
+ },
+ alpha: function (color) {
+ return new(tree.Dimension)(color.toHSL().a);
+ },
+ saturate: function (color, amount) {
+ 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) {
+ 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));
+ },
+ 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++) {
+ 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);
+ },
+ round: function (n) {
+ return this._math('round', n);
+ },
+ ceil: function (n) {
+ return this._math('ceil', n);
+ },
+ floor: function (n) {
+ return this._math('floor', n);
+ },
+ _math: function (fn, n) {
+ if (n instanceof tree.Dimension) {
+ return new(tree.Dimension)(Math[fn](number(n)), n.unit);
+ } else if (typeof(n) === 'number') {
+ return Math[fn](n);
+ } else {
+ throw { type: "Argument", message: "argument must be a number" };
+ }
+ },
+ 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) {
+ return new(tree.Color)(n.value.slice(1));
+ } 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 (n instanceof tree.Dimension) && n.unit === 'px' ? tree.True : tree.False;
+ },
+ ispercentage: function (n) {
+ return (n instanceof tree.Dimension) && n.unit === '%' ? tree.True : tree.False;
+ },
+ isem: function (n) {
+ return (n instanceof tree.Dimension) && n.unit === 'em' ? tree.True : tree.False;
+ },
+ _isa: function (n, Type) {
+ return (n instanceof Type) ? tree.True : tree.False;
+ }
+};
+
+function hsla(hsla) {
+ return tree.functions.hsla(hsla.h, hsla.s, hsla.l, hsla.a);
+}
+
+function number(n) {
+ if (n instanceof tree.Dimension) {
+ return parseFloat(n.unit == '%' ? 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));
+}
+
+})(require('./tree'));
View
148 bin/lib/less/index.js
@@ -0,0 +1,148 @@
+var path = require('path'),
+ sys = require('util'),
+ fs = require('fs');
+
+var less = {
+ version: [1, 3, 0],
+ Parser: require('./parser').Parser,
+ importer: require('./parser').importer,
+ tree: require('./tree'),
+ render: function (input, options, callback) {
+ options = options || {};
+
+ if (typeof(options) === 'function') {
+ callback = options, options = {};
+ }
+
+ var parser = new(less.Parser)(options),
+ ee;
+
+ if (callback) {
+ parser.parse(input, function (e, root) {
+ callback(e, root && root.toCSS && root.toCSS(options));
+ });
+ } else {
+ ee = new(require('events').EventEmitter);
+
+ process.nextTick(function () {
+ parser.parse(input, function (e, root) {
+ if (e) { ee.emit('error', e) }
+ else { ee.emit('success', root.toCSS(options)) }
+ });
+ });
+ return ee;
+ }
+ },
+ writeError: function (ctx, options) {
+ options = options || {};
+
+ var message = "";
+ var extract = ctx.extract;
+ var error = [];
+ var stylize = options.color ? less.stylize : function (str) { return str };
+
+ if (options.silent) { return }
+
+ if (ctx.stack) { return sys.error(stylize(ctx.stack, 'red')) }
+
+ if (!ctx.hasOwnProperty('index')) {
+ return sys.error(ctx.stack || ctx.message);
+ }
+
+ if (typeof(extract[0]) === 'string') {
+ error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
+ }
+
+ if (extract[1]) {
+ error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
+ + stylize(stylize(stylize(extract[1][ctx.column], 'bold')
+ + extract[1].slice(ctx.column + 1), 'red'), 'inverse'));
+ }
+
+ if (typeof(extract[2]) === 'string') {
+ error.push(stylize((ctx.line + 1) + ' ' + extract[2], 'grey'));
+ }
+ error = error.join('\n') + '\033[0m\n';
+
+ message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
+ ctx.filename && (message += stylize(' in ', 'red') + ctx.filename +
+ stylize(':' + ctx.line + ':' + ctx.column, 'grey'));
+
+ sys.error(message, error);
+
+ if (ctx.callLine) {
+ sys.error(stylize('from ', 'red') + (ctx.filename || ''));
+ sys.error(stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract);
+ }
+ }
+};
+
+['color', 'directive', 'operation', 'dimension',
+ 'keyword', 'variable', 'ruleset', 'element',
+ 'selector', 'quoted', 'expression', 'rule',
+ 'call', 'url', 'alpha', 'import',
+ 'mixin', 'comment', 'anonymous', 'value',
+ 'javascript', 'assignment', 'condition', 'paren',
+ 'media'
+].forEach(function (n) {
+ require('./tree/' + n);
+});
+
+less.Parser.importer = function (file, paths, callback, env) {
+ var pathname;
+
+ // TODO: Undo this at some point,
+ // or use different approach.
+ paths.unshift('.');
+
+ for (var i = 0; i < paths.length; i++) {
+ try {
+ pathname = path.join(paths[i], file);
+ fs.statSync(pathname);
+ break;
+ } catch (e) {
+ pathname = null;
+ }
+ }
+
+ if (pathname) {
+ fs.readFile(pathname, 'utf-8', function(e, data) {
+ if (e) return callback(e);
+
+ new(less.Parser)({
+ paths: [path.dirname(pathname)].concat(paths),
+ filename: pathname
+ }).parse(data, function (e, root) {
+ callback(e, root, data);
+ });
+ });
+ } else {
+ if (typeof(env.errback) === "function") {
+ env.errback(file, paths, callback);
+ } else {
+ callback({ type: 'File', message: "'" + file + "' wasn't found.\n" });
+ }
+ }
+}
+
+require('./functions');
+require('./colors');
+
+for (var k in less) { exports[k] = less[k] }
+
+// Stylize a string
+function stylize(str, style) {
+ var styles = {
+ 'bold' : [1, 22],
+ 'inverse' : [7, 27],
+ 'underline' : [4, 24],
+ 'yellow' : [33, 39],
+ 'green' : [32, 39],
+ 'red' : [31, 39],
+ 'grey' : [90, 39]
+ };
+ return '\033[' + styles[style][0] + 'm' + str +
+ '\033[' + styles[style][1] + 'm';
+}
+less.stylize = stylize;
+
View
1,334 bin/lib/less/parser.js
@@ -0,0 +1,1334 @@
+var less, tree;
+
+if (typeof environment === "object" && ({}).toString.call(environment) === "[object Environment]") {
+ // Rhino
+ // Details on how to detect Rhino: https://github.com/ringo/ringojs/issues/88
+ if (typeof(window) === 'undefined') { less = {} }
+ else { less = window.less = {} }
+ tree = less.tree = {};
+ less.mode = 'rhino';
+} else if (typeof(window) === 'undefined') {
+ // Node.js
+ less = exports,
+ tree = require('./tree');
+ less.mode = 'node';
+} else {
+ // Browser
+ if (typeof(window.less) === 'undefined') { window.less = {} }
+ less = window.less,
+ tree = window.less.tree = {};
+ less.mode = 'browser';
+}
+//
+// less.js - parser
+//
+// A relatively straight-forward predictive parser.
+// There is no tokenization/lexing stage, the input is parsed
+// in one sweep.
+//
+// To make the parser fast enough to run in the browser, several
+// optimization had to be made:
+//
+// - Matching and slicing on a huge input is often cause of slowdowns.
+// The solution is to chunkify the input into smaller strings.
+// The chunks are stored in the `chunks` var,
+// `j` holds the current chunk index, and `current` holds
+// the index of the current chunk in relation to `input`.
+// This gives us an almost 4x speed-up.
+//
+// - In many cases, we don't need to match individual tokens;
+// for example, if a value doesn't hold any variables, operations
+// or dynamic references, the parser can effectively 'skip' it,
+// treating it as a literal.
+// An example would be '1px solid #000' - which evaluates to itself,
+// we don't need to know what the individual components are.
+// The drawback, of course is that you don't get the benefits of
+// syntax-checking on the CSS. This gives us a 50% speed-up in the parser,
+// and a smaller speed-up in the code-gen.
+//
+//
+// Token matching is done with the `$` function, which either takes
+// a terminal string or regexp, or a non-terminal function to call.
+// It also takes care of moving all the indices forwards.
+//
+//
+less.Parser = function Parser(env) {
+ var input, // LeSS input string
+ i, // current index in `input`
+ j, // current chunk
+ temp, // temporarily holds a chunk's state, for backtracking
+ memo, // temporarily holds `i`, when backtracking
+ furthest, // furthest index the parser has gone to
+ chunks, // chunkified input
+ current, // index of current chunk, in `input`
+ parser;
+
+ var that = this;
+
+ // This function is called after all files
+ // have been imported through `@import`.
+ var finish = function () {};
+
+ var imports = this.imports = {
+ paths: env && env.paths || [], // Search paths, when importing
+ queue: [], // Files which haven't been imported yet
+ files: {}, // Holds the imported parse trees
+ contents: {}, // Holds the imported file contents
+ mime: env && env.mime, // MIME type of .less files
+ error: null, // Error in parsing/evaluating an import
+ push: function (path, callback) {
+ var that = this;
+ this.queue.push(path);
+
+ //
+ // Import a file asynchronously
+ //
+ less.Parser.importer(path, this.paths, function (e, root, contents) {
+ that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue
+
+ var imported = path in that.files;
+
+ that.files[path] = root; // Store the root
+ that.contents[path] = contents;
+
+ if (e && !that.error) { that.error = e }
+
+ callback(e, root, imported);
+
+ if (that.queue.length === 0) { finish() } // Call `finish` if we're done importing
+ }, env);
+ }
+ };
+
+ function save() { temp = chunks[j], memo = i, current = i }
+ function restore() { chunks[j] = temp, i = memo, current = i }
+
+ function sync() {
+ if (i > current) {
+ chunks[j] = chunks[j].slice(i - current);
+ current = i;
+ }
+ }
+ //
+ // Parse from a token, regexp or string, and move forward if match
+ //
+ function $(tok) {
+ var match, args, length, c, index, endIndex, k, mem;
+
+ //
+ // Non-terminal
+ //
+ if (tok instanceof Function) {
+ return tok.call(parser.parsers);
+ //
+ // Terminal
+ //
+ // Either match a single character in the input,
+ // or match a regexp in the current chunk (chunk[j]).
+ //
+ } else if (typeof(tok) === 'string') {
+ match = input.charAt(i) === tok ? tok : null;
+ length = 1;
+ sync ();
+ } else {
+ sync ();
+
+ if (match = tok.exec(chunks[j])) {
+ length = match[0].length;
+ } else {
+ return null;
+ }
+ }
+
+ // The match is confirmed, add the match length to `i`,
+ // and consume any extra white-space characters (' ' || '\n')
+ // which come after that. The reason for this is that LeSS's
+ // grammar is mostly white-space insensitive.
+ //
+ if (match) {
+ mem = i += length;
+ endIndex = i + chunks[j].length - length;
+
+ while (i < endIndex) {
+ c = input.charCodeAt(i);
+ if (! (c === 32 || c === 10 || c === 9)) { break }
+ i++;
+ }
+ chunks[j] = chunks[j].slice(length + (i - mem));
+ current = i;
+
+ if (chunks[j].length === 0 && j < chunks.length - 1) { j++ }
+
+ if(typeof(match) === 'string') {
+ return match;
+ } else {
+ return match.length === 1 ? match[0] : match;
+ }
+ }
+ }
+
+ function expect(arg, msg) {
+ var result = $(arg);
+ if (! result) {
+ error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + input.charAt(i) + "'"
+ : "unexpected token"));
+ } else {
+ return result;
+ }
+ }
+
+ function error(msg, type) {
+ throw { index: i, type: type || 'Syntax', message: msg };
+ }
+
+ // Same as $(), but don't change the state of the parser,
+ // just return the match.
+ function peek(tok) {
+ if (typeof(tok) === 'string') {
+ return input.charAt(i) === tok;
+ } else {
+ if (tok.test(chunks[j])) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+
+ function basename(pathname) {
+ if (less.mode === 'node') {
+ return require('path').basename(pathname);
+ } else {
+ return pathname.match(/[^\/]+$/)[0];
+ }
+ }
+
+ function getInput(e, env) {
+ if (e.filename && env.filename && (e.filename !== env.filename)) {
+ return parser.imports.contents[basename(e.filename)];
+ } else {
+ return input;
+ }
+ }
+
+ function getLocation(index, input) {
+ for (var n = index, column = -1;
+ n >= 0 && input.charAt(n) !== '\n';
+ n--) { column++ }
+
+ return { line: typeof(index) === 'number' ? (input.slice(0, index).match(/\n/g) || "").length : null,
+ column: column };
+ }
+
+ function LessError(e, env) {
+ var input = getInput(e, env),
+ loc = getLocation(e.index, input),
+ line = loc.line,
+ col = loc.column,
+ lines = input.split('\n');
+
+ this.type = e.type || 'Syntax';
+ this.message = e.message;
+ this.filename = e.filename || env.filename;
+ this.index = e.index;
+ this.line = typeof(line) === 'number' ? line + 1 : null;
+ this.callLine = e.call && (getLocation(e.call, input).line + 1);
+ this.callExtract = lines[getLocation(e.call, input).line];
+ this.stack = e.stack;
+ this.column = col;
+ this.extract = [
+ lines[line - 1],
+ lines[line],
+ lines[line + 1]
+ ];
+ }
+
+ this.env = env = env || {};
+
+ // The optimization level dictates the thoroughness of the parser,
+ // the lower the number, the less nodes it will create in the tree.
+ // This could matter for debugging, or if you want to access
+ // the individual nodes in the tree.
+ this.optimization = ('optimization' in this.env) ? this.env.optimization : 1;
+
+ this.env.filename = this.env.filename || null;
+
+ //
+ // The Parser
+ //
+ return parser = {
+
+ imports: imports,
+ //
+ // Parse an input string into an abstract syntax tree,
+ // call `callback` when done.
+ //
+ parse: function (str, callback) {
+ var root, start, end, zone, line, lines, buff = [], c, error = null;
+
+ i = j = current = furthest = 0;
+ input = str.replace(/\r\n/g, '\n');
+
+ // Split the input into chunks.
+ chunks = (function (chunks) {
+ var j = 0,
+ skip = /[^"'`\{\}\/\(\)\\]+/g,
+ comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,
+ string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`\\\r\n]|\\.)*)`/g,
+ level = 0,
+ match,
+ chunk = chunks[0],
+ inParam;
+
+ for (var i = 0, c, cc; i < input.length; i++) {
+ skip.lastIndex = i;
+ if (match = skip.exec(input)) {
+ if (match.index === i) {
+ i += match[0].length;
+ chunk.push(match[0]);
+ }
+ }
+ c = input.charAt(i);
+ comment.lastIndex = string.lastIndex = i;
+
+ if (match = string.exec(input)) {
+ if (match.index === i) {
+ i += match[0].length;
+ chunk.push(match[0]);
+ c = input.charAt(i);
+ }
+ }
+
+ if (!inParam && c === '/') {
+ cc = input.charAt(i + 1);
+ if (cc === '/' || cc === '*') {
+ if (match = comment.exec(input)) {
+ if (match.index === i) {
+ i += match[0].length;
+ chunk.push(match[0]);
+ c = input.charAt(i);
+ }
+ }
+ }
+ }
+
+ switch (c) {
+ case '{': if (! inParam) { level ++; chunk.push(c); break }
+ case '}': if (! inParam) { level --; chunk.push(c); chunks[++j] = chunk = []; break }
+ case '(': if (! inParam) { inParam = true; chunk.push(c); break }
+ case ')': if ( inParam) { inParam = false; chunk.push(c); break }
+ default: chunk.push(c);
+ }
+ }
+ if (level > 0) {
+ error = new(LessError)({
+ index: i,
+ type: 'Parse',
+ message: "missing closing `}`",
+ filename: env.filename
+ }, env);
+ }
+
+ return chunks.map(function (c) { return c.join('') });;
+ })([[]]);
+
+ if (error) {
+ return callback(error);
+ }
+
+ // Start with the primary rule.
+ // The whole syntax tree is held under a Ruleset node,
+ // with the `root` property set to true, so no `{}` are
+ // output. The callback is called when the input is parsed.
+ try {
+ root = new(tree.Ruleset)([], $(this.parsers.primary));
+ root.root = true;
+ } catch (e) {
+ return callback(new(LessError)(e, env));
+ }
+
+ root.toCSS = (function (evaluate) {
+ var line, lines, column;
+
+ return function (options, variables) {
+ var frames = [], importError;
+
+ options = options || {};
+ //
+ // Allows setting variables with a hash, so:
+ //
+ // `{ color: new(tree.Color)('#f01') }` will become:
+ //
+ // new(tree.Rule)('@color',
+ // new(tree.Value)([
+ // new(tree.Expression)([
+ // new(tree.Color)('#f01')
+ // ])
+ // ])
+ // )
+ //
+ if (typeof(variables) === 'object' && !Array.isArray(variables)) {
+ variables = Object.keys(variables).map(function (k) {
+ var value = variables[k];
+
+ if (! (value instanceof tree.Value)) {
+ if (! (value instanceof tree.Expression)) {
+ value = new(tree.Expression)([value]);
+ }
+ value = new(tree.Value)([value]);
+ }
+ return new(tree.Rule)('@' + k, value, false, 0);
+ });
+ frames = [new(tree.Ruleset)(null, variables)];
+ }
+
+ try {
+ var css = evaluate.call(this, { frames: frames })
+ .toCSS([], { compress: options.compress || false });
+ } catch (e) {
+ throw new(LessError)(e, env);
+ }
+
+ if ((importError = parser.imports.error)) { // Check if there was an error during importing
+ if (importError instanceof LessError) throw importError;
+ else throw new(LessError)(importError, env);
+ }
+
+ if (options.yuicompress && less.mode === 'node') {
+ return require('./cssmin').compressor.cssmin(css);
+ } else if (options.compress) {
+ return css.replace(/(\s)+/g, "$1");
+ } else {
+ return css;
+ }
+ };
+ })(root.eval);
+
+ // If `i` is smaller than the `input.length - 1`,
+ // it means the parser wasn't able to parse the whole
+ // string, so we've got a parsing error.
+ //
+ // We try to extract a \n delimited string,
+ // showing the line where the parse error occured.
+ // We split it up into two parts (the part which parsed,
+ // and the part which didn't), so we can color them differently.
+ if (i < input.length - 1) {
+ i = furthest;
+ lines = input.split('\n');
+ line = (input.slice(0, i).match(/\n/g) || "").length + 1;
+
+ for (var n = i, column = -1; n >= 0 && input.charAt(n) !== '\n'; n--) { column++ }
+
+ error = {
+ type: "Parse",
+ message: "Syntax Error on line " + line,
+ index: i,
+ filename: env.filename,
+ line: line,
+ column: column,
+ extract: [
+ lines[line - 2],
+ lines[line - 1],
+ lines[line]
+ ]
+ };
+ }
+
+ if (this.imports.queue.length > 0) {
+ finish = function () { callback(error, root) };
+ } else {
+ callback(error, root);
+ }
+ },
+
+ //
+ // Here in, the parsing rules/functions
+ //
+ // The basic structure of the syntax tree generated is as follows:
+ //
+ // Ruleset -> Rule -> Value -> Expression -> Entity
+ //
+ // Here's some LESS code:
+ //
+ // .class {
+ // color: #fff;
+ // border: 1px solid #000;
+ // width: @w + 4px;
+ // > .child {...}
+ // }
+ //
+ // And here's what the parse tree might look like:
+ //
+ // Ruleset (Selector '.class', [
+ // Rule ("color", Value ([Expression [Color #fff]]))
+ // Rule ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]]))
+ // Rule ("width", Value ([Expression [Operation "+" [Variable "@w"][Dimension 4px]]]))
+ // Ruleset (Selector [Element '>', '.child'], [...])
+ // ])
+ //
+ // In general, most rules will try to parse a token with the `$()` function, and if the return
+ // value is truly, will return a new node, of the relevant type. Sometimes, we need to check
+ // first, before parsing, that's when we use `peek()`.
+ //
+ parsers: {
+ //
+ // The `primary` rule is the *entry* and *exit* point of the parser.
+ // The rules here can appear at any level of the parse tree.
+ //
+ // The recursive nature of the grammar is an interplay between the `block`
+ // rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,
+ // as represented by this simplified grammar:
+ //
+ // primary → (ruleset | rule)+
+ // ruleset → selector+ block
+ // block → '{' primary '}'
+ //
+ // Only at one point is the primary rule not called from the
+ // block rule: at the root level.
+ //
+ primary: function () {
+ var node, root = [];
+
+ while ((node = $(this.mixin.definition) || $(this.rule) || $(this.ruleset) ||
+ $(this.mixin.call) || $(this.comment) || $(this.directive))
+ || $(/^[\s\n]+/)) {
+ node && root.push(node);
+ }
+ return root;
+ },
+
+ // We create a Comment node for CSS comments `/* */`,
+ // but keep the LeSS comments `//` silent, by just skipping
+ // over them.
+ comment: function () {
+ var comment;
+
+ if (input.charAt(i) !== '/') return;
+
+ if (input.charAt(i + 1) === '/') {
+ return new(tree.Comment)($(/^\/\/.*/), true);
+ } else if (comment = $(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) {
+ return new(tree.Comment)(comment);
+ }
+ },
+
+ //
+ // Entities are tokens which can be found inside an Expression
+ //
+ entities: {
+ //
+ // A string, which supports escaping " and '
+ //
+ // "milky way" 'he\'s the one!'
+ //
+ quoted: function () {
+ var str, j = i, e;
+
+ if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
+ if (input.charAt(j) !== '"' && input.charAt(j) !== "'") return;
+
+ e && $('~');
+
+ if (str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) {
+ return new(tree.Quoted)(str[0], str[1] || str[2], e);
+ }
+ },
+
+ //
+ // A catch-all word, such as:
+ //
+ // black border-collapse
+ //
+ keyword: function () {
+ var k;
+
+ if (k = $(/^[_A-Za-z-][_A-Za-z0-9-]*/)) {
+ if (tree.colors.hasOwnProperty(k)) {
+ // detect named color
+ return new(tree.Color)(tree.colors[k].slice(1));
+ } else {
+ return new(tree.Keyword)(k);
+ }
+ }
+ },
+
+ //
+ // A function call
+ //
+ // rgb(255, 0, 255)
+ //
+ // We also try to catch IE's `alpha()`, but let the `alpha` parser
+ // deal with the details.
+ //
+ // The arguments are parsed with the `entities.arguments` parser.
+ //
+ call: function () {
+ var name, args, index = i;
+
+ if (! (name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(chunks[j]))) return;
+
+ name = name[1].toLowerCase();
+
+ if (name === 'url') { return null }
+ else { i += name.length }
+
+ if (name === 'alpha') { return $(this.alpha) }
+
+ $('('); // Parse the '(' and consume whitespace.
+
+ args = $(this.entities.arguments);
+
+ if (! $(')')) return;
+
+ if (name) { return new(tree.Call)(name, args, index, env.filename) }
+ },
+ arguments: function () {
+ var args = [], arg;
+
+ while (arg = $(this.entities.assignment) || $(this.expression)) {
+ args.push(arg);
+ if (! $(',')) { break }
+ }
+ return args;
+ },
+ literal: function () {
+ return $(this.entities.dimension) ||
+ $(this.entities.color) ||
+ $(this.entities.quoted);
+ },
+
+ // Assignments are argument entities for calls.
+ // They are present in ie filter properties as shown below.
+ //
+ // filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* )
+ //
+
+ assignment: function () {
+ var key, value;
+ if ((key = $(/^\w+(?=\s?=)/i)) && $('=') && (value = $(this.entity))) {
+ return new(tree.Assignment)(key, value);
+ }
+ },
+
+ //
+ // Parse url() tokens
+ //
+ // We use a specific rule for urls, because they don't really behave like
+ // standard function calls. The difference is that the argument doesn't have
+ // to be enclosed within a string, so it can't be parsed as an Expression.
+ //
+ url: function () {
+ var value;
+
+ if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
+ value = $(this.entities.quoted) || $(this.entities.variable) ||
+ $(this.entities.dataURI) || $(/^[-\w%@$\/.&=:;#+?~]+/) || "";
+
+ expect(')');
+
+ return new(tree.URL)((value.value || value.data || value instanceof tree.Variable)
+ ? value : new(tree.Anonymous)(value), imports.paths);
+ },
+
+ dataURI: function () {
+ var obj;
+
+ if ($(/^data:/)) {
+ obj = {};
+ obj.mime = $(/^[^\/]+\/[^,;)]+/) || '';
+ obj.charset = $(/^;\s*charset=[^,;)]+/) || '';
+ obj.base64 = $(/^;\s*base64/) || '';
+ obj.data = $(/^,\s*[^)]+/);
+
+ if (obj.data) { return obj }
+ }
+ },
+
+ //
+ // A Variable entity, such as `@fink`, in
+ //
+ // width: @fink + 2px
+ //
+ // We use a different parser for variable definitions,
+ // see `parsers.variable`.
+ //
+ variable: function () {
+ var name, index = i;
+
+ if (input.charAt(i) === '@' && (name = $(/^@@?[\w-]+/))) {
+ return new(tree.Variable)(name, index, env.filename);
+ }
+ },
+
+ //
+ // A Hexadecimal color
+ //
+ // #4F3C2F
+ //
+ // `rgb` and `hsl` colors are parsed through the `entities.call` parser.
+ //
+ color: function () {
+ var rgb;
+
+ if (input.charAt(i) === '#' && (rgb = $(/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})/))) {
+ return new(tree.Color)(rgb[1]);
+ }
+ },
+
+ //
+ // A Dimension, that is, a number and a unit
+ //
+ // 0.5em 95%
+ //
+ dimension: function () {
+ var value, c = input.charCodeAt(i);
+ if ((c > 57 || c < 45) || c === 47) return;
+
+ if (value = $(/^(-?\d*\.?\d+)(px|%|em|rem|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn|dpi)?/)) {
+ return new(tree.Dimension)(value[1], value[2]);
+ }
+ },
+
+ //
+ // JavaScript code to be evaluated
+ //
+ // `window.location.href`
+ //
+ javascript: function () {
+ var str, j = i, e;
+
+ if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
+ if (input.charAt(j) !== '`') { return }
+
+ e && $('~');
+
+ if (str = $(/^`([^`]*)`/)) {
+ return new(tree.JavaScript)(str[1], i, e);
+ }
+ }
+ },
+
+ //
+ // The variable part of a variable definition. Used in the `rule` parser
+ //
+ // @fink:
+ //
+ variable: function () {
+ var name;
+
+ if (input.charAt(i) === '@' && (name = $(/^(@[\w-]+)\s*:/))) { return name[1] }
+ },
+
+ //
+ // A font size/line-height shorthand
+ //
+ // small/12px
+ //
+ // We need to peek first, or we'll match on keywords and dimensions
+ //
+ shorthand: function () {
+ var a, b;
+
+ if (! peek(/^[@\w.%-]+\/[@\w.-]+/)) return;
+
+ if ((a = $(this.entity)) && $('/') && (b = $(this.entity))) {
+ return new(tree.Shorthand)(a, b);
+ }
+ },
+
+ //
+ // Mixins
+ //
+ mixin: {
+ //
+ // A Mixin call, with an optional argument list
+ //
+ // #mixins > .square(#fff);
+ // .rounded(4px, black);
+ // .button;
+ //
+ // The `while` loop is there because mixins can be
+ // namespaced, but we only support the child and descendant
+ // selector for now.
+ //
+ call: function () {
+ var elements = [], e, c, args = [], arg, index = i, s = input.charAt(i), name, value, important = false;
+
+ if (s !== '.' && s !== '#') { return }
+
+ while (e = $(/^[#.](?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+/)) {
+ elements.push(new(tree.Element)(c, e, i));
+ c = $('>');
+ }
+ if ($('(')) {
+ while (arg = $(this.expression)) {
+ value = arg;
+ name = null;
+
+ // Variable
+ if (arg.value.length == 1) {
+ var val = arg.value[0];
+ if (val instanceof tree.Variable) {
+ if ($(':')) {
+ if (value = $(this.expression)) {
+ name = val.name;
+ } else {
+ throw new(Error)("Expected value");
+ }
+ }
+ }
+ }
+
+ args.push({ name: name, value: value });
+
+ if (! $(',')) { break }
+ }
+ if (! $(')')) throw new(Error)("Expected )");
+ }
+
+ if ($(this.important)) {
+ important = true;
+ }
+
+ if (elements.length > 0 && ($(';') || peek('}'))) {
+ return new(tree.mixin.Call)(elements, args, index, env.filename, important);
+ }
+ },
+
+ //
+ // A Mixin definition, with a list of parameters
+ //
+ // .rounded (@radius: 2px, @color) {
+ // ...
+ // }
+ //
+ // Until we have a finer grained state-machine, we have to
+ // do a look-ahead, to make sure we don't have a mixin call.
+ // See the `rule` function for more information.
+ //
+ // We start by matching `.rounded (`, and then proceed on to
+ // the argument list, which has optional default values.
+ // We store the parameters in `params`, with a `value` key,
+ // if there is a value, such as in the case of `@radius`.
+ //
+ // Once we've got our params list, and a closing `)`, we parse
+ // the `{...}` block.
+ //