less 4.8.1 → 5.0.0-alpha.1

package/lib/less/import-manager.js

@@ -1,183 +0,0 @@
-import contexts from './contexts.js';
-import Parser from './parser/parser.js';
-import LessError from './less-error.js';
-import * as utils from './utils.js';
-import logger from './logger.js';
-
-export default function(environment) {
-    // FileInfo = {
-    //  'rewriteUrls' - 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
-
-    class ImportManager {
-        constructor(less, context, rootFileInfo) {
-            this.less = less;
-            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 tryAppendExtension - whether to try appending a file extension (.less or .js 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
-         */
-        push(path, tryAppendExtension, currentFileInfo, importOptions, callback) {
-            const importManager = this, pluginLoader = this.context.pluginManager.Loader;
-
-            this.queue.push(path);
-
-            const fileParsedFunc = function (e, root, fullPath) {
-                importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
-
-                const importedEqualsRoot = fullPath === importManager.rootFilename;
-                if (importOptions.optional && e) {
-                    callback(null, {rules:[]}, false, null);
-                    logger.info(`The file ${fullPath} was skipped because it was not found and the import was marked optional.`);
-                }
-                else {
-                    // Inline imports aren't cached here.
-                    // If we start to cache them, please make sure they won't conflict with non-inline imports of the
-                    // same name as they used to do before this comment and the condition below have been added.
-                    if (!importManager.files[fullPath] && !importOptions.inline) {
-                        importManager.files[fullPath] = { root, options: importOptions };
-                    }
-                    if (e && !importManager.error) { importManager.error = e; }
-                    callback(e, root, importedEqualsRoot, fullPath);
-                }
-            };
-
-            const newFileInfo = {
-                rewriteUrls: this.context.rewriteUrls,
-                entryPath: currentFileInfo.entryPath,
-                rootpath: currentFileInfo.rootpath,
-                rootFilename: currentFileInfo.rootFilename
-            };
-
-            const fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
-
-            if (!fileManager) {
-                fileParsedFunc({ message: `Could not find a file-manager for ${path}` });
-                return;
-            }
-
-            const loadFileCallback = function(loadedFile) {
-                let plugin;
-                const resolvedFilename = loadedFile.filename;
-                const 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.rewriteUrls) {
-                    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;
-
-                const newEnv = new contexts.Parse(importManager.context);
-
-                newEnv.processImports = false;
-                importManager.contents[resolvedFilename] = contents;
-
-                if (currentFileInfo.reference || importOptions.reference) {
-                    newFileInfo.reference = true;
-                }
-
-                if (importOptions.isPlugin) {
-                    plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
-                    if (plugin instanceof LessError) {
-                        fileParsedFunc(plugin, null, resolvedFilename);
-                    }
-                    else {
-                        fileParsedFunc(null, plugin, resolvedFilename);
-                    }
-                } else if (importOptions.inline) {
-                    fileParsedFunc(null, contents, resolvedFilename);
-                } else {
-                    // import (multiple) parse trees apparently get altered and can't be cached.
-                    // TODO: investigate why this is
-                    if (importManager.files[resolvedFilename]
-                        && !importManager.files[resolvedFilename].options.multiple
-                        && !importOptions.multiple) {
-
-                        fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
-                    }
-                    else {
-                        new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
-                            fileParsedFunc(e, root, resolvedFilename);
-                        });
-                    }
-                }
-            };
-            let loadedFile;
-            let promise;
-            const context = utils.clone(this.context);
-
-            if (tryAppendExtension) {
-                context.ext = importOptions.isPlugin ? '.js' : '.less';
-            }
-
-            if (importOptions.isPlugin) {
-                context.mime = 'application/javascript';
-
-                if (context.syncImport) {
-                    loadedFile = pluginLoader.loadPluginSync(path, currentFileInfo.currentDirectory, context, environment, fileManager);
-                } else {
-                    promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
-                }
-            }
-            else {
-                if (context.syncImport) {
-                    loadedFile = fileManager.loadFileSync(path, currentFileInfo.currentDirectory, context, environment);
-                } else {
-                    promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment,
-                        (err, loadedFile) => {
-                            if (err) {
-                                fileParsedFunc(err);
-                            } else {
-                                loadFileCallback(loadedFile);
-                            }
-                        });
-                }
-            }
-            if (loadedFile) {
-                if (!loadedFile.filename) {
-                    fileParsedFunc(loadedFile);
-                } else {
-                    loadFileCallback(loadedFile);
-                }
-            } else if (promise) {
-                promise.then(loadFileCallback, fileParsedFunc);
-            }
-        }
-    }
-
-    return ImportManager;
-}

package/lib/less/index.js

