less-execjs 2.6.0.3

data/lib/less/js/less/lib/less/functions/types.js

@@ -0,0 +1,89 @@
+var Keyword = require("../tree/keyword"),
+    DetachedRuleset = require("../tree/detached-ruleset"),
+    Dimension = require("../tree/dimension"),
+    Color = require("../tree/color"),
+    Quoted = require("../tree/quoted"),
+    Anonymous = require("../tree/anonymous"),
+    URL = require("../tree/url"),
+    Operation = require("../tree/operation"),
+    functionRegistry = require("./function-registry");
+
+var isa = function (n, Type) {
+        return (n instanceof Type) ? Keyword.True : Keyword.False;
+    },
+    isunit = function (n, unit) {
+        if (unit === undefined) {
+            throw { type: "Argument", message: "missing the required second argument to isunit." };
+        }
+        unit = typeof unit.value === "string" ? unit.value : unit;
+        if (typeof unit !== "string") {
+            throw { type: "Argument", message: "Second argument to isunit should be a unit or a string." };
+        }
+        return (n instanceof Dimension) && n.unit.is(unit) ? Keyword.True : Keyword.False;
+    },
+    getItemsFromNode = function(node) {
+        // handle non-array values as an array of length 1
+        // return 'undefined' if index is invalid
+        var items = Array.isArray(node.value) ?
+            node.value : Array(node);
+
+        return items;
+    };
+functionRegistry.addMultiple({
+    isruleset: function (n) {
+        return isa(n, DetachedRuleset);
+    },
+    iscolor: function (n) {
+        return isa(n, Color);
+    },
+    isnumber: function (n) {
+        return isa(n, Dimension);
+    },
+    isstring: function (n) {
+        return isa(n, Quoted);
+    },
+    iskeyword: function (n) {
+        return isa(n, Keyword);
+    },
+    isurl: function (n) {
+        return isa(n, URL);
+    },
+    ispixel: function (n) {
+        return isunit(n, 'px');
+    },
+    ispercentage: function (n) {
+        return isunit(n, '%');
+    },
+    isem: function (n) {
+        return isunit(n, 'em');
+    },
+    isunit: isunit,
+    unit: function (val, unit) {
+        if (!(val instanceof Dimension)) {
+            throw { type: "Argument",
+                message: "the first argument to unit must be a number" +
+                    (val instanceof Operation ? ". Have you forgotten parenthesis?" : "") };
+        }
+        if (unit) {
+            if (unit instanceof Keyword) {
+                unit = unit.value;
+            } else {
+                unit = unit.toCSS();
+            }
+        } else {
+            unit = "";
+        }
+        return new Dimension(val.value, unit);
+    },
+    "get-unit": function (n) {
+        return new Anonymous(n.unit);
+    },
+    extract: function(values, index) {
+        index = index.value - 1; // (1-based index)
+
+        return getItemsFromNode(values)[index];
+    },
+    length: function(values) {
+        return new Dimension(getItemsFromNode(values).length);
+    }
+});

data/lib/less/js/less/lib/less/import-manager.js

@@ -0,0 +1,131 @@
+var contexts = require("./contexts"),
+    Parser = require('./parser/parser'),
+    FunctionImporter = require('./plugins/function-importer');
+
+module.exports = function(environment) {
+
+    // FileInfo = {
+    //  'relativeUrls' - option - whether to adjust URL's to be relative
+    //  'filename' - full resolved filename of current file
+    //  'rootpath' - path to append to normal URLs for this node
+    //  'currentDirectory' - path to the current file, absolute
+    //  'rootFilename' - filename of the base file
+    //  'entryPath' - absolute path to the entry file
+    //  'reference' - whether the file should not be output and only output parts that are referenced
+
+    var ImportManager = function(context, rootFileInfo) {
+        this.rootFilename = rootFileInfo.filename;
+        this.paths = context.paths || [];  // Search paths, when importing
+        this.contents = {};             // map - filename to contents of all the files
+        this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
+        this.mime = context.mime;
+        this.error = null;
+        this.context = context;
+        // Deprecated? Unused outside of here, could be useful.
+        this.queue = [];        // Files which haven't been imported yet
+        this.files = {};        // Holds the imported parse trees.
+    };
+    /**
+     * Add an import to be imported
+     * @param path - the raw path
+     * @param tryAppendLessExtension - whether to try appending the less extension (if the path has no extension)
+     * @param currentFileInfo - the current file info (used for instance to work out relative paths)
+     * @param importOptions - import options
+     * @param callback - callback for when it is imported
+     */
+    ImportManager.prototype.push = function (path, tryAppendLessExtension, currentFileInfo, importOptions, callback) {
+        var importManager = this;
+        this.queue.push(path);
+
+        var fileParsedFunc = function (e, root, fullPath) {
+            importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
+
+            var importedEqualsRoot = fullPath === importManager.rootFilename;
+            if (importOptions.optional && e) {
+                callback(null, {rules:[]}, false, null);
+            }
+            else {
+                importManager.files[fullPath] = root;
+                if (e && !importManager.error) { importManager.error = e; }
+                callback(e, root, importedEqualsRoot, fullPath);
+            }
+        };
+
+        var newFileInfo = {
+            relativeUrls: this.context.relativeUrls,
+            entryPath: currentFileInfo.entryPath,
+            rootpath: currentFileInfo.rootpath,
+            rootFilename: currentFileInfo.rootFilename
+        };
+
+        var fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
+
+        if (!fileManager) {
+            fileParsedFunc({ message: "Could not find a file-manager for " + path });
+            return;
+        }
+
+        if (tryAppendLessExtension) {
+            path = fileManager.tryAppendExtension(path, importOptions.plugin ? ".js" : ".less");
+        }
+
+        var loadFileCallback = function(loadedFile) {
+            var resolvedFilename = loadedFile.filename,
+                contents = loadedFile.contents.replace(/^\uFEFF/, '');
+
+            // Pass on an updated rootpath if path of imported file is relative and file
+            // is in a (sub|sup) directory
+            //
+            // Examples:
+            // - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
+            //   then rootpath should become 'less/module/nav/'
+            // - If path of imported file is '../mixins.less' and rootpath is 'less/',
+            //   then rootpath should become 'less/../'
+            newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
+            if (newFileInfo.relativeUrls) {
+                newFileInfo.rootpath = fileManager.join(
+                    (importManager.context.rootpath || ""),
+                    fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
+
+                if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
+                    newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
+                }
+            }
+            newFileInfo.filename = resolvedFilename;
+
+            var newEnv = new contexts.Parse(importManager.context);
+
+            newEnv.processImports = false;
+            importManager.contents[resolvedFilename] = contents;
+
+            if (currentFileInfo.reference || importOptions.reference) {
+                newFileInfo.reference = true;
+            }
+
+            if (importOptions.plugin) {
+                new FunctionImporter(newEnv, newFileInfo).eval(contents, function (e, root) {
+                    fileParsedFunc(e, root, resolvedFilename);
+                });
+            } else if (importOptions.inline) {
+                fileParsedFunc(null, contents, resolvedFilename);
+            } else {
+                new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
+                    fileParsedFunc(e, root, resolvedFilename);
+                });
+            }
+        };
+
+        var promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, this.context, environment,
+            function(err, loadedFile) {
+            if (err) {
+                fileParsedFunc(err);
+            } else {
+                loadFileCallback(loadedFile);
+            }
+        });
+        if (promise) {
+            promise.then(loadFileCallback, fileParsedFunc);
+        }
+    };
+    return ImportManager;
+};

data/lib/less/js/less/lib/less/index.js

@@ -0,0 +1,29 @@
+module.exports = function(environment, fileManagers) {
+    var SourceMapOutput, SourceMapBuilder, ParseTree, ImportManager, Environment;
+
+    var less = {
+        version: [2, 6, 0],
+        data: require('./data'),
+        tree: require('./tree'),
+        Environment: (Environment = require("./environment/environment")),
+        AbstractFileManager: require("./environment/abstract-file-manager"),
+        environment: (environment = new Environment(environment, fileManagers)),
+        visitors: require('./visitors'),
+        Parser: require('./parser/parser'),
+        functions: require('./functions')(environment),
+        contexts: require("./contexts"),
+        SourceMapOutput: (SourceMapOutput = require('./source-map-output')(environment)),
+        SourceMapBuilder: (SourceMapBuilder = require('./source-map-builder')(SourceMapOutput, environment)),
+        ParseTree: (ParseTree = require('./parse-tree')(SourceMapBuilder)),
+        ImportManager: (ImportManager = require('./import-manager')(environment)),
+        render: require("./render")(environment, ParseTree, ImportManager),
+        parse: require("./parse")(environment, ParseTree, ImportManager),
+        LessError: require('./less-error'),
+        transformTree: require('./transform-tree'),
+        utils: require('./utils'),
+        PluginManager: require('./plugin-manager'),
+        logger: require('./logger')
+    };
+
+    return less;
+};

data/lib/less/js/less/lib/less/less-error.js

@@ -0,0 +1,42 @@
+var utils = require("./utils");
+
+var LessError = module.exports = function LessError(e, importManager, currentFilename) {
+
+    Error.call(this);
+
+    var filename = e.filename || currentFilename;
+
+    if (importManager && filename) {
+        var input = importManager.contents[filename],
+            loc = utils.getLocation(e.index, input),
+            line = loc.line,
+            col  = loc.column,
+            callLine = e.call && utils.getLocation(e.call, input).line,
+            lines = input.split('\n');
+
+        this.type = e.type || 'Syntax';
+        this.filename = filename;
+        this.index = e.index;
+        this.line = typeof line === 'number' ? line + 1 : null;
+        this.callLine = callLine + 1;
+        this.callExtract = lines[callLine];
+        this.column = col;
+        this.extract = [
+            lines[line - 1],
+            lines[line],
+            lines[line + 1]
+        ];
+    }
+    this.message = e.message;
+    this.stack = e.stack;
+};
+
+if (typeof Object.create === 'undefined') {
+    var F = function () {};
+    F.prototype = Error.prototype;
+    LessError.prototype = new F();
+} else {
+    LessError.prototype = Object.create(Error.prototype);
+}
+
+LessError.prototype.constructor = LessError;

