less 4.5.1 → 4.6.0

package/lib/less/default-options.js

@@ -1,79 +1,89 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 // Export a new default each time
-function default_1() {
+export default function() {
     return {
         /* Inline Javascript - @plugin still allowed */
         javascriptEnabled: false,
+
         /* Outputs a makefile import dependency list to stdout. */
         depends: false,
-        /* (DEPRECATED) Compress using less built-in compression.
-         * This does an okay job but does not utilise all the tricks of
+
+        /* (DEPRECATED) Compress using less built-in compression. 
+         * This does an okay job but does not utilise all the tricks of 
          * dedicated css compression. */
         compress: false,
+
         /* Runs the less parser and just reports errors without any output. */
         lint: false,
+
         /* Sets available include paths.
-         * If the file in an @import rule does not exist at that exact location,
-         * less will look for it at the location(s) passed to this option.
-         * You might use this for instance to specify a path to a library which
+         * If the file in an @import rule does not exist at that exact location, 
+         * less will look for it at the location(s) passed to this option. 
+         * You might use this for instance to specify a path to a library which 
          * you want to be referenced simply and relatively in the less files. */
         paths: [],
+
         /* color output in the terminal */
         color: true,
+
         /**
          * @deprecated This option has confusing behavior and may be removed in a future version.
-         *
+         * 
          * When true, prevents @import statements for .less files from being evaluated inside
          * selector blocks (rulesets). The imports are silently ignored and not output.
-         *
+         * 
          * Behavior:
          * - @import at root level: Always processed
          * - @import inside @-rules (@media, @supports, etc.): Processed (these are not selector blocks)
          * - @import inside selector blocks (.class, #id, etc.): NOT processed (silently ignored)
-         *
+         * 
          * When false (default): All @import statements are processed regardless of context.
-         *
+         * 
          * Note: Despite the name "strict", this option does NOT throw an error when imports
          * are used in selector blocks - it silently ignores them. This is confusing
          * behavior that may catch users off guard.
-         *
+         * 
          * Note: Only affects .less file imports. CSS imports (url(...) or .css files) are
          * always output as CSS @import statements regardless of this setting.
-         *
+         * 
          * @see https://github.com/less/less.js/issues/656
          */
         strictImports: false,
+
         /* Allow Imports from Insecure HTTPS Hosts */
         insecure: false,
-        /* Allows you to add a path to every generated import and url in your css.
-         * This does not affect less import statements that are processed, just ones
+
+        /* Allows you to add a path to every generated import and url in your css. 
+         * This does not affect less import statements that are processed, just ones 
          * that are left in the output css. */
         rootpath: '',
-        /* By default URLs are kept as-is, so if you import a file in a sub-directory
-         * that references an image, exactly the same URL will be output in the css.
-         * This option allows you to re-write URL's in imported files so that the
+
+        /* By default URLs are kept as-is, so if you import a file in a sub-directory 
+         * that references an image, exactly the same URL will be output in the css. 
+         * This option allows you to re-write URL's in imported files so that the 
          * URL is always relative to the base imported file */
         rewriteUrls: false,
-        /* How to process math
+
+        /* How to process math 
          *   0 always           - eagerly try to solve all operations
          *   1 parens-division  - require parens for division "/"
          *   2 parens | strict  - require parens for all operations
          *   3 strict-legacy    - legacy strict behavior (super-strict)
          */
         math: 1,
+
         /* Without this option, less attempts to guess at the output unit when it does maths. */
         strictUnits: false,
-        /* Effectively the declaration is put at the top of your base Less file,
-         * meaning it can be used but it also can be overridden if this variable
+
+        /* Effectively the declaration is put at the top of your base Less file, 
+         * meaning it can be used but it also can be overridden if this variable 
          * is defined in the file. */
         globalVars: null,
+
         /* As opposed to the global variable option, this puts the declaration at the
          * end of your base file, meaning it will override anything defined in your Less file. */
         modifyVars: null,
+
         /* This option allows you to specify a argument to go on to every URL.  */
         urlArgs: ''
-    };
-}
-exports.default = default_1;
-//# sourceMappingURL=default-options.js.map
+    }
+}

