less 4.5.1 → 4.6.0

package/lib/less-browser/image-size.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var function_registry_1 = tslib_1.__importDefault(require("./../less/functions/function-registry"));
-exports.default = (function () {
+
+import functionRegistry from './../less/functions/function-registry.js';
+
+export default () => {
     function imageSize() {
         throw {
             type: 'Runtime',
             message: 'Image size functions are not supported in browser version of less'
         };
     }
-    var imageFunctions = {
-        'image-size': function (filePathNode) {
+
+    const imageFunctions = {
+        'image-size': function(filePathNode) {
             imageSize(this, filePathNode);
             return -1;
         },
-        'image-width': function (filePathNode) {
+        'image-width': function(filePathNode) {
             imageSize(this, filePathNode);
             return -1;
         },
-        'image-height': function (filePathNode) {
+        'image-height': function(filePathNode) {
             imageSize(this, filePathNode);
             return -1;
         }
     };
-    function_registry_1.default.addMultiple(imageFunctions);
-});
-//# sourceMappingURL=image-size.js.map
+
+    functionRegistry.addMultiple(imageFunctions);
+};

package/lib/less-browser/index.js

@@ -1,258 +1,284 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
 //
 // index.js
 // Should expose the additional browser functions on to the less object
 //
-var utils_1 = require("./utils");
-var less_1 = tslib_1.__importDefault(require("../less"));
-var browser_1 = tslib_1.__importDefault(require("./browser"));
-var file_manager_1 = tslib_1.__importDefault(require("./file-manager"));
-var plugin_loader_1 = tslib_1.__importDefault(require("./plugin-loader"));
-var log_listener_1 = tslib_1.__importDefault(require("./log-listener"));
-var error_reporting_1 = tslib_1.__importDefault(require("./error-reporting"));
-var cache_1 = tslib_1.__importDefault(require("./cache"));
-var image_size_1 = tslib_1.__importDefault(require("./image-size"));
-exports.default = (function (window, options) {
-    var document = window.document;
-    var less = (0, less_1.default)();
+import {addDataAttr} from './utils.js';
+import lessRoot from '../less/index.js';
+import browser from './browser.js';
+import FM from './file-manager.js';
+import PluginLoader from './plugin-loader.js';
+import LogListener from './log-listener.js';
+import ErrorReporting from './error-reporting.js';
+import Cache from './cache.js';
+import ImageSize from './image-size.js';
+import pkg from '../../package.json';
+
+/**
+ * @param {Window} window
+ * @param {Object} options
+ */
+export default (window, options) => {
+    const document = window.document;
+    const less = lessRoot(undefined, undefined, pkg.version);
+
     less.options = options;
-    var environment = less.environment;
-    var FileManager = (0, file_manager_1.default)(options, less.logger);
-    var fileManager = new FileManager();
+    const environment = less.environment;
+    const FileManager = FM(options, less.logger);
+    const fileManager = new FileManager();
     environment.addFileManager(fileManager);
     less.FileManager = FileManager;
-    less.PluginLoader = plugin_loader_1.default;
-    (0, log_listener_1.default)(less, options);
-    var errors = (0, error_reporting_1.default)(window, less, options);
-    var cache = less.cache = options.cache || (0, cache_1.default)(window, options, less.logger);
-    (0, image_size_1.default)(less.environment);
+    less.PluginLoader = PluginLoader;
+
+    LogListener(less, options);
+    const errors = ErrorReporting(window, less, options);
+    const cache = less.cache = options.cache || Cache(window, options, less.logger);
+    ImageSize(less.environment);
+
     // Setup user functions - Deprecate?
     if (options.functions) {
         less.functions.functionRegistry.addMultiple(options.functions);
     }
-    var typePattern = /^text\/(x-)?less$/;
+
+    const typePattern = /^text\/(x-)?less$/;
+
     function clone(obj) {
-        var cloned = {};
-        for (var prop in obj) {
+        const cloned = {};
+        for (const prop in obj) {
             if (Object.prototype.hasOwnProperty.call(obj, prop)) {
                 cloned[prop] = obj[prop];
             }
         }
         return cloned;
     }
-    // only really needed for phantom
-    function bind(func, thisArg) {
-        var curryArgs = Array.prototype.slice.call(arguments, 2);
-        return function () {
-            var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
-            return func.apply(thisArg, args);
-        };
-    }
+
     function loadStyles(modifyVars) {
-        var styles = document.getElementsByTagName('style');
-        var style;
-        for (var i = 0; i < styles.length; i++) {
-            style = styles[i];
+        const styles = document.getElementsByTagName('style');
+
+        for (let style of styles) {
             if (style.type.match(typePattern)) {
-                var instanceOptions = clone(options);
-                instanceOptions.modifyVars = modifyVars;
-                var lessText = style.innerHTML || '';
-                instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+                const instanceOptions = {
+                    ...clone(options),
+                    modifyVars,
+                    filename: document.location.href.replace(/#.*$/, '')
+                }
+
+                const lessText = style.innerHTML || '';
+
                 /* jshint loopfunc:true */
-                // use closure to store current style
-                less.render(lessText, instanceOptions, bind(function (style, e, result) {
-                    if (e) {
-                        errors.add(e, 'inline');
-                    }
-                    else {
+                less.render(lessText, instanceOptions, (err, result) => {
+                    if (err) {
+                        errors.add(err, 'inline');
+                    } else {
                         style.type = 'text/css';
                         if (style.styleSheet) {
                             style.styleSheet.cssText = result.css;
-                        }
-                        else {
+                        } else {
                             style.innerHTML = result.css;
                         }
                     }
-                }, null, style));
+                });
             }
         }
     }
+
     function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
-        var instanceOptions = clone(options);
-        (0, utils_1.addDataAttr)(instanceOptions, sheet);
+
+        const instanceOptions = clone(options);
+        addDataAttr(instanceOptions, sheet);
         instanceOptions.mime = sheet.type;
+
         if (modifyVars) {
             instanceOptions.modifyVars = modifyVars;
         }
+
         function loadInitialFileCallback(loadedFile) {
-            var data = loadedFile.contents;
-            var path = loadedFile.filename;
-            var webInfo = loadedFile.webInfo;
-            var newFileInfo = {
+            const data = loadedFile.contents;
+            const path = loadedFile.filename;
+            const webInfo = loadedFile.webInfo;
+
+            const newFileInfo = {
                 currentDirectory: fileManager.getPath(path),
                 filename: path,
                 rootFilename: path,
                 rewriteUrls: instanceOptions.rewriteUrls
             };
+
             newFileInfo.entryPath = newFileInfo.currentDirectory;
             newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
+
             if (webInfo) {
                 webInfo.remaining = remaining;
-                var css = cache.getCSS(path, webInfo, instanceOptions.modifyVars);
+
+                const css = cache.getCSS(path, webInfo, instanceOptions.modifyVars);
                 if (!reload && css) {
                     webInfo.local = true;
                     callback(null, css, data, sheet, webInfo, path);
                     return;
                 }
+
             }
+
             // TODO add tests around how this behaves when reloading
             errors.remove(path);
+
             instanceOptions.rootFileInfo = newFileInfo;
-            less.render(data, instanceOptions, function (e, result) {
+            less.render(data, instanceOptions, (e, result) => {
                 if (e) {
                     e.href = path;
                     callback(e);
-                }
-                else {
+                } else {
                     cache.setCSS(sheet.href, webInfo.lastModified, instanceOptions.modifyVars, result.css);
                     callback(null, result.css, data, sheet, webInfo, path);
                 }
             });
         }
+
         fileManager.loadFile(sheet.href, null, instanceOptions, environment)
-            .then(function (loadedFile) {
-            loadInitialFileCallback(loadedFile);
-        }).catch(function (err) {
-            console.log(err);
-            callback(err);
-        });
+            .then(loadedFile => {
+                loadInitialFileCallback(loadedFile);
+            }).catch(err => {
+                console.log(err);
+                callback(err);
+            });
+
     }
+
     function loadStyleSheets(callback, reload, modifyVars) {
-        for (var i = 0; i < less.sheets.length; i++) {
+        for (let i = 0; i < less.sheets.length; i++) {
             loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
         }
     }
+
     function initRunningMode() {
         if (less.env === 'development') {
-            less.watchTimer = setInterval(function () {
+            less.watchTimer = setInterval(() => {
                 if (less.watchMode) {
                     fileManager.clearFileCache();
                     /**
                      * @todo remove when this is typed with JSDoc
                      */
                     // eslint-disable-next-line no-unused-vars
-                    loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                    loadStyleSheets((e, css, _, sheet, webInfo) => {
                         if (e) {
                             errors.add(e, e.href || sheet.href);
-                        }
-                        else if (css) {
-                            browser_1.default.createCSS(window.document, css, sheet);
+                        } else if (css) {
+                            browser.createCSS(window.document, css, sheet);
                         }
                     });
                 }
             }, options.poll);
         }
     }
+
     //
     // Watch mode
     //
     less.watch = function () {
-        if (!less.watchMode) {
+        if (!less.watchMode ) {
             less.env = 'development';
             initRunningMode();
         }
         this.watchMode = true;
         return true;
     };
-    less.unwatch = function () { clearInterval(less.watchTimer); this.watchMode = false; return false; };
+
+    less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
+
     //
     // Synchronously get all <link> tags with the 'rel' attribute set to
     // "stylesheet/less".
     //
-    less.registerStylesheetsImmediately = function () {
-        var links = document.getElementsByTagName('link');
+    less.registerStylesheetsImmediately = () => {
+        const links = document.getElementsByTagName('link');
         less.sheets = [];
-        for (var i = 0; i < links.length; i++) {
+
+        for (let i = 0; i < links.length; i++) {
             if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
                 (links[i].type.match(typePattern)))) {
                 less.sheets.push(links[i]);
             }
         }
     };
+
     //
     // Asynchronously get all <link> tags with the 'rel' attribute set to
     // "stylesheet/less", returning a Promise.
     //
-    less.registerStylesheets = function () { return new Promise(function (resolve) {
+    less.registerStylesheets = () => new Promise((resolve) => {
         less.registerStylesheetsImmediately();
         resolve();
-    }); };
+    });
+
     //
     // With this function, it's possible to alter variables and re-render
     // CSS without reloading less-files
     //
-    less.modifyVars = function (record) { return less.refresh(true, record, false); };
-    less.refresh = function (reload, modifyVars, clearFileCache) {
+    less.modifyVars = record => less.refresh(true, record, false);
+
+    less.refresh = (reload, modifyVars, clearFileCache) => {
         if ((reload || clearFileCache) && clearFileCache !== false) {
             fileManager.clearFileCache();
         }
-        return new Promise(function (resolve, reject) {
-            var startTime;
-            var endTime;
-            var totalMilliseconds;
-            var remainingSheets;
+        return new Promise((resolve, reject) => {
+            let startTime;
+            let endTime;
+            let totalMilliseconds;
+            let remainingSheets;
             startTime = endTime = new Date();
+
             // Set counter for remaining unprocessed sheets
             remainingSheets = less.sheets.length;
+
             if (remainingSheets === 0) {
+
                 endTime = new Date();
                 totalMilliseconds = endTime - startTime;
                 less.logger.info('Less has finished and no sheets were loaded.');
                 resolve({
-                    startTime: startTime,
-                    endTime: endTime,
-                    totalMilliseconds: totalMilliseconds,
+                    startTime,
+                    endTime,
+                    totalMilliseconds,
                     sheets: less.sheets.length
                 });
-            }
-            else {
+
+            } else {
                 // Relies on less.sheets array, callback seems to be guaranteed to be called for every element of the array
-                loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                loadStyleSheets((e, css, _, sheet, webInfo) => {
                     if (e) {
                         errors.add(e, e.href || sheet.href);
                         reject(e);
                         return;
                     }
                     if (webInfo.local) {
-                        less.logger.info("Loading ".concat(sheet.href, " from cache."));
-                    }
-                    else {
-                        less.logger.info("Rendered ".concat(sheet.href, " successfully."));
+                        less.logger.info(`Loading ${sheet.href} from cache.`);
+                    } else {
+                        less.logger.info(`Rendered ${sheet.href} successfully.`);
                     }
-                    browser_1.default.createCSS(window.document, css, sheet);
-                    less.logger.info("CSS for ".concat(sheet.href, " generated in ").concat(new Date() - endTime, "ms"));
+                    browser.createCSS(window.document, css, sheet);
+                    less.logger.info(`CSS for ${sheet.href} generated in ${new Date() - endTime}ms`);
+
                     // Count completed sheet
                     remainingSheets--;
+
                     // Check if the last remaining sheet was processed and then call the promise
                     if (remainingSheets === 0) {
                         totalMilliseconds = new Date() - startTime;
-                        less.logger.info("Less has finished. CSS generated in ".concat(totalMilliseconds, "ms"));
+                        less.logger.info(`Less has finished. CSS generated in ${totalMilliseconds}ms`);
                         resolve({
-                            startTime: startTime,
-                            endTime: endTime,
-                            totalMilliseconds: totalMilliseconds,
+                            startTime,
+                            endTime,
+                            totalMilliseconds,
                             sheets: less.sheets.length
                         });
                     }
                     endTime = new Date();
                 }, reload, modifyVars);
             }
+
             loadStyles(modifyVars);
         });
     };
+
     less.refreshStyles = loadStyles;
     return less;
-});
-//# sourceMappingURL=index.js.map
+};

package/lib/less-browser/log-listener.js

@@ -1,43 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (function (less, options) {
-    var logLevel_debug = 4;
-    var logLevel_info = 3;
-    var logLevel_warn = 2;
-    var logLevel_error = 1;
+export default (less, options) => {
+    const logLevel_debug = 4;
+    const logLevel_info = 3;
+    const logLevel_warn = 2;
+    const logLevel_error = 1;
+
     // The amount of logging in the javascript console.
     // 3 - Debug, information and errors
     // 2 - Information and errors
     // 1 - Errors
     // 0 - None
     // Defaults to 2
-    options.logLevel = typeof options.logLevel !== 'undefined' ? options.logLevel : (options.env === 'development' ? logLevel_info : logLevel_error);
+    options.logLevel = typeof options.logLevel !== 'undefined' ? options.logLevel : (options.env === 'development' ?  logLevel_info : logLevel_error);
+
     if (!options.loggers) {
         options.loggers = [{
-                debug: function (msg) {
-                    if (options.logLevel >= logLevel_debug) {
-                        console.log(msg);
-                    }
-                },
-                info: function (msg) {
-                    if (options.logLevel >= logLevel_info) {
-                        console.log(msg);
-                    }
-                },
-                warn: function (msg) {
-                    if (options.logLevel >= logLevel_warn) {
-                        console.warn(msg);
-                    }
-                },
-                error: function (msg) {
-                    if (options.logLevel >= logLevel_error) {
-                        console.error(msg);
-                    }
+            debug: function(msg) {
+                if (options.logLevel >= logLevel_debug) {
+                    console.log(msg);
                 }
-            }];
+            },
+            info: function(msg) {
+                if (options.logLevel >= logLevel_info) {
+                    console.log(msg);
+                }
+            },
+            warn: function(msg) {
+                if (options.logLevel >= logLevel_warn) {
+                    console.warn(msg);
+                }
+            },
+            error: function(msg) {
+                if (options.logLevel >= logLevel_error) {
+                    console.error(msg);
+                }
+            }
+        }];
     }
-    for (var i = 0; i < options.loggers.length; i++) {
+    for (let i = 0; i < options.loggers.length; i++) {
         less.logger.addListener(options.loggers[i]);
     }
-});
-//# sourceMappingURL=log-listener.js.map
+};

package/lib/less-browser/plugin-loader.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
 /**
  * @todo Add tests for browser `@plugin`
  */
-var abstract_plugin_loader_js_1 = tslib_1.__importDefault(require("../less/environment/abstract-plugin-loader.js"));
+import AbstractPluginLoader from '../less/environment/abstract-plugin-loader.js';
+
 /**
  * Browser Plugin Loader
  */
-var PluginLoader = function (less) {
+const PluginLoader = function(less) {
     this.less = less;
     // Should we shim this.require for browser? Probably not?
 };
-PluginLoader.prototype = Object.assign(new abstract_plugin_loader_js_1.default(), {
-    loadPlugin: function (filename, basePath, context, environment, fileManager) {
-        return new Promise(function (fulfill, reject) {
+
+PluginLoader.prototype = Object.assign(new AbstractPluginLoader(), {
+    loadPlugin(filename, basePath, context, environment, fileManager) {
+        return new Promise((fulfill, reject) => {
             fileManager.loadFile(filename, basePath, context, environment)
                 .then(fulfill).catch(reject);
         });
     }
 });
-exports.default = PluginLoader;
-//# sourceMappingURL=plugin-loader.js.map
+
+export default PluginLoader;
+

package/lib/less-browser/utils.js

@@ -1,32 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addDataAttr = exports.extractId = void 0;
-function extractId(href) {
-    return href.replace(/^[a-z-]+:\/+?[^/]+/, '') // Remove protocol & domain
-        .replace(/[?&]livereload=\w+/, '') // Remove LiveReload cachebuster
-        .replace(/^\//, '') // Remove root /
-        .replace(/\.[a-zA-Z]+$/, '') // Remove simple extension
-        .replace(/[^.\w-]+/g, '-') // Replace illegal characters
-        .replace(/\./g, ':'); // Replace dots with colons(for valid id)
+
+/** @param {string} href */
+export function extractId(href) {
+    return href.replace(/^[a-z-]+:\/+?[^/]+/, '')  // Remove protocol & domain
+        .replace(/[?&]livereload=\w+/, '')        // Remove LiveReload cachebuster
+        .replace(/^\//, '')                         // Remove root /
+        .replace(/\.[a-zA-Z]+$/, '')                // Remove simple extension
+        .replace(/[^.\w-]+/g, '-')                 // Replace illegal characters
+        .replace(/\./g, ':');                       // Replace dots with colons(for valid id)
 }
-exports.extractId = extractId;
-function addDataAttr(options, tag) {
-    if (!tag) {
-        return;
-    } // in case of tag is null or undefined
-    for (var opt in tag.dataset) {
+
+/**
+ * @param {Record<string, *>} options
+ * @param {HTMLElement | null} tag
+ */
+export function addDataAttr(options, tag) {
+    if (!tag) {return;} // in case of tag is null or undefined
+    for (const opt in tag.dataset) {
         if (Object.prototype.hasOwnProperty.call(tag.dataset, opt)) {
             if (opt === 'env' || opt === 'dumpLineNumbers' || opt === 'rootpath' || opt === 'errorReporting') {
                 options[opt] = tag.dataset[opt];
-            }
-            else {
+            } else {
                 try {
                     options[opt] = JSON.parse(tag.dataset[opt]);
                 }
-                catch (_) { }
+                catch (_) {}
             }
         }
     }
 }
-exports.addDataAttr = addDataAttr;
-//# sourceMappingURL=utils.js.map

package/lib/less-node/environment.js

@@ -1,19 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+class SourceMapGeneratorFallback {
+    addMapping(){}
+    setSourceContent(){}
+    toJSON(){
+        return null;
+    }
+};
+
+export default {
     encodeBase64: function encodeBase64(str) {
         // Avoid Buffer constructor on newer versions of Node.js.
-        var buffer = (Buffer.from ? Buffer.from(str) : (new Buffer(str)));
+        const buffer = (Buffer.from ? Buffer.from(str) : (new Buffer(str)));
         return buffer.toString('base64');
     },
     mimeLookup: function (filename) {
-        return require('mime').lookup(filename);
+        try {
+            const mimeModule = require('mime');
+            return mimeModule ? mimeModule.lookup(filename) : "application/octet-stream";
+        } catch (e) {
+            return "application/octet-stream";
+        }
     },
     charsetLookup: function (mime) {
-        return require('mime').charsets.lookup(mime);
+        try {
+            const mimeModule = require('mime');
+            return mimeModule ? mimeModule.charsets.lookup(mime) : undefined;
+        } catch (e) {
+            return undefined;
+        }
     },
     getSourceMapGenerator: function getSourceMapGenerator() {
-        return require('source-map').SourceMapGenerator;
+        try {
+            const sourceMapModule = require('source-map');
+            return sourceMapModule ? sourceMapModule.SourceMapGenerator : SourceMapGeneratorFallback;
+        } catch (e) {
+            return SourceMapGeneratorFallback;
+        }
     }
 };
-//# sourceMappingURL=environment.js.map