data/lib/less/js/less/lib/less/logger.js

@@ -0,0 +1,34 @@
+module.exports = {
+    error: function(msg) {
+        this._fireEvent("error", msg);
+    },
+    warn: function(msg) {
+        this._fireEvent("warn", msg);
+    },
+    info: function(msg) {
+        this._fireEvent("info", msg);
+    },
+    debug: function(msg) {
+        this._fireEvent("debug", msg);
+    },
+    addListener: function(listener) {
+        this._listeners.push(listener);
+    },
+    removeListener: function(listener) {
+        for (var i = 0; i < this._listeners.length; i++) {
+            if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+            }
+        }
+    },
+    _fireEvent: function(type, msg) {
+        for (var i = 0; i < this._listeners.length; i++) {
+            var logFunction = this._listeners[i][type];
+            if (logFunction) {
+                logFunction(msg);
+            }
+        }
+    },
+    _listeners: []
+};

data/lib/less/js/less/lib/less/parse-tree.js

@@ -0,0 +1,60 @@
+var LessError = require('./less-error'),
+    transformTree = require("./transform-tree"),
+    logger = require("./logger");
+
+module.exports = function(SourceMapBuilder) {
+    var ParseTree = function(root, imports) {
+        this.root = root;
+        this.imports = imports;
+    };
+
+    ParseTree.prototype.toCSS = function(options) {
+        var evaldRoot, result = {}, sourceMapBuilder;
+        try {
+            evaldRoot = transformTree(this.root, options);
+        } catch (e) {
+            throw new LessError(e, this.imports);
+        }
+
+        try {
+            var compress = Boolean(options.compress);
+            if (compress) {
+                logger.warn("The compress option has been deprecated. We recommend you use a dedicated css minifier, for instance see less-plugin-clean-css.");
+            }
+
+            var toCSSOptions = {
+                compress: compress,
+                dumpLineNumbers: options.dumpLineNumbers,
+                strictUnits: Boolean(options.strictUnits),
+                numPrecision: 8};
+
+            if (options.sourceMap) {
+                sourceMapBuilder = new SourceMapBuilder(options.sourceMap);
+                result.css = sourceMapBuilder.toCSS(evaldRoot, toCSSOptions, this.imports);
+            } else {
+                result.css = evaldRoot.toCSS(toCSSOptions);
+            }
+        } catch (e) {
+            throw new LessError(e, this.imports);
+        }
+
+        if (options.pluginManager) {
+            var postProcessors = options.pluginManager.getPostProcessors();
+            for (var i = 0; i < postProcessors.length; i++) {
+                result.css = postProcessors[i].process(result.css, { sourceMap: sourceMapBuilder, options: options, imports: this.imports });
+            }
+        }
+        if (options.sourceMap) {
+            result.map = sourceMapBuilder.getExternalSourceMap();
+        }
+
+        result.imports = [];
+        for (var file in this.imports.files) {
+            if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
+                result.imports.push(file);
+            }
+        }
+        return result;
+    };
+    return ParseTree;
+};

data/lib/less/js/less/lib/less/parse.js

@@ -0,0 +1,68 @@
+var PromiseConstructor,
+    contexts = require("./contexts"),
+    Parser = require('./parser/parser'),
+    PluginManager = require('./plugin-manager');
+
+module.exports = function(environment, ParseTree, ImportManager) {
+    var parse = function (input, options, callback) {
+        options = options || {};
+
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+
+        if (!callback) {
+            if (!PromiseConstructor) {
+                PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
+            }
+            var self = this;
+            return new PromiseConstructor(function (resolve, reject) {
+                parse.call(self, input, options, function(err, output) {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(output);
+                    }
+                });
+            });
+        } else {
+            var context,
+                rootFileInfo,
+                pluginManager = new PluginManager(this);
+
+            pluginManager.addPlugins(options.plugins);
+            options.pluginManager = pluginManager;
+
+            context = new contexts.Parse(options);
+
+            if (options.rootFileInfo) {
+                rootFileInfo = options.rootFileInfo;
+            } else {
+                var filename = options.filename || "input";
+                var entryPath = filename.replace(/[^\/\\]*$/, "");
+                rootFileInfo = {
+                    filename: filename,
+                    relativeUrls: context.relativeUrls,
+                    rootpath: context.rootpath || "",
+                    currentDirectory: entryPath,
+                    entryPath: entryPath,
+                    rootFilename: filename
+                };
+                // add in a missing trailing slash
+                if (rootFileInfo.rootpath && rootFileInfo.rootpath.slice(-1) !== "/") {
+                    rootFileInfo.rootpath += "/";
+                }
+            }
+
+            var imports = new ImportManager(context, rootFileInfo);
+
+            new Parser(context, imports, rootFileInfo)
+                .parse(input, function (e, root) {
+                if (e) { return callback(e); }
+                callback(null, root, imports, options);
+            }, options);
+        }
+    };
+    return parse;
+};