package/lib/less/deprecation.js

@@ -0,0 +1,67 @@
+/**
+ * Deprecation registry for Less.js
+ *
+ * Each deprecation has a unique ID and description.
+ * Repetition limiting caps warnings at 5 per deprecation type per parse.
+ * Use --quiet-deprecations to suppress all deprecation warnings.
+ */
+
+const deprecations = {
+    'mixin-call-no-parens': {
+        description: 'Calling a mixin without parentheses is deprecated.'
+    },
+    'mixin-call-whitespace': {
+        description: 'Whitespace between a mixin name and parentheses for a mixin call is deprecated.'
+    },
+    'dot-slash-operator': {
+        description: 'The ./ operator is deprecated.'
+    },
+    'variable-in-unknown-value': {
+        description: '@[ident] in custom property values is treated as literal text.'
+    },
+    'property-in-unknown-value': {
+        description: '$[ident] in custom property values is treated as literal text.'
+    },
+    'js-eval': {
+        description: 'Inline JavaScript evaluation (backtick expressions) is deprecated and will be removed in Less 5.x.'
+    },
+    'at-plugin': {
+        description: 'The @plugin directive is deprecated and will be replaced in Less 5.x.'
+    },
+    'dump-line-numbers': {
+        description: 'The dumpLineNumbers option is deprecated and will be removed in Less 5.x.'
+    },
+    'math-always': {
+        description: '--math=always is deprecated and will be removed in Less 5.x.'
+    }
+};
+
+const MAX_REPETITIONS = 5;
+
+class DeprecationHandler {
+    constructor() {
+        /** @type {Record<string, number>} */
+        this._counts = {};
+    }
+
+    /** @param {string} deprecationId */
+    shouldWarn(deprecationId) {
+        if (!deprecationId) { return true; }
+        const count = (this._counts[deprecationId] || 0) + 1;
+        this._counts[deprecationId] = count;
+        return count <= MAX_REPETITIONS;
+    }
+
+    /** @param {{ warn: (msg: string) => void }} logger */
+    summarize(logger) {
+        for (const id of Object.keys(this._counts)) {
+            const omitted = this._counts[id] - MAX_REPETITIONS;
+            if (omitted > 0) {
+                logger.warn(`${omitted} repetitive "${id}" deprecation warning(s) omitted.`);
+            }
+        }
+    }
+}
+
+export { deprecations, DeprecationHandler, MAX_REPETITIONS };
+export default { deprecations, DeprecationHandler };

