less 4.4.2 → 4.6.0

package/lib/less/parse-tree.js

@@ -1,68 +1,124 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var less_error_1 = tslib_1.__importDefault(require("./less-error"));
-var transform_tree_1 = tslib_1.__importDefault(require("./transform-tree"));
-var logger_1 = tslib_1.__importDefault(require("./logger"));
-function default_1(SourceMapBuilder) {
-    var ParseTree = /** @class */ (function () {
-        function ParseTree(root, imports) {
+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;
         }
-        ParseTree.prototype.toCSS = function (options) {
-            var evaldRoot;
-            var result = {};
-            var sourceMapBuilder;
+
+        toCSS(options) {
+            let evaldRoot;
+            const result = {};
+            let sourceMapBuilder;
             try {
-                evaldRoot = (0, transform_tree_1.default)(this.root, options);
-            }
-            catch (e) {
-                throw new less_error_1.default(e, this.imports);
+                evaldRoot = transformTree(this.root, options);
+            } catch (e) {
+                throw new LessError(e, this.imports);
             }
+
             try {
-                var compress = Boolean(options.compress);
+                const compress = Boolean(options.compress);
                 if (compress) {
-                    logger_1.default.warn('The compress option has been deprecated. ' +
+                    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,
+
+                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
-                };
+                    numPrecision: 8};
+
                 if (options.sourceMap) {
-                    sourceMapBuilder = new SourceMapBuilder(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 {
+                } else {
                     result.css = evaldRoot.toCSS(toCSSOptions);
                 }
+            } catch (e) {
+                throw new LessError(e, this.imports);
             }
-            catch (e) {
-                throw new less_error_1.default(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 });
+                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 (var file in this.imports.files) {
+            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;
-    }());
+        }
+    }
+
     return ParseTree;
 }
-exports.default = default_1;
-//# sourceMappingURL=parse-tree.js.map

package/lib/less/parse.js

@@ -1,13 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var contexts_1 = tslib_1.__importDefault(require("./contexts"));
-var parser_1 = tslib_1.__importDefault(require("./parser/parser"));
-var plugin_manager_1 = tslib_1.__importDefault(require("./plugin-manager"));
-var less_error_1 = tslib_1.__importDefault(require("./less-error"));
-var utils = tslib_1.__importStar(require("./utils"));
-function default_1(environment, ParseTree, ImportManager) {
-    var parse = function (input, options, callback) {
+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, {});
@@ -15,37 +14,38 @@ function default_1(environment, ParseTree, ImportManager) {
         else {
             options = utils.copyOptions(this.options, options || {});
         }
+
         if (!callback) {
-            var self_1 = this;
+            const self = this;
             return new Promise(function (resolve, reject) {
-                parse.call(self_1, input, options, function (err, output) {
+                parse.call(self, input, options, function(err, output) {
                     if (err) {
                         reject(err);
-                    }
-                    else {
+                    } else {
                         resolve(output);
                     }
                 });
             });
-        }
-        else {
-            var context_1;
-            var rootFileInfo = void 0;
-            var pluginManager_1 = new plugin_manager_1.default(this, !options.reUsePluginManager);
-            options.pluginManager = pluginManager_1;
-            context_1 = new contexts_1.default.Parse(options);
+        } 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 {
-                var filename = options.filename || 'input';
-                var entryPath = filename.replace(/[^/\\]*$/, '');
+            } else {
+                const filename = options.filename || 'input';
+                const entryPath = filename.replace(/[^/\\]*$/, '');
                 rootFileInfo = {
-                    filename: filename,
-                    rewriteUrls: context_1.rewriteUrls,
-                    rootpath: context_1.rootpath || '',
+                    filename,
+                    rewriteUrls: context.rewriteUrls,
+                    rootpath: context.rootpath || '',
                     currentDirectory: entryPath,
-                    entryPath: entryPath,
+                    entryPath,
                     rootFilename: filename
                 };
                 // add in a missing trailing slash
@@ -53,35 +53,35 @@ function default_1(environment, ParseTree, ImportManager) {
                     rootFileInfo.rootpath += '/';
                 }
             }
-            var imports_1 = new ImportManager(this, context_1, rootFileInfo);
-            this.importManager = imports_1;
+
+            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) {
-                    var evalResult, contents;
+                options.plugins.forEach(function(plugin) {
+                    let evalResult, contents;
                     if (plugin.fileContent) {
                         contents = plugin.fileContent.replace(/^\uFEFF/, '');
-                        evalResult = pluginManager_1.Loader.evalPlugin(contents, context_1, imports_1, plugin.options, plugin.filename);
-                        if (evalResult instanceof less_error_1.default) {
+                        evalResult = pluginManager.Loader.evalPlugin(contents, context, imports, plugin.options, plugin.filename);
+                        if (evalResult instanceof LessError) {
                             return callback(evalResult);
                         }
                     }
                     else {
-                        pluginManager_1.addPlugin(plugin);
+                        pluginManager.addPlugin(plugin);
                     }
                 });
             }
-            new parser_1.default(context_1, imports_1, rootFileInfo)
+
+            new Parser(context, imports, rootFileInfo)
                 .parse(input, function (e, root) {
-                if (e) {
-                    return callback(e);
-                }
-                callback(null, root, imports_1, options);
-            }, options);
+                    if (e) { return callback(e); }
+                    callback(null, root, imports, options);
+                }, options);
         }
     };
     return parse;
 }
-exports.default = default_1;
-//# sourceMappingURL=parse.js.map