Last active
December 12, 2015 02:58
-
-
Save zkenda/4703407 to your computer and use it in GitHub Desktop.
My approach to less.modifyVars. To avoid reparsing I just modify "expression tree" and then render again. Only intresting file is less-1.3.1.modifyVars.js and perhaps modified less-1.3.1.js (which is actually 1.3.3). Index.html, test.less and jsLitmus.js are for demonstration.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!DOCTYPE html> | |
<html> | |
<head> | |
<title></title> | |
<meta charset="UTF-8" /> | |
<link rel="stylesheet/less" type="text/css" href="test.less"> | |
<script type="text/javascript" src="less-1.3.1.js"></script> | |
<script type="text/javascript" src="less-1.3.1.modifyVars.js"></script> | |
<script type="text/javascript" src="JsLitmus.js"></script> | |
<script type="text/javascript"> | |
//lame random color | |
function getColor() | |
{ | |
return "#"+Math.floor((Math.random()*9)+1) + Math.floor((Math.random()*9)+1) + Math.floor((Math.random()*9)+1); | |
} | |
window.onload = function() { | |
//less.modifyVars_new({'@color1': '#e2e'}); | |
JSLitmus.test('less.modifyVars',function(){ less.modifyVars({"@color1": getColor()});}); | |
JSLitmus.test('less.modify',function(){ less.modify({"@color1": getColor()});}); | |
}; | |
</script> | |
</head> | |
<body> | |
<h3>test</h3> | |
<p>less.modifyVars - official</p> | |
<button onclick="less.modifyVars({'@color1': 'darken(@color2, 21%)'});">modifyVars 1</button> | |
<button onclick="less.modifyVars({'@color1': '#eee'});">modifyVars 2</button> | |
<p>less.modify - experimental</p> | |
<button onclick="less.modify({'@color1': '#252'});">modifyVars 1</button> | |
<button onclick="less.modify({'@color1': '#369'});">modifyVars 2</button> | |
</body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// JSLitmus.js | |
// | |
// Copyright (c) 2010, Robert Kieffer, http://broofa.com | |
// Available under MIT license (http://en.wikipedia.org/wiki/MIT_License) | |
(function() { | |
// Private methods and state | |
// Get platform info but don't go crazy trying to recognize everything | |
// that's out there. This is just for the major platforms and OSes. | |
var platform = 'unknown platform', ua = navigator.userAgent; | |
// Detect OS | |
var oses = ['Windows','iPhone OS','(Intel |PPC )?Mac OS X','Linux'].join('|'); | |
var pOS = new RegExp('((' + oses + ') [^ \);]*)').test(ua) ? RegExp.$1 : null; | |
if (!pOS) pOS = new RegExp('((' + oses + ')[^ \);]*)').test(ua) ? RegExp.$1 : null; | |
// Detect browser | |
var pName = /(Chrome|MSIE|Safari|Opera|Firefox)/.test(ua) ? RegExp.$1 : null; | |
// Detect version | |
var vre = new RegExp('(Version|' + pName + ')[ \/]([^ ;]*)'); | |
var pVersion = (pName && vre.test(ua)) ? RegExp.$2 : null; | |
var platform = (pOS && pName && pVersion) ? pName + ' ' + pVersion + ' on ' + pOS : 'unknown platform'; | |
/** | |
* A smattering of methods that are needed to implement the JSLitmus testbed. | |
*/ | |
var jsl = { | |
/** | |
* Enhanced version of escape() | |
*/ | |
escape: function(s) { | |
s = s.replace(/,/g, '\\,'); | |
s = escape(s); | |
s = s.replace(/\+/g, '%2b'); | |
s = s.replace(/ /g, '+'); | |
return s; | |
}, | |
/** | |
* Get an element by ID. | |
*/ | |
$: function(id) { | |
return document.getElementById(id); | |
}, | |
/** | |
* Null function | |
*/ | |
F: function() {}, | |
/** | |
* Set the status shown in the UI | |
*/ | |
status: function(msg) { | |
var el = jsl.$('jsl_status'); | |
if (el) el.innerHTML = msg || ''; | |
}, | |
/** | |
* Convert a number to an abbreviated string like, "15K" or "10M" | |
*/ | |
toLabel: function(n) { | |
if (n == Infinity) { | |
return 'Infinity'; | |
} else if (n > 1e9) { | |
n = Math.round(n/1e8); | |
return n/10 + 'B'; | |
} else if (n > 1e6) { | |
n = Math.round(n/1e5); | |
return n/10 + 'M'; | |
} else if (n > 1e3) { | |
n = Math.round(n/1e2); | |
return n/10 + 'K'; | |
} | |
return n; | |
}, | |
/** | |
* Copy properties from src to dst | |
*/ | |
extend: function(dst, src) { | |
for (var k in src) dst[k] = src[k]; return dst; | |
}, | |
/** | |
* Like Array.join(), but for the key-value pairs in an object | |
*/ | |
join: function(o, delimit1, delimit2) { | |
if (o.join) return o.join(delimit1); // If it's an array | |
var pairs = []; | |
for (var k in o) pairs.push(k + delimit1 + o[k]); | |
return pairs.join(delimit2); | |
}, | |
/** | |
* Array#indexOf isn't supported in IE, so we use this as a cross-browser solution | |
*/ | |
indexOf: function(arr, o) { | |
if (arr.indexOf) return arr.indexOf(o); | |
for (var i = 0; i < this.length; i++) if (arr[i] === o) return i; | |
return -1; | |
} | |
}; | |
/** | |
* Test manages a single test (created with | |
* JSLitmus.test()) | |
* | |
* @private | |
*/ | |
var Test = function (name, f) { | |
if (!f) throw new Error('Undefined test function'); | |
if (!/function[^\(]*\(([^,\)]*)/.test(f.toString())) { | |
throw new Error('"' + name + '" test: Test is not a valid Function object'); | |
} | |
this.loopArg = RegExp.$1; | |
this.name = name; | |
this.f = f; | |
}; | |
jsl.extend(Test, /** @lends Test */ { | |
/** Calibration tests for establishing iteration loop overhead */ | |
CALIBRATIONS: [ | |
new Test('calibrating loop', function(count) {while (count--);}), | |
new Test('calibrating function', jsl.F) | |
], | |
/** | |
* Run calibration tests. Returns true if calibrations are not yet | |
* complete (in which case calling code should run the tests yet again). | |
* onCalibrated - Callback to invoke when calibrations have finished | |
*/ | |
calibrate: function(onCalibrated) { | |
for (var i = 0; i < Test.CALIBRATIONS.length; i++) { | |
var cal = Test.CALIBRATIONS[i]; | |
if (cal.running) return true; | |
if (!cal.count) { | |
cal.isCalibration = true; | |
cal.onStop = onCalibrated; | |
//cal.MIN_TIME = .1; // Do calibrations quickly | |
cal.run(2e4); | |
return true; | |
} | |
} | |
return false; | |
} | |
}); | |
jsl.extend(Test.prototype, {/** @lends Test.prototype */ | |
/** Initial number of iterations */ | |
INIT_COUNT: 10, | |
/** Max iterations allowed (i.e. used to detect bad looping functions) */ | |
MAX_COUNT: 1e9, | |
/** Minimum time a test should take to get valid results (secs) */ | |
MIN_TIME: .5, | |
/** Callback invoked when test state changes */ | |
onChange: jsl.F, | |
/** Callback invoked when test is finished */ | |
onStop: jsl.F, | |
/** | |
* Reset test state | |
*/ | |
reset: function() { | |
delete this.count; | |
delete this.time; | |
delete this.running; | |
delete this.error; | |
}, | |
/** | |
* Run the test (in a timeout). We use a timeout to make sure the browser | |
* has a chance to finish rendering any UI changes we've made, like | |
* updating the status message. | |
*/ | |
run: function(count) { | |
count = count || this.INIT_COUNT; | |
jsl.status(this.name + ' x ' + count); | |
this.running = true; | |
var me = this; | |
setTimeout(function() {me._run(count);}, 200); | |
}, | |
/** | |
* The nuts and bolts code that actually runs a test | |
*/ | |
_run: function(count) { | |
var me = this; | |
// Make sure calibration tests have run | |
if (!me.isCalibration && Test.calibrate(function() {me.run(count);})) return; | |
this.error = null; | |
try { | |
var start, f = this.f, now, i = count; | |
// Start the timer | |
start = new Date(); | |
// Now for the money shot. If this is a looping function ... | |
if (this.loopArg) { | |
// ... let it do the iteration itself | |
f(count); | |
} else { | |
// ... otherwise do the iteration for it | |
while (i--) f(); | |
} | |
// Get time test took (in secs) | |
this.time = Math.max(1,new Date() - start)/1000; | |
// Store iteration count and per-operation time taken | |
this.count = count; | |
this.period = this.time/count; | |
// Do we need to do another run? | |
this.running = this.time <= this.MIN_TIME; | |
// ... if so, compute how many times we should iterate | |
if (this.running) { | |
// Bump the count to the nearest power of 2 | |
var x = this.MIN_TIME/this.time; | |
var pow = Math.pow(2, Math.max(1, Math.ceil(Math.log(x)/Math.log(2)))); | |
count *= pow; | |
if (count > this.MAX_COUNT) { | |
throw new Error('Max count exceeded. If this test uses a looping function, make sure the iteration loop is working properly.'); | |
} | |
} | |
} catch (e) { | |
// Exceptions are caught and displayed in the test UI | |
this.reset(); | |
this.error = e; | |
} | |
// Figure out what to do next | |
if (this.running) { | |
me.run(count); | |
} else { | |
jsl.status(''); | |
me.onStop(me); | |
} | |
// Finish up | |
this.onChange(this); | |
}, | |
/** | |
* Get the number of operations per second for this test. | |
* | |
* @param normalize if true, iteration loop overhead taken into account | |
*/ | |
getHz: function(/**Boolean*/ normalize) { | |
var p = this.period; | |
// Adjust period based on the calibration test time | |
if (normalize && !this.isCalibration) { | |
var cal = Test.CALIBRATIONS[this.loopArg ? 0 : 1]; | |
// If the period is within 20% of the calibration time, then zero the | |
// it out | |
p = p < cal.period*1.2 ? 0 : p - cal.period; | |
} | |
return Math.round(1/p); | |
}, | |
/** | |
* Get a friendly string describing the test | |
*/ | |
toString: function() { | |
return this.name + ' - ' + this.time/this.count + ' secs'; | |
} | |
}); | |
// CSS we need for the UI | |
var STYLESHEET = '<style> \ | |
#jslitmus {font-family:sans-serif; font-size: 12px;} \ | |
#jslitmus a {text-decoration: none;} \ | |
#jslitmus a:hover {text-decoration: underline;} \ | |
#jsl_status { \ | |
margin-top: 10px; \ | |
font-size: 10px; \ | |
color: #888; \ | |
} \ | |
A IMG {border:none} \ | |
#test_results { \ | |
margin-top: 10px; \ | |
font-size: 12px; \ | |
font-family: sans-serif; \ | |
border-collapse: collapse; \ | |
border-spacing: 0px; \ | |
} \ | |
#test_results th, #test_results td { \ | |
border: solid 1px #ccc; \ | |
vertical-align: top; \ | |
padding: 3px; \ | |
} \ | |
#test_results th { \ | |
vertical-align: bottom; \ | |
background-color: #ccc; \ | |
padding: 1px; \ | |
font-size: 10px; \ | |
} \ | |
#test_results #test_platform { \ | |
color: #444; \ | |
text-align:center; \ | |
} \ | |
#test_results .test_row { \ | |
color: #006; \ | |
cursor: pointer; \ | |
} \ | |
#test_results .test_nonlooping { \ | |
border-left-style: dotted; \ | |
border-left-width: 2px; \ | |
} \ | |
#test_results .test_looping { \ | |
border-left-style: solid; \ | |
border-left-width: 2px; \ | |
} \ | |
#test_results .test_name {white-space: nowrap;} \ | |
#test_results .test_pending { \ | |
} \ | |
#test_results .test_running { \ | |
font-style: italic; \ | |
} \ | |
#test_results .test_done {} \ | |
#test_results .test_done { \ | |
text-align: right; \ | |
font-family: monospace; \ | |
} \ | |
#test_results .test_error {color: #600;} \ | |
#test_results .test_error .error_head {font-weight:bold;} \ | |
#test_results .test_error .error_body {font-size:85%;} \ | |
#test_results .test_row:hover td { \ | |
background-color: #ffc; \ | |
text-decoration: underline; \ | |
} \ | |
#chart { \ | |
margin: 10px 0px; \ | |
width: 250px; \ | |
} \ | |
#chart img { \ | |
border: solid 1px #ccc; \ | |
margin-bottom: 5px; \ | |
} \ | |
#chart #tiny_url { \ | |
height: 40px; \ | |
width: 250px; \ | |
} \ | |
#jslitmus_credit { \ | |
font-size: 10px; \ | |
color: #888; \ | |
margin-top: 8px; \ | |
} \ | |
</style>'; | |
// HTML markup for the UI | |
var MARKUP = '<div id="jslitmus"> \ | |
<button onclick="JSLitmus.runAll(event)">Run Tests</button> \ | |
<button id="stop_button" disabled="disabled" onclick="JSLitmus.stop()">Stop Tests</button> \ | |
<br \> \ | |
<br \> \ | |
<input type="checkbox" style="vertical-align: middle" id="test_normalize" checked="checked" onchange="JSLitmus.renderAll()""> Normalize results \ | |
<table id="test_results"> \ | |
<colgroup> \ | |
<col /> \ | |
<col width="100" /> \ | |
</colgroup> \ | |
<tr><th id="test_platform" colspan="2">' + platform + '</th></tr> \ | |
<tr><th>Test</th><th>Ops/sec</th></tr> \ | |
<tr id="test_row_template" class="test_row" style="display:none"> \ | |
<td class="test_name"></td> \ | |
<td class="test_result">Ready</td> \ | |
</tr> \ | |
</table> \ | |
<div id="jsl_status"></div> \ | |
<div id="chart" style="display:none"> \ | |
<a id="chart_link" target="_blank"><img id="chart_image"></a> \ | |
TinyURL (for chart): \ | |
<iframe id="tiny_url" frameBorder="0" scrolling="no" src=""></iframe> \ | |
</div> \ | |
<a id="jslitmus_credit" title="JSLitmus home page" href="http://code.google.com/p/jslitmus" target="_blank">Powered by JSLitmus</a> \ | |
</div>'; | |
/** | |
* The public API for creating and running tests | |
*/ | |
window.JSLitmus = { | |
/** The list of all tests that have been registered with JSLitmus.test */ | |
_tests: [], | |
/** The queue of tests that need to be run */ | |
_queue: [], | |
/** | |
* The parsed query parameters the current page URL. This is provided as a | |
* convenience for test functions - it's not used by JSLitmus proper | |
*/ | |
params: {}, | |
/** | |
* Initialize | |
*/ | |
_init: function() { | |
// Parse query params into JSLitmus.params[] hash | |
var match = (location + '').match(/([^?#]*)(#.*)?$/); | |
if (match) { | |
var pairs = match[1].split('&'); | |
for (var i = 0; i < pairs.length; i++) { | |
var pair = pairs[i].split('='); | |
if (pair.length > 1) { | |
var key = pair.shift(); | |
var value = pair.length > 1 ? pair.join('=') : pair[0]; | |
this.params[key] = value; | |
} | |
} | |
} | |
// Write out the stylesheet. We have to do this here because IE | |
// doesn't honor sheets written after the document has loaded. | |
document.write(STYLESHEET); | |
// Setup the rest of the UI once the document is loaded | |
if (window.addEventListener) { | |
window.addEventListener('load', this._setup, false); | |
} else if (document.addEventListener) { | |
document.addEventListener('load', this._setup, false); | |
} else if (window.attachEvent) { | |
window.attachEvent('onload', this._setup); | |
} | |
return this; | |
}, | |
/** | |
* Set up the UI | |
*/ | |
_setup: function() { | |
var el = jsl.$('jslitmus_container'); | |
if (!el) document.body.appendChild(el = document.createElement('div')); | |
el.innerHTML = MARKUP; | |
// Render the UI for all our tests | |
for (var i=0; i < JSLitmus._tests.length; i++) | |
JSLitmus.renderTest(JSLitmus._tests[i]); | |
}, | |
/** | |
* (Re)render all the test results | |
*/ | |
renderAll: function() { | |
for (var i = 0; i < JSLitmus._tests.length; i++) | |
JSLitmus.renderTest(JSLitmus._tests[i]); | |
JSLitmus.renderChart(); | |
}, | |
/** | |
* (Re)render the chart graphics | |
*/ | |
renderChart: function() { | |
var url = JSLitmus.chartUrl(); | |
jsl.$('chart_link').href = url; | |
jsl.$('chart_image').src = url; | |
jsl.$('chart').style.display = ''; | |
// Update the tiny URL | |
jsl.$('tiny_url').src = 'http://tinyurl.com/api-create.php?url='+escape(url); | |
}, | |
/** | |
* (Re)render the results for a specific test | |
*/ | |
renderTest: function(test) { | |
// Make a new row if needed | |
if (!test._row) { | |
var trow = jsl.$('test_row_template'); | |
if (!trow) return; | |
test._row = trow.cloneNode(true); | |
test._row.style.display = ''; | |
test._row.id = ''; | |
test._row.onclick = function() {JSLitmus._queueTest(test);}; | |
test._row.title = 'Run ' + test.name + ' test'; | |
trow.parentNode.appendChild(test._row); | |
test._row.cells[0].innerHTML = test.name; | |
} | |
var cell = test._row.cells[1]; | |
var cns = [test.loopArg ? 'test_looping' : 'test_nonlooping']; | |
if (test.error) { | |
cns.push('test_error'); | |
cell.innerHTML = | |
'<div class="error_head">' + test.error + '</div>' + | |
'<ul class="error_body"><li>' + | |
jsl.join(test.error, ': ', '</li><li>') + | |
'</li></ul>'; | |
} else { | |
if (test.running) { | |
cns.push('test_running'); | |
cell.innerHTML = 'running'; | |
} else if (jsl.indexOf(JSLitmus._queue, test) >= 0) { | |
cns.push('test_pending'); | |
cell.innerHTML = 'pending'; | |
} else if (test.count) { | |
cns.push('test_done'); | |
var hz = test.getHz(jsl.$('test_normalize').checked); | |
cell.innerHTML = hz != Infinity ? hz : '∞'; | |
cell.title = 'Looped ' + test.count + ' times in ' + test.time + ' seconds'; | |
} else { | |
cell.innerHTML = 'ready'; | |
} | |
} | |
cell.className = cns.join(' '); | |
}, | |
/** | |
* Create a new test | |
*/ | |
test: function(name, f) { | |
// Create the Test object | |
var test = new Test(name, f); | |
JSLitmus._tests.push(test); | |
// Re-render if the test state changes | |
test.onChange = JSLitmus.renderTest; | |
// Run the next test if this one finished | |
test.onStop = function(test) { | |
if (JSLitmus.onTestFinish) JSLitmus.onTestFinish(test); | |
JSLitmus.currentTest = null; | |
JSLitmus._nextTest(); | |
}; | |
// Render the new test | |
this.renderTest(test); | |
}, | |
/** | |
* Add all tests to the run queue | |
*/ | |
runAll: function(e) { | |
e = e || window.event; | |
var reverse = e && e.shiftKey, len = JSLitmus._tests.length; | |
for (var i = 0; i < len; i++) { | |
JSLitmus._queueTest(JSLitmus._tests[!reverse ? i : (len - i - 1)]); | |
} | |
}, | |
/** | |
* Remove all tests from the run queue. The current test has to finish on | |
* it's own though | |
*/ | |
stop: function() { | |
while (JSLitmus._queue.length) { | |
var test = JSLitmus._queue.shift(); | |
JSLitmus.renderTest(test); | |
} | |
}, | |
/** | |
* Run the next test in the run queue | |
*/ | |
_nextTest: function() { | |
if (!JSLitmus.currentTest) { | |
var test = JSLitmus._queue.shift(); | |
if (test) { | |
jsl.$('stop_button').disabled = false; | |
JSLitmus.currentTest = test; | |
test.run(); | |
JSLitmus.renderTest(test); | |
if (JSLitmus.onTestStart) JSLitmus.onTestStart(test); | |
} else { | |
jsl.$('stop_button').disabled = true; | |
JSLitmus.renderChart(); | |
} | |
} | |
}, | |
/** | |
* Add a test to the run queue | |
*/ | |
_queueTest: function(test) { | |
if (jsl.indexOf(JSLitmus._queue, test) >= 0) return; | |
JSLitmus._queue.push(test); | |
JSLitmus.renderTest(test); | |
JSLitmus._nextTest(); | |
}, | |
/** | |
* Generate a Google Chart URL that shows the data for all tests | |
*/ | |
chartUrl: function() { | |
var n = JSLitmus._tests.length, markers = [], data = []; | |
var d, min = 0, max = -1e10; | |
var normalize = jsl.$('test_normalize').checked; | |
// Gather test data | |
for (var i=0; i < JSLitmus._tests.length; i++) { | |
var test = JSLitmus._tests[i]; | |
if (test.count) { | |
var hz = test.getHz(normalize); | |
var v = hz != Infinity ? hz : 0; | |
data.push(v); | |
markers.push('t' + jsl.escape(test.name + '(' + jsl.toLabel(hz)+ ')') + ',000000,0,' + | |
markers.length + ',10'); | |
max = Math.max(v, max); | |
} | |
} | |
if (markers.length <= 0) return null; | |
// Build chart title | |
var title = document.getElementsByTagName('title'); | |
title = (title && title.length) ? title[0].innerHTML : null; | |
var chart_title = []; | |
if (title) chart_title.push(title); | |
chart_title.push('Ops/sec (' + platform + ')'); | |
// Build labels | |
var labels = [jsl.toLabel(min), jsl.toLabel(max)]; | |
var w = 250, bw = 15; | |
var bs = 5; | |
var h = markers.length*(bw + bs) + 30 + chart_title.length*20; | |
var params = { | |
chtt: escape(chart_title.join('|')), | |
chts: '000000,10', | |
cht: 'bhg', // chart type | |
chd: 't:' + data.join(','), // data set | |
chds: min + ',' + max, // max/min of data | |
chxt: 'x', // label axes | |
chxl: '0:|' + labels.join('|'), // labels | |
chsp: '0,1', | |
chm: markers.join('|'), // test names | |
chbh: [bw, 0, bs].join(','), // bar widths | |
// chf: 'bg,lg,0,eeeeee,0,eeeeee,.5,ffffff,1', // gradient | |
chs: w + 'x' + h | |
}; | |
return 'http://chart.apis.google.com/chart?' + jsl.join(params, '=', '&'); | |
} | |
}; | |
JSLitmus._init(); | |
})(); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// | |
// LESS - Leaner CSS v1.3.3 | |
// http://lesscss.org | |
// | |
// Copyright (c) 2009-2013, Alexis Sellier | |
// Licensed under the Apache 2.0 License. | |
// | |
(function (window, undefined) { | |
// | |
// Stub out `require` in the browser | |
// | |
function require(arg) { | |
return window.less[arg.split('/')[1]]; | |
}; | |
// ecma-5.js | |
// | |
// -- kriskowal Kris Kowal Copyright (C) 2009-2010 MIT License | |
// -- tlrobinson Tom Robinson | |
// dantman Daniel Friesen | |
// | |
// Array | |
// | |
if (!Array.isArray) { | |
Array.isArray = function(obj) { | |
return Object.prototype.toString.call(obj) === "[object Array]" || | |
(obj instanceof Array); | |
}; | |
} | |
if (!Array.prototype.forEach) { | |
Array.prototype.forEach = function(block, thisObject) { | |
var len = this.length >>> 0; | |
for (var i = 0; i < len; i++) { | |
if (i in this) { | |
block.call(thisObject, this[i], i, this); | |
} | |
} | |
}; | |
} | |
if (!Array.prototype.map) { | |
Array.prototype.map = function(fun /*, thisp*/) { | |
var len = this.length >>> 0; | |
var res = new Array(len); | |
var thisp = arguments[1]; | |
for (var i = 0; i < len; i++) { | |
if (i in this) { | |
res[i] = fun.call(thisp, this[i], i, this); | |
} | |
} | |
return res; | |
}; | |
} | |
if (!Array.prototype.filter) { | |
Array.prototype.filter = function (block /*, thisp */) { | |
var values = []; | |
var thisp = arguments[1]; | |
for (var i = 0; i < this.length; i++) { | |
if (block.call(thisp, this[i])) { | |
values.push(this[i]); | |
} | |
} | |
return values; | |
}; | |
} | |
if (!Array.prototype.reduce) { | |
Array.prototype.reduce = function(fun /*, initial*/) { | |
var len = this.length >>> 0; | |
var i = 0; | |
// no value to return if no initial value and an empty array | |
if (len === 0 && arguments.length === 1) throw new TypeError(); | |
if (arguments.length >= 2) { | |
var rv = arguments[1]; | |
} else { | |
do { | |
if (i in this) { | |
rv = this[i++]; | |
break; | |
} | |
// if array contains no values, no initial value to return | |
if (++i >= len) throw new TypeError(); | |
} while (true); | |
} | |
for (; i < len; i++) { | |
if (i in this) { | |
rv = fun.call(null, rv, this[i], i, this); | |
} | |
} | |
return rv; | |
}; | |
} | |
if (!Array.prototype.indexOf) { | |
Array.prototype.indexOf = function (value /*, fromIndex */ ) { | |
var length = this.length; | |
var i = arguments[1] || 0; | |
if (!length) return -1; | |
if (i >= length) return -1; | |
if (i < 0) i += length; | |
for (; i < length; i++) { | |
if (!Object.prototype.hasOwnProperty.call(this, i)) { continue } | |
if (value === this[i]) return i; | |
} | |
return -1; | |
}; | |
} | |
// | |
// Object | |
// | |
if (!Object.keys) { | |
Object.keys = function (object) { | |
var keys = []; | |
for (var name in object) { | |
if (Object.prototype.hasOwnProperty.call(object, name)) { | |
keys.push(name); | |
} | |
} | |
return keys; | |
}; | |
} | |
// | |
// String | |
// | |
if (!String.prototype.trim) { | |
String.prototype.trim = function () { | |
return String(this).replace(/^\s\s*/, '').replace(/\s\s*$/, ''); | |
}; | |
} | |
var less, tree, charset; | |
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; | |
// Top parser on an import tree must be sure there is one "env" | |
// which will then be passed arround by reference. | |
var env = env || { }; | |
// env.contents and files must be passed arround with top env | |
if (!env.contents) { env.contents = {}; } | |
env.rootpath = env.rootpath || ''; // env.rootpath must be initialized to '' if not provided | |
if (!env.files) { env.files = {}; } | |
// This function is called after all files | |
// have been imported through `@import`. | |
var finish = function () {}; | |
var imports = this.imports = { | |
paths: env.paths || [], // Search paths, when importing | |
queue: [], // Files which haven't been imported yet | |
files: env.files, // Holds the imported parse trees | |
contents: env.contents, // Holds the imported file contents | |
mime: 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, fullPath) { | |
that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue | |
var imported = fullPath in that.files; | |
that.files[fullPath] = root; // Store the root | |
if (e && !that.error) { that.error = e } | |
callback(e, root, imported); | |
if (that.queue.length === 0) { finish(that.error) } // 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; | |
} | |
} | |
function isWhitespace(c) { | |
// Could change to \s? | |
var code = c.charCodeAt(0); | |
return code === 32 || code === 10 || code === 9; | |
} | |
// | |
// Parse from a token, regexp or string, and move forward if match | |
// | |
function $(tok) { | |
var match, args, length, index, k; | |
// | |
// 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) { | |
skipWhitespace(length); | |
if(typeof(match) === 'string') { | |
return match; | |
} else { | |
return match.length === 1 ? match[0] : match; | |
} | |
} | |
} | |
function skipWhitespace(length) { | |
var oldi = i, oldj = j, | |
endIndex = i + chunks[j].length, | |
mem = i += length; | |
while (i < endIndex) { | |
if (! isWhitespace(input.charAt(i))) { break } | |
i++; | |
} | |
chunks[j] = chunks[j].slice(length + (i - mem)); | |
current = i; | |
if (chunks[j].length === 0 && j < chunks.length - 1) { j++ } | |
return oldi !== i || oldj !== j; | |
} | |
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) { | |
var e = new Error(msg); | |
e.index = i; | |
e.type = type || 'Syntax'; | |
throw e; | |
} | |
// 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 getInput(e, env) { | |
if (e.filename && env.filename && (e.filename !== env.filename)) { | |
return parser.imports.contents[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 getFileName(e) { | |
if(less.mode === 'browser' || less.mode === 'rhino') | |
return e.filename; | |
else | |
return require('path').resolve(e.filename); | |
} | |
function getDebugInfo(index, inputStream, e) { | |
return { | |
lineNumber: getLocation(index, inputStream).line + 1, | |
fileName: getFileName(e) | |
}; | |
} | |
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'); | |
// Remove potential UTF Byte Order Mark | |
input = input.replace(/^\uFEFF/, ''); | |
// Split the input into chunks. | |
chunks = (function (chunks) { | |
var j = 0, | |
skip = /(?:@\{[\w-]+\}|[^"'`\{\}\/\(\)\\])+/g, | |
comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g, | |
string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`]|\\.)*)`/g, | |
level = 0, | |
match, | |
chunk = chunks[0], | |
inParam; | |
for (var i = 0, c, cc; i < input.length;) { | |
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]); | |
continue; | |
} | |
} | |
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]); | |
continue; | |
} | |
} | |
} | |
} | |
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); | |
} | |
i++; | |
} | |
if (level != 0) { | |
error = new(LessError)({ | |
index: i-1, | |
type: 'Parse', | |
message: (level > 0) ? "missing closing `}`" : "missing opening `{`", | |
filename: env.filename | |
}, env); | |
} | |
return chunks.map(function (c) { return c.join('') });; | |
})([[]]); | |
if (error) { | |
return callback(error, env); | |
} | |
// 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, dumpLineNumbers: env.dumpLineNumbers }); | |
} 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('ycssmin').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 (e) { | |
e = error || e; | |
if (e) callback(e); | |
else callback(null, 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, nameLC, args, alpha_ret, index = i; | |
if (! (name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(chunks[j]))) return; | |
name = name[1]; | |
nameLC = name.toLowerCase(); | |
if (nameLC === 'url') { return null } | |
else { i += name.length } | |
if (nameLC === 'alpha') { | |
alpha_ret = $(this.alpha); | |
if(typeof alpha_ret !== 'undefined') { | |
return alpha_ret; | |
} | |
} | |
$('('); // 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.ratio) || | |
$(this.entities.dimension) || | |
$(this.entities.color) || | |
$(this.entities.quoted) || | |
$(this.entities.unicodeDescriptor); | |
}, | |
// 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) || | |
$(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || ""; | |
expect(')'); | |
return new(tree.URL)((value.value != null || value instanceof tree.Variable) | |
? value : new(tree.Anonymous)(value), env.rootpath); | |
}, | |
// | |
// 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 variable entity useing the protective {} e.g. @{var} | |
variableCurly: function () { | |
var name, curly, index = i; | |
if (input.charAt(i) === '@' && (curly = $(/^@\{([\w-]+)\}/))) { | |
return new(tree.Variable)("@" + curly[1], 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); | |
//Is the first char of the dimension 0-9, '.', '+' or '-' | |
if ((c > 57 || c < 43) || c === 47 || c == 44) return; | |
if (value = $(/^([+-]?\d*\.?\d+)(px|%|em|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn|dpi|dpcm|dppx|rem|vw|vh|vmin|vm|ch)?/)) { | |
return new(tree.Dimension)(value[1], value[2]); | |
} | |
}, | |
// | |
// A Ratio | |
// | |
// 16/9 | |
// | |
ratio: function () { | |
var value, c = input.charCodeAt(i); | |
if (c > 57 || c < 48) return; | |
if (value = $(/^(\d+\/\d+)/)) { | |
return new(tree.Ratio)(value[1]); | |
} | |
}, | |
// | |
// A unicode descriptor, as is used in unicode-range | |
// | |
// U+0?? or U+00A1-00A9 | |
// | |
unicodeDescriptor: function () { | |
var ud; | |
if (ud = $(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/)) { | |
return new(tree.UnicodeDescriptor)(ud[0]); | |
} | |
}, | |
// | |
// 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; | |
save(); | |
if ((a = $(this.entity)) && $('/') && (b = $(this.entity))) { | |
return new(tree.Shorthand)(a, b); | |
} | |
restore(); | |
}, | |
// | |
// 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, argsSemiColon = [], argsComma = [], args, delim, arg, nameLoop, expressions, isSemiColonSeperated, expressionContainsNamed, index = i, s = input.charAt(i), name, value, important = false; | |
if (s !== '.' && s !== '#') { return } | |
save(); // stop us absorbing part of an invalid selector | |
while (e = $(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/)) { | |
elements.push(new(tree.Element)(c, e, i)); | |
c = $('>'); | |
} | |
if ($('(')) { | |
expressions = []; | |
while (arg = $(this.expression)) { | |
nameLoop = null; | |
value = arg; | |
// Variable | |
if (arg.value.length == 1) { | |
var val = arg.value[0]; | |
if (val instanceof tree.Variable) { | |
if ($(':')) { | |
if (expressions.length > 0) { | |
if (isSemiColonSeperated) { | |
error("Cannot mix ; and , as delimiter types"); | |
} | |
expressionContainsNamed = true; | |
} | |
value = expect(this.expression); | |
nameLoop = (name = val.name); | |
} | |
} | |
} | |
expressions.push(value); | |
argsComma.push({ name: nameLoop, value: value }); | |
if ($(',')) { | |
continue; | |
} | |
if ($(';') || isSemiColonSeperated) { | |
if (expressionContainsNamed) { | |
error("Cannot mix ; and , as delimiter types"); | |
} | |
isSemiColonSeperated = true; | |
if (expressions.length > 1) { | |
value = new(tree.Value)(expressions); | |
} | |
argsSemiColon.push({ name: name, value: value }); | |
name = null; | |
expressions = []; | |
expressionContainsNamed = false; | |
} | |
} | |
expect(')'); | |
} | |
args = isSemiColonSeperated ? argsSemiColon : argsComma; | |
if ($(this.important)) { | |
important = true; | |
} | |
if (elements.length > 0 && ($(';') || peek('}'))) { | |
return new(tree.mixin.Call)(elements, args, index, env.filename, important); | |
} | |
restore(); | |
}, | |
// | |
// 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. | |
// | |
definition: function () { | |
var name, params = [], match, ruleset, param, value, cond, variadic = false; | |
if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') || | |
peek(/^[^{]*\}/)) return; | |
save(); | |
if (match = $(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/)) { | |
name = match[1]; | |
do { | |
$(this.comment); | |
if (input.charAt(i) === '.' && $(/^\.{3}/)) { | |
variadic = true; | |
params.push({ variadic: true }); | |
break; | |
} else if (param = $(this.entities.variable) || $(this.entities.literal) | |
|| $(this.entities.keyword)) { | |
// Variable | |
if (param instanceof tree.Variable) { | |
if ($(':')) { | |
value = expect(this.expression, 'expected expression'); | |
params.push({ name: param.name, value: value }); | |
} else if ($(/^\.{3}/)) { | |
params.push({ name: param.name, variadic: true }); | |
variadic = true; | |
break; | |
} else { | |
params.push({ name: param.name }); | |
} | |
} else { | |
params.push({ value: param }); | |
} | |
} else { | |
break; | |
} | |
} while ($(',') || $(';')) | |
// .mixincall("@{a}"); | |
// looks a bit like a mixin definition.. so we have to be nice and restore | |
if (!$(')')) { | |
furthest = i; | |
restore(); | |
} | |
$(this.comment); | |
if ($(/^when/)) { // Guard | |
cond = expect(this.conditions, 'expected condition'); | |
} | |
ruleset = $(this.block); | |
if (ruleset) { | |
return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic); | |
} else { | |
restore(); | |
} | |
} | |
} | |
}, | |
// | |
// Entities are the smallest recognized token, | |
// and can be found inside a rule's value. | |
// | |
entity: function () { | |
return $(this.entities.literal) || $(this.entities.variable) || $(this.entities.url) || | |
$(this.entities.call) || $(this.entities.keyword) ||$(this.entities.javascript) || | |
$(this.comment); | |
}, | |
// | |
// A Rule terminator. Note that we use `peek()` to check for '}', | |
// because the `block` rule will be expecting it, but we still need to make sure | |
// it's there, if ';' was ommitted. | |
// | |
end: function () { | |
return $(';') || peek('}'); | |
}, | |
// | |
// IE's alpha function | |
// | |
// alpha(opacity=88) | |
// | |
alpha: function () { | |
var value; | |
if (! $(/^\(opacity=/i)) return; | |
if (value = $(/^\d+/) || $(this.entities.variable)) { | |
expect(')'); | |
return new(tree.Alpha)(value); | |
} | |
}, | |
// | |
// A Selector Element | |
// | |
// div | |
// + h1 | |
// #socks | |
// input[type="text"] | |
// | |
// Elements are the building blocks for Selectors, | |
// they are made out of a `Combinator` (see combinator rule), | |
// and an element name, such as a tag a class, or `*`. | |
// | |
element: function () { | |
var e, t, c, v; | |
c = $(this.combinator); | |
e = $(/^(?:\d+\.\d+|\d+)%/) || $(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) || | |
$('*') || $('&') || $(this.attribute) || $(/^\([^()@]+\)/) || $(/^[\.#](?=@)/) || $(this.entities.variableCurly); | |
if (! e) { | |
if ($('(')) { | |
if ((v = ($(this.entities.variableCurly) || | |
$(this.entities.variable) || | |
$(this.selector))) && | |
$(')')) { | |
e = new(tree.Paren)(v); | |
} | |
} | |
} | |
if (e) { return new(tree.Element)(c, e, i) } | |
}, | |
// | |
// Combinators combine elements together, in a Selector. | |
// | |
// Because our parser isn't white-space sensitive, special care | |
// has to be taken, when parsing the descendant combinator, ` `, | |
// as it's an empty space. We have to check the previous character | |
// in the input, to see if it's a ` ` character. More info on how | |
// we deal with this in *combinator.js*. | |
// | |
combinator: function () { | |
var match, c = input.charAt(i); | |
if (c === '>' || c === '+' || c === '~' || c === '|') { | |
i++; | |
while (input.charAt(i).match(/\s/)) { i++ } | |
return new(tree.Combinator)(c); | |
} else if (input.charAt(i - 1).match(/\s/)) { | |
return new(tree.Combinator)(" "); | |
} else { | |
return new(tree.Combinator)(null); | |
} | |
}, | |
// | |
// A CSS Selector | |
// | |
// .class > div + h1 | |
// li a:hover | |
// | |
// Selectors are made out of one or more Elements, see above. | |
// | |
selector: function () { | |
var sel, e, elements = [], c, match; | |
// depreciated, will be removed soon | |
if ($('(')) { | |
sel = $(this.entity); | |
if (!$(')')) { return null; } | |
return new(tree.Selector)([new(tree.Element)('', sel, i)]); | |
} | |
while (e = $(this.element)) { | |
c = input.charAt(i); | |
elements.push(e) | |
if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') { break } | |
} | |
if (elements.length > 0) { return new(tree.Selector)(elements) } | |
}, | |
attribute: function () { | |
var attr = '', key, val, op; | |
if (! $('[')) return; | |
if (key = $(/^(?:[_A-Za-z0-9-]|\\.)+/) || $(this.entities.quoted)) { | |
if ((op = $(/^[|~*$^]?=/)) && | |
(val = $(this.entities.quoted) || $(/^[\w-]+/))) { | |
attr = [key, op, val.toCSS ? val.toCSS() : val].join(''); | |
} else { attr = key } | |
} | |
if (! $(']')) return; | |
if (attr) { return "[" + attr + "]" } | |
}, | |
// | |
// The `block` rule is used by `ruleset` and `mixin.definition`. | |
// It's a wrapper around the `primary` rule, with added `{}`. | |
// | |
block: function () { | |
var content; | |
if ($('{') && (content = $(this.primary)) && $('}')) { | |
return content; | |
} | |
}, | |
// | |
// div, .class, body > p {...} | |
// | |
ruleset: function () { | |
var selectors = [], s, rules, match, debugInfo; | |
save(); | |
if (env.dumpLineNumbers) | |
debugInfo = getDebugInfo(i, input, env); | |
while (s = $(this.selector)) { | |
selectors.push(s); | |
$(this.comment); | |
if (! $(',')) { break } | |
$(this.comment); | |
} | |
if (selectors.length > 0 && (rules = $(this.block))) { | |
var ruleset = new(tree.Ruleset)(selectors, rules, env.strictImports); | |
if (env.dumpLineNumbers) | |
ruleset.debugInfo = debugInfo; | |
return ruleset; | |
} else { | |
// Backtrack | |
furthest = i; | |
restore(); | |
} | |
}, | |
rule: function () { | |
var name, value, c = input.charAt(i), important, match; | |
save(); | |
if (c === '.' || c === '#' || c === '&') { return } | |
if (name = $(this.variable) || $(this.property)) { | |
if ((name.charAt(0) != '@') && (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j]))) { | |
i += match[0].length - 1; | |
value = new(tree.Anonymous)(match[1]); | |
} else if (name === "font") { | |
value = $(this.font); | |
} else { | |
value = $(this.value); | |
} | |
important = $(this.important); | |
if (value && $(this.end)) { | |
return new(tree.Rule)(name, value, important, memo); | |
} else { | |
furthest = i; | |
restore(); | |
} | |
} | |
}, | |
// | |
// An @import directive | |
// | |
// @import "lib"; | |
// | |
// Depending on our environemnt, importing is done differently: | |
// In the browser, it's an XHR request, in Node, it would be a | |
// file-system operation. The function used for importing is | |
// stored in `import`, which we pass to the Import constructor. | |
// | |
"import": function () { | |
var path, features, index = i; | |
save(); | |
var dir = $(/^@import(?:-(once))?\s+/); | |
if (dir && (path = $(this.entities.quoted) || $(this.entities.url))) { | |
features = $(this.mediaFeatures); | |
if ($(';')) { | |
return new(tree.Import)(path, imports, features, (dir[1] === 'once'), index, env.rootpath); | |
} | |
} | |
restore(); | |
}, | |
mediaFeature: function () { | |
var e, p, nodes = []; | |
do { | |
if (e = $(this.entities.keyword)) { | |
nodes.push(e); | |
} else if ($('(')) { | |
p = $(this.property); | |
e = $(this.entity); | |
if ($(')')) { | |
if (p && e) { | |
nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, true))); | |
} else if (e) { | |
nodes.push(new(tree.Paren)(e)); | |
} else { | |
return null; | |
} | |
} else { return null } | |
} | |
} while (e); | |
if (nodes.length > 0) { | |
return new(tree.Expression)(nodes); | |
} | |
}, | |
mediaFeatures: function () { | |
var e, features = []; | |
do { | |
if (e = $(this.mediaFeature)) { | |
features.push(e); | |
if (! $(',')) { break } | |
} else if (e = $(this.entities.variable)) { | |
features.push(e); | |
if (! $(',')) { break } | |
} | |
} while (e); | |
return features.length > 0 ? features : null; | |
}, | |
media: function () { | |
var features, rules, media, debugInfo; | |
if (env.dumpLineNumbers) | |
debugInfo = getDebugInfo(i, input, env); | |
if ($(/^@media/)) { | |
features = $(this.mediaFeatures); | |
if (rules = $(this.block)) { | |
media = new(tree.Media)(rules, features); | |
if(env.dumpLineNumbers) | |
media.debugInfo = debugInfo; | |
return media; | |
} | |
} | |
}, | |
// | |
// A CSS Directive | |
// | |
// @charset "utf-8"; | |
// | |
directive: function () { | |
var name, value, rules, identifier, e, nodes, nonVendorSpecificName, | |
hasBlock, hasIdentifier, hasExpression; | |
if (input.charAt(i) !== '@') return; | |
if (value = $(this['import']) || $(this.media)) { | |
return value; | |
} | |
save(); | |
name = $(/^@[a-z-]+/); | |
if (!name) return; | |
nonVendorSpecificName = name; | |
if (name.charAt(1) == '-' && name.indexOf('-', 2) > 0) { | |
nonVendorSpecificName = "@" + name.slice(name.indexOf('-', 2) + 1); | |
} | |
switch(nonVendorSpecificName) { | |
case "@font-face": | |
hasBlock = true; | |
break; | |
case "@viewport": | |
case "@top-left": | |
case "@top-left-corner": | |
case "@top-center": | |
case "@top-right": | |
case "@top-right-corner": | |
case "@bottom-left": | |
case "@bottom-left-corner": | |
case "@bottom-center": | |
case "@bottom-right": | |
case "@bottom-right-corner": | |
case "@left-top": | |
case "@left-middle": | |
case "@left-bottom": | |
case "@right-top": | |
case "@right-middle": | |
case "@right-bottom": | |
hasBlock = true; | |
break; | |
case "@page": | |
case "@document": | |
case "@supports": | |
case "@keyframes": | |
hasBlock = true; | |
hasIdentifier = true; | |
break; | |
case "@namespace": | |
hasExpression = true; | |
break; | |
} | |
if (hasIdentifier) { | |
name += " " + ($(/^[^{]+/) || '').trim(); | |
} | |
if (hasBlock) | |
{ | |
if (rules = $(this.block)) { | |
return new(tree.Directive)(name, rules); | |
} | |
} else { | |
if ((value = hasExpression ? $(this.expression) : $(this.entity)) && $(';')) { | |
var directive = new(tree.Directive)(name, value); | |
if (env.dumpLineNumbers) { | |
directive.debugInfo = getDebugInfo(i, input, env); | |
} | |
return directive; | |
} | |
} | |
restore(); | |
}, | |
font: function () { | |
var value = [], expression = [], weight, shorthand, font, e; | |
while (e = $(this.shorthand) || $(this.entity)) { | |
expression.push(e); | |
} | |
value.push(new(tree.Expression)(expression)); | |
if ($(',')) { | |
while (e = $(this.expression)) { | |
value.push(e); | |
if (! $(',')) { break } | |
} | |
} | |
return new(tree.Value)(value); | |
}, | |
// | |
// A Value is a comma-delimited list of Expressions | |
// | |
// font-family: Baskerville, Georgia, serif; | |
// | |
// In a Rule, a Value represents everything after the `:`, | |
// and before the `;`. | |
// | |
value: function () { | |
var e, expressions = [], important; | |
while (e = $(this.expression)) { | |
expressions.push(e); | |
if (! $(',')) { break } | |
} | |
if (expressions.length > 0) { | |
return new(tree.Value)(expressions); | |
} | |
}, | |
important: function () { | |
if (input.charAt(i) === '!') { | |
return $(/^! *important/); | |
} | |
}, | |
sub: function () { | |
var e; | |
if ($('(') && (e = $(this.expression)) && $(')')) { | |
return e; | |
} | |
}, | |
multiplication: function () { | |
var m, a, op, operation; | |
if (m = $(this.operand)) { | |
while (!peek(/^\/[*\/]/) && (op = ($('/') || $('*'))) && (a = $(this.operand))) { | |
operation = new(tree.Operation)(op, [operation || m, a]); | |
} | |
return operation || m; | |
} | |
}, | |
addition: function () { | |
var m, a, op, operation; | |
if (m = $(this.multiplication)) { | |
while ((op = $(/^[-+]\s+/) || (!isWhitespace(input.charAt(i - 1)) && ($('+') || $('-')))) && | |
(a = $(this.multiplication))) { | |
operation = new(tree.Operation)(op, [operation || m, a]); | |
} | |
return operation || m; | |
} | |
}, | |
conditions: function () { | |
var a, b, index = i, condition; | |
if (a = $(this.condition)) { | |
while ($(',') && (b = $(this.condition))) { | |
condition = new(tree.Condition)('or', condition || a, b, index); | |
} | |
return condition || a; | |
} | |
}, | |
condition: function () { | |
var a, b, c, op, index = i, negate = false; | |
if ($(/^not/)) { negate = true } | |
expect('('); | |
if (a = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) { | |
if (op = $(/^(?:>=|=<|[<=>])/)) { | |
if (b = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) { | |
c = new(tree.Condition)(op, a, b, index, negate); | |
} else { | |
error('expected expression'); | |
} | |
} else { | |
c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate); | |
} | |
expect(')'); | |
return $(/^and/) ? new(tree.Condition)('and', c, $(this.condition)) : c; | |
} | |
}, | |
// | |
// An operand is anything that can be part of an operation, | |
// such as a Color, or a Variable | |
// | |
operand: function () { | |
var negate, p = input.charAt(i + 1); | |
if (input.charAt(i) === '-' && (p === '@' || p === '(')) { negate = $('-') } | |
var o = $(this.sub) || $(this.entities.dimension) || | |
$(this.entities.color) || $(this.entities.variable) || | |
$(this.entities.call); | |
return negate ? new(tree.Operation)('*', [new(tree.Dimension)(-1), o]) | |
: o; | |
}, | |
// | |
// Expressions either represent mathematical operations, | |
// or white-space delimited Entities. | |
// | |
// 1px solid black | |
// @var * 2 | |
// | |
expression: function () { | |
var e, delim, entities = [], d; | |
while (e = $(this.addition) || $(this.entity)) { | |
entities.push(e); | |
} | |
if (entities.length > 0) { | |
return new(tree.Expression)(entities); | |
} | |
}, | |
property: function () { | |
var name; | |
if (name = $(/^(\*?-?[_a-z0-9-]+)\s*:/)) { | |
return name[1]; | |
} | |
} | |
} | |
}; | |
}; | |
if (less.mode === 'browser' || less.mode === 'rhino') { | |
// | |
// Used by `@import` directives | |
// | |
less.Parser.importer = function (path, paths, callback, env) { | |
if (!/^([a-z-]+:)?\//.test(path) && paths.length > 0) { | |
path = paths[0] + path; | |
} | |
// We pass `true` as 3rd argument, to force the reload of the import. | |
// This is so we can get the syntax tree as opposed to just the CSS output, | |
// as we need this to evaluate the current stylesheet. | |
loadStyleSheet({ | |
href: path, | |
title: path, | |
type: env.mime, | |
contents: env.contents, | |
files: env.files, | |
rootpath: env.rootpath, | |
entryPath: env.entryPath, | |
relativeUrls: env.relativeUrls }, | |
function (e, root, data, sheet, _, path) { | |
if (e && typeof(env.errback) === "function") { | |
env.errback.call(null, path, paths, callback, env); | |
} else { | |
callback.call(null, e, root, path); | |
} | |
}, true); | |
}; | |
} | |
(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, 256); }); | |
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; | |
} | |
}, | |
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), '%'); | |
}, | |
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((0.2126 * (color.rgb[0]/255) + | |
0.7152 * (color.rgb[1]/255) + | |
0.0722 * (color.rgb[2]/255)) * | |
color.alpha * 100), '%'); | |
}, | |
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) { | |
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); | |
} | |
if (typeof threshold === 'undefined') { | |
threshold = 0.43; | |
} else { | |
threshold = threshold.value; | |
} | |
if (((0.2126 * (color.rgb[0]/255) + 0.7152 * (color.rgb[1]/255) + 0.0722 * (color.rgb[2]/255)) * color.alpha) < 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++) { | |
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) { | |
return new(tree.Dimension)(val.value, unit ? unit.toCSS() : ""); | |
}, | |
round: function (n, f) { | |
var fraction = typeof(f) === "undefined" ? 0 : f.value; | |
return this._math(function(num) { return num.toFixed(fraction); }, n); | |
}, | |
ceil: function (n) { | |
return this._math(Math.ceil, n); | |
}, | |
floor: function (n) { | |
return this._math(Math.floor, n); | |
}, | |
_math: function (fn, n) { | |
if (n instanceof tree.Dimension) { | |
return new(tree.Dimension)(fn(parseFloat(n.value)), n.unit); | |
} else if (typeof(n) === 'number') { | |
return 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; | |
}, | |
/* Blending modes */ | |
multiply: function(color1, color2) { | |
var r = color1.rgb[0] * color2.rgb[0] / 255; | |
var g = color1.rgb[1] * color2.rgb[1] / 255; | |
var b = color1.rgb[2] * color2.rgb[2] / 255; | |
return this.rgb(r, g, b); | |
}, | |
screen: function(color1, color2) { | |
var r = 255 - (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255; | |
var g = 255 - (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255; | |
var b = 255 - (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255; | |
return this.rgb(r, g, b); | |
}, | |
overlay: function(color1, color2) { | |
var r = color1.rgb[0] < 128 ? 2 * color1.rgb[0] * color2.rgb[0] / 255 : 255 - 2 * (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255; | |
var g = color1.rgb[1] < 128 ? 2 * color1.rgb[1] * color2.rgb[1] / 255 : 255 - 2 * (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255; | |
var b = color1.rgb[2] < 128 ? 2 * color1.rgb[2] * color2.rgb[2] / 255 : 255 - 2 * (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255; | |
return this.rgb(r, g, b); | |
}, | |
softlight: function(color1, color2) { | |
var t = color2.rgb[0] * color1.rgb[0] / 255; | |
var r = t + color1.rgb[0] * (255 - (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255 - t) / 255; | |
t = color2.rgb[1] * color1.rgb[1] / 255; | |
var g = t + color1.rgb[1] * (255 - (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255 - t) / 255; | |
t = color2.rgb[2] * color1.rgb[2] / 255; | |
var b = t + color1.rgb[2] * (255 - (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255 - t) / 255; | |
return this.rgb(r, g, b); | |
}, | |
hardlight: function(color1, color2) { | |
var r = color2.rgb[0] < 128 ? 2 * color2.rgb[0] * color1.rgb[0] / 255 : 255 - 2 * (255 - color2.rgb[0]) * (255 - color1.rgb[0]) / 255; | |
var g = color2.rgb[1] < 128 ? 2 * color2.rgb[1] * color1.rgb[1] / 255 : 255 - 2 * (255 - color2.rgb[1]) * (255 - color1.rgb[1]) / 255; | |
var b = color2.rgb[2] < 128 ? 2 * color2.rgb[2] * color1.rgb[2] / 255 : 255 - 2 * (255 - color2.rgb[2]) * (255 - color1.rgb[2]) / 255; | |
return this.rgb(r, g, b); | |
}, | |
difference: function(color1, color2) { | |
var r = Math.abs(color1.rgb[0] - color2.rgb[0]); | |
var g = Math.abs(color1.rgb[1] - color2.rgb[1]); | |
var b = Math.abs(color1.rgb[2] - color2.rgb[2]); | |
return this.rgb(r, g, b); | |
}, | |
exclusion: function(color1, color2) { | |
var r = color1.rgb[0] + color2.rgb[0] * (255 - color1.rgb[0] - color1.rgb[0]) / 255; | |
var g = color1.rgb[1] + color2.rgb[1] * (255 - color1.rgb[1] - color1.rgb[1]) / 255; | |
var b = color1.rgb[2] + color2.rgb[2] * (255 - color1.rgb[2] - color1.rgb[2]) / 255; | |
return this.rgb(r, g, b); | |
}, | |
average: function(color1, color2) { | |
var r = (color1.rgb[0] + color2.rgb[0]) / 2; | |
var g = (color1.rgb[1] + color2.rgb[1]) / 2; | |
var b = (color1.rgb[2] + color2.rgb[2]) / 2; | |
return this.rgb(r, g, b); | |
}, | |
negation: function(color1, color2) { | |
var r = 255 - Math.abs(255 - color2.rgb[0] - color1.rgb[0]); | |
var g = 255 - Math.abs(255 - color2.rgb[1] - color1.rgb[1]); | |
var b = 255 - Math.abs(255 - color2.rgb[2] - color1.rgb[2]); | |
return this.rgb(r, g, b); | |
}, | |
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); | |
} | |
}; | |
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 == '%') { | |
return parseFloat(n.value * size / 100); | |
} else { | |
return number(n); | |
} | |
} | |
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')); | |
(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')); | |
(function (tree) { | |
tree.Alpha = function (val) { | |
this.value = val; | |
}; | |
tree.Alpha.prototype = { | |
toCSS: function () { | |
return "alpha(opacity=" + | |
(this.value.toCSS ? this.value.toCSS() : this.value) + ")"; | |
}, | |
eval: function (env) { | |
if (this.value.eval) { this.value = this.value.eval(env) } | |
return this; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Anonymous = function (string) { | |
this.value = string.value || string; | |
}; | |
tree.Anonymous.prototype = { | |
toCSS: function () { | |
return this.value; | |
}, | |
eval: function () { return this }, | |
compare: function (x) { | |
if (!x.toCSS) { | |
return -1; | |
} | |
var left = this.toCSS(), | |
right = x.toCSS(); | |
if (left === right) { | |
return 0; | |
} | |
return left < right ? -1 : 1; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Assignment = function (key, val) { | |
this.key = key; | |
this.value = val; | |
}; | |
tree.Assignment.prototype = { | |
toCSS: function () { | |
return this.key + '=' + (this.value.toCSS ? this.value.toCSS() : this.value); | |
}, | |
eval: function (env) { | |
if (this.value.eval) { | |
return new(tree.Assignment)(this.key, this.value.eval(env)); | |
} | |
return this; | |
} | |
}; | |
})(require('../tree'));(function (tree) { | |
// | |
// A function call node. | |
// | |
tree.Call = function (name, args, index, filename) { | |
this.name = name; | |
this.args = args; | |
this.index = index; | |
this.filename = filename; | |
}; | |
tree.Call.prototype = { | |
// | |
// When evaluating a function call, | |
// we either find the function in `tree.functions` [1], | |
// in which case we call it, passing the evaluated arguments, | |
// if this returns null or we cannot find the function, we | |
// simply print it out as it appeared originally [2]. | |
// | |
// The *functions.js* file contains the built-in functions. | |
// | |
// The reason why we evaluate the arguments, is in the case where | |
// we try to pass a variable to a function, like: `saturate(@color)`. | |
// The function should receive the value, not the variable. | |
// | |
eval: function (env) { | |
var args = this.args.map(function (a) { return a.eval(env) }), | |
result; | |
if (this.name in tree.functions) { // 1. | |
try { | |
result = tree.functions[this.name].apply(tree.functions, args); | |
if (result != null) { | |
return result; | |
} | |
} catch (e) { | |
throw { type: e.type || "Runtime", | |
message: "error evaluating function `" + this.name + "`" + | |
(e.message ? ': ' + e.message : ''), | |
index: this.index, filename: this.filename }; | |
} | |
} | |
// 2. | |
return new(tree.Anonymous)(this.name + | |
"(" + args.map(function (a) { return a.toCSS(env) }).join(', ') + ")"); | |
}, | |
toCSS: function (env) { | |
return this.eval(env).toCSS(); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
// | |
// RGB Colors - #ff0014, #eee | |
// | |
tree.Color = function (rgb, a) { | |
// | |
// The end goal here, is to parse the arguments | |
// into an integer triplet, such as `128, 255, 0` | |
// | |
// This facilitates operations and conversions. | |
// | |
if (Array.isArray(rgb)) { | |
this.rgb = rgb; | |
} else if (rgb.length == 6) { | |
this.rgb = rgb.match(/.{2}/g).map(function (c) { | |
return parseInt(c, 16); | |
}); | |
} else { | |
this.rgb = rgb.split('').map(function (c) { | |
return parseInt(c + c, 16); | |
}); | |
} | |
this.alpha = typeof(a) === 'number' ? a : 1; | |
}; | |
tree.Color.prototype = { | |
eval: function () { return this }, | |
// | |
// If we have some transparency, the only way to represent it | |
// is via `rgba`. Otherwise, we use the hex representation, | |
// which has better compatibility with older browsers. | |
// Values are capped between `0` and `255`, rounded and zero-padded. | |
// | |
toCSS: function () { | |
if (this.alpha < 1.0) { | |
return "rgba(" + this.rgb.map(function (c) { | |
return Math.round(c); | |
}).concat(this.alpha).join(', ') + ")"; | |
} else { | |
return '#' + this.rgb.map(function (i) { | |
i = Math.round(i); | |
i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16); | |
return i.length === 1 ? '0' + i : i; | |
}).join(''); | |
} | |
}, | |
// | |
// Operations have to be done per-channel, if not, | |
// channels will spill onto each other. Once we have | |
// our result, in the form of an integer triplet, | |
// we create a new Color node to hold the result. | |
// | |
operate: function (op, other) { | |
var result = []; | |
if (! (other instanceof tree.Color)) { | |
other = other.toColor(); | |
} | |
for (var c = 0; c < 3; c++) { | |
result[c] = tree.operate(op, this.rgb[c], other.rgb[c]); | |
} | |
return new(tree.Color)(result, this.alpha + other.alpha); | |
}, | |
toHSL: function () { | |
var r = this.rgb[0] / 255, | |
g = this.rgb[1] / 255, | |
b = this.rgb[2] / 255, | |
a = this.alpha; | |
var max = Math.max(r, g, b), min = Math.min(r, g, b); | |
var h, s, l = (max + min) / 2, d = max - min; | |
if (max === min) { | |
h = s = 0; | |
} else { | |
s = l > 0.5 ? d / (2 - max - min) : d / (max + min); | |
switch (max) { | |
case r: h = (g - b) / d + (g < b ? 6 : 0); break; | |
case g: h = (b - r) / d + 2; break; | |
case b: h = (r - g) / d + 4; break; | |
} | |
h /= 6; | |
} | |
return { h: h * 360, s: s, l: l, a: a }; | |
}, | |
toARGB: function () { | |
var argb = [Math.round(this.alpha * 255)].concat(this.rgb); | |
return '#' + argb.map(function (i) { | |
i = Math.round(i); | |
i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16); | |
return i.length === 1 ? '0' + i : i; | |
}).join(''); | |
}, | |
compare: function (x) { | |
if (!x.rgb) { | |
return -1; | |
} | |
return (x.rgb[0] === this.rgb[0] && | |
x.rgb[1] === this.rgb[1] && | |
x.rgb[2] === this.rgb[2] && | |
x.alpha === this.alpha) ? 0 : -1; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Comment = function (value, silent) { | |
this.value = value; | |
this.silent = !!silent; | |
}; | |
tree.Comment.prototype = { | |
toCSS: function (env) { | |
return env.compress ? '' : this.value; | |
}, | |
eval: function () { return this } | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Condition = function (op, l, r, i, negate) { | |
this.op = op.trim(); | |
this.lvalue = l; | |
this.rvalue = r; | |
this.index = i; | |
this.negate = negate; | |
}; | |
tree.Condition.prototype.eval = function (env) { | |
var a = this.lvalue.eval(env), | |
b = this.rvalue.eval(env); | |
var i = this.index, result; | |
var result = (function (op) { | |
switch (op) { | |
case 'and': | |
return a && b; | |
case 'or': | |
return a || b; | |
default: | |
if (a.compare) { | |
result = a.compare(b); | |
} else if (b.compare) { | |
result = b.compare(a); | |
} else { | |
throw { type: "Type", | |
message: "Unable to perform comparison", | |
index: i }; | |
} | |
switch (result) { | |
case -1: return op === '<' || op === '=<'; | |
case 0: return op === '=' || op === '>=' || op === '=<'; | |
case 1: return op === '>' || op === '>='; | |
} | |
} | |
})(this.op); | |
return this.negate ? !result : result; | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
// | |
// A number with a unit | |
// | |
tree.Dimension = function (value, unit) { | |
this.value = parseFloat(value); | |
this.unit = unit || null; | |
}; | |
tree.Dimension.prototype = { | |
eval: function () { return this }, | |
toColor: function () { | |
return new(tree.Color)([this.value, this.value, this.value]); | |
}, | |
toCSS: function () { | |
var css = this.value + this.unit; | |
return css; | |
}, | |
// In an operation between two Dimensions, | |
// we default to the first Dimension's unit, | |
// so `1px + 2em` will yield `3px`. | |
// In the future, we could implement some unit | |
// conversions such that `100cm + 10mm` would yield | |
// `101cm`. | |
operate: function (op, other) { | |
return new(tree.Dimension) | |
(tree.operate(op, this.value, other.value), | |
this.unit || other.unit); | |
}, | |
compare: function (other) { | |
if (other instanceof tree.Dimension) { | |
if (other.value > this.value) { | |
return -1; | |
} else if (other.value < this.value) { | |
return 1; | |
} else { | |
if (other.unit && this.unit !== other.unit) { | |
return -1; | |
} | |
return 0; | |
} | |
} else { | |
return -1; | |
} | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Directive = function (name, value) { | |
this.name = name; | |
if (Array.isArray(value)) { | |
this.ruleset = new(tree.Ruleset)([], value); | |
this.ruleset.allowImports = true; | |
} else { | |
this.value = value; | |
} | |
}; | |
tree.Directive.prototype = { | |
toCSS: function (ctx, env) { | |
if (this.ruleset) { | |
this.ruleset.root = true; | |
return this.name + (env.compress ? '{' : ' {\n ') + | |
this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n ') + | |
(env.compress ? '}': '\n}\n'); | |
} else { | |
return this.name + ' ' + this.value.toCSS() + ';\n'; | |
} | |
}, | |
eval: function (env) { | |
var evaldDirective = this; | |
if (this.ruleset) { | |
env.frames.unshift(this); | |
evaldDirective = new(tree.Directive)(this.name); | |
evaldDirective.ruleset = this.ruleset.eval(env); | |
env.frames.shift(); | |
} | |
return evaldDirective; | |
}, | |
variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) }, | |
find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) }, | |
rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) } | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Element = function (combinator, value, index) { | |
this.combinator = combinator instanceof tree.Combinator ? | |
combinator : new(tree.Combinator)(combinator); | |
if (typeof(value) === 'string') { | |
this.value = value.trim(); | |
} else if (value) { | |
this.value = value; | |
} else { | |
this.value = ""; | |
} | |
this.index = index; | |
}; | |
tree.Element.prototype.eval = function (env) { | |
return new(tree.Element)(this.combinator, | |
this.value.eval ? this.value.eval(env) : this.value, | |
this.index); | |
}; | |
tree.Element.prototype.toCSS = function (env) { | |
var value = (this.value.toCSS ? this.value.toCSS(env) : this.value); | |
if (value == '' && this.combinator.value.charAt(0) == '&') { | |
return ''; | |
} else { | |
return this.combinator.toCSS(env || {}) + value; | |
} | |
}; | |
tree.Combinator = function (value) { | |
if (value === ' ') { | |
this.value = ' '; | |
} else { | |
this.value = value ? value.trim() : ""; | |
} | |
}; | |
tree.Combinator.prototype.toCSS = function (env) { | |
return { | |
'' : '', | |
' ' : ' ', | |
':' : ' :', | |
'+' : env.compress ? '+' : ' + ', | |
'~' : env.compress ? '~' : ' ~ ', | |
'>' : env.compress ? '>' : ' > ', | |
'|' : env.compress ? '|' : ' | ' | |
}[this.value]; | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Expression = function (value) { this.value = value }; | |
tree.Expression.prototype = { | |
eval: function (env) { | |
if (this.value.length > 1) { | |
return new(tree.Expression)(this.value.map(function (e) { | |
return e.eval(env); | |
})); | |
} else if (this.value.length === 1) { | |
return this.value[0].eval(env); | |
} else { | |
return this; | |
} | |
}, | |
toCSS: function (env) { | |
return this.value.map(function (e) { | |
return e.toCSS ? e.toCSS(env) : ''; | |
}).join(' '); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
// | |
// CSS @import node | |
// | |
// The general strategy here is that we don't want to wait | |
// for the parsing to be completed, before we start importing | |
// the file. That's because in the context of a browser, | |
// most of the time will be spent waiting for the server to respond. | |
// | |
// On creation, we push the import path to our import queue, though | |
// `import,push`, we also pass it a callback, which it'll call once | |
// the file has been fetched, and parsed. | |
// | |
tree.Import = function (path, imports, features, once, index, rootpath) { | |
var that = this; | |
this.once = once; | |
this.index = index; | |
this._path = path; | |
this.features = features && new(tree.Value)(features); | |
this.rootpath = rootpath; | |
// The '.less' extension is optional | |
if (path instanceof tree.Quoted) { | |
this.path = /(\.[a-z]*$)|([\?;].*)$/.test(path.value) ? path.value : path.value + '.less'; | |
} else { | |
this.path = path.value.value || path.value; | |
} | |
this.css = /css([\?;].*)?$/.test(this.path); | |
// Only pre-compile .less files | |
if (! this.css) { | |
imports.push(this.path, function (e, root, imported) { | |
if (e) { e.index = index } | |
if (imported && that.once) that.skip = imported; | |
that.root = root || new(tree.Ruleset)([], []); | |
}); | |
} | |
}; | |
// | |
// The actual import node doesn't return anything, when converted to CSS. | |
// The reason is that it's used at the evaluation stage, so that the rules | |
// it imports can be treated like any other rules. | |
// | |
// In `eval`, we make sure all Import nodes get evaluated, recursively, so | |
// we end up with a flat structure, which can easily be imported in the parent | |
// ruleset. | |
// | |
tree.Import.prototype = { | |
toCSS: function (env) { | |
var features = this.features ? ' ' + this.features.toCSS(env) : ''; | |
if (this.css) { | |
// Add the base path if the import is relative | |
if (typeof this._path.value === "string" && !/^(?:[a-z-]+:|\/)/.test(this._path.value)) { | |
this._path.value = this.rootpath + this._path.value; | |
} | |
return "@import " + this._path.toCSS() + features + ';\n'; | |
} else { | |
return ""; | |
} | |
}, | |
eval: function (env) { | |
var ruleset, features = this.features && this.features.eval(env); | |
if (this.skip) return []; | |
if (this.css) { | |
return this; | |
} else { | |
ruleset = new(tree.Ruleset)([], this.root.rules.slice(0)); | |
ruleset.evalImports(env); | |
return this.features ? new(tree.Media)(ruleset.rules, this.features.value) : ruleset.rules; | |
} | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.JavaScript = function (string, index, escaped) { | |
this.escaped = escaped; | |
this.expression = string; | |
this.index = index; | |
}; | |
tree.JavaScript.prototype = { | |
eval: function (env) { | |
var result, | |
that = this, | |
context = {}; | |
var expression = this.expression.replace(/@\{([\w-]+)\}/g, function (_, name) { | |
return tree.jsify(new(tree.Variable)('@' + name, that.index).eval(env)); | |
}); | |
try { | |
expression = new(Function)('return (' + expression + ')'); | |
} catch (e) { | |
throw { message: "JavaScript evaluation error: `" + expression + "`" , | |
index: this.index }; | |
} | |
for (var k in env.frames[0].variables()) { | |
context[k.slice(1)] = { | |
value: env.frames[0].variables()[k].value, | |
toJS: function () { | |
return this.value.eval(env).toCSS(); | |
} | |
}; | |
} | |
try { | |
result = expression.call(context); | |
} catch (e) { | |
throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message + "'" , | |
index: this.index }; | |
} | |
if (typeof(result) === 'string') { | |
return new(tree.Quoted)('"' + result + '"', result, this.escaped, this.index); | |
} else if (Array.isArray(result)) { | |
return new(tree.Anonymous)(result.join(', ')); | |
} else { | |
return new(tree.Anonymous)(result); | |
} | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Keyword = function (value) { this.value = value }; | |
tree.Keyword.prototype = { | |
eval: function () { return this }, | |
toCSS: function () { return this.value }, | |
compare: function (other) { | |
if (other instanceof tree.Keyword) { | |
return other.value === this.value ? 0 : 1; | |
} else { | |
return -1; | |
} | |
} | |
}; | |
tree.True = new(tree.Keyword)('true'); | |
tree.False = new(tree.Keyword)('false'); | |
})(require('../tree')); | |
(function (tree) { | |
tree.Media = function (value, features) { | |
var selectors = this.emptySelectors(); | |
this.features = new(tree.Value)(features); | |
this.ruleset = new(tree.Ruleset)(selectors, value); | |
this.ruleset.allowImports = true; | |
}; | |
tree.Media.prototype = { | |
toCSS: function (ctx, env) { | |
var features = this.features.toCSS(env); | |
this.ruleset.root = (ctx.length === 0 || ctx[0].multiMedia); | |
return '@media ' + features + (env.compress ? '{' : ' {\n ') + | |
this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n ') + | |
(env.compress ? '}': '\n}\n'); | |
}, | |
eval: function (env) { | |
if (!env.mediaBlocks) { | |
env.mediaBlocks = []; | |
env.mediaPath = []; | |
} | |
var media = new(tree.Media)([], []); | |
if(this.debugInfo) { | |
this.ruleset.debugInfo = this.debugInfo; | |
media.debugInfo = this.debugInfo; | |
} | |
media.features = this.features.eval(env); | |
env.mediaPath.push(media); | |
env.mediaBlocks.push(media); | |
env.frames.unshift(this.ruleset); | |
media.ruleset = this.ruleset.eval(env); | |
env.frames.shift(); | |
env.mediaPath.pop(); | |
return env.mediaPath.length === 0 ? media.evalTop(env) : | |
media.evalNested(env) | |
}, | |
variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) }, | |
find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) }, | |
rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) }, | |
emptySelectors: function() { | |
var el = new(tree.Element)('', '&', 0); | |
return [new(tree.Selector)([el])]; | |
}, | |
evalTop: function (env) { | |
var result = this; | |
// Render all dependent Media blocks. | |
if (env.mediaBlocks.length > 1) { | |
var selectors = this.emptySelectors(); | |
result = new(tree.Ruleset)(selectors, env.mediaBlocks); | |
result.multiMedia = true; | |
} | |
delete env.mediaBlocks; | |
delete env.mediaPath; | |
return result; | |
}, | |
evalNested: function (env) { | |
var i, value, | |
path = env.mediaPath.concat([this]); | |
// Extract the media-query conditions separated with `,` (OR). | |
for (i = 0; i < path.length; i++) { | |
value = path[i].features instanceof tree.Value ? | |
path[i].features.value : path[i].features; | |
path[i] = Array.isArray(value) ? value : [value]; | |
} | |
// Trace all permutations to generate the resulting media-query. | |
// | |
// (a, b and c) with nested (d, e) -> | |
// a and d | |
// a and e | |
// b and c and d | |
// b and c and e | |
this.features = new(tree.Value)(this.permute(path).map(function (path) { | |
path = path.map(function (fragment) { | |
return fragment.toCSS ? fragment : new(tree.Anonymous)(fragment); | |
}); | |
for(i = path.length - 1; i > 0; i--) { | |
path.splice(i, 0, new(tree.Anonymous)("and")); | |
} | |
return new(tree.Expression)(path); | |
})); | |
// Fake a tree-node that doesn't output anything. | |
return new(tree.Ruleset)([], []); | |
}, | |
permute: function (arr) { | |
if (arr.length === 0) { | |
return []; | |
} else if (arr.length === 1) { | |
return arr[0]; | |
} else { | |
var result = []; | |
var rest = this.permute(arr.slice(1)); | |
for (var i = 0; i < rest.length; i++) { | |
for (var j = 0; j < arr[0].length; j++) { | |
result.push([arr[0][j]].concat(rest[i])); | |
} | |
} | |
return result; | |
} | |
}, | |
bubbleSelectors: function (selectors) { | |
this.ruleset = new(tree.Ruleset)(selectors.slice(0), [this.ruleset]); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.mixin = {}; | |
tree.mixin.Call = function (elements, args, index, filename, important) { | |
this.selector = new(tree.Selector)(elements); | |
this.arguments = args; | |
this.index = index; | |
this.filename = filename; | |
this.important = important; | |
}; | |
tree.mixin.Call.prototype = { | |
eval: function (env) { | |
var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound; | |
args = this.arguments && this.arguments.map(function (a) { | |
return { name: a.name, value: a.value.eval(env) }; | |
}); | |
for (i = 0; i < env.frames.length; i++) { | |
if ((mixins = env.frames[i].find(this.selector)).length > 0) { | |
isOneFound = true; | |
for (m = 0; m < mixins.length; m++) { | |
mixin = mixins[m]; | |
isRecursive = false; | |
for(f = 0; f < env.frames.length; f++) { | |
if ((!(mixin instanceof tree.mixin.Definition)) && mixin === (env.frames[f].originalRuleset || env.frames[f])) { | |
isRecursive = true; | |
break; | |
} | |
} | |
if (isRecursive) { | |
continue; | |
} | |
if (mixin.matchArgs(args, env)) { | |
if (!mixin.matchCondition || mixin.matchCondition(args, env)) { | |
try { | |
Array.prototype.push.apply( | |
rules, mixin.eval(env, args, this.important).rules); | |
} catch (e) { | |
throw { message: e.message, index: this.index, filename: this.filename, stack: e.stack }; | |
} | |
} | |
match = true; | |
} | |
} | |
if (match) { | |
return rules; | |
} | |
} | |
} | |
if (isOneFound) { | |
throw { type: 'Runtime', | |
message: 'No matching definition was found for `' + | |
this.selector.toCSS().trim() + '(' + | |
(args ? args.map(function (a) { | |
var argValue = ""; | |
if (a.name) { | |
argValue += a.name + ":"; | |
} | |
if (a.value.toCSS) { | |
argValue += a.value.toCSS(); | |
} else { | |
argValue += "???"; | |
} | |
return argValue; | |
}).join(', ') : "") + ")`", | |
index: this.index, filename: this.filename }; | |
} else { | |
throw { type: 'Name', | |
message: this.selector.toCSS().trim() + " is undefined", | |
index: this.index, filename: this.filename }; | |
} | |
} | |
}; | |
tree.mixin.Definition = function (name, params, rules, condition, variadic) { | |
this.name = name; | |
this.selectors = [new(tree.Selector)([new(tree.Element)(null, name)])]; | |
this.params = params; | |
this.condition = condition; | |
this.variadic = variadic; | |
this.arity = params.length; | |
this.rules = rules; | |
this._lookups = {}; | |
this.required = params.reduce(function (count, p) { | |
if (!p.name || (p.name && !p.value)) { return count + 1 } | |
else { return count } | |
}, 0); | |
this.parent = tree.Ruleset.prototype; | |
this.frames = []; | |
}; | |
tree.mixin.Definition.prototype = { | |
toCSS: function () { return "" }, | |
variable: function (name) { return this.parent.variable.call(this, name) }, | |
variables: function () { return this.parent.variables.call(this) }, | |
find: function () { return this.parent.find.apply(this, arguments) }, | |
rulesets: function () { return this.parent.rulesets.apply(this) }, | |
evalParams: function (env, mixinEnv, args, evaldArguments) { | |
var frame = new(tree.Ruleset)(null, []), varargs, arg, params = this.params.slice(0), i, j, val, name, isNamedFound, argIndex; | |
if (args) { | |
args = args.slice(0); | |
for(i = 0; i < args.length; i++) { | |
arg = args[i]; | |
if (name = (arg && arg.name)) { | |
isNamedFound = false; | |
for(j = 0; j < params.length; j++) { | |
if (!evaldArguments[j] && name === params[j].name) { | |
evaldArguments[j] = arg.value.eval(env); | |
frame.rules.unshift(new(tree.Rule)(name, arg.value.eval(env))); | |
isNamedFound = true; | |
break; | |
} | |
} | |
if (isNamedFound) { | |
args.splice(i, 1); | |
i--; | |
continue; | |
} else { | |
throw { type: 'Runtime', message: "Named argument for " + this.name + | |
' ' + args[i].name + ' not found' }; | |
} | |
} | |
} | |
} | |
argIndex = 0; | |
for (i = 0; i < params.length; i++) { | |
if (evaldArguments[i]) continue; | |
arg = args && args[argIndex]; | |
if (name = params[i].name) { | |
if (params[i].variadic && args) { | |
varargs = []; | |
for (j = argIndex; j < args.length; j++) { | |
varargs.push(args[j].value.eval(env)); | |
} | |
frame.rules.unshift(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env))); | |
} else { | |
val = arg && arg.value; | |
if (val) { | |
val = val.eval(env); | |
} else if (params[i].value) { | |
val = params[i].value.eval(mixinEnv); | |
} else { | |
throw { type: 'Runtime', message: "wrong number of arguments for " + this.name + | |
' (' + args.length + ' for ' + this.arity + ')' }; | |
} | |
frame.rules.unshift(new(tree.Rule)(name, val)); | |
evaldArguments[i] = val; | |
} | |
} | |
if (params[i].variadic && args) { | |
for (j = argIndex; j < args.length; j++) { | |
evaldArguments[j] = args[j].value.eval(env); | |
} | |
} | |
argIndex++; | |
} | |
return frame; | |
}, | |
eval: function (env, args, important) { | |
var _arguments = [], | |
mixinFrames = this.frames.concat(env.frames), | |
frame = this.evalParams(env, {frames: mixinFrames}, args, _arguments), | |
context, rules, start, ruleset; | |
frame.rules.unshift(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env))); | |
rules = important ? | |
this.parent.makeImportant.apply(this).rules : this.rules.slice(0); | |
ruleset = new(tree.Ruleset)(null, rules).eval({ | |
frames: [this, frame].concat(mixinFrames) | |
}); | |
ruleset.originalRuleset = this; | |
return ruleset; | |
}, | |
matchCondition: function (args, env) { | |
if (this.condition && !this.condition.eval({ | |
frames: [this.evalParams(env, {frames: this.frames.concat(env.frames)}, args, [])].concat(env.frames) | |
})) { return false } | |
return true; | |
}, | |
matchArgs: function (args, env) { | |
var argsLength = (args && args.length) || 0, len, frame; | |
if (! this.variadic) { | |
if (argsLength < this.required) { return false } | |
if (argsLength > this.params.length) { return false } | |
if ((this.required > 0) && (argsLength > this.params.length)) { return false } | |
} | |
len = Math.min(argsLength, this.arity); | |
for (var i = 0; i < len; i++) { | |
if (!this.params[i].name && !this.params[i].variadic) { | |
if (args[i].value.eval(env).toCSS() != this.params[i].value.eval(env).toCSS()) { | |
return false; | |
} | |
} | |
} | |
return true; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Operation = function (op, operands) { | |
this.op = op.trim(); | |
this.operands = operands; | |
}; | |
tree.Operation.prototype.eval = function (env) { | |
var a = this.operands[0].eval(env), | |
b = this.operands[1].eval(env), | |
temp; | |
if (a instanceof tree.Dimension && b instanceof tree.Color) { | |
if (this.op === '*' || this.op === '+') { | |
temp = b, b = a, a = temp; | |
} else { | |
throw { name: "OperationError", | |
message: "Can't substract or divide a color from a number" }; | |
} | |
} | |
if (!a.operate) { | |
throw { name: "OperationError", | |
message: "Operation on an invalid type" }; | |
} | |
return a.operate(this.op, b); | |
}; | |
tree.operate = function (op, a, b) { | |
switch (op) { | |
case '+': return a + b; | |
case '-': return a - b; | |
case '*': return a * b; | |
case '/': return a / b; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Paren = function (node) { | |
this.value = node; | |
}; | |
tree.Paren.prototype = { | |
toCSS: function (env) { | |
return '(' + this.value.toCSS(env) + ')'; | |
}, | |
eval: function (env) { | |
return new(tree.Paren)(this.value.eval(env)); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Quoted = function (str, content, escaped, i) { | |
this.escaped = escaped; | |
this.value = content || ''; | |
this.quote = str.charAt(0); | |
this.index = i; | |
}; | |
tree.Quoted.prototype = { | |
toCSS: function () { | |
if (this.escaped) { | |
return this.value; | |
} else { | |
return this.quote + this.value + this.quote; | |
} | |
}, | |
eval: function (env) { | |
var that = this; | |
var value = this.value.replace(/`([^`]+)`/g, function (_, exp) { | |
return new(tree.JavaScript)(exp, that.index, true).eval(env).value; | |
}).replace(/@\{([\w-]+)\}/g, function (_, name) { | |
var v = new(tree.Variable)('@' + name, that.index).eval(env); | |
return (v instanceof tree.Quoted) ? v.value : v.toCSS(); | |
}); | |
return new(tree.Quoted)(this.quote + value + this.quote, value, this.escaped, this.index); | |
}, | |
compare: function (x) { | |
if (!x.toCSS) { | |
return -1; | |
} | |
var left = this.toCSS(), | |
right = x.toCSS(); | |
if (left === right) { | |
return 0; | |
} | |
return left < right ? -1 : 1; | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Ratio = function (value) { | |
this.value = value; | |
}; | |
tree.Ratio.prototype = { | |
toCSS: function (env) { | |
return this.value; | |
}, | |
eval: function () { return this } | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Rule = function (name, value, important, index, inline) { | |
this.name = name; | |
this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]); | |
this.important = important ? ' ' + important.trim() : ''; | |
this.index = index; | |
this.inline = inline || false; | |
if (name.charAt(0) === '@') { | |
this.variable = true; | |
} else { this.variable = false } | |
}; | |
tree.Rule.prototype.toCSS = function (env) { | |
if (this.variable) { return "" } | |
else { | |
return this.name + (env.compress ? ':' : ': ') + | |
this.value.toCSS(env) + | |
this.important + (this.inline ? "" : ";"); | |
} | |
}; | |
tree.Rule.prototype.eval = function (context) { | |
return new(tree.Rule)(this.name, | |
this.value.eval(context), | |
this.important, | |
this.index, this.inline); | |
}; | |
tree.Rule.prototype.makeImportant = function () { | |
return new(tree.Rule)(this.name, | |
this.value, | |
"!important", | |
this.index, this.inline); | |
}; | |
tree.Shorthand = function (a, b) { | |
this.a = a; | |
this.b = b; | |
}; | |
tree.Shorthand.prototype = { | |
toCSS: function (env) { | |
return this.a.toCSS(env) + "/" + this.b.toCSS(env); | |
}, | |
eval: function () { return this } | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Ruleset = function (selectors, rules, strictImports) { | |
this.selectors = selectors; | |
this.rules = rules; | |
this._lookups = {}; | |
this.strictImports = strictImports; | |
}; | |
tree.Ruleset.prototype = { | |
eval: function (env) { | |
var selectors = this.selectors && this.selectors.map(function (s) { return s.eval(env) }); | |
var ruleset = new(tree.Ruleset)(selectors, this.rules.slice(0), this.strictImports); | |
var rules; | |
ruleset.originalRuleset = this; | |
ruleset.root = this.root; | |
ruleset.allowImports = this.allowImports; | |
if(this.debugInfo) { | |
ruleset.debugInfo = this.debugInfo; | |
} | |
// push the current ruleset to the frames stack | |
env.frames.unshift(ruleset); | |
// Evaluate imports | |
if (ruleset.root || ruleset.allowImports || !ruleset.strictImports) { | |
ruleset.evalImports(env); | |
} | |
// Store the frames around mixin definitions, | |
// so they can be evaluated like closures when the time comes. | |
for (var i = 0; i < ruleset.rules.length; i++) { | |
if (ruleset.rules[i] instanceof tree.mixin.Definition) { | |
ruleset.rules[i].frames = env.frames.slice(0); | |
} | |
} | |
var mediaBlockCount = (env.mediaBlocks && env.mediaBlocks.length) || 0; | |
// Evaluate mixin calls. | |
for (var i = 0; i < ruleset.rules.length; i++) { | |
if (ruleset.rules[i] instanceof tree.mixin.Call) { | |
rules = ruleset.rules[i].eval(env); | |
ruleset.rules.splice.apply(ruleset.rules, [i, 1].concat(rules)); | |
i += rules.length-1; | |
ruleset.resetCache(); | |
} | |
} | |
// Evaluate everything else | |
for (var i = 0, rule; i < ruleset.rules.length; i++) { | |
rule = ruleset.rules[i]; | |
if (! (rule instanceof tree.mixin.Definition)) { | |
ruleset.rules[i] = rule.eval ? rule.eval(env) : rule; | |
} | |
} | |
// Pop the stack | |
env.frames.shift(); | |
if (env.mediaBlocks) { | |
for(var i = mediaBlockCount; i < env.mediaBlocks.length; i++) { | |
env.mediaBlocks[i].bubbleSelectors(selectors); | |
} | |
} | |
return ruleset; | |
}, | |
evalImports: function(env) { | |
var i, rules; | |
for (i = 0; i < this.rules.length; i++) { | |
if (this.rules[i] instanceof tree.Import) { | |
rules = this.rules[i].eval(env); | |
if (typeof rules.length === "number") { | |
this.rules.splice.apply(this.rules, [i, 1].concat(rules)); | |
i+= rules.length-1; | |
} else { | |
this.rules.splice(i, 1, rules); | |
} | |
this.resetCache(); | |
} | |
} | |
}, | |
makeImportant: function() { | |
return new tree.Ruleset(this.selectors, this.rules.map(function (r) { | |
if (r.makeImportant) { | |
return r.makeImportant(); | |
} else { | |
return r; | |
} | |
}), this.strictImports); | |
}, | |
matchArgs: function (args) { | |
return !args || args.length === 0; | |
}, | |
resetCache: function () { | |
this._rulesets = null; | |
this._variables = null; | |
this._lookups = {}; | |
}, | |
variables: function () { | |
if (this._variables) { return this._variables } | |
else { | |
return this._variables = this.rules.reduce(function (hash, r) { | |
if (r instanceof tree.Rule && r.variable === true) { | |
hash[r.name] = r; | |
} | |
return hash; | |
}, {}); | |
} | |
}, | |
variable: function (name) { | |
return this.variables()[name]; | |
}, | |
rulesets: function () { | |
if (this._rulesets) { return this._rulesets } | |
else { | |
return this._rulesets = this.rules.filter(function (r) { | |
return (r instanceof tree.Ruleset) || (r instanceof tree.mixin.Definition); | |
}); | |
} | |
}, | |
find: function (selector, self) { | |
self = self || this; | |
var rules = [], rule, match, | |
key = selector.toCSS(); | |
if (key in this._lookups) { return this._lookups[key] } | |
this.rulesets().forEach(function (rule) { | |
if (rule !== self) { | |
for (var j = 0; j < rule.selectors.length; j++) { | |
if (match = selector.match(rule.selectors[j])) { | |
if (selector.elements.length > rule.selectors[j].elements.length) { | |
Array.prototype.push.apply(rules, rule.find( | |
new(tree.Selector)(selector.elements.slice(1)), self)); | |
} else { | |
rules.push(rule); | |
} | |
break; | |
} | |
} | |
} | |
}); | |
return this._lookups[key] = rules; | |
}, | |
// | |
// Entry point for code generation | |
// | |
// `context` holds an array of arrays. | |
// | |
toCSS: function (context, env) { | |
var css = [], // The CSS output | |
rules = [], // node.Rule instances | |
_rules = [], // | |
rulesets = [], // node.Ruleset instances | |
paths = [], // Current selectors | |
selector, // The fully rendered selector | |
debugInfo, // Line number debugging | |
rule; | |
if (! this.root) { | |
this.joinSelectors(paths, context, this.selectors); | |
} | |
// Compile rules and rulesets | |
for (var i = 0; i < this.rules.length; i++) { | |
rule = this.rules[i]; | |
if (rule.rules || (rule instanceof tree.Media)) { | |
rulesets.push(rule.toCSS(paths, env)); | |
} else if (rule instanceof tree.Directive) { | |
var cssValue = rule.toCSS(paths, env); | |
// Output only the first @charset definition as such - convert the others | |
// to comments in case debug is enabled | |
if (rule.name === "@charset") { | |
// Only output the debug info together with subsequent @charset definitions | |
// a comment (or @media statement) before the actual @charset directive would | |
// be considered illegal css as it has to be on the first line | |
if (env.charset) { | |
if (rule.debugInfo) { | |
rulesets.push(tree.debugInfo(env, rule)); | |
rulesets.push(new tree.Comment("/* "+cssValue.replace(/\n/g, "")+" */\n").toCSS(env)); | |
} | |
continue; | |
} | |
env.charset = true; | |
} | |
rulesets.push(cssValue); | |
} else if (rule instanceof tree.Comment) { | |
if (!rule.silent) { | |
if (this.root) { | |
rulesets.push(rule.toCSS(env)); | |
} else { | |
rules.push(rule.toCSS(env)); | |
} | |
} | |
} else { | |
if (rule.toCSS && !rule.variable) { | |
rules.push(rule.toCSS(env)); | |
} else if (rule.value && !rule.variable) { | |
rules.push(rule.value.toString()); | |
} | |
} | |
} | |
rulesets = rulesets.join(''); | |
// If this is the root node, we don't render | |
// a selector, or {}. | |
// Otherwise, only output if this ruleset has rules. | |
if (this.root) { | |
css.push(rules.join(env.compress ? '' : '\n')); | |
} else { | |
if (rules.length > 0) { | |
debugInfo = tree.debugInfo(env, this); | |
selector = paths.map(function (p) { | |
return p.map(function (s) { | |
return s.toCSS(env); | |
}).join('').trim(); | |
}).join(env.compress ? ',' : ',\n'); | |
// Remove duplicates | |
for (var i = rules.length - 1; i >= 0; i--) { | |
if (_rules.indexOf(rules[i]) === -1) { | |
_rules.unshift(rules[i]); | |
} | |
} | |
rules = _rules; | |
css.push(debugInfo + selector + | |
(env.compress ? '{' : ' {\n ') + | |
rules.join(env.compress ? '' : '\n ') + | |
(env.compress ? '}' : '\n}\n')); | |
} | |
} | |
css.push(rulesets); | |
return css.join('') + (env.compress ? '\n' : ''); | |
}, | |
joinSelectors: function (paths, context, selectors) { | |
for (var s = 0; s < selectors.length; s++) { | |
this.joinSelector(paths, context, selectors[s]); | |
} | |
}, | |
joinSelector: function (paths, context, selector) { | |
var i, j, k, | |
hasParentSelector, newSelectors, el, sel, parentSel, | |
newSelectorPath, afterParentJoin, newJoinedSelector, | |
newJoinedSelectorEmpty, lastSelector, currentElements, | |
selectorsMultiplied; | |
for (i = 0; i < selector.elements.length; i++) { | |
el = selector.elements[i]; | |
if (el.value === '&') { | |
hasParentSelector = true; | |
} | |
} | |
if (!hasParentSelector) { | |
if (context.length > 0) { | |
for(i = 0; i < context.length; i++) { | |
paths.push(context[i].concat(selector)); | |
} | |
} | |
else { | |
paths.push([selector]); | |
} | |
return; | |
} | |
// The paths are [[Selector]] | |
// The first list is a list of comma seperated selectors | |
// The inner list is a list of inheritance seperated selectors | |
// e.g. | |
// .a, .b { | |
// .c { | |
// } | |
// } | |
// == [[.a] [.c]] [[.b] [.c]] | |
// | |
// the elements from the current selector so far | |
currentElements = []; | |
// the current list of new selectors to add to the path. | |
// We will build it up. We initiate it with one empty selector as we "multiply" the new selectors | |
// by the parents | |
newSelectors = [[]]; | |
for (i = 0; i < selector.elements.length; i++) { | |
el = selector.elements[i]; | |
// non parent reference elements just get added | |
if (el.value !== "&") { | |
currentElements.push(el); | |
} else { | |
// the new list of selectors to add | |
selectorsMultiplied = []; | |
// merge the current list of non parent selector elements | |
// on to the current list of selectors to add | |
if (currentElements.length > 0) { | |
this.mergeElementsOnToSelectors(currentElements, newSelectors); | |
} | |
// loop through our current selectors | |
for(j = 0; j < newSelectors.length; j++) { | |
sel = newSelectors[j]; | |
// if we don't have any parent paths, the & might be in a mixin so that it can be used | |
// whether there are parents or not | |
if (context.length == 0) { | |
// the combinator used on el should now be applied to the next element instead so that | |
// it is not lost | |
if (sel.length > 0) { | |
sel[0].elements = sel[0].elements.slice(0); | |
sel[0].elements.push(new(tree.Element)(el.combinator, '', 0)); //new Element(el.Combinator, "")); | |
} | |
selectorsMultiplied.push(sel); | |
} | |
else { | |
// and the parent selectors | |
for(k = 0; k < context.length; k++) { | |
parentSel = context[k]; | |
// We need to put the current selectors | |
// then join the last selector's elements on to the parents selectors | |
// our new selector path | |
newSelectorPath = []; | |
// selectors from the parent after the join | |
afterParentJoin = []; | |
newJoinedSelectorEmpty = true; | |
//construct the joined selector - if & is the first thing this will be empty, | |
// if not newJoinedSelector will be the last set of elements in the selector | |
if (sel.length > 0) { | |
newSelectorPath = sel.slice(0); | |
lastSelector = newSelectorPath.pop(); | |
newJoinedSelector = new(tree.Selector)(lastSelector.elements.slice(0)); | |
newJoinedSelectorEmpty = false; | |
} | |
else { | |
newJoinedSelector = new(tree.Selector)([]); | |
} | |
//put together the parent selectors after the join | |
if (parentSel.length > 1) { | |
afterParentJoin = afterParentJoin.concat(parentSel.slice(1)); | |
} | |
if (parentSel.length > 0) { | |
newJoinedSelectorEmpty = false; | |
// join the elements so far with the first part of the parent | |
newJoinedSelector.elements.push(new(tree.Element)(el.combinator, parentSel[0].elements[0].value, 0)); | |
newJoinedSelector.elements = newJoinedSelector.elements.concat(parentSel[0].elements.slice(1)); | |
} | |
if (!newJoinedSelectorEmpty) { | |
// now add the joined selector | |
newSelectorPath.push(newJoinedSelector); | |
} | |
// and the rest of the parent | |
newSelectorPath = newSelectorPath.concat(afterParentJoin); | |
// add that to our new set of selectors | |
selectorsMultiplied.push(newSelectorPath); | |
} | |
} | |
} | |
// our new selectors has been multiplied, so reset the state | |
newSelectors = selectorsMultiplied; | |
currentElements = []; | |
} | |
} | |
// if we have any elements left over (e.g. .a& .b == .b) | |
// add them on to all the current selectors | |
if (currentElements.length > 0) { | |
this.mergeElementsOnToSelectors(currentElements, newSelectors); | |
} | |
for(i = 0; i < newSelectors.length; i++) { | |
paths.push(newSelectors[i]); | |
} | |
}, | |
mergeElementsOnToSelectors: function(elements, selectors) { | |
var i, sel; | |
if (selectors.length == 0) { | |
selectors.push([ new(tree.Selector)(elements) ]); | |
return; | |
} | |
for(i = 0; i < selectors.length; i++) { | |
sel = selectors[i]; | |
// if the previous thing in sel is a parent this needs to join on to it | |
if (sel.length > 0) { | |
sel[sel.length - 1] = new(tree.Selector)(sel[sel.length - 1].elements.concat(elements)); | |
} | |
else { | |
sel.push(new(tree.Selector)(elements)); | |
} | |
} | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Selector = function (elements) { | |
this.elements = elements; | |
}; | |
tree.Selector.prototype.match = function (other) { | |
var elements = this.elements, | |
len = elements.length, | |
oelements, olen, max, i; | |
oelements = other.elements.slice( | |
(other.elements.length && other.elements[0].value === "&") ? 1 : 0); | |
olen = oelements.length; | |
max = Math.min(len, olen) | |
if (olen === 0 || len < olen) { | |
return false; | |
} else { | |
for (i = 0; i < max; i++) { | |
if (elements[i].value !== oelements[i].value) { | |
return false; | |
} | |
} | |
} | |
return true; | |
}; | |
tree.Selector.prototype.eval = function (env) { | |
return new(tree.Selector)(this.elements.map(function (e) { | |
return e.eval(env); | |
})); | |
}; | |
tree.Selector.prototype.toCSS = function (env) { | |
if (this._css) { return this._css } | |
if (this.elements[0].combinator.value === "") { | |
this._css = ' '; | |
} else { | |
this._css = ''; | |
} | |
this._css += this.elements.map(function (e) { | |
if (typeof(e) === 'string') { | |
return ' ' + e.trim(); | |
} else { | |
return e.toCSS(env); | |
} | |
}).join(''); | |
return this._css; | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.UnicodeDescriptor = function (value) { | |
this.value = value; | |
}; | |
tree.UnicodeDescriptor.prototype = { | |
toCSS: function (env) { | |
return this.value; | |
}, | |
eval: function () { return this } | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.URL = function (val, rootpath) { | |
this.value = val; | |
this.rootpath = rootpath; | |
}; | |
tree.URL.prototype = { | |
toCSS: function () { | |
return "url(" + this.value.toCSS() + ")"; | |
}, | |
eval: function (ctx) { | |
var val = this.value.eval(ctx), rootpath; | |
// Add the base path if the URL is relative | |
if (typeof val.value === "string" && !/^(?:[a-z-]+:|\/)/.test(val.value)) { | |
rootpath = this.rootpath; | |
if (!val.quote) { | |
rootpath = rootpath.replace(/[\(\)'"\s]/g, function(match) { return "\\"+match; }); | |
} | |
val.value = rootpath + val.value; | |
} | |
return new(tree.URL)(val, this.rootpath); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Value = function (value) { | |
this.value = value; | |
this.is = 'value'; | |
}; | |
tree.Value.prototype = { | |
eval: function (env) { | |
if (this.value.length === 1) { | |
return this.value[0].eval(env); | |
} else { | |
return new(tree.Value)(this.value.map(function (v) { | |
return v.eval(env); | |
})); | |
} | |
}, | |
toCSS: function (env) { | |
return this.value.map(function (e) { | |
return e.toCSS(env); | |
}).join(env.compress ? ',' : ', '); | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.Variable = function (name, index, file) { this.name = name, this.index = index, this.file = file }; | |
tree.Variable.prototype = { | |
eval: function (env) { | |
var variable, v, name = this.name; | |
if (name.indexOf('@@') == 0) { | |
name = '@' + new(tree.Variable)(name.slice(1)).eval(env).value; | |
} | |
if (this.evaluating) { | |
throw { type: 'Name', | |
message: "Recursive variable definition for " + name, | |
filename: this.file, | |
index: this.index }; | |
} | |
this.evaluating = true; | |
if (variable = tree.find(env.frames, function (frame) { | |
if (v = frame.variable(name)) { | |
return v.value.eval(env); | |
} | |
})) { | |
this.evaluating = false; | |
return variable; | |
} | |
else { | |
throw { type: 'Name', | |
message: "variable " + name + " is undefined", | |
filename: this.file, | |
index: this.index }; | |
} | |
} | |
}; | |
})(require('../tree')); | |
(function (tree) { | |
tree.debugInfo = function(env, ctx) { | |
var result=""; | |
if (env.dumpLineNumbers && !env.compress) { | |
switch(env.dumpLineNumbers) { | |
case 'comments': | |
result = tree.debugInfo.asComment(ctx); | |
break; | |
case 'mediaquery': | |
result = tree.debugInfo.asMediaQuery(ctx); | |
break; | |
case 'all': | |
result = tree.debugInfo.asComment(ctx)+tree.debugInfo.asMediaQuery(ctx); | |
break; | |
} | |
} | |
return result; | |
}; | |
tree.debugInfo.asComment = function(ctx) { | |
return '/* line ' + ctx.debugInfo.lineNumber + ', ' + ctx.debugInfo.fileName + ' */\n'; | |
}; | |
tree.debugInfo.asMediaQuery = function(ctx) { | |
return '@media -sass-debug-info{filename{font-family:' + | |
('file://' + ctx.debugInfo.fileName).replace(/[\/:.]/g, '\\$&') + | |
'}line{font-family:\\00003' + ctx.debugInfo.lineNumber + '}}\n'; | |
}; | |
tree.find = function (obj, fun) { | |
for (var i = 0, r; i < obj.length; i++) { | |
if (r = fun.call(obj, obj[i])) { return r } | |
} | |
return null; | |
}; | |
tree.jsify = function (obj) { | |
if (Array.isArray(obj.value) && (obj.value.length > 1)) { | |
return '[' + obj.value.map(function (v) { return v.toCSS(false) }).join(', ') + ']'; | |
} else { | |
return obj.toCSS(false); | |
} | |
}; | |
})(require('./tree')); | |
// | |
// browser.js - client-side engine | |
// | |
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.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 = 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]; | |
} | |
// | |
// Watch mode | |
// | |
less.watch = function () { | |
if (!less.watchMode ){ | |
less.env = 'development'; | |
initRunningMode(); | |
} | |
return this.watchMode = true | |
}; | |
less.unwatch = function () {clearInterval(less.watchTimer); return this.watchMode = false; }; | |
function initRunningMode(){ | |
if (less.env === 'development') { | |
less.optimization = 0; | |
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; | |
} | |
} | |
if (/!watch/.test(location.hash)) { | |
less.watch(); | |
} | |
var cache = null; | |
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'); | |
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]); | |
} | |
} | |
// | |
// With this function, it's possible to alter variables and re-render | |
// CSS without reloading less-files | |
// | |
var session_cache = ''; | |
less.modifyVars = function(record) { | |
var str = session_cache; | |
for (name in record) { | |
str += ((name.slice(0,1) === '@')? '' : '@') + name +': '+ | |
((record[name].slice(-1) === ';')? record[name] : record[name] +';'); | |
} | |
new(less.Parser)().parse(str, function (e, root) { | |
createCSS(root.toCSS(), less.sheets[less.sheets.length - 1]); | |
}); | |
}; | |
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)({ | |
filename: document.location.href.replace(/#.*$/, ''), | |
dumpLineNumbers: less.dumpLineNumbers | |
}).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) { | |
less.roots = []; //zoki | |
for (var i = 0; i < less.sheets.length; i++) { | |
loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1)); | |
} | |
} | |
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 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-]+:)?\/\/(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/, | |
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] = baseUrlParts[1]; | |
if (!urlParts[2]) { | |
urlParts[3] = baseUrlParts[3] + urlParts[3]; | |
} | |
} | |
if (urlParts[3]) { | |
directories = urlParts[3].replace("\\", "/").split("/"); | |
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 loadStyleSheet(sheet, callback, reload, remaining) { | |
// sheet may be set to the stylesheet for the initial load or a collection of properties including | |
// some env variables for imports | |
var contents = sheet.contents || {}; | |
var files = sheet.files || {}; | |
var hrefParts = extractUrlParts(sheet.href, window.location.href); | |
var href = hrefParts.url; | |
var css = cache && cache.getItem(href); | |
var timestamp = cache && cache.getItem(href + ':timestamp'); | |
var styles = { css: css, timestamp: timestamp }; | |
var rootpath; | |
if (less.relativeUrls) { | |
if (less.rootpath) { | |
if (sheet.entryPath) { | |
rootpath = extractUrlParts(less.rootpath + pathDiff(hrefParts.path, sheet.entryPath)).path; | |
} else { | |
rootpath = less.rootpath; | |
} | |
} else { | |
rootpath = hrefParts.path; | |
} | |
} else { | |
if (less.rootpath) { | |
rootpath = less.rootpath; | |
} else { | |
if (sheet.entryPath) { | |
rootpath = sheet.entryPath; | |
} else { | |
rootpath = hrefParts.path; | |
} | |
} | |
} | |
xhr(href, sheet.type, function (data, lastModified) { | |
// Store data this session | |
session_cache += data.replace(/@import .+?;/ig, ''); | |
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 }, href); | |
} else { | |
// Use remote copy (re-parse) | |
try { | |
contents[href] = data; // Updating top importing parser content cache | |
new(less.Parser)({ | |
optimization: less.optimization, | |
paths: [hrefParts.path], | |
entryPath: sheet.entryPath || hrefParts.path, | |
mime: sheet.type, | |
filename: href, | |
rootpath: rootpath, | |
relativeUrls: sheet.relativeUrls, | |
contents: contents, // Passing top importing parser content cache ref down. | |
files: files, | |
dumpLineNumbers: less.dumpLineNumbers | |
}).parse(data, function (e, root) { | |
if (e) { return error(e, href) } | |
try { | |
less.roots.push({root: root, sheet : sheet}); //zoki | |
callback(e, root, data, sheet, { local: false, lastModified: lastModified, remaining: remaining }, href); | |
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(/\.[a-zA-Z]+$/, '' ) // Remove simple 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 || ''; | |
// 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'; | |
if( sheet.media ){ css.media = sheet.media; } | |
css.id = id; | |
var nextEl = sheet && sheet.nextSibling || null; | |
(nextEl || document.getElementsByTagName('head')[0]).parentNode.insertBefore(css, nextEl); | |
} | |
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.'); | |
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'); | |
} | |
} | |
} | |
function xhr(url, type, callback, errback) { | |
var xhr = getXMLHttpRequest(); | |
var async = isFileProtocol ? less.fileAsync : 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 && !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 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; | |
var filenameNoPath = filename.match(/([^\/]+(\?.*)?)$/)[1]; | |
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 + '">' + filenameNoPath + "</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); | |
} | |
} | |
// amd.js | |
// | |
// Define Less as an AMD module. | |
if (typeof define === "function" && define.amd) { | |
define("less", [], function () { return less; } ); | |
} | |
})(window); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/************** LESS modifyVars 1.3 *************** | |
Copyright (c) 2012, Zoran Kenda | |
Licensed under the Apache 2.0 License. | |
Modified version of less.js is required. I tried to keep modifications at minumum to ensure future versions compatibility. | |
Modifications in less.js (v.1.3): | |
--- | |
function loadStyleSheets(callback, reload) { | |
less.roots = []; //modification 1 ln 3224 | |
--- | |
function loadStyleSheet( | |
... | |
}).parse(data, function (e, root) { | |
if (e) { return error(e, href) } | |
try { | |
less.roots.push({root: root, sheet : sheet}); //modification 2 ln:3267 <--- | |
Usage: | |
var modifications= { | |
"@baseRotation": function(){ | |
index+=3; | |
return index; | |
}, | |
"@headerColor": "#08c", | |
"@footerColor":{value:"spin(@headerColor,150 + @baseRotation)",type:"expression"}, | |
"@focusImage":"focus1.png?a.h=@{baseRotation}" | |
} | |
less.modify(modifications); | |
************************************************/ | |
(function (window, undefined) { | |
if(!less){ console.log("Less.js not loaded. exiting"); return; } | |
less.modify = function(modifications){ | |
if(!less.roots || less.roots.length==0) | |
less.refresh(true); | |
if(!less.roots) { console.log("less.roots is null. Are you using an unmodified version of less.js?"); return; } | |
for(var i = 0;i<less.roots.length;i++){ | |
var modified = false; | |
var rootInfo = less.roots[i]; | |
var root = rootInfo.root; | |
var sheet = rootInfo.sheet; | |
for(var name in modifications){ | |
var variable = root.variable(name); | |
var valx = null; | |
if(variable && variable.value){ | |
var value = modifications[name]; | |
var type = typeof value; | |
if(type === "function"){ | |
value = value(); | |
var type = typeof value; | |
} //zanalasc ni else | |
if(typeof value ==="object" && value.value && value.type){ | |
type = value.type; | |
value = value.value; | |
} | |
console.log("modifiing var "+name +" value: "+value); | |
try{ | |
//valx = variable.value.eval(); | |
if(type =="number"){ | |
variable.value = getDimension(value); | |
modified = true; | |
} else if((type=="color" || (type == "string" && value.length>0)) && value.charAt(0)=="#"){ //barva je | |
variable.value = getColor(value); | |
modified = true; | |
} else if(type=="expression"){ | |
new( less.Parser)().parse("@tempExpr:"+value+";",function(e,f){ | |
variable.value = f.variable("@tempExpr").value; | |
}); | |
modified = true; | |
} | |
else if(type =="string"){ //barva je | |
variable.value = getLiteral(value); | |
modified = true; | |
} | |
else{ | |
console.log("ni rbg, ni number, ni literal"); | |
} | |
}catch(e){ | |
console.log(e); | |
} | |
console.log("modified var "+name); | |
} | |
} | |
if(modified) | |
createCSS(root.toCSS(), sheet); | |
} | |
} | |
/* values to expressions */ | |
function getValue(val){ | |
return new(less.tree.Value)([new(less.tree.Expression)([val])]); | |
} | |
function getDimension(val){ | |
return getValue(new(less.tree.Dimension)(val)); | |
} | |
function getColor(val){ | |
var rgb; | |
if ( (val.charAt(0) === '#') && (rgb = (/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})/).exec(val)) ) { | |
val = rgb[1]; | |
} | |
return getValue(new(less.tree.Color)(val)); | |
} | |
function getLiteral(val){ | |
return getValue(new(less.tree.Quoted)("'",val,false)); | |
} | |
/******************* Slightly modified functions taken from less.js ***************/ | |
//copied from less.js and modified a little (removed cache update code) | |
function createCSS(styles, sheet) { | |
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)); | |
} | |
} | |
//copied from less.js 1.3 | |
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) | |
} | |
})(window); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
@color1: #f00; | |
@color2: #f90; | |
@font-face { | |
font-family: 'PFSquareSansProRegular'; | |
src: url('/res/font/pfsquaresanspro-regular-webfont.eot'); | |
src: url('/res/font/pfsquaresanspro-regular-webfont.eot?#iefix') format('embedded-opentype'), | |
url('/res/font/pfsquaresanspro-regular-webfont.woff') format('woff'), | |
url('/res/font/pfsquaresanspro-regular-webfont.ttf') format('truetype'), | |
url('/res/font/pfsquaresanspro-regular-webfont.svg#PFSquareSansProRegular') format('svg'); | |
font-weight: normal; | |
font-style: normal; | |
} | |
@font-face { | |
font-family: 'PFSquareSansProBold'; | |
src: url('/res/font/pfsquaresanspro-bold-webfont.eot'); | |
src: url('/res/font/pfsquaresanspro-bold-webfont.eot?#iefix') format('embedded-opentype'), | |
url('/res/font/pfsquaresanspro-bold-webfont.woff') format('woff'), | |
url('/res/font/pfsquaresanspro-bold-webfont.ttf') format('truetype'), | |
url('/res/font/pfsquaresanspro-bold-webfont.svg#PFSquareSansProBold') format('svg'); | |
font-weight: normal; | |
font-style: normal; | |
} | |
@font-face { | |
font-family: 'PFSquareSansProRegular'; | |
src: url('/res/font/pfsquaresanspro-regular-webfont.eot'); | |
src: url('/res/font/pfsquaresanspro-regular-webfont.eot?#iefix') format('embedded-opentype'), | |
url('/res/font/pfsquaresanspro-regular-webfont.woff') format('woff'), | |
url('/res/font/pfsquaresanspro-regular-webfont.ttf') format('truetype'), | |
url('/res/font/pfsquaresanspro-regular-webfont.svg#PFSquareSansProRegular') format('svg'); | |
font-weight: normal; | |
font-style: normal; | |
} | |
@font-face { | |
font-family: 'PFSquareSansProMedium'; | |
src: url('/res/font/pfsquaresanspro-medium-webfont.eot'); | |
src: url('/res/font/pfsquaresanspro-medium-webfont.eot?#iefix') format('embedded-opentype'), | |
url('/res/font/pfsquaresanspro-medium-webfont.woff') format('woff'), | |
url('/res/font/pfsquaresanspro-medium-webfont.ttf') format('truetype'), | |
url('/res/font/pfsquaresanspro-medium-webfont.svg#PFSquareSansProMedium') format('svg'); | |
font-weight: normal; | |
font-style: normal; | |
} | |
@font-face { | |
font-family: 'PFSquareSansProLight'; | |
src: url('/res/font/pfsquaresanspro-light-webfont.eot'); | |
src: url('/res/font/pfsquaresanspro-light-webfont.eot?#iefix') format('embedded-opentype'), | |
url('/res/font/pfsquaresanspro-light-webfont.woff') format('woff'), | |
url('/res/font/pfsquaresanspro-light-webfont.ttf') format('truetype'), | |
url('/res/font/pfsquaresanspro-light-webfont.svg#PFSquareSansProLight') format('svg'); | |
font-weight: normal; | |
font-style: normal; | |
} | |
body { | |
background: @color1; | |
color: @color2; | |
font-family: Arial; | |
font-size: 12px; | |
} | |
td { | |
vertical-align: top; | |
} | |
input { | |
outline: none; | |
} | |
.hideMe { | |
display: none !important; | |
} | |
.sprite { | |
background: @color1 url(/res/img/sprite-box.png) 0px 0px no-repeat; | |
position: relative; | |
} | |
.tu-main { | |
position: relative; | |
width: 960px; | |
margin: 10px auto; | |
&.uploading { | |
.big-btn { | |
display: none; | |
} | |
.uploading-cover { | |
display: block; | |
} | |
.progress-track { | |
display: block; | |
} | |
} | |
a { | |
text-decoration: none; | |
outline: none; | |
color: #00baf2; | |
&:hover { | |
text-decoration: underline; | |
} | |
} | |
h2 { | |
color: #00baf2; | |
font-weight: normal; | |
font-family: 'PFSquareSansProRegular','Arial','sans-serif'; | |
font-size: 26px; | |
line-height: 26px; | |
margin: 0px 0px 10px 0px; | |
} | |
h3 { | |
color: @color1; | |
font-size: 18px; | |
font-weight: normal; | |
font-family: 'PFSquareSansProRegular','Arial','sans-serif'; | |
margin: 4px 0px 10px 0px; | |
} | |
p { | |
color: #676f6c; | |
font-family: 'PFSquareSansProRegular','Arial','sans-serif'; | |
font-size: 13px; | |
line-height: 18px; | |
padding-bottom: 6px; | |
} | |
.mail_laptop { | |
text-align: center; | |
margin: 40px 0px 0px 0px; | |
} | |
.thanx-mail { | |
p { | |
font-size: 15px; | |
line-height: 20px; | |
} | |
} | |
.uploading-cover { | |
display: none; | |
position: absolute; | |
top: 0px; | |
left: 0px; | |
right: 0px; | |
bottom: 0px; | |
z-index: 999; | |
//background: url(/res/img/uploading-cover.png); | |
background: url(/res/img/_.gif); | |
} | |
} | |
.box-gradient { | |
position: relative; | |
padding: 22px; | |
margin-bottom: 18px; | |
&.box-intro { | |
padding-bottom: 200px; | |
a { | |
font-style: italic; | |
} | |
.box-content { | |
padding: 25px; | |
p.intro-text-1 { | |
width: 560px; | |
padding-bottom: 18px; | |
font-size: 15px; | |
line-height: 20px; | |
} | |
p.intro-text-2 { | |
width: 620px; | |
padding-bottom: 18px; | |
font-size: 15px; | |
line-height: 20px; | |
} | |
} | |
} | |
&.box-form { | |
.box-content { | |
padding: 21px; | |
} | |
} | |
.box-tl, .box-tr, | |
.box-bl, .box-br, | |
.box-tm, .box-bm { | |
background: url(/res/img/sprite-box.png) 0px 0px no-repeat; | |
position: absolute; | |
height: 43px; | |
} | |
.box-tl {width: 44px; top: 0px; left: 0px; background-position: 0px 0px;} | |
.box-tr {width: 44px; top: 0px; right: 0px; background-position: -44px 0px;} | |
.box-bl {width: 44px; bottom: 0px; left: 0px; background-position: 0px -43px;} | |
.box-br {width: 44px; bottom: 0px; right: 0px; background-position: -44px -43px;} | |
.box-tm {top: 0px; left: 44px; right: 44px; background-repeat: repeat-x; background-position: 0px -86px;} | |
.box-bm {bottom: 0px; left: 44px; right: 44px; background-repeat: repeat-x; background-position: 0px -129px;} | |
.box-ml, .box-mr { | |
background: url(/res/img/sprite-box_hrzn.png) 0px 0px repeat-y; | |
position: absolute; | |
} | |
.box-ml {top: 43px; bottom: 43px; left: 0px; width: 44px; background-position: 0px 0px;} | |
.box-mr {top: 43px; bottom: 43px; right: 0px; width: 44px; background-position: -44px 0px;} | |
.box-content { | |
//background: #fff; | |
position: relative; | |
min-height: 42px; | |
z-index: 2; | |
} | |
} | |
.how-does-it-work { | |
background: url(/res/img/how-does-it-work.png) 50% 0px no-repeat; | |
position: absolute; | |
bottom: 0px; | |
left: 0px; | |
right: 0px; | |
height: 196px; | |
.how-desc { | |
position: absolute; | |
top: 120px; | |
left: 0px; | |
width: 160px; | |
color: #787878; | |
text-align: center; | |
font-family: 'PFSquareSansProMedium','Arial','sans-serif'; | |
font-size: 12px; | |
line-height: 16px; | |
&.how-step-1 {left: 19px;} | |
&.how-step-2 {left: 211px;} | |
&.how-step-3 {left: 402px;} | |
&.how-step-4 {left: 596px;} | |
&.how-step-5 {left: 785px;} | |
} | |
} | |
.help { | |
display: inline-block; | |
position: relative; | |
top: 4px; | |
width: 20px; | |
height: 20px; | |
margin-left: 4px; | |
background-position: -58px -304px; | |
cursor: help; | |
&.over { | |
.box-bubble { | |
display: block; | |
} | |
} | |
.box-bubble { | |
display: none; | |
position: absolute; | |
top: -24px; | |
left: 100%; | |
margin-left: 18px; | |
z-index: 12; | |
.box-content { | |
background: #fff; | |
position: relative; | |
display: block; | |
width: 100px; | |
padding: 3px 9px 6px 6px; | |
margin: 9px 9px 9px 9px; | |
text-align: left; | |
font-family: Arial; | |
font-size: 10px; | |
line-height: 15px; | |
color: #666; | |
} | |
.box-arrow, | |
.box-tl, .box-tr, | |
.box-bl, .box-br, | |
.box-tm, .box-bm { | |
background: url(/res/img/sprite-box.png) 0px 0px no-repeat; | |
position: absolute; | |
height: 11px; | |
} | |
.box-tl {width: 9px; top: 0px; left: 0px; background-position: 0px -304px;} | |
.box-tr {width: 11px; top: 0px; right: 0px; background-position: -9px -304px;} | |
.box-bl {width: 9px; bottom: 0px; left: 0px; background-position: 0px -315px;} | |
.box-br {width: 11px; bottom: 0px; right: 0px; background-position: -9px -315px;} | |
.box-tm {top: 0px; left: 9px; right: 11px; background-repeat: repeat-x; background-position: 0px -326px;} | |
.box-bm {bottom: 0px; left: 9px; right: 11px; background-repeat: repeat-x; background-position: 0px -337px;} | |
.box-ml {top: 11px; bottom: 11px; left: 0px; width: 9px; background-position: -88px 0px;} | |
.box-mr {top: 11px; bottom: 11px; right: 0px; width: 9px; background-position: -99px 0px;} | |
.box-arrow {top: 20px; left: -11px; width: 13px; height: 28px; background-position: -66px -220px;} | |
} | |
} | |
.btn_delRow { | |
display: none; | |
position: absolute; | |
top: -2px; | |
right: 22px; | |
width: 26px; | |
height: 27px; | |
background-position: -39px -414px; | |
cursor: pointer; | |
} | |
.more-than-one { | |
.btn_delRow { | |
display: block; | |
} | |
} | |
.box-form { | |
color: #666; | |
h2 {margin-bottom: 25px;} | |
input { | |
margin: 0px; | |
border: 1px solid #00A8E2; | |
box-shadow: inset 1px 1px 0px #bbb; | |
&:disabled { | |
background: transparent; | |
} | |
} | |
label { | |
a {text-decoration: underline;} | |
} | |
.check_label { | |
clear: both; | |
width: 400px; | |
height: 22px; | |
.diff_delivery { | |
position: relative; | |
height: 22px; | |
display: inline-block; | |
padding: 4px 0px 0px 0px; | |
} | |
} | |
.form-part-6 { | |
.check_label { | |
margin: 14px 0px 10px 0px; | |
} | |
} | |
.form-part-4, | |
.form-part-5 { | |
.col_1 { | |
float: left; | |
width: 174px; | |
margin: 0px 35px 4px 0px; | |
input { | |
width: 172px; | |
margin: 3px 0px 3px 0px; | |
} | |
} | |
.col_2 { | |
position: relative; | |
float: left; | |
width: 180px; | |
margin: 0px 0px 20px 0px; | |
input { | |
width: 172px; | |
margin: 3px 0px 3px 0px; | |
} | |
.select { | |
top: 0px; | |
} | |
.form_cover { | |
display: none; | |
} | |
&.disabled { | |
.form_cover { | |
display: block; | |
position: absolute; | |
top: 0px; | |
left: 0px; | |
right: 0px; | |
bottom: 0px; | |
z-index: 7; | |
background: url(/res/img/bg-form_cover.png); | |
} | |
h3 { | |
color: #666; | |
} | |
input { | |
border: #666 1px solid; | |
box-shadow: 0px 0px 0px; | |
} | |
.select { | |
top: 2px; | |
left: 0px; | |
width: 172px; | |
height: 16px; | |
border: #666 1px solid; | |
.select_start, | |
.select_middle, | |
.select_end { | |
display: none; | |
} | |
} | |
} | |
} | |
label { | |
clear: both; | |
display: block; | |
margin: 0px 0px 8px 0px; | |
.select { | |
top: 1px; | |
width: 149px; | |
margin: 1px 0px 1px 0px; | |
} | |
} | |
} | |
.form-part-5 .col_1 {margin-bottom: 14px;} | |
.strings { | |
position: relative; | |
font-size: 10px; | |
line-height: 12px; | |
width: 170px; | |
.sample_str {color: #aaa;} | |
.error_str {color: #ff0101; display: none;} | |
} | |
.calc_sum { | |
width: 385px; | |
.product_row { | |
font-size: 12px; | |
height: 16px; | |
padding: 1px 0px 2px 0px; | |
clear: both; | |
white-space: nowrap; | |
.prod_name {float: left;} | |
.prod_worth {float: right;} | |
} | |
.calc_total { | |
color: #00baf2; | |
font-size: 15px; | |
border-top: #c2c2c2 1px solid; | |
padding-top: 5px; | |
height: 20px; | |
.total_name {float: left;} | |
.total_worth {float: right;} | |
} | |
} | |
.tbl_divider { | |
clear: both; | |
height: 1px; | |
width: 100%; | |
border-bottom: #dbe0e1 1px solid; | |
margin: 25px 0px 20px 0px; | |
} | |
.tbl_row { | |
clear: both; | |
display: block; | |
min-height: 22px; | |
margin: 0px 0px 6px 0px; | |
&.row-new-product { | |
position: relative; | |
z-index: 3; | |
} | |
&.tbl_headrow { | |
height: 14px; | |
margin: 14px 0px 2px 0px; | |
} | |
&.form_files { | |
.cell_2 .strings { | |
top: 0px; | |
padding-top: 6px; | |
} | |
} | |
.tbl_head, | |
.tbl_cell { | |
position: relative; | |
float: left; | |
font-size: 12px; | |
&.cell_1 { | |
width: 210px; | |
input {width: 173px;} | |
.strings {display: none; width: 186px; height: 15px; top: -2px;} | |
} | |
&.cell_2 { | |
width: 202px; | |
input {width: 173px; margin-bottom: 6px;} | |
.select {width: 150px;} | |
.strings {display: none; width: 175px; height: 15px; top: -2px;} | |
&.files_list { | |
display: none; | |
line-height: 20px; | |
padding-top: 2px; | |
} | |
} | |
&.cell_3 { | |
width: 100px; | |
input {width: 35px; margin-bottom: 6px;} | |
.strings {display: none; width: 132px; height: 15px; top: -2px;} | |
} | |
} | |
} | |
.matches { | |
display: none; | |
position: absolute; | |
top: 19px; | |
left: 0px; | |
width: 173px; | |
z-index: 13; | |
background: #fff; | |
border: #01a0d7 1px solid; | |
border-top: 0px; | |
color: #666; | |
box-shadow: 0px 3px 3px #ddd; | |
.match { | |
border-top: #01a0d7 1px solid; | |
font: 10px/18px Arial; | |
padding: 0px 0px 0px 5px; | |
cursor: pointer; | |
} | |
.over, | |
.active { | |
//background: #EEE; | |
color: #01a0d7; | |
} | |
} | |
.select { | |
position: relative; | |
top: -2px; | |
left: 5px; | |
height: 24px; | |
width: 160px; | |
.select_middle { | |
background-position: 0px -196px; | |
background-repeat: repeat-x; | |
height: 24px; | |
width: 100%; | |
cursor: pointer; | |
color: #fff; | |
font: bold 10px Arial; | |
line-height: 23px; | |
padding: 0px; | |
} | |
.select_start { | |
position: absolute; | |
left: -6px; | |
top: 0px; | |
width: 6px; | |
height: 24px; | |
background-position: 0px -172px; | |
} | |
.select_end { | |
position: absolute; | |
right: -22px; | |
top: 0px; | |
width: 22px; | |
height: 24px; | |
background-position: -66px -172px; | |
} | |
.options { | |
display: none; | |
position: absolute; | |
top: 21px; | |
left: -5px; | |
right: -21px; | |
z-index: 13; | |
background: #fff; | |
border: #01a0d7 1px solid; | |
border-top: 0px; | |
color: #666; | |
box-shadow: 0px 3px 3px #ddd; | |
.option { | |
border-top: #01a0d7 1px solid; | |
font: 10px/18px Arial; | |
padding: 0px 0px 0px 5px; | |
cursor: pointer; | |
} | |
} | |
&.over { | |
.select_middle { | |
background-position: 0px -348px; | |
} | |
.select_start { | |
background-position: -37px -172px; | |
} | |
.select_end { | |
background-position: -44px -172px; | |
} | |
} | |
&.down { | |
z-index: 13; | |
.select_middle { | |
background-position: 0px -348px; | |
} | |
.select_start { | |
background-position: -37px -172px; | |
} | |
.select_end { | |
background-position: -44px -172px; | |
} | |
.options { | |
display: block; | |
z-index: 113; | |
} | |
} | |
} | |
.uploadify-queue { | |
position: absolute; | |
top: 0px; | |
left: 210px; | |
width: 365px; | |
} | |
.uploadify-button-text { | |
display: none; | |
} | |
.file { | |
position: relative; | |
top: -1px; | |
left: 5px; | |
width: auto; | |
height: 27px; | |
display: inline-block; | |
margin-right: 24px; | |
.file_middle { | |
background-position: 0px -441px; | |
background-repeat: repeat-x; | |
height: 27px; | |
width: 100%; | |
color: #fff; | |
font: bold 10px Arial; | |
line-height: 26px; | |
margin-right: 11px; | |
} | |
.file_start { | |
position: absolute; | |
left: -13px; | |
top: 0px; | |
width: 13px; | |
height: 27px; | |
background-position: 0px -414px; | |
} | |
.file_end { | |
position: absolute; | |
right: -13px; | |
top: 0px; | |
width: 13px; | |
height: 27px; | |
background-position: -14px -414px; | |
} | |
.file_remove { | |
position: absolute; | |
right: -4px; | |
top: 6px; | |
width: 12px; | |
height: 12px; | |
background-position: -27px -414px; | |
z-index: 2; | |
cursor: pointer; | |
} | |
} | |
.button { | |
position: relative; | |
top: -2px; | |
left: 5px; | |
width: 176px; | |
height: 24px; | |
cursor: pointer; | |
.btn_middle { | |
background-position: 0px -196px; | |
background-repeat: repeat-x; | |
height: 24px; | |
width: 100%; | |
color: #fff; | |
font: bold 10px Arial; | |
line-height: 23px; | |
} | |
.btn_start { | |
position: absolute; | |
left: -6px; | |
top: 0px; | |
width: 6px; | |
height: 24px; | |
background-position: 0px -172px; | |
} | |
.btn_end { | |
position: absolute; | |
right: -6px; | |
top: 0px; | |
width: 6px; | |
height: 24px; | |
background-position: -7px -172px; | |
} | |
&.over, | |
&.down { | |
.btn_middle { | |
background-position: 0px -348px; | |
} | |
.btn_start { | |
background-position: -13px -172px; | |
} | |
.btn_end { | |
background-position: -20px -172px; | |
} | |
} | |
&.file-wrapper { | |
input { | |
position: absolute; | |
top: 0px; | |
left: 0px; | |
width: 100%; | |
height: 100%; | |
//opacity: 0; | |
} | |
#uploader { | |
position: absolute; | |
top: 0px; | |
left: 0px; | |
opacity: 0; | |
} | |
} | |
} | |
.progress-track { | |
display: none; | |
position: relative; | |
left: 10px; | |
width: 365px; | |
height: 13px; | |
margin: 35px 0px 30px 0px; | |
background-position: 0px -468px; | |
background-repeat: repeat-x; | |
.pt-left { | |
position: absolute; | |
top: 0px; | |
left: -10px; | |
width: 10px; | |
height: 13px; | |
background-position: -66px -414px; | |
} | |
.pt-right { | |
position: absolute; | |
top: 0px; | |
right: -11px; | |
width: 11px; | |
height: 13px; | |
background-position: -77px -414px; | |
} | |
.progress-bar { | |
position: relative; | |
left: -3px; | |
width: 1px; | |
height: 13px; | |
background-position: 0px -481px; | |
background-repeat: repeat-x; | |
.pb-left { | |
position: absolute; | |
top: 0px; | |
left: -7px; | |
width: 7px; | |
height: 13px; | |
background-position: -73px -428px; | |
} | |
.pb-right { | |
position: absolute; | |
top: 0px; | |
right: -7px; | |
width: 7px; | |
height: 13px; | |
background-position: -81px -428px; | |
} | |
.pb-bubble { | |
position: absolute; | |
top: -35px; | |
right: -27px; | |
width: 44px; | |
height: 36px; | |
background-position: 0px -494px; | |
line-height: 28px; | |
text-align: center; | |
padding: 1px 2px 0px 0px; | |
} | |
} | |
} | |
.big-btn { | |
position: relative; | |
left: 5px; | |
width: 176px; | |
height: 42px; | |
cursor: pointer; | |
.btn_middle { | |
background-position: 0px -262px; | |
background-repeat: repeat-x; | |
height: 42px; | |
color: #fff; | |
font: 20px 'PFSquareSansProLight'; | |
line-height: 38px; | |
text-align: center; | |
img { | |
position: relative; | |
top: 11px; | |
} | |
} | |
.btn_start { | |
position: absolute; | |
left: -6px; | |
top: 0px; | |
width: 6px; | |
height: 42px; | |
background-position: 0px -220px; | |
} | |
.btn_end { | |
position: absolute; | |
right: -6px; | |
top: 0px; | |
width: 6px; | |
height: 42px; | |
background-position: -82px -220px; | |
} | |
&.down { | |
.btn_middle { | |
background-position: -6px -372px; | |
} | |
.btn_start { | |
background-position: -6px -220px; | |
} | |
.btn_end { | |
background-position: -13px -220px; | |
} | |
} | |
} | |
.submit-strings { | |
position: absolute; | |
top: 0px; | |
left: 100%; | |
margin-left: 35px; | |
width: 150px; | |
font-family: 'PFSquareSansProRegular'; | |
font-size: 18px; | |
line-height: 20px; | |
color: #f00; | |
.sample_str {display: none;} | |
.error_str {display: none;} | |
} | |
.accept-conditions { | |
position: relative; | |
height: 26px; | |
display: block; | |
padding: 4px 0px 0px 0px; | |
} | |
.error_str_2 { | |
display: none; | |
} | |
.checkbox { | |
float: left; | |
height: 19px; | |
width: 18px; | |
overflow: hidden; | |
margin: 0px 3px 4px 0px; | |
line-height: 10px; | |
background: url(/res/img/sprite-box.png) -20px -305px no-repeat; | |
cursor: pointer; | |
text-align: left; | |
border: #FFF 1px dotted; | |
position: relative; | |
top: -2px; | |
&.focus { | |
border-color: #00a8e2; | |
} | |
&.focus { | |
border-color: #00a8e2; | |
} | |
&.checked { | |
background-position: -39px -305px; | |
} | |
} | |
.checkbox input, | |
.radio input { | |
//display: none; | |
width: 20px!important; | |
height: 20px; | |
opacity: 0; | |
filter: alpha(opacity=0); | |
} | |
} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment