less 3.10.0-beta.2 → 3.10.3

package/lib/less/index.js

@@ -0,0 +1,92 @@
+import data from './data';
+import tree from './tree';
+import Environment from './environment/environment';
+import AbstractFileManager from './environment/abstract-file-manager';
+import AbstractPluginLoader from './environment/abstract-plugin-loader';
+import visitors from './visitors';
+import Parser from './parser/parser';
+import Functions from './functions';
+import contexts from './contexts';
+import sourceMapOutput from './source-map-output';
+import sourceMapBuilder from './source-map-builder';
+import parseTree from './parse-tree';
+import importManager from './import-manager';
+import Render from './render';
+import Parse from './parse';
+import LessError from './less-error';
+import transformTree from './transform-tree';
+import * as utils from './utils';
+import PluginManager from './plugin-manager';
+import logger from './logger';
+
+export default (environment, fileManagers) => {
+    /**
+     * @todo
+     * This original code could be improved quite a bit.
+     * Many classes / modules currently add side-effects / mutations to passed in objects,
+     * which makes it hard to refactor and reason about. 
+     */
+    environment = new Environment(environment, fileManagers);
+
+    const SourceMapOutput = sourceMapOutput(environment);
+    const SourceMapBuilder = sourceMapBuilder(SourceMapOutput, environment);
+    const ParseTree = parseTree(SourceMapBuilder);
+    const ImportManager = importManager(environment);
+    const render = Render(environment, ParseTree, ImportManager);
+    const parse = Parse(environment, ParseTree, ImportManager);
+    const functions = Functions(environment);
+
+    /**
+     * @todo
+     * This root properties / methods need to be organized.
+     * It's not clear what should / must be public and why.
+     */
+    const initial = {
+        version: [3, 10, 3],
+        data,
+        tree,
+        Environment,
+        AbstractFileManager,
+        AbstractPluginLoader,
+        environment,
+        visitors,
+        Parser,
+        functions,
+        contexts,
+        SourceMapOutput,
+        SourceMapBuilder,
+        ParseTree,
+        ImportManager,
+        render,
+        parse,
+        LessError,
+        transformTree,
+        utils,
+        PluginManager,
+        logger
+    };
+
+    // Create a public API
+    const ctor = t => function (...args) {
+        return new t(...args);
+    };
+
+    let t;
+    const api = Object.create(initial);
+    for (const n in initial.tree) {
+        /* eslint guard-for-in: 0 */
+        t = initial.tree[n];
+        if (typeof t === 'function') {
+            api[n.toLowerCase()] = ctor(t);
+        }
+        else {
+            api[n] = Object.create(null);
+            for (const o in t) {
+                /* eslint guard-for-in: 0 */
+                api[n][o.toLowerCase()] = ctor(t[o]);
+            }
+        }
+    }
+
+    return api;
+};

package/lib/less/less-error.js

@@ -0,0 +1,140 @@
+import * as utils from './utils';
+/**
+ * This is a centralized class of any error that could be thrown internally (mostly by the parser).
+ * Besides standard .message it keeps some additional data like a path to the file where the error
+ * occurred along with line and column numbers.
+ *
+ * @class
+ * @extends Error
+ * @type {module.LessError}
+ *
+ * @prop {string} type
+ * @prop {string} filename
+ * @prop {number} index
+ * @prop {number} line
+ * @prop {number} column
+ * @prop {number} callLine
+ * @prop {number} callExtract
+ * @prop {string[]} extract
+ *
+ * @param {Object} e              - An error object to wrap around or just a descriptive object
+ * @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
+ * @param {string} [currentFilename]
+ */
+const LessError = function LessError(e, fileContentMap, currentFilename) {
+    Error.call(this);
+
+    const filename = e.filename || currentFilename;
+
+    this.message = e.message;
+    this.stack = e.stack;
+
+    if (fileContentMap && filename) {
+        const input = fileContentMap.contents[filename];
+        const loc = utils.getLocation(e.index, input);
+        const line = loc.line;
+        const col  = loc.column;
+        const callLine = e.call && utils.getLocation(e.call, input).line;
+        const lines = input ? input.split('\n') : '';
+
+        this.type = e.type || 'Syntax';
+        this.filename = filename;
+        this.index = e.index;
+        this.line = typeof line === 'number' ? line + 1 : null;
+        this.column = col;
+
+        if (!this.line && this.stack) {
+            const found = this.stack.match(/(<anonymous>|Function):(\d+):(\d+)/);
+
+            if (found) {
+                if (found[2]) {
+                    this.line = parseInt(found[2]) - 2;
+                }
+                if (found[3]) {
+                    this.column = parseInt(found[3]);
+                }
+            }
+        }
+
+        this.callLine = callLine + 1;
+        this.callExtract = lines[callLine];
+
+        this.extract = [
+            lines[this.line - 2],
+            lines[this.line - 1],
+            lines[this.line]
+        ];
+    }
+
+};
+
+if (typeof Object.create === 'undefined') {
+    const F = () => {};
+    F.prototype = Error.prototype;
+    LessError.prototype = new F();
+} else {
+    LessError.prototype = Object.create(Error.prototype);
+}
+
+LessError.prototype.constructor = LessError;
+
+/**
+ * An overridden version of the default Object.prototype.toString
+ * which uses additional information to create a helpful message.
+ *
+ * @param {Object} options
+ * @returns {string}
+ */
+LessError.prototype.toString = function(options = {}) {
+    let message = '';
+    const extract = this.extract || [];
+    let error = [];
+    let stylize = str => str;
+    if (options.stylize) {
+        const type = typeof options.stylize;
+        if (type !== 'function') {
+            throw Error(`options.stylize should be a function, got a ${type}!`);
+        }
+        stylize = options.stylize;
+    }
+
+    if (this.line !== null) {
+        if (typeof extract[0] === 'string') {
+            error.push(stylize(`${this.line - 1} ${extract[0]}`, 'grey'));
+        }
+
+        if (typeof extract[1] === 'string') {
+            let errorTxt = `${this.line} `;
+            if (extract[1]) {
+                errorTxt += extract[1].slice(0, this.column) +
+                    stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') +
+                        extract[1].slice(this.column + 1), 'red'), 'inverse');
+            }
+            error.push(errorTxt);
+        }
+
+        if (typeof extract[2] === 'string') {
+            error.push(stylize(`${this.line + 1} ${extract[2]}`, 'grey'));
+        }
+        error = `${error.join('\n') + stylize('', 'reset')}\n`;
+    }
+
+    message += stylize(`${this.type}Error: ${this.message}`, 'red');
+    if (this.filename) {
+        message += stylize(' in ', 'red') + this.filename;
+    }
+    if (this.line) {
+        message += stylize(` on line ${this.line}, column ${this.column + 1}:`, 'grey');
+    }
+
+    message += `\n${error}`;
+
+    if (this.callLine) {
+        message += `${stylize('from ', 'red') + (this.filename || '')}/n`;
+        message += `${stylize(this.callLine, 'grey')} ${this.callExtract}/n`;
+    }
+
+    return message;
+};
+
+export default LessError;

package/lib/less/logger.js

@@ -0,0 +1,34 @@
+export default {
+    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 (let i = 0; i < this._listeners.length; i++) {
+            if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+            }
+        }
+    },
+    _fireEvent: function(type, msg) {
+        for (let i = 0; i < this._listeners.length; i++) {
+            const logFunction = this._listeners[i][type];
+            if (logFunction) {
+                logFunction(msg);
+            }
+        }
+    },
+    _listeners: []
+};

package/lib/less/parse-tree.js

@@ -0,0 +1,66 @@
+import LessError from './less-error';
+import transformTree from './transform-tree';
+import logger from './logger';
+
+export default SourceMapBuilder => {
+    class ParseTree {
+        constructor(root, imports) {
+            this.root = root;
+            this.imports = imports;
+        }
+
+        toCSS(options) {
+            let evaldRoot;
+            const result = {};
+            let sourceMapBuilder;
+            try {
+                evaldRoot = transformTree(this.root, options);
+            } catch (e) {
+                throw new LessError(e, this.imports);
+            }
+
+            try {
+                const 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.');
+                }
+
+                const toCSSOptions = {
+                    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) {
+                const postProcessors = options.pluginManager.getPostProcessors();
+                for (let i = 0; i < postProcessors.length; i++) {
+                    result.css = postProcessors[i].process(result.css, { sourceMap: sourceMapBuilder, options, imports: this.imports });
+                }
+            }
+            if (options.sourceMap) {
+                result.map = sourceMapBuilder.getExternalSourceMap();
+            }
+
+            result.imports = [];
+            for (const file in this.imports.files) {
+                if (this.imports.files.hasOwnProperty(file) && file !== this.imports.rootFilename) {
+                    result.imports.push(file);
+                }
+            }
+            return result;
+        }
+    }
+
+    return ParseTree;
+};

package/lib/less/parse.js

@@ -0,0 +1,89 @@
+let PromiseConstructor;
+import contexts from './contexts';
+import Parser from './parser/parser';
+import PluginManager from './plugin-manager';
+import LessError from './less-error';
+import * as utils from './utils';
+
+export default (environment, ParseTree, ImportManager) => {
+    const parse = function (input, options, callback) {
+
+        if (typeof options === 'function') {
+            callback = options;
+            options = utils.copyOptions(this.options, {});
+        }
+        else {
+            options = utils.copyOptions(this.options, options || {});
+        }
+
+        if (!callback) {
+            const self = this;
+            return new Promise((resolve, reject) => {
+                parse.call(self, input, options, (err, output) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(output);
+                    }
+                });
+            });
+        } else {
+            let context;
+            let rootFileInfo;
+            const pluginManager = new PluginManager(this, !options.reUsePluginManager);
+
+            options.pluginManager = pluginManager;
+
+            context = new contexts.Parse(options);
+
+            if (options.rootFileInfo) {
+                rootFileInfo = options.rootFileInfo;
+            } else {
+                const filename = options.filename || 'input';
+                const entryPath = filename.replace(/[^\/\\]*$/, '');
+                rootFileInfo = {
+                    filename,
+                    rewriteUrls: context.rewriteUrls,
+                    rootpath: context.rootpath || '',
+                    currentDirectory: entryPath,
+                    entryPath,
+                    rootFilename: filename
+                };
+                // add in a missing trailing slash
+                if (rootFileInfo.rootpath && rootFileInfo.rootpath.slice(-1) !== '/') {
+                    rootFileInfo.rootpath += '/';
+                }
+            }
+
+            const imports = new ImportManager(this, context, rootFileInfo);
+            this.importManager = imports;
+
+            // TODO: allow the plugins to be just a list of paths or names
+            // Do an async plugin queue like lessc
+
+            if (options.plugins) {
+                options.plugins.forEach(plugin => {
+                    let evalResult;
+                    let contents;
+                    if (plugin.fileContent) {
+                        contents = plugin.fileContent.replace(/^\uFEFF/, '');
+                        evalResult = pluginManager.Loader.evalPlugin(contents, context, imports, plugin.options, plugin.filename);
+                        if (evalResult instanceof LessError) {
+                            return callback(evalResult);
+                        }
+                    }
+                    else {
+                        pluginManager.addPlugin(plugin);
+                    }
+                });
+            }
+
+            new Parser(context, imports, rootFileInfo)
+                .parse(input, (e, root) => {
+                    if (e) { return callback(e); }
+                    callback(null, root, imports, options);
+                }, options);
+        }
+    };
+    return parse;
+};

package/lib/less/parser/chunker.js

