less-execjs 2.6.0.3

data/lib/less/js/less/test/less/visitorPlugin/visitor.less

@@ -0,0 +1,4 @@
+.test {
+    color: red;
+    -some-aribitrary-property: value;
+}

data/lib/less/js/less/test/less/whitespace.less

@@ -0,0 +1,44 @@
+
+
+.whitespace
+  { color: white; }
+
+.whitespace
+{
+  color: white;
+}
+  .whitespace
+{ color: white; }
+
+.whitespace{color:white;}
+.whitespace { color : white ; }
+
+.white,
+.space,
+.mania
+{ color: white; }
+
+.no-semi-column { color: white }
+.no-semi-column {
+  color: white;
+  white-space: pre
+}
+.no-semi-column {border: 2px solid white}
+.newlines {
+  background: the,
+              great,
+              wall;
+  border: 2px
+          solid
+          black;
+}
+.empty {
+
+}
+.sel
+.newline_ws .tab_ws {
+color:
+white;
+background-position: 45
+-23;
+}

data/lib/less/js/less/test/modify-vars.js

@@ -0,0 +1,19 @@
+var less = require('../lib/less'),
+  fs = require('fs');
+
+var input = fs.readFileSync("./test/less/modifyVars/extended.less", 'utf8');
+var expectedCss = fs.readFileSync('./test/css/modifyVars/extended.css', 'utf8');
+var options = {
+    modifyVars: JSON.parse(fs.readFileSync("./test/less/modifyVars/extended.json", 'utf8'))
+};
+
+less.render(input, options, function (err, result) {
+    if (err) {
+        console.log(err);
+    }
+    if (result.css === expectedCss) {
+        console.log("PASS");
+    } else {
+        console.log("FAIL");
+    }
+});

data/lib/less/js/less/test/plugins/filemanager/index.js

@@ -0,0 +1,19 @@
+(function(exports) {
+    var plugin = function(less) {
+        var FileManager = less.FileManager, TestFileManager = new FileManager();
+        function TestFileManager() { };
+        TestFileManager.loadFile = function (filename, currentDirectory, options, environment, callback) {
+            if (filename.match(/.*\.test$/)) {
+                return less.environment.fileManagers[0].loadFile("colors.test", currentDirectory, options, environment, callback);
+            }
+            return less.environment.fileManagers[0].loadFile(filename, currentDirectory, options, environment, callback);
+        };
+
+        return TestFileManager;
+    };
+
+    exports.install = function(less, pluginManager) {
+        less.environment.addFileManager(new plugin(less));
+    };
+
+})(typeof exports === 'undefined' ? this['AddFilePlugin'] = {} : exports);

data/lib/less/js/less/test/plugins/postprocess/index.js

@@ -0,0 +1,14 @@
+(function(exports) {
+    var postProcessor = function() {};
+
+    postProcessor.prototype = {
+        process: function (css) {
+            return 'hr {height:50px;}\n' + css;
+        }
+    };
+
+    exports.install = function(less, pluginManager) {
+        pluginManager.addPostProcessor( new postProcessor());
+    };
+
+})(typeof exports === 'undefined' ? this['postProcessorPlugin'] = {} : exports);

data/lib/less/js/less/test/plugins/preprocess/index.js

@@ -0,0 +1,19 @@
+(function(exports) {
+    var preProcessor = function() {};
+
+    preProcessor.prototype = {
+        process : function (src, extra) {
+            var injected = '@color: red;\n';
+            var ignored = extra.imports.contentsIgnoredChars;
+            var fileInfo = extra.fileInfo;
+            ignored[fileInfo.filename] = ignored[fileInfo.filename] || 0;
+            ignored[fileInfo.filename] += injected.length;
+            return injected + src;
+        }
+    };
+
+    exports.install = function(less, pluginManager) {
+        pluginManager.addPreProcessor( new preProcessor() );
+    };
+
+})(typeof exports === 'undefined' ? this['preProcessorPlugin'] = {} : exports);

data/lib/less/js/less/test/plugins/visitor/index.js