@@ -1,95 +0,0 @@
-import Environment from './environment/environment.js';
-import data from './data/index.js';
-import tree from './tree/index.js';
-import AbstractFileManager from './environment/abstract-file-manager.js';
-import AbstractPluginLoader from './environment/abstract-plugin-loader.js';
-import visitors from './visitors/index.js';
-import Parser from './parser/parser.js';
-import functions from './functions/index.js';
-import contexts from './contexts.js';
-import LessError from './less-error.js';
-import transformTree from './transform-tree.js';
-import * as utils from './utils.js';
-import PluginManager from './plugin-manager.js';
-import logger from './logger.js';
-import SourceMapOutput from './source-map-output.js';
-import SourceMapBuilder from './source-map-builder.js';
-import ParseTree from './parse-tree.js';
-import ImportManager from './import-manager.js';
-import Parse from './parse.js';
-import Render from './render.js';
-import parseVersion from 'parse-node-version';
-
-export default function(environment, fileManagers, version = '0.0.0') {
-    let sourceMapOutput, sourceMapBuilder, parseTree, importManager;
-
-    environment = new Environment(environment, fileManagers);
-    sourceMapOutput = SourceMapOutput(environment);
-    sourceMapBuilder = SourceMapBuilder(sourceMapOutput, environment);
-    parseTree = ParseTree(sourceMapBuilder);
-    importManager = ImportManager(environment);
-
-    const render = Render(environment, parseTree, importManager);
-    const parse = Parse(environment, parseTree, importManager);
-
-    const v = parseVersion(`v${version}`);
-    const initial = {
-        version: [v.major, v.minor, v.patch],
-        data,
-        tree,
-        Environment,
-        AbstractFileManager,
-        AbstractPluginLoader,
-        environment,
-        visitors,
-        Parser,
-        functions: functions(environment),
-        contexts,
-        SourceMapOutput: sourceMapOutput,
-        SourceMapBuilder: sourceMapBuilder,
-        ParseTree: parseTree,
-        ImportManager: importManager,
-        render,
-        parse,
-        LessError,
-        transformTree,
-        utils,
-        PluginManager,
-        logger
-    };
-
-    // Create a public API
-
-    const ctor = function(t) {
-        return 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]);
-            }
-        }
-    }
-
-    /**
-     * Some of the functions assume a `this` context of the API object,
-     * which causes it to fail when wrapped for ES6 imports.
-     * 
-     * An assumed `this` should be removed in the future.
-     */
-    initial.parse = initial.parse.bind(api);
-    initial.render = initial.render.bind(api);
-
-    return api;
-}

package/lib/less/less-error.js

@@ -1,166 +0,0 @@
-import * as utils from './utils.js';
-
-const anonymousFunc = /(<anonymous>|Function):(\d+):(\d+)/;
-
-/**
- * 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(e, fileContentMap, currentFilename) {
-    Error.call(this);
-
-    const filename = e.filename || currentFilename;
-
-    this.message = e.message;
-    this.stack = e.stack;
-    
-    // Set type early so it's always available, even if fileContentMap is missing
-    this.type = e.type || 'Syntax';
-
-    if (fileContentMap && filename) {
-        const input = fileContentMap.contents[filename];
-        const loc = utils.getLocation(e.index, input);
-        var line = loc.line;
-        const col  = loc.column;
-        const callLine = e.call && utils.getLocation(e.call, input).line;
-        const lines = input ? input.split('\n') : '';
-
-        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(anonymousFunc);
-
-            /**
-             * We have to figure out how this environment stringifies anonymous functions
-             * so we can correctly map plugin errors.
-             *
-             * Note, in Node 8, the output of anonymous funcs varied based on parameters
-             * being present or not, so we inject dummy params.
-             */
-            const func = new Function('a', 'throw new Error()');
-            let lineAdjust = 0;
-            try {
-                func();
-            } catch (e) {
-                const match = e.stack.match(anonymousFunc);
-                lineAdjust = 1 - parseInt(match[2]);
-            }
-
-            if (found) {
-                if (found[2]) {
-                    this.line = parseInt(found[2]) + lineAdjust;
-                }
-                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 = function () {};
-    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) {
-    options = options || {};
-    const isWarning = (this.type ?? '').toLowerCase().includes('warning');
-    const type = isWarning ? this.type : `${this.type}Error`;
-    const color = isWarning ? 'yellow' : 'red';
-
-    let message = '';
-    const extract = this.extract || [];
-    let error = [];
-    let stylize = function (str) { return 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 (!isWarning && 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].slice(this.column, this.column + 1), 'bold') +
-                        extract[1].slice(this.column + 1), 'red'), 'inverse');
-            }
-            error.push(errorTxt);
-        }
-
-        if (!isWarning && typeof extract[2] === 'string') {
-            error.push(stylize(`${this.line + 1} ${extract[2]}`, 'grey'));
-        }
-        error = `${error.join('\n') + stylize('', 'reset')}\n`;
-    }
-
-    message += stylize(`${type}: ${this.message}`, color);
-    if (this.filename) {
-        message += stylize(' in ', color) + 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 ', color) + (this.filename || '')}/n`;
-        message += `${stylize(this.callLine, 'grey')} ${this.callExtract}/n`;
-    }
-
-    return message;
-};
-
-export default LessError;

