less 4.5.1 → 4.6.1

package/lib/less/plugin-manager.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Plugin Manager
  */
-var PluginManager = /** @class */ (function () {
-    function PluginManager(less) {
+class PluginManager {
+    constructor(less) {
         this.less = less;
         this.visitors = [];
         this.preProcessors = [];
@@ -15,23 +13,25 @@ var PluginManager = /** @class */ (function () {
         this.pluginCache = {};
         this.Loader = new less.PluginLoader(less);
     }
+
     /**
      * Adds all the plugins in the array
      * @param {Array} plugins
      */
-    PluginManager.prototype.addPlugins = function (plugins) {
+    addPlugins(plugins) {
         if (plugins) {
-            for (var i = 0; i < plugins.length; i++) {
+            for (let i = 0; i < plugins.length; i++) {
                 this.addPlugin(plugins[i]);
             }
         }
-    };
+    }
+
     /**
      *
      * @param plugin
      * @param {String} filename
      */
-    PluginManager.prototype.addPlugin = function (plugin, filename, functionRegistry) {
+    addPlugin(plugin, filename, functionRegistry) {
         this.installedPlugins.push(plugin);
         if (filename) {
             this.pluginCache[filename] = plugin;
@@ -39,119 +39,130 @@ var PluginManager = /** @class */ (function () {
         if (plugin.install) {
             plugin.install(this.less, this, functionRegistry || this.less.functions.functionRegistry);
         }
-    };
+    }
+
     /**
      *
      * @param filename
      */
-    PluginManager.prototype.get = function (filename) {
+    get(filename) {
         return this.pluginCache[filename];
-    };
+    }
+
     /**
      * Adds a visitor. The visitor object has options on itself to determine
      * when it should run.
      * @param visitor
      */
-    PluginManager.prototype.addVisitor = function (visitor) {
+    addVisitor(visitor) {
         this.visitors.push(visitor);
-    };
+    }
+
     /**
      * Adds a pre processor object
      * @param {object} preProcessor
      * @param {number} priority - guidelines 1 = before import, 1000 = import, 2000 = after import
      */
-    PluginManager.prototype.addPreProcessor = function (preProcessor, priority) {
-        var indexToInsertAt;
+    addPreProcessor(preProcessor, priority) {
+        let indexToInsertAt;
         for (indexToInsertAt = 0; indexToInsertAt < this.preProcessors.length; indexToInsertAt++) {
             if (this.preProcessors[indexToInsertAt].priority >= priority) {
                 break;
             }
         }
-        this.preProcessors.splice(indexToInsertAt, 0, { preProcessor: preProcessor, priority: priority });
-    };
+        this.preProcessors.splice(indexToInsertAt, 0, {preProcessor, priority});
+    }
+
     /**
      * Adds a post processor object
      * @param {object} postProcessor
      * @param {number} priority - guidelines 1 = before compression, 1000 = compression, 2000 = after compression
      */
-    PluginManager.prototype.addPostProcessor = function (postProcessor, priority) {
-        var indexToInsertAt;
+    addPostProcessor(postProcessor, priority) {
+        let indexToInsertAt;
         for (indexToInsertAt = 0; indexToInsertAt < this.postProcessors.length; indexToInsertAt++) {
             if (this.postProcessors[indexToInsertAt].priority >= priority) {
                 break;
             }
         }
-        this.postProcessors.splice(indexToInsertAt, 0, { postProcessor: postProcessor, priority: priority });
-    };
+        this.postProcessors.splice(indexToInsertAt, 0, {postProcessor, priority});
+    }
+
     /**
      *
      * @param manager
      */
-    PluginManager.prototype.addFileManager = function (manager) {
+    addFileManager(manager) {
         this.fileManagers.push(manager);
-    };
+    }
+
     /**
      *
      * @returns {Array}
      * @private
      */
-    PluginManager.prototype.getPreProcessors = function () {
-        var preProcessors = [];
-        for (var i = 0; i < this.preProcessors.length; i++) {
+    getPreProcessors() {
+        const preProcessors = [];
+        for (let i = 0; i < this.preProcessors.length; i++) {
             preProcessors.push(this.preProcessors[i].preProcessor);
         }
         return preProcessors;
-    };
+    }
+
     /**
      *
      * @returns {Array}
      * @private
      */
-    PluginManager.prototype.getPostProcessors = function () {
-        var postProcessors = [];
-        for (var i = 0; i < this.postProcessors.length; i++) {
+    getPostProcessors() {
+        const postProcessors = [];
+        for (let i = 0; i < this.postProcessors.length; i++) {
             postProcessors.push(this.postProcessors[i].postProcessor);
         }
         return postProcessors;
-    };
+    }
+
     /**
      *
      * @returns {Array}
      * @private
      */
-    PluginManager.prototype.getVisitors = function () {
+    getVisitors() {
         return this.visitors;
-    };
-    PluginManager.prototype.visitor = function () {
-        var self = this;
+    }
+
+    visitor() {
+        const self = this;
         return {
-            first: function () {
+            first: function() {
                 self.iterator = -1;
                 return self.visitors[self.iterator];
             },
-            get: function () {
+            get: function() {
                 self.iterator += 1;
                 return self.visitors[self.iterator];
             }
         };
-    };
+    }
+
     /**
      *
      * @returns {Array}
      * @private
      */
-    PluginManager.prototype.getFileManagers = function () {
+    getFileManagers() {
         return this.fileManagers;
-    };
-    return PluginManager;
-}());
-var pm;
-var PluginManagerFactory = function (less, newFactory) {
+    }
+}
+
+let pm;
+
+const PluginManagerFactory = function(less, newFactory) {
     if (newFactory || !pm) {
         pm = new PluginManager(less);
     }
     return pm;
 };
+
 //
-exports.default = PluginManagerFactory;
-//# sourceMappingURL=plugin-manager.js.map
+export default PluginManagerFactory;

package/lib/less/render.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var utils = tslib_1.__importStar(require("./utils"));
-function default_1(environment, ParseTree) {
-    var render = function (input, options, callback) {
+import * as utils from './utils.js';
+
+export default function(environment, ParseTree) {
+    const render = function (input, options, callback) {
         if (typeof options === 'function') {
             callback = options;
             options = utils.copyOptions(this.options, {});
@@ -11,37 +9,33 @@ function default_1(environment, ParseTree) {
         else {
             options = utils.copyOptions(this.options, options || {});
         }
+
         if (!callback) {
-            var self_1 = this;
+            const self = this;
             return new Promise(function (resolve, reject) {
-                render.call(self_1, input, options, function (err, output) {
+                render.call(self, input, options, function(err, output) {
                     if (err) {
                         reject(err);
-                    }
-                    else {
+                    } else {
                         resolve(output);
                     }
                 });
             });
-        }
-        else {
-            this.parse(input, options, function (err, root, imports, options) {
-                if (err) {
-                    return callback(err);
-                }
-                var result;
+        } else {
+            this.parse(input, options, function(err, root, imports, options) {
+                if (err) { return callback(err); }
+
+                let result;
                 try {
-                    var parseTree = new ParseTree(root, imports);
+                    const parseTree = new ParseTree(root, imports);
                     result = parseTree.toCSS(options);
                 }
-                catch (err) {
-                    return callback(err);
-                }
+                catch (err) { return callback(err); }
+
                 callback(null, result);
             });
         }
     };
+
     return render;
 }
-exports.default = default_1;
-//# sourceMappingURL=render.js.map

package/lib/less/source-map-builder.js

@@ -1,26 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function default_1(SourceMapOutput, environment) {
-    var SourceMapBuilder = /** @class */ (function () {
-        function SourceMapBuilder(options) {
+export default function (SourceMapOutput, environment) {
+    class SourceMapBuilder {
+        constructor(options) {
             this.options = options;
         }
-        SourceMapBuilder.prototype.toCSS = function (rootNode, options, imports) {
-            var sourceMapOutput = new SourceMapOutput({
-                contentsIgnoredCharsMap: imports.contentsIgnoredChars,
-                rootNode: rootNode,
-                contentsMap: imports.contents,
-                sourceMapFilename: this.options.sourceMapFilename,
-                sourceMapURL: this.options.sourceMapURL,
-                outputFilename: this.options.sourceMapOutputFilename,
-                sourceMapBasepath: this.options.sourceMapBasepath,
-                sourceMapRootpath: this.options.sourceMapRootpath,
-                outputSourceFiles: this.options.outputSourceFiles,
-                sourceMapGenerator: this.options.sourceMapGenerator,
-                sourceMapFileInline: this.options.sourceMapFileInline,
-                disableSourcemapAnnotation: this.options.disableSourcemapAnnotation
-            });
-            var css = sourceMapOutput.toCSS(options);
+
+        toCSS(rootNode, options, imports) {
+            const sourceMapOutput = new SourceMapOutput(
+                {
+                    contentsIgnoredCharsMap: imports.contentsIgnoredChars,
+                    rootNode,
+                    contentsMap: imports.contents,
+                    sourceMapFilename: this.options.sourceMapFilename,
+                    sourceMapURL: this.options.sourceMapURL,
+                    outputFilename: this.options.sourceMapOutputFilename,
+                    sourceMapBasepath: this.options.sourceMapBasepath,
+                    sourceMapRootpath: this.options.sourceMapRootpath,
+                    outputSourceFiles: this.options.outputSourceFiles,
+                    sourceMapGenerator: this.options.sourceMapGenerator,
+                    sourceMapFileInline: this.options.sourceMapFileInline,    
+                    disableSourcemapAnnotation: this.options.disableSourcemapAnnotation
+                });
+
+            const css = sourceMapOutput.toCSS(options);
             this.sourceMap = sourceMapOutput.sourceMap;
             this.sourceMapURL = sourceMapOutput.sourceMapURL;
             if (this.options.sourceMapInputFilename) {
@@ -30,44 +31,52 @@ function default_1(SourceMapOutput, environment) {
                 this.sourceMapURL = sourceMapOutput.removeBasepath(this.sourceMapURL);
             }
             return css + this.getCSSAppendage();
-        };
-        SourceMapBuilder.prototype.getCSSAppendage = function () {
-            var sourceMapURL = this.sourceMapURL;
+        }
+
+        getCSSAppendage() {
+
+            let sourceMapURL = this.sourceMapURL;
             if (this.options.sourceMapFileInline) {
                 if (this.sourceMap === undefined) {
                     return '';
                 }
-                sourceMapURL = "data:application/json;base64,".concat(environment.encodeBase64(this.sourceMap));
+                sourceMapURL = `data:application/json;base64,${environment.encodeBase64(this.sourceMap)}`;
             }
+
             if (this.options.disableSourcemapAnnotation) {
                 return '';
             }
+
             if (sourceMapURL) {
-                return "/*# sourceMappingURL=".concat(sourceMapURL, " */");
+                return `/*# sourceMappingURL=${sourceMapURL} */`;
             }
             return '';
-        };
-        SourceMapBuilder.prototype.getExternalSourceMap = function () {
+        }
+
+        getExternalSourceMap() {
             return this.sourceMap;
-        };
-        SourceMapBuilder.prototype.setExternalSourceMap = function (sourceMap) {
+        }
+
+        setExternalSourceMap(sourceMap) {
             this.sourceMap = sourceMap;
-        };
-        SourceMapBuilder.prototype.isInline = function () {
+        }
+
+        isInline() {
             return this.options.sourceMapFileInline;
-        };
-        SourceMapBuilder.prototype.getSourceMapURL = function () {
+        }
+
+        getSourceMapURL() {
             return this.sourceMapURL;
-        };
-        SourceMapBuilder.prototype.getOutputFilename = function () {
+        }
+
+        getOutputFilename() {
             return this.options.sourceMapOutputFilename;
-        };
-        SourceMapBuilder.prototype.getInputFilename = function () {
+        }
+
+        getInputFilename() {
             return this.sourceMapInputFilename;
-        };
-        return SourceMapBuilder;
-    }());
+        }
+    }
+
     return SourceMapBuilder;
 }
-exports.default = default_1;
-//# sourceMappingURL=source-map-builder.js.map

package/lib/less/source-map-output.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function default_1(environment) {
-    var SourceMapOutput = /** @class */ (function () {
-        function SourceMapOutput(options) {
+export default function (environment) {
+    class SourceMapOutput {
+        constructor(options) {
             this._css = [];
             this._rootNode = options.rootNode;
             this._contentsMap = options.contentsMap;
@@ -20,48 +18,55 @@ function default_1(environment) {
                 if (this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/') {
                     this._sourceMapRootpath += '/';
                 }
-            }
-            else {
+            } else {
                 this._sourceMapRootpath = '';
             }
             this._outputSourceFiles = options.outputSourceFiles;
             this._sourceMapGeneratorConstructor = environment.getSourceMapGenerator();
+
             this._lineNumber = 0;
             this._column = 0;
         }
-        SourceMapOutput.prototype.removeBasepath = function (path) {
+
+        removeBasepath(path) {
             if (this._sourceMapBasepath && path.indexOf(this._sourceMapBasepath) === 0) {
                 path = path.substring(this._sourceMapBasepath.length);
                 if (path.charAt(0) === '\\' || path.charAt(0) === '/') {
                     path = path.substring(1);
                 }
             }
+
             return path;
-        };
-        SourceMapOutput.prototype.normalizeFilename = function (filename) {
+        }
+
+        normalizeFilename(filename) {
             filename = filename.replace(/\\/g, '/');
             filename = this.removeBasepath(filename);
             return (this._sourceMapRootpath || '') + filename;
-        };
-        SourceMapOutput.prototype.add = function (chunk, fileInfo, index, mapLines) {
+        }
+
+        add(chunk, fileInfo, index, mapLines) {
+
             // ignore adding empty strings
             if (!chunk) {
                 return;
             }
-            var lines, sourceLines, columns, sourceColumns, i;
+
+            let lines, sourceLines, columns, sourceColumns, i;
+
             if (fileInfo && fileInfo.filename) {
-                var inputSource = this._contentsMap[fileInfo.filename];
+                let inputSource = this._contentsMap[fileInfo.filename];
+
                 // remove vars/banner added to the top of the file
                 if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
                     // adjust the index
                     index -= this._contentsIgnoredCharsMap[fileInfo.filename];
-                    if (index < 0) {
-                        index = 0;
-                    }
+                    if (index < 0) { index = 0; }
                     // adjust the source
                     inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
                 }
-                /**
+
+                /** 
                  * ignore empty content, or failsafe
                  * if contents map is incorrect
                  */
@@ -69,45 +74,51 @@ function default_1(environment) {
                     this._css.push(chunk);
                     return;
                 }
+
                 inputSource = inputSource.substring(0, index);
                 sourceLines = inputSource.split('\n');
                 sourceColumns = sourceLines[sourceLines.length - 1];
             }
+
             lines = chunk.split('\n');
             columns = lines[lines.length - 1];
+
             if (fileInfo && fileInfo.filename) {
                 if (!mapLines) {
-                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column },
-                        original: { line: sourceLines.length, column: sourceColumns.length },
-                        source: this.normalizeFilename(fileInfo.filename) });
-                }
-                else {
+                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column},
+                        original: { line: sourceLines.length, column: sourceColumns.length},
+                        source: this.normalizeFilename(fileInfo.filename)});
+                } else {
                     for (i = 0; i < lines.length; i++) {
-                        this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0 },
-                            original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0 },
-                            source: this.normalizeFilename(fileInfo.filename) });
+                        this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0},
+                            original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0},
+                            source: this.normalizeFilename(fileInfo.filename)});
                     }
                 }
             }
+
             if (lines.length === 1) {
                 this._column += columns.length;
-            }
-            else {
+            } else {
                 this._lineNumber += lines.length - 1;
                 this._column = columns.length;
             }
+
             this._css.push(chunk);
-        };
-        SourceMapOutput.prototype.isEmpty = function () {
+        }
+
+        isEmpty() {
             return this._css.length === 0;
-        };
-        SourceMapOutput.prototype.toCSS = function (context) {
+        }
+
+        toCSS(context) {
             this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
+
             if (this._outputSourceFiles) {
-                for (var filename in this._contentsMap) {
+                for (const filename in this._contentsMap) {
                     // eslint-disable-next-line no-prototype-builtins
                     if (this._contentsMap.hasOwnProperty(filename)) {
-                        var source = this._contentsMap[filename];
+                        let source = this._contentsMap[filename];
                         if (this._contentsIgnoredCharsMap[filename]) {
                             source = source.slice(this._contentsIgnoredCharsMap[filename]);
                         }
@@ -115,24 +126,26 @@ function default_1(environment) {
                     }
                 }
             }
+
             this._rootNode.genCSS(context, this);
+
             if (this._css.length > 0) {
-                var sourceMapURL = void 0;
-                var sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
+                let sourceMapURL;
+                const sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
+
                 if (this.sourceMapURL) {
                     sourceMapURL = this.sourceMapURL;
-                }
-                else if (this._sourceMapFilename) {
+                } else if (this._sourceMapFilename) {
                     sourceMapURL = this._sourceMapFilename;
                 }
                 this.sourceMapURL = sourceMapURL;
+
                 this.sourceMap = sourceMapContent;
             }
+
             return this._css.join('');
-        };
-        return SourceMapOutput;
-    }());
+        }
+    }
+
     return SourceMapOutput;
 }
-exports.default = default_1;
-//# sourceMappingURL=source-map-output.js.map