less 4.4.2 → 4.6.0

package/lib/less/tree/call.js

@@ -1,26 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var function_caller_1 = tslib_1.__importDefault(require("../functions/function-caller"));
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo } from './node.js' */
+import Node from './node.js';
+import Anonymous from './anonymous.js';
+import FunctionCaller from '../functions/function-caller.js';
+
 //
 // A function call node.
 //
-var Call = function (name, args, index, currentFileInfo) {
-    this.name = name;
-    this.args = args;
-    this.calc = name === 'calc';
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Call.prototype = Object.assign(new node_1.default(), {
-    type: 'Call',
-    accept: function (visitor) {
+class Call extends Node {
+    get type() { return 'Call'; }
+
+    /**
+     * @param {string} name
+     * @param {Node[]} args
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     */
+    constructor(name, args, index, currentFileInfo) {
+        super();
+        this.name = name;
+        this.args = args;
+        this.calc = name === 'calc';
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.args) {
             this.args = visitor.visitArray(this.args);
         }
-    },
+    }
+
     //
     // When evaluating a function call,
     // we either find the function in the functionRegistry,
@@ -32,73 +43,90 @@ Call.prototype = Object.assign(new node_1.default(), {
     // we try to pass a variable to a function, like: `saturate(@color)`.
     // The function should receive the value, not the variable.
     //
-    eval: function (context) {
-        var _this = this;
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
         /**
          * Turn off math for calc(), and switch back on for evaluating nested functions
          */
-        var currentMathContext = context.mathOn;
+        const currentMathContext = context.mathOn;
         context.mathOn = !this.calc;
         if (this.calc || context.inCalc) {
             context.enterCalc();
         }
-        var exitCalc = function () {
-            if (_this.calc || context.inCalc) {
+
+        const exitCalc = () => {
+            if (this.calc || context.inCalc) {
                 context.exitCalc();
             }
             context.mathOn = currentMathContext;
         };
-        var result;
-        var funcCaller = new function_caller_1.default(this.name, context, this.getIndex(), this.fileInfo());
+
+        /** @type {Node | string | boolean | null | undefined} */
+        let result;
+        const funcCaller = new FunctionCaller(this.name, context, this.getIndex(), this.fileInfo());
+
         if (funcCaller.isValid()) {
             try {
                 result = funcCaller.call(this.args);
                 exitCalc();
-            }
-            catch (e) {
+            } catch (e) {
                 // eslint-disable-next-line no-prototype-builtins
-                if (e.hasOwnProperty('line') && e.hasOwnProperty('column')) {
+                if (/** @type {Record<string, unknown>} */ (e).hasOwnProperty('line') && /** @type {Record<string, unknown>} */ (e).hasOwnProperty('column')) {
                     throw e;
                 }
                 throw {
-                    type: e.type || 'Runtime',
-                    message: "Error evaluating function `".concat(this.name, "`").concat(e.message ? ": ".concat(e.message) : ''),
+                    type: /** @type {Record<string, string>} */ (e).type || 'Runtime',
+                    message: `Error evaluating function \`${this.name}\`${/** @type {Error} */ (e).message ? `: ${/** @type {Error} */ (e).message}` : ''}`,
                     index: this.getIndex(),
                     filename: this.fileInfo().filename,
-                    line: e.lineNumber,
-                    column: e.columnNumber
+                    line: /** @type {Record<string, number>} */ (e).lineNumber,
+                    column: /** @type {Record<string, number>} */ (e).columnNumber
                 };
             }
         }
+
         if (result !== null && result !== undefined) {
             // Results that that are not nodes are cast as Anonymous nodes
             // Falsy values or booleans are returned as empty nodes
-            if (!(result instanceof node_1.default)) {
+            if (!(result instanceof Node)) {
                 if (!result || result === true) {
-                    result = new anonymous_1.default(null);
+                    result = new Anonymous(null);
                 }
                 else {
-                    result = new anonymous_1.default(result.toString());
+                    result = new Anonymous(result.toString());
                 }
+
             }
             result._index = this._index;
             result._fileInfo = this._fileInfo;
             return result;
         }
-        var args = this.args.map(function (a) { return a.eval(context); });
+
+        const args = this.args.map(a => a.eval(context));
         exitCalc();
+
         return new Call(this.name, args, this.getIndex(), this.fileInfo());
-    },
-    genCSS: function (context, output) {
-        output.add("".concat(this.name, "("), this.fileInfo(), this.getIndex());
-        for (var i = 0; i < this.args.length; i++) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        output.add(`${this.name}(`, this.fileInfo(), this.getIndex());
+
+        for (let i = 0; i < this.args.length; i++) {
             this.args[i].genCSS(context, output);
             if (i + 1 < this.args.length) {
                 output.add(', ');
             }
         }
+
         output.add(')');
     }
-});
-exports.default = Call;
-//# sourceMappingURL=call.js.map
+}
+
+export default Call;

package/lib/less/tree/color.js

@@ -1,94 +1,119 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var colors_1 = tslib_1.__importDefault(require("../data/colors"));
+// @ts-check
+import Node from './node.js';
+import colors from '../data/colors.js';
+
+/** @import { EvalContext, CSSOutput } from './node.js' */
+
 //
 // RGB Colors - #ff0014, #eee
 //
-var Color = function (rgb, a, originalForm) {
-    var self = this;
-    //
-    // The end goal here, is to parse the arguments
-    // into an integer triplet, such as `128, 255, 0`
-    //
-    // This facilitates operations and conversions.
-    //
-    if (Array.isArray(rgb)) {
-        this.rgb = rgb;
-    }
-    else if (rgb.length >= 6) {
-        this.rgb = [];
-        rgb.match(/.{2}/g).map(function (c, i) {
-            if (i < 3) {
-                self.rgb.push(parseInt(c, 16));
-            }
-            else {
-                self.alpha = (parseInt(c, 16)) / 255;
-            }
-        });
-    }
-    else {
-        this.rgb = [];
-        rgb.split('').map(function (c, i) {
-            if (i < 3) {
-                self.rgb.push(parseInt(c + c, 16));
-            }
-            else {
-                self.alpha = (parseInt(c + c, 16)) / 255;
-            }
-        });
-    }
-    this.alpha = this.alpha || (typeof a === 'number' ? a : 1);
-    if (typeof originalForm !== 'undefined') {
-        this.value = originalForm;
+class Color extends Node {
+    get type() { return 'Color'; }
+
+    /**
+     * @param {number[] | string} rgb
+     * @param {number} [a]
+     * @param {string} [originalForm]
+     */
+    constructor(rgb, a, originalForm) {
+        super();
+        const self = this;
+        //
+        // The end goal here, is to parse the arguments
+        // into an integer triplet, such as `128, 255, 0`
+        //
+        // This facilitates operations and conversions.
+        //
+        if (Array.isArray(rgb)) {
+            /** @type {number[]} */
+            this.rgb = rgb;
+        } else if (rgb.length >= 6) {
+            /** @type {number[]} */
+            this.rgb = [];
+            /** @type {RegExpMatchArray} */ (rgb.match(/.{2}/g)).map(function (c, i) {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c, 16));
+                } else {
+                    self.alpha = (parseInt(c, 16)) / 255;
+                }
+            });
+        } else {
+            /** @type {number[]} */
+            this.rgb = [];
+            rgb.split('').map(function (c, i) {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c + c, 16));
+                } else {
+                    self.alpha = (parseInt(c + c, 16)) / 255;
+                }
+            });
+        }
+        /** @type {number} */
+        if (typeof this.alpha === 'undefined') {
+            this.alpha = (typeof a === 'number') ? a : 1;
+        }
+        if (typeof originalForm !== 'undefined') {
+            this.value = originalForm;
+        }
     }
-};
-Color.prototype = Object.assign(new node_1.default(), {
-    type: 'Color',
-    luma: function () {
-        var r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255;
+
+    luma() {
+        let r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255;
+
         r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
         g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
         b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
+
         return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-    },
-    genCSS: function (context, output) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add(this.toCSS(context));
-    },
-    toCSS: function (context, doNotCompress) {
-        var compress = context && context.compress && !doNotCompress;
-        var color;
-        var alpha;
-        var colorFunction;
-        var args = [];
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {boolean} [doNotCompress]
+     * @returns {string}
+     */
+    toCSS(context, doNotCompress) {
+        const compress = context && context.compress && !doNotCompress;
+        let color;
+        let alpha;
+        /** @type {string | undefined} */
+        let colorFunction;
+        /** @type {(string | number)[]} */
+        let args = [];
+
         // `value` is set if this color was originally
         // converted from a named color string so we need
         // to respect this and try to output named color too.
         alpha = this.fround(context, this.alpha);
+
         if (this.value) {
-            if (this.value.indexOf('rgb') === 0) {
+            if (/** @type {string} */ (this.value).indexOf('rgb') === 0) {
                 if (alpha < 1) {
                     colorFunction = 'rgba';
                 }
-            }
-            else if (this.value.indexOf('hsl') === 0) {
+            } else if (/** @type {string} */ (this.value).indexOf('hsl') === 0) {
                 if (alpha < 1) {
                     colorFunction = 'hsla';
-                }
-                else {
+                } else {
                     colorFunction = 'hsl';
                 }
+            } else {
+                return /** @type {string} */ (this.value);
             }
-            else {
-                return this.value;
-            }
-        }
-        else {
+        } else {
             if (alpha < 1) {
                 colorFunction = 'rgba';
             }
         }
+
         switch (colorFunction) {
             case 'rgba':
                 args = this.rgb.map(function (c) {
@@ -102,135 +127,159 @@ Color.prototype = Object.assign(new node_1.default(), {
                 color = this.toHSL();
                 args = [
                     this.fround(context, color.h),
-                    "".concat(this.fround(context, color.s * 100), "%"),
-                    "".concat(this.fround(context, color.l * 100), "%")
+                    `${this.fround(context, color.s * 100)}%`,
+                    `${this.fround(context, color.l * 100)}%`
                 ].concat(args);
         }
+
         if (colorFunction) {
             // Values are capped between `0` and `255`, rounded and zero-padded.
-            return "".concat(colorFunction, "(").concat(args.join(",".concat(compress ? '' : ' ')), ")");
+            return `${colorFunction}(${args.join(`,${compress ? '' : ' '}`)})`;
         }
+
         color = this.toRGB();
+
         if (compress) {
-            var splitcolor = color.split('');
+            const splitcolor = color.split('');
+
             // Convert color to short format
             if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
-                color = "#".concat(splitcolor[1]).concat(splitcolor[3]).concat(splitcolor[5]);
+                color = `#${splitcolor[1]}${splitcolor[3]}${splitcolor[5]}`;
             }
         }
+
         return color;
-    },
+    }
+
     //
     // Operations have to be done per-channel, if not,
     // channels will spill onto each other. Once we have
     // our result, in the form of an integer triplet,
     // we create a new Color node to hold the result.
     //
-    operate: function (context, op, other) {
-        var rgb = new Array(3);
-        var alpha = this.alpha * (1 - other.alpha) + other.alpha;
-        for (var c = 0; c < 3; c++) {
+    /**
+     * @param {EvalContext} context
+     * @param {string} op
+     * @param {Color} other
+     */
+    operate(context, op, other) {
+        const rgb = new Array(3);
+        const alpha = this.alpha * (1 - other.alpha) + other.alpha;
+        for (let c = 0; c < 3; c++) {
             rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
         }
         return new Color(rgb, alpha);
-    },
-    toRGB: function () {
+    }
+
+    toRGB() {
         return toHex(this.rgb);
-    },
-    toHSL: function () {
-        var r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255, a = this.alpha;
-        var max = Math.max(r, g, b), min = Math.min(r, g, b);
-        var h;
-        var s;
-        var l = (max + min) / 2;
-        var d = max - min;
+    }
+
+    toHSL() {
+        const r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255, a = this.alpha;
+
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        /** @type {number} */
+        let h;
+        let s;
+        const l = (max + min) / 2;
+        const d = max - min;
+
         if (max === min) {
             h = s = 0;
-        }
-        else {
+        } else {
             s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
             switch (max) {
-                case r:
-                    h = (g - b) / d + (g < b ? 6 : 0);
-                    break;
-                case g:
-                    h = (b - r) / d + 2;
-                    break;
-                case b:
-                    h = (r - g) / d + 4;
-                    break;
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2;               break;
+                case b: h = (r - g) / d + 4;               break;
             }
-            h /= 6;
+            /** @type {number} */ (h) /= 6;
         }
-        return { h: h * 360, s: s, l: l, a: a };
-    },
+        return { h: /** @type {number} */ (h) * 360, s, l, a };
+    }
+
     // Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
-    toHSV: function () {
-        var r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255, a = this.alpha;
-        var max = Math.max(r, g, b), min = Math.min(r, g, b);
-        var h;
-        var s;
-        var v = max;
-        var d = max - min;
+    toHSV() {
+        const r = this.rgb[0] / 255, g = this.rgb[1] / 255, b = this.rgb[2] / 255, a = this.alpha;
+
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        /** @type {number} */
+        let h;
+        let s;
+        const v = max;
+
+        const d = max - min;
         if (max === 0) {
             s = 0;
-        }
-        else {
+        } else {
             s = d / max;
         }
+
         if (max === min) {
             h = 0;
-        }
-        else {
+        } else {
             switch (max) {
-                case r:
-                    h = (g - b) / d + (g < b ? 6 : 0);
-                    break;
-                case g:
-                    h = (b - r) / d + 2;
-                    break;
-                case b:
-                    h = (r - g) / d + 4;
-                    break;
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
             }
-            h /= 6;
+            /** @type {number} */ (h) /= 6;
         }
-        return { h: h * 360, s: s, v: v, a: a };
-    },
-    toARGB: function () {
+        return { h: /** @type {number} */ (h) * 360, s, v, a };
+    }
+
+    toARGB() {
         return toHex([this.alpha * 255].concat(this.rgb));
-    },
-    compare: function (x) {
+    }
+
+    /**
+     * @param {Node & { rgb?: number[], alpha?: number }} x
+     * @returns {0 | undefined}
+     */
+    compare(x) {
         return (x.rgb &&
             x.rgb[0] === this.rgb[0] &&
             x.rgb[1] === this.rgb[1] &&
             x.rgb[2] === this.rgb[2] &&
-            x.alpha === this.alpha) ? 0 : undefined;
-    }
-});
-Color.fromKeyword = function (keyword) {
-    var c;
-    var key = keyword.toLowerCase();
-    // eslint-disable-next-line no-prototype-builtins
-    if (colors_1.default.hasOwnProperty(key)) {
-        c = new Color(colors_1.default[key].slice(1));
-    }
-    else if (key === 'transparent') {
-        c = new Color([0, 0, 0], 0);
+            x.alpha  === this.alpha) ? 0 : undefined;
     }
-    if (c) {
-        c.value = keyword;
-        return c;
+
+    /** @param {string} keyword */
+    static fromKeyword(keyword) {
+        /** @type {Color | undefined} */
+        let c;
+        const key = keyword.toLowerCase();
+        // eslint-disable-next-line no-prototype-builtins
+        if (colors.hasOwnProperty(key)) {
+            c = new Color(/** @type {string} */ (colors[/** @type {keyof typeof colors} */ (key)]).slice(1));
+        }
+        else if (key === 'transparent') {
+            c = new Color([0, 0, 0], 0);
+        }
+
+        if (c) {
+            c.value = keyword;
+            return c;
+        }
     }
-};
+}
+
+/**
+ * @param {number} v
+ * @param {number} max
+ */
 function clamp(v, max) {
     return Math.min(Math.max(v, 0), max);
 }
+
+/** @param {number[]} v */
 function toHex(v) {
-    return "#".concat(v.map(function (c) {
+    return `#${v.map(function (c) {
         c = clamp(Math.round(c), 255);
         return (c < 16 ? '0' : '') + c.toString(16);
-    }).join(''));
+    }).join('')}`;
 }
-exports.default = Color;
-//# sourceMappingURL=color.js.map
+
+export default Color;

package/lib/less/tree/combinator.js

@@ -1,28 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var _noSpaceCombinators = {
+// @ts-check
+import Node from './node.js';
+
+/** @import { EvalContext, CSSOutput } from './node.js' */
+
+/** @type {Record<string, boolean>} */
+const _noSpaceCombinators = {
     '': true,
     ' ': true,
     '|': true
 };
-var Combinator = function (value) {
-    if (value === ' ') {
-        this.value = ' ';
-        this.emptyOrWhitespace = true;
+
+class Combinator extends Node {
+    get type() { return 'Combinator'; }
+
+    /** @param {string} value */
+    constructor(value) {
+        super();
+        if (value === ' ') {
+            this.value = ' ';
+            this.emptyOrWhitespace = true;
+        } else {
+            this.value = value ? value.trim() : '';
+            this.emptyOrWhitespace = this.value === '';
+        }
     }
-    else {
-        this.value = value ? value.trim() : '';
-        this.emptyOrWhitespace = this.value === '';
-    }
-};
-Combinator.prototype = Object.assign(new node_1.default(), {
-    type: 'Combinator',
-    genCSS: function (context, output) {
-        var spaceOrEmpty = (context.compress || _noSpaceCombinators[this.value]) ? '' : ' ';
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        const spaceOrEmpty = (context.compress || _noSpaceCombinators[/** @type {string} */ (this.value)]) ? '' : ' ';
         output.add(spaceOrEmpty + this.value + spaceOrEmpty);
     }
-});
-exports.default = Combinator;
-//# sourceMappingURL=combinator.js.map
+}
+
+export default Combinator;