@@ -0,0 +1,24 @@
+(function(exports) {
+    var RemoveProperty = function(less) {
+        this._visitor = new less.visitors.Visitor(this);
+    };
+
+    RemoveProperty.prototype = {
+        isReplacing: true,
+        run: function (root) {
+            return this._visitor.visit(root);
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            if (ruleNode.name != '-some-aribitrary-property') {
+                return ruleNode;
+            } else {
+                return [];
+            }
+        }
+    };
+
+    exports.install = function(less, pluginManager) {
+        pluginManager.addVisitor( new RemoveProperty(less));
+    };
+
+})(typeof exports === 'undefined' ? this['VisitorPlugin'] = {} : exports);

data/lib/less/js/less/test/rhino/test-header.js

@@ -0,0 +1,15 @@
+function initRhinoTest() {
+    process = { title: 'dummy' };
+
+    less.tree.functions.add = function (a, b) {
+        return new(less.tree.Dimension)(a.value + b.value);
+    };
+    less.tree.functions.increment = function (a) {
+        return new(less.tree.Dimension)(a.value + 1);
+    };
+    less.tree.functions._color = function (str) {
+        if (str.value === "evil red") { return new(less.tree.Color)("600"); }
+    };
+}
+
+initRhinoTest();

data/lib/less/js/less/test/sourcemaps/basic.json

@@ -0,0 +1 @@
+{"version":3,"sources":["testweb/sourcemaps/basic.less","testweb/sourcemaps/imported.css"],"names":[],"mappings":"AAMA;EACE,YAAA;EAJA,UAAA;EAWA,iBAAA;EALA,WAAA;EACA,iBAAA;;AAJF,EASE;AATF,EASM;EACF,gBAAA;;AACA,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;EAGA,UAAA;;AALN;AAAI;AAUJ;EATE,iBAAA;;AADF,EAEE;AAFE,EAEF;AAFF,EAEM;AAFF,EAEE;AAQN,OARE;AAQF,OARM;EACF,gBAAA;;AACA,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFA;AAQN,OARE,GAQF,UARE;AAQF,OARE,GAEI,KAFJ;AAQF,OARE,GAQF,UARM;AAQN,OARE,GAEI,KAFA;AAEF,EAFF,GAQF,UARE;AAEE,EAFF,GAQF,UARM;AAQN,OARM,GAQN,UARE;AAQF,OARM,GAEA,KAFJ;AAQF,OARM,GAQN,UARM;AAQN,OARM,GAEA,KAFA;AAEF,EAFE,GAQN,UARE;AAEE,EAFE,GAQN,UARM;EAGA,UAAA;;AAKN;EACE,WAAA;;ACxBF;AACA;AACA;AACA;AACA;AACA;AACA","file":"sourcemaps/basic.css"}

data/lib/less/js/less/test/sourcemaps/index.html

@@ -0,0 +1,17 @@
+<html>
+   <link type="text/css" rel="stylesheet" media="all" href="import.css">
+   <link type="text/css" rel="stylesheet" media="all" href="basic.css">
+<head>
+</head>
+<body>
+<div id="import-test">id import-test</div>
+<div id="import">id import-test</div>
+<div class="imported inline">class imported inline</div>
+<div id="mixin">class mixin</div>
+<div class="a">class a</div>
+<div class="b">class b</div>
+<div class="b">class b<div class="c">class c</div></div>
+<div class="a">class a<div class="d">class d</div></div>
+<div class="extend">class extend<div class="c">class c</div></div>
+</body>
+</html>

data/lib/less/js/node-mime/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+npm-debug.log

data/lib/less/js/node-mime/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Benjamin Thomas, Robert Kieffer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/less/js/node-mime/README.md

