less 4.4.2 → 4.6.0

package/lib/less/environment/environment.js

@@ -1,55 +1,59 @@
-"use strict";
 /**
  * @todo Document why this abstraction exists, and the relationship between
  *       environment, file managers, and plugin manager
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var logger_1 = tslib_1.__importDefault(require("../logger"));
-var Environment = /** @class */ (function () {
-    function Environment(externalEnvironment, fileManagers) {
+
+import logger from '../logger.js';
+
+class Environment {
+    constructor(externalEnvironment, fileManagers) {
         this.fileManagers = fileManagers || [];
         externalEnvironment = externalEnvironment || {};
-        var optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'];
-        var requiredFunctions = [];
-        var functions = requiredFunctions.concat(optionalFunctions);
-        for (var i = 0; i < functions.length; i++) {
-            var propName = functions[i];
-            var environmentFunc = externalEnvironment[propName];
+
+        const optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'];
+        const requiredFunctions = [];
+        const functions = requiredFunctions.concat(optionalFunctions);
+
+        for (let i = 0; i < functions.length; i++) {
+            const propName = functions[i];
+            const environmentFunc = externalEnvironment[propName];
             if (environmentFunc) {
                 this[propName] = environmentFunc.bind(externalEnvironment);
-            }
-            else if (i < requiredFunctions.length) {
-                this.warn("missing required function in environment - ".concat(propName));
+            } else if (i < requiredFunctions.length) {
+                this.warn(`missing required function in environment - ${propName}`);
             }
         }
     }
-    Environment.prototype.getFileManager = function (filename, currentDirectory, options, environment, isSync) {
+
+    getFileManager(filename, currentDirectory, options, environment, isSync) {
+
         if (!filename) {
-            logger_1.default.warn('getFileManager called with no filename.. Please report this issue. continuing.');
+            logger.warn('getFileManager called with no filename.. Please report this issue. continuing.');
         }
         if (currentDirectory === undefined) {
-            logger_1.default.warn('getFileManager called with null directory.. Please report this issue. continuing.');
+            logger.warn('getFileManager called with null directory.. Please report this issue. continuing.');
         }
-        var fileManagers = this.fileManagers;
+
+        let fileManagers = this.fileManagers;
         if (options.pluginManager) {
             fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
         }
-        for (var i = fileManagers.length - 1; i >= 0; i--) {
-            var fileManager = fileManagers[i];
+        for (let i = fileManagers.length - 1; i >= 0 ; i--) {
+            const fileManager = fileManagers[i];
             if (fileManager[isSync ? 'supportsSync' : 'supports'](filename, currentDirectory, options, environment)) {
                 return fileManager;
             }
         }
         return null;
-    };
-    Environment.prototype.addFileManager = function (fileManager) {
+    }
+
+    addFileManager(fileManager) {
         this.fileManagers.push(fileManager);
-    };
-    Environment.prototype.clearFileManagers = function () {
+    }
+
+    clearFileManagers() {
         this.fileManagers = [];
-    };
-    return Environment;
-}());
-exports.default = Environment;
-//# sourceMappingURL=environment.js.map
+    }
+}
+
+export default Environment;

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

@@ -0,0 +1,77 @@
+import type { Environment } from './environment-api'
+
+export interface FileManager {
+    /**
+     * Given the full path to a file, return the path component
+     * Provided by AbstractFileManager
+     */
+    getPath(filename: string): string
+    /**
+     * Append a .less extension if appropriate. Only called if less thinks one could be added.
+     * Provided by AbstractFileManager
+     */
+    tryAppendLessExtension(filename: string): string
+    /**
+     * Whether the rootpath should be converted to be absolute.
+     * The browser ovverides this to return true because urls must be absolute.
+     * Provided by AbstractFileManager (returns false)
+     */
+    alwaysMakePathsAbsolute(): boolean
+    /**
+     * Returns whether a path is absolute
+     * Provided by AbstractFileManager
+     */
+    isPathAbsolute(path: string): boolean
+    /**
+     * joins together 2 paths
+     * Provided by AbstractFileManager
+     */
+    join(basePath: string, laterPath: string): string
+    /**
+     * Returns the difference between 2 paths
+     * E.g. url = a/ baseUrl = a/b/ returns ../
+     * url = a/b/ baseUrl = a/ returns b/
+     * Provided by AbstractFileManager
+     */
+    pathDiff(url: string, baseUrl: string): string
+    /**
+     * Returns whether this file manager supports this file for syncronous file retrieval
+     * If true is returned, loadFileSync will then be called with the file.
+     * Provided by AbstractFileManager (returns false)
+     * 
+     * @todo - Narrow Options type
+     */
+    supportsSync(
+        filename: string,
+        currentDirectory: string,
+        options: Record<string, any>,
+        environment: Environment
+    ): boolean
+    /**
+     * If file manager supports async file retrieval for this file type
+     */
+    supports(
+        filename: string,
+        currentDirectory: string,
+        options: Record<string, any>,
+        environment: Environment
+    ): boolean
+    /**
+     * Loads a file asynchronously.
+     */
+    loadFile(
+        filename: string,
+        currentDirectory: string,
+        options: Record<string, any>,
+        environment: Environment
+    ): Promise<{ filename: string, contents: string }>
+    /**
+     * Loads a file synchronously. Expects an immediate return with an object
+     */
+    loadFileSync(
+        filename: string,
+        currentDirectory: string,
+        options: Record<string, any>,
+        environment: Environment
+    ): { error?: unknown, filename: string, contents: string }
+}

package/lib/less/functions/boolean.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var anonymous_1 = tslib_1.__importDefault(require("../tree/anonymous"));
-var keyword_1 = tslib_1.__importDefault(require("../tree/keyword"));
+import Anonymous from '../tree/anonymous.js';
+import Keyword from '../tree/keyword.js';
+
 function boolean(condition) {
-    return condition ? keyword_1.default.True : keyword_1.default.False;
+    return condition ? Keyword.True : Keyword.False;
 }
+
 /**
  * Functions with evalArgs set to false are sent context
  * as the first argument.
  */
 function If(context, condition, trueValue, falseValue) {
     return condition.eval(context) ? trueValue.eval(context)
-        : (falseValue ? falseValue.eval(context) : new anonymous_1.default);
+        : (falseValue ? falseValue.eval(context) : new Anonymous);
 }
 If.evalArgs = false;
+
 function isdefined(context, variable) {
     try {
         variable.eval(context);
-        return keyword_1.default.True;
-    }
-    catch (e) {
-        return keyword_1.default.False;
+        return Keyword.True;
+    } catch (e) {
+        return Keyword.False;
     }
 }
+
 isdefined.evalArgs = false;
-exports.default = { isdefined: isdefined, boolean: boolean, 'if': If };
-//# sourceMappingURL=boolean.js.map
+
+export default { isdefined, boolean, 'if': If };

package/lib/less/functions/color-blending.js

@@ -1,48 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var color_1 = tslib_1.__importDefault(require("../tree/color"));
+import Color from '../tree/color.js';
+
 // Color Blending
 // ref: http://www.w3.org/TR/compositing-1
+
 function colorBlend(mode, color1, color2) {
-    var ab = color1.alpha; // result
-    var // backdrop
-    cb;
-    var as = color2.alpha;
-    var // source
-    cs;
-    var ar;
-    var cr;
-    var r = [];
+    const ab = color1.alpha;        // result
+
+    let // backdrop
+        cb;
+
+    const as = color2.alpha;
+
+    let // source
+        cs;
+
+    let ar;
+    let cr;
+    const r = [];
+
     ar = as + ab * (1 - as);
-    for (var i = 0; i < 3; i++) {
+    for (let i = 0; i < 3; i++) {
         cb = color1.rgb[i] / 255;
         cs = color2.rgb[i] / 255;
         cr = mode(cb, cs);
         if (ar) {
             cr = (as * cs + ab * (cb -
-                as * (cb + cs - cr))) / ar;
+                  as * (cb + cs - cr))) / ar;
         }
         r[i] = cr * 255;
     }
-    return new color_1.default(r, ar);
+
+    return new Color(r, ar);
 }
-var colorBlendModeFunctions = {
-    multiply: function (cb, cs) {
+
+const colorBlendModeFunctions = {
+    multiply: function(cb, cs) {
         return cb * cs;
     },
-    screen: function (cb, cs) {
+    screen: function(cb, cs) {
         return cb + cs - cb * cs;
     },
-    overlay: function (cb, cs) {
+    overlay: function(cb, cs) {
         cb *= 2;
         return (cb <= 1) ?
             colorBlendModeFunctions.multiply(cb, cs) :
             colorBlendModeFunctions.screen(cb - 1, cs);
     },
-    softlight: function (cb, cs) {
-        var d = 1;
-        var e = cb;
+    softlight: function(cb, cs) {
+        let d = 1;
+        let e = cb;
         if (cs > 0.5) {
             e = 1;
             d = (cb > 0.25) ? Math.sqrt(cb)
@@ -50,28 +56,30 @@ var colorBlendModeFunctions = {
         }
         return cb - (1 - 2 * cs) * e * (d - cb);
     },
-    hardlight: function (cb, cs) {
+    hardlight: function(cb, cs) {
         return colorBlendModeFunctions.overlay(cs, cb);
     },
-    difference: function (cb, cs) {
+    difference: function(cb, cs) {
         return Math.abs(cb - cs);
     },
-    exclusion: function (cb, cs) {
+    exclusion: function(cb, cs) {
         return cb + cs - 2 * cb * cs;
     },
+
     // non-w3c functions:
-    average: function (cb, cs) {
+    average: function(cb, cs) {
         return (cb + cs) / 2;
     },
-    negation: function (cb, cs) {
+    negation: function(cb, cs) {
         return 1 - Math.abs(cb + cs - 1);
     }
 };
-for (var f in colorBlendModeFunctions) {
+
+for (const f in colorBlendModeFunctions) {
     // eslint-disable-next-line no-prototype-builtins
     if (colorBlendModeFunctions.hasOwnProperty(f)) {
         colorBlend[f] = colorBlend.bind(null, colorBlendModeFunctions[f]);
     }
 }
-exports.default = colorBlend;
-//# sourceMappingURL=color-blending.js.map
+
+export default colorBlend;