package/lib/less/logger.js

@@ -1,34 +0,0 @@
-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

@@ -1,124 +0,0 @@
-import LessError from './less-error.js';
-import transformTree from './transform-tree.js';
-import logger from './logger.js';
-
-export default function(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,
-                    // @deprecated The dumpLineNumbers option is deprecated. Use sourcemaps instead. All modes will be removed in a future version.
-                    dumpLineNumbers: options.dumpLineNumbers,
-                    strictUnits: Boolean(options.strictUnits),
-                    numPrecision: 8};
-
-                if (options.sourceMap) {
-                    // Normalize sourceMap option: if it's just true, convert to object
-                    if (options.sourceMap === true) {
-                        options.sourceMap = {};
-                    }
-                    const sourceMapOpts = options.sourceMap;
-                    
-                    // Set sourceMapInputFilename if not set and filename is available
-                    if (!sourceMapOpts.sourceMapInputFilename && options.filename) {
-                        sourceMapOpts.sourceMapInputFilename = options.filename;
-                    }
-                    
-                    // Default sourceMapBasepath to the input file's directory if not set
-                    // This matches the behavior documented and implemented in bin/lessc
-                    if (sourceMapOpts.sourceMapBasepath === undefined && options.filename) {
-                        // Get directory from filename using string manipulation (works cross-platform)
-                        const lastSlash = Math.max(options.filename.lastIndexOf('/'), options.filename.lastIndexOf('\\'));
-                        if (lastSlash >= 0) {
-                            sourceMapOpts.sourceMapBasepath = options.filename.substring(0, lastSlash);
-                        } else {
-                            // No directory separator found, use current directory
-                            sourceMapOpts.sourceMapBasepath = '.';
-                        }
-                    }
-                    
-                    // Handle sourceMapFullFilename (CLI-specific: --source-map=filename)
-                    // This is converted to sourceMapFilename and sourceMapOutputFilename
-                    if (sourceMapOpts.sourceMapFullFilename && !sourceMapOpts.sourceMapFileInline) {
-                        // This case is handled by lessc before calling render
-                        // We just need to ensure sourceMapFilename is set if sourceMapFullFilename is provided
-                        if (!sourceMapOpts.sourceMapFilename && !sourceMapOpts.sourceMapURL) {
-                            // Extract just the basename for the sourceMappingURL comment
-                            const mapBase = sourceMapOpts.sourceMapFullFilename.split(/[/\\]/).pop();
-                            sourceMapOpts.sourceMapFilename = mapBase;
-                        }
-                    } else if (!sourceMapOpts.sourceMapFilename && !sourceMapOpts.sourceMapURL) {
-                        // If sourceMapFilename is not set and sourceMapURL is not set,
-                        // derive it from the output filename (if available) or input filename
-                        if (sourceMapOpts.sourceMapOutputFilename) {
-                            // Use output filename + .map
-                            sourceMapOpts.sourceMapFilename = sourceMapOpts.sourceMapOutputFilename + '.map';
-                        } else if (options.filename) {
-                            // Fallback to input filename + .css.map (basename only)
-                            const inputBasename = options.filename.split(/[/\\]/).pop().replace(/\.[^/.]+$/, '');
-                            sourceMapOpts.sourceMapFilename = inputBasename + '.css.map';
-                        }
-                    }
-                    
-                    // Default sourceMapOutputFilename if not set
-                    if (!sourceMapOpts.sourceMapOutputFilename) {
-                        if (options.filename) {
-                            const inputBasename = options.filename.split(/[/\\]/).pop().replace(/\.[^/.]+$/, '');
-                            sourceMapOpts.sourceMapOutputFilename = inputBasename + '.css';
-                        } else {
-                            sourceMapOpts.sourceMapOutputFilename = 'output.css';
-                        }
-                    }
-                    
-                    sourceMapBuilder = new SourceMapBuilder(sourceMapOpts);
-                    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 (Object.prototype.hasOwnProperty.call(this.imports.files, file) && file !== this.imports.rootFilename) {
-                    result.imports.push(file);
-                }
-            }
-            return result;
-        }
-    }
-
-    return ParseTree;
-}

package/lib/less/parse.js

@@ -1,87 +0,0 @@
-import contexts from './contexts.js';
-import Parser from './parser/parser.js';
-import PluginManager from './plugin-manager.js';
-import LessError from './less-error.js';
-import * as utils from './utils.js';
-
-export default function(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(function (resolve, reject) {
-                parse.call(self, input, options, function(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(function(plugin) {
-                    let evalResult, 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, function (e, root) {
-                    if (e) { return callback(e); }
-                    callback(null, root, imports, options);
-                }, options);
-        }
-    };
-    return parse;
-}