@@ -0,0 +1,90 @@
+# mime
+
+Comprehensive MIME type mapping API based on mime-db module.
+
+## Install
+
+Install with [npm](http://github.com/isaacs/npm):
+
+    npm install mime
+
+## Contributing / Testing
+
+    npm run test
+
+## Command Line
+
+    mime [path_string]
+
+E.g.
+
+    > mime scripts/jquery.js
+    application/javascript
+
+## API - Queries
+
+### mime.lookup(path)
+Get the mime type associated with a file, if no mime type is found `application/octet-stream` is returned. Performs a case-insensitive lookup using the extension in `path` (the substring after the last '/' or '.').  E.g.
+
+```js
+var mime = require('mime');
+
+mime.lookup('/path/to/file.txt');         // => 'text/plain'
+mime.lookup('file.txt');                  // => 'text/plain'
+mime.lookup('.TXT');                      // => 'text/plain'
+mime.lookup('htm');                       // => 'text/html'
+```
+
+### mime.default_type
+Sets the mime type returned when `mime.lookup` fails to find the extension searched for. (Default is `application/octet-stream`.)
+
+### mime.extension(type)
+Get the default extension for `type`
+
+```js
+mime.extension('text/html');                 // => 'html'
+mime.extension('application/octet-stream');  // => 'bin'
+```
+
+### mime.charsets.lookup()
+
+Map mime-type to charset
+
+```js
+mime.charsets.lookup('text/plain');        // => 'UTF-8'
+```
+
+(The logic for charset lookups is pretty rudimentary.  Feel free to suggest improvements.)
+
+## API - Defining Custom Types
+
+Custom type mappings can be added on a per-project basis via the following APIs.
+
+### mime.define()
+
+Add custom mime/extension mappings
+
+```js
+mime.define({
+    'text/x-some-format': ['x-sf', 'x-sft', 'x-sfml'],
+    'application/x-my-type': ['x-mt', 'x-mtt'],
+    // etc ...
+});
+
+mime.lookup('x-sft');                 // => 'text/x-some-format'
+```
+
+The first entry in the extensions array is returned by `mime.extension()`. E.g.
+
+```js
+mime.extension('text/x-some-format'); // => 'x-sf'
+```
+
+### mime.load(filepath)
+
+Load mappings from an Apache ".types" format file
+
+```js
+mime.load('./my_project.types');
+```
+The .types file format is simple -  See the `types` dir for examples.

data/lib/less/js/node-mime/build/build.js

@@ -0,0 +1,11 @@
+var db = require('mime-db');
+
+var mapByType = {};
+Object.keys(db).forEach(function(key) {
+  var extensions = db[key].extensions;
+  if (extensions) {
+    mapByType[key] = extensions;
+  }
+});
+
+console.log(JSON.stringify(mapByType));

data/lib/less/js/node-mime/build/test.js

@@ -0,0 +1,57 @@
+/**
+ * Usage: node test.js
+ */
+
+var mime = require('../mime');
+var assert = require('assert');
+var path = require('path');
+
+//
+// Test mime lookups
+//
+
+assert.equal('text/plain', mime.lookup('text.txt'));     // normal file
+assert.equal('text/plain', mime.lookup('TEXT.TXT'));     // uppercase
+assert.equal('text/plain', mime.lookup('dir/text.txt')); // dir + file
+assert.equal('text/plain', mime.lookup('.text.txt'));    // hidden file
+assert.equal('text/plain', mime.lookup('.txt'));         // nameless
+assert.equal('text/plain', mime.lookup('txt'));          // extension-only
+assert.equal('text/plain', mime.lookup('/txt'));         // extension-less ()
+assert.equal('text/plain', mime.lookup('\\txt'));        // Windows, extension-less
+assert.equal('application/octet-stream', mime.lookup('text.nope')); // unrecognized
+assert.equal('fallback', mime.lookup('text.fallback', 'fallback')); // alternate default
+
+//
+// Test extensions
+//
+
+assert.equal('txt', mime.extension(mime.types.text));
+assert.equal('html', mime.extension(mime.types.htm));
+assert.equal('bin', mime.extension('application/octet-stream'));
+assert.equal('bin', mime.extension('application/octet-stream '));
+assert.equal('html', mime.extension(' text/html; charset=UTF-8'));
+assert.equal('html', mime.extension('text/html; charset=UTF-8 '));
+assert.equal('html', mime.extension('text/html; charset=UTF-8'));
+assert.equal('html', mime.extension('text/html ; charset=UTF-8'));
+assert.equal('html', mime.extension('text/html;charset=UTF-8'));
+assert.equal('html', mime.extension('text/Html;charset=UTF-8'));
+assert.equal(undefined, mime.extension('unrecognized'));
+
+//
+// Test node.types lookups
+//
+
+assert.equal('application/font-woff', mime.lookup('file.woff'));
+assert.equal('application/octet-stream', mime.lookup('file.buffer'));
+assert.equal('audio/mp4', mime.lookup('file.m4a'));
+assert.equal('font/opentype', mime.lookup('file.otf'));
+
+//
+// Test charsets
+//
+
+assert.equal('UTF-8', mime.charsets.lookup('text/plain'));
+assert.equal(undefined, mime.charsets.lookup(mime.types.js));
+assert.equal('fallback', mime.charsets.lookup('application/octet-stream', 'fallback'));
+
+console.log('\nAll tests passed');

data/lib/less/js/node-mime/cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+var mime = require('./mime.js');
+var file = process.argv[2];
+var type = mime.lookup(file);
+
+process.stdout.write(type + '\n');
+

data/lib/less/js/node-mime/mime.js

@@ -0,0 +1,108 @@
+var path = require('path');
+var fs = require('fs');
+
+function Mime() {
+  // Map of extension -> mime type
+  this.types = Object.create(null);
+
+  // Map of mime type -> extension
+  this.extensions = Object.create(null);
+}
+
+/**
+ * Define mimetype -> extension mappings.  Each key is a mime-type that maps
+ * to an array of extensions associated with the type.  The first extension is
+ * used as the default extension for the type.
+ *
+ * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
+ *
+ * @param map (Object) type definitions
+ */
+Mime.prototype.define = function (map) {
+  for (var type in map) {
+    var exts = map[type];
+    for (var i = 0; i < exts.length; i++) {
+      if (process.env.DEBUG_MIME && this.types[exts]) {
+        console.warn(this._loading.replace(/.*\//, ''), 'changes "' + exts[i] + '" extension type from ' +
+          this.types[exts] + ' to ' + type);
+      }
+
+      this.types[exts[i]] = type;
+    }
+
+    // Default extension is the first one we encounter
+    if (!this.extensions[type]) {
+      this.extensions[type] = exts[0];
+    }
+  }
+};
+
+/**
+ * Load an Apache2-style ".types" file
+ *
+ * This may be called multiple times (it's expected).  Where files declare
+ * overlapping types/extensions, the last file wins.
+ *
+ * @param file (String) path of file to load.
+ */
+Mime.prototype.load = function(file) {
+  this._loading = file;
+  // Read file and split into lines
+  var map = {},
+      content = fs.readFileSync(file, 'ascii'),
+      lines = content.split(/[\r\n]+/);
+
+  lines.forEach(function(line) {
+    // Clean up whitespace/comments, and split into fields
+    var fields = line.replace(/\s*#.*|^\s*|\s*$/g, '').split(/\s+/);
+    map[fields.shift()] = fields;
+  });
+
+  this.define(map);
+
+  this._loading = null;
+};
+
+/**
+ * Lookup a mime type based on extension
+ */
+Mime.prototype.lookup = function(path, fallback) {
+  var ext = path.replace(/.*[\.\/\\]/, '').toLowerCase();
+
+  return this.types[ext] || fallback || this.default_type;
+};
+
+/**
+ * Return file extension associated with a mime type
+ */
+Mime.prototype.extension = function(mimeType) {
+  var type = mimeType.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();
+  return this.extensions[type];
+};
+
+// Default instance
+var mime = new Mime();
+
+// Define built-in types
+mime.define(require('./types.json'));
+
+// Default type
+mime.default_type = mime.lookup('bin');
+
+//
+// Additional API specific to the default instance
+//
+
+mime.Mime = Mime;
+
+/**
+ * Lookup a charset based on mime type.
+ */
+mime.charsets = {
+  lookup: function(mimeType, fallback) {
+    // Assume text types are utf8
+    return (/^text\//).test(mimeType) ? 'UTF-8' : fallback;
+  }
+};
+
+module.exports = mime;