@@ -0,0 +1,122 @@
+// Split the input into chunks.
+export default (input, fail) => {
+    const len = input.length;
+    let level = 0;
+    let parenLevel = 0;
+    let lastOpening;
+    let lastOpeningParen;
+    let lastMultiComment;
+    let lastMultiCommentEndBrace;
+    const chunks = [];
+    let emitFrom = 0;
+    let chunkerCurrentIndex;
+    let currentChunkStartIndex;
+    let cc;
+    let cc2;
+    let matched;
+
+    function emitChunk(force) {
+        const len = chunkerCurrentIndex - emitFrom;
+        if (((len < 512) && !force) || !len) {
+            return;
+        }
+        chunks.push(input.slice(emitFrom, chunkerCurrentIndex + 1));
+        emitFrom = chunkerCurrentIndex + 1;
+    }
+
+    for (chunkerCurrentIndex = 0; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
+        cc = input.charCodeAt(chunkerCurrentIndex);
+        if (((cc >= 97) && (cc <= 122)) || (cc < 34)) {
+            // a-z or whitespace
+            continue;
+        }
+
+        switch (cc) {
+            case 40:                        // (
+                parenLevel++;
+                lastOpeningParen = chunkerCurrentIndex;
+                continue;
+            case 41:                        // )
+                if (--parenLevel < 0) {
+                    return fail('missing opening `(`', chunkerCurrentIndex);
+                }
+                continue;
+            case 59:                        // ;
+                if (!parenLevel) { emitChunk(); }
+                continue;
+            case 123:                       // {
+                level++;
+                lastOpening = chunkerCurrentIndex;
+                continue;
+            case 125:                       // }
+                if (--level < 0) {
+                    return fail('missing opening `{`', chunkerCurrentIndex);
+                }
+                if (!level && !parenLevel) { emitChunk(); }
+                continue;
+            case 92:                        // \
+                if (chunkerCurrentIndex < len - 1) { chunkerCurrentIndex++; continue; }
+                return fail('unescaped `\\`', chunkerCurrentIndex);
+            case 34:
+            case 39:
+            case 96:                        // ", ' and `
+                matched = 0;
+                currentChunkStartIndex = chunkerCurrentIndex;
+                for (chunkerCurrentIndex = chunkerCurrentIndex + 1; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
+                    cc2 = input.charCodeAt(chunkerCurrentIndex);
+                    if (cc2 > 96) { continue; }
+                    if (cc2 == cc) { matched = 1; break; }
+                    if (cc2 == 92) {        // \
+                        if (chunkerCurrentIndex == len - 1) {
+                            return fail('unescaped `\\`', chunkerCurrentIndex);
+                        }
+                        chunkerCurrentIndex++;
+                    }
+                }
+                if (matched) { continue; }
+                return fail(`unmatched \`${String.fromCharCode(cc)}\``, currentChunkStartIndex);
+            case 47:                        // /, check for comment
+                if (parenLevel || (chunkerCurrentIndex == len - 1)) { continue; }
+                cc2 = input.charCodeAt(chunkerCurrentIndex + 1);
+                if (cc2 == 47) {
+                    // //, find lnfeed
+                    for (chunkerCurrentIndex = chunkerCurrentIndex + 2; chunkerCurrentIndex < len; chunkerCurrentIndex++) {
+                        cc2 = input.charCodeAt(chunkerCurrentIndex);
+                        if ((cc2 <= 13) && ((cc2 == 10) || (cc2 == 13))) { break; }
+                    }
+                } else if (cc2 == 42) {
+                    // /*, find */
+                    lastMultiComment = currentChunkStartIndex = chunkerCurrentIndex;
+                    for (chunkerCurrentIndex = chunkerCurrentIndex + 2; chunkerCurrentIndex < len - 1; chunkerCurrentIndex++) {
+                        cc2 = input.charCodeAt(chunkerCurrentIndex);
+                        if (cc2 == 125) { lastMultiCommentEndBrace = chunkerCurrentIndex; }
+                        if (cc2 != 42) { continue; }
+                        if (input.charCodeAt(chunkerCurrentIndex + 1) == 47) { break; }
+                    }
+                    if (chunkerCurrentIndex == len - 1) {
+                        return fail('missing closing `*/`', currentChunkStartIndex);
+                    }
+                    chunkerCurrentIndex++;
+                }
+                continue;
+            case 42:                       // *, check for unmatched */
+                if ((chunkerCurrentIndex < len - 1) && (input.charCodeAt(chunkerCurrentIndex + 1) == 47)) {
+                    return fail('unmatched `/*`', chunkerCurrentIndex);
+                }
+                continue;
+        }
+    }
+
+    if (level !== 0) {
+        if ((lastMultiComment > lastOpening) && (lastMultiCommentEndBrace > lastMultiComment)) {
+            return fail('missing closing `}` or `*/`', lastOpening);
+        } else {
+            return fail('missing closing `}`', lastOpening);
+        }
+    } else if (parenLevel !== 0) {
+        return fail('missing closing `)`', lastOpeningParen);
+    }
+
+    emitChunk(true);
+    return chunks;
+};