package/lib/less/environment/abstract-file-manager.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var AbstractFileManager = /** @class */ (function () {
-    function AbstractFileManager() {
-    }
-    AbstractFileManager.prototype.getPath = function (filename) {
-        var j = filename.lastIndexOf('?');
+class AbstractFileManager {
+    getPath(filename) {
+        let j = filename.lastIndexOf('?');
         if (j > 0) {
             filename = filename.slice(0, j);
         }
@@ -16,46 +12,53 @@ var AbstractFileManager = /** @class */ (function () {
             return '';
         }
         return filename.slice(0, j + 1);
-    };
-    AbstractFileManager.prototype.tryAppendExtension = function (path, ext) {
+    }
+
+    tryAppendExtension(path, ext) {
         return /(\.[a-z]*$)|([?;].*)$/.test(path) ? path : path + ext;
-    };
-    AbstractFileManager.prototype.tryAppendLessExtension = function (path) {
+    }
+
+    tryAppendLessExtension(path) {
         return this.tryAppendExtension(path, '.less');
-    };
-    AbstractFileManager.prototype.supportsSync = function () {
+    }
+
+    supportsSync() {
         return false;
-    };
-    AbstractFileManager.prototype.alwaysMakePathsAbsolute = function () {
+    }
+
+    alwaysMakePathsAbsolute() {
         return false;
-    };
-    AbstractFileManager.prototype.isPathAbsolute = function (filename) {
+    }
+
+    isPathAbsolute(filename) {
         return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
-    };
+    }
+
     // TODO: pull out / replace?
-    AbstractFileManager.prototype.join = function (basePath, laterPath) {
+    join(basePath, laterPath) {
         if (!basePath) {
             return laterPath;
         }
         return basePath + laterPath;
-    };
-    AbstractFileManager.prototype.pathDiff = function (url, baseUrl) {
+    }
+
+    pathDiff(url, baseUrl) {
         // diff between two paths to create a relative path
-        var urlParts = this.extractUrlParts(url);
-        var baseUrlParts = this.extractUrlParts(baseUrl);
-        var i;
-        var max;
-        var urlDirectories;
-        var baseUrlDirectories;
-        var diff = '';
+
+        const urlParts = this.extractUrlParts(url);
+
+        const baseUrlParts = this.extractUrlParts(baseUrl);
+        let i;
+        let max;
+        let urlDirectories;
+        let baseUrlDirectories;
+        let diff = '';
         if (urlParts.hostPart !== baseUrlParts.hostPart) {
             return '';
         }
         max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
         for (i = 0; i < max; i++) {
-            if (baseUrlParts.directories[i] !== urlParts.directories[i]) {
-                break;
-            }
+            if (baseUrlParts.directories[i] !== urlParts.directories[i]) { break; }
         }
         baseUrlDirectories = baseUrlParts.directories.slice(i);
         urlDirectories = urlParts.directories.slice(i);
@@ -63,56 +66,66 @@ var AbstractFileManager = /** @class */ (function () {
             diff += '../';
         }
         for (i = 0; i < urlDirectories.length - 1; i++) {
-            diff += "".concat(urlDirectories[i], "/");
+            diff += `${urlDirectories[i]}/`;
         }
         return diff;
-    };
+    }
+
     /**
      * Helper function, not part of API.
      * This should be replaceable by newer Node / Browser APIs
-     *
-     * @param {string} url
+     * 
+     * @param {string} url 
      * @param {string} baseUrl
      */
-    AbstractFileManager.prototype.extractUrlParts = function (url, baseUrl) {
+    extractUrlParts(url, baseUrl) {
         // urlParts[1] = protocol://hostname/ OR /
         // urlParts[2] = / if path relative to host base
         // urlParts[3] = directories
         // urlParts[4] = filename
         // urlParts[5] = parameters
-        var urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^/?#]*\/)|([/\\]))?((?:[^/\\?#]*[/\\])*)([^/\\?#]*)([#?].*)?$/i;
-        var urlParts = url.match(urlPartsRegex);
-        var returner = {};
-        var rawDirectories = [];
-        var directories = [];
-        var i;
-        var baseUrlParts;
+
+        const urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^/?#]*\/)|([/\\]))?((?:[^/\\?#]*[/\\])*)([^/\\?#]*)([#?].*)?$/i;
+
+        const urlParts = url.match(urlPartsRegex);
+        const returner = {};
+        let rawDirectories = [];
+        const directories = [];
+        let i;
+        let baseUrlParts;
+
         if (!urlParts) {
-            throw new Error("Could not parse sheet href - '".concat(url, "'"));
+            throw new Error(`Could not parse sheet href - '${url}'`);
         }
+
         // Stylesheets in IE don't always return the full path
         if (baseUrl && (!urlParts[1] || urlParts[2])) {
             baseUrlParts = baseUrl.match(urlPartsRegex);
             if (!baseUrlParts) {
-                throw new Error("Could not parse page url - '".concat(baseUrl, "'"));
+                throw new Error(`Could not parse page url - '${baseUrl}'`);
             }
             urlParts[1] = urlParts[1] || baseUrlParts[1] || '';
             if (!urlParts[2]) {
                 urlParts[3] = baseUrlParts[3] + urlParts[3];
             }
         }
+
         if (urlParts[3]) {
             rawDirectories = urlParts[3].replace(/\\/g, '/').split('/');
+
             // collapse '..' and skip '.'
             for (i = 0; i < rawDirectories.length; i++) {
+
                 if (rawDirectories[i] === '..') {
                     directories.pop();
                 }
                 else if (rawDirectories[i] !== '.') {
                     directories.push(rawDirectories[i]);
                 }
+            
             }
         }
+
         returner.hostPart = urlParts[1];
         returner.directories = directories;
         returner.rawPath = (urlParts[1] || '') + rawDirectories.join('/');
@@ -121,8 +134,7 @@ var AbstractFileManager = /** @class */ (function () {
         returner.fileUrl = returner.path + (urlParts[4] || '');
         returner.url = returner.fileUrl + (urlParts[5] || '');
         return returner;
-    };
-    return AbstractFileManager;
-}());
-exports.default = AbstractFileManager;
-//# sourceMappingURL=abstract-file-manager.js.map
+    }
+}
+
+export default AbstractFileManager;

package/lib/less/environment/abstract-plugin-loader.js

@@ -1,18 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var function_registry_1 = tslib_1.__importDefault(require("../functions/function-registry"));
-var less_error_1 = tslib_1.__importDefault(require("../less-error"));
-var AbstractPluginLoader = /** @class */ (function () {
-    function AbstractPluginLoader() {
+import functionRegistry from '../functions/function-registry.js';
+import LessError from '../less-error.js';
+
+class AbstractPluginLoader {
+    constructor() {
         // Implemented by Node.js plugin loader
-        this.require = function () {
+        this.require = function() {
             return null;
-        };
+        }
     }
-    AbstractPluginLoader.prototype.evalPlugin = function (contents, context, imports, pluginOptions, fileInfo) {
-        var loader, registry, pluginObj, localModule, pluginManager, filename, result;
+
+    evalPlugin(contents, context, imports, pluginOptions, fileInfo) {
+
+        let loader, registry, pluginObj, localModule, pluginManager, filename, result;
+
         pluginManager = context.pluginManager;
+
         if (fileInfo) {
             if (typeof fileInfo === 'string') {
                 filename = fileInfo;
@@ -21,9 +23,11 @@ var AbstractPluginLoader = /** @class */ (function () {
                 filename = fileInfo.filename;
             }
         }
-        var shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
+        const shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
+
         if (filename) {
             pluginObj = pluginManager.get(filename);
+
             if (pluginObj) {
                 result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
                 if (result) {
@@ -36,52 +40,62 @@ var AbstractPluginLoader = /** @class */ (function () {
                 }
                 catch (e) {
                     e.message = e.message || 'Error during @plugin call';
-                    return new less_error_1.default(e, imports, filename);
+                    return new LessError(e, imports, filename);
                 }
                 return pluginObj;
             }
         }
         localModule = {
             exports: {},
-            pluginManager: pluginManager,
-            fileInfo: fileInfo
+            pluginManager,
+            fileInfo
         };
-        registry = function_registry_1.default.create();
-        var registerPlugin = function (obj) {
+        registry = functionRegistry.create();
+
+        const registerPlugin = function(obj) {
             pluginObj = obj;
         };
+
         try {
             loader = new Function('module', 'require', 'registerPlugin', 'functions', 'tree', 'less', 'fileInfo', contents);
             loader(localModule, this.require(filename), registerPlugin, registry, this.less.tree, this.less, fileInfo);
         }
         catch (e) {
-            return new less_error_1.default(e, imports, filename);
+            return new LessError(e, imports, filename);
         }
+
         if (!pluginObj) {
             pluginObj = localModule.exports;
         }
         pluginObj = this.validatePlugin(pluginObj, filename, shortname);
-        if (pluginObj instanceof less_error_1.default) {
+
+        if (pluginObj instanceof LessError) {
             return pluginObj;
         }
+
         if (pluginObj) {
             pluginObj.imports = imports;
             pluginObj.filename = filename;
+
             // For < 3.x (or unspecified minVersion) - setOptions() before install()
             if (!pluginObj.minVersion || this.compareVersion('3.0.0', pluginObj.minVersion) < 0) {
                 result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+
                 if (result) {
                     return result;
                 }
             }
+
             // Run on first load
             pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
             pluginObj.functions = registry.getLocalFunctions();
+
             // Need to call setOptions again because the pluginObj might have functions
             result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
             if (result) {
                 return result;
             }
+
             // Run every @plugin call
             try {
                 if (pluginObj.use) {
@@ -90,73 +104,82 @@ var AbstractPluginLoader = /** @class */ (function () {
             }
             catch (e) {
                 e.message = e.message || 'Error during @plugin call';
-                return new less_error_1.default(e, imports, filename);
+                return new LessError(e, imports, filename);
             }
+
         }
         else {
-            return new less_error_1.default({ message: 'Not a valid plugin' }, imports, filename);
+            return new LessError({ message: 'Not a valid plugin' }, imports, filename);
         }
+
         return pluginObj;
-    };
-    AbstractPluginLoader.prototype.trySetOptions = function (plugin, filename, name, options) {
+
+    }
+
+    trySetOptions(plugin, filename, name, options) {
         if (options && !plugin.setOptions) {
-            return new less_error_1.default({
-                message: "Options have been provided but the plugin ".concat(name, " does not support any options.")
+            return new LessError({
+                message: `Options have been provided but the plugin ${name} does not support any options.`
             });
         }
         try {
             plugin.setOptions && plugin.setOptions(options);
         }
         catch (e) {
-            return new less_error_1.default(e);
+            return new LessError(e);
         }
-    };
-    AbstractPluginLoader.prototype.validatePlugin = function (plugin, filename, name) {
+    }
+
+    validatePlugin(plugin, filename, name) {
         if (plugin) {
             // support plugins being a function
             // so that the plugin can be more usable programmatically
             if (typeof plugin === 'function') {
                 plugin = new plugin();
             }
+
             if (plugin.minVersion) {
                 if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
-                    return new less_error_1.default({
-                        message: "Plugin ".concat(name, " requires version ").concat(this.versionToString(plugin.minVersion))
+                    return new LessError({
+                        message: `Plugin ${name} requires version ${this.versionToString(plugin.minVersion)}`
                     });
                 }
             }
             return plugin;
         }
         return null;
-    };
-    AbstractPluginLoader.prototype.compareVersion = function (aVersion, bVersion) {
+    }
+
+    compareVersion(aVersion, bVersion) {
         if (typeof aVersion === 'string') {
             aVersion = aVersion.match(/^(\d+)\.?(\d+)?\.?(\d+)?/);
             aVersion.shift();
         }
-        for (var i = 0; i < aVersion.length; i++) {
+        for (let i = 0; i < aVersion.length; i++) {
             if (aVersion[i] !== bVersion[i]) {
                 return parseInt(aVersion[i]) > parseInt(bVersion[i]) ? -1 : 1;
             }
         }
         return 0;
-    };
-    AbstractPluginLoader.prototype.versionToString = function (version) {
-        var versionString = '';
-        for (var i = 0; i < version.length; i++) {
+    }
+
+    versionToString(version) {
+        let versionString = '';
+        for (let i = 0; i < version.length; i++) {
             versionString += (versionString ? '.' : '') + version[i];
         }
         return versionString;
-    };
-    AbstractPluginLoader.prototype.printUsage = function (plugins) {
-        for (var i = 0; i < plugins.length; i++) {
-            var plugin = plugins[i];
+    }
+
+    printUsage(plugins) {
+        for (let i = 0; i < plugins.length; i++) {
+            const plugin = plugins[i];
             if (plugin.printUsage) {
                 plugin.printUsage();
             }
         }
-    };
-    return AbstractPluginLoader;
-}());
-exports.default = AbstractPluginLoader;
-//# sourceMappingURL=abstract-plugin-loader.js.map
+    }
+}
+
+export default AbstractPluginLoader;
+

package/lib/less/environment/environment-api.ts

@@ -0,0 +1,21 @@
+export interface Environment {
+    /**
+     * Converts a string to a base 64 string
+     */
+    encodeBase64(str: string): string
+    /**
+     * Lookup the mime-type of a filename
+     */
+    mimeLookup(filename: string): string
+    /**
+     * Look up the charset of a mime type
+     * @param mime
+     */
+    charsetLookup(mime: string): string
+    /**
+     * Gets a source map generator
+     *
+     * @todo - Figure out precise type
+     */
+    getSourceMapGenerator(): any
+}