less 4.5.1 → 4.6.1

package/lib/less/tree/detached-ruleset.js

@@ -1,27 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var contexts_1 = tslib_1.__importDefault(require("../contexts"));
-var utils = tslib_1.__importStar(require("../utils"));
-var DetachedRuleset = function (ruleset, frames) {
-    this.ruleset = ruleset;
-    this.frames = frames;
-    this.setParent(this.ruleset, this);
-};
-DetachedRuleset.prototype = Object.assign(new node_1.default(), {
-    type: 'DetachedRuleset',
-    evalFirst: true,
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, TreeVisitor } from './node.js' */
+import Node from './node.js';
+import contexts from '../contexts.js';
+import * as utils from '../utils.js';
+
+class DetachedRuleset extends Node {
+    get type() { return 'DetachedRuleset'; }
+
+    /**
+     * @param {Node} ruleset
+     * @param {Node[]} [frames]
+     */
+    constructor(ruleset, frames) {
+        super();
+        this.ruleset = ruleset;
+        this.frames = frames;
+        this.evalFirst = true;
+        this.setParent(this.ruleset, this);
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         this.ruleset = visitor.visit(this.ruleset);
-    },
-    eval: function (context) {
-        var frames = this.frames || utils.copyArray(context.frames);
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {DetachedRuleset}
+     */
+    eval(context) {
+        const frames = this.frames || utils.copyArray(context.frames);
         return new DetachedRuleset(this.ruleset, frames);
-    },
-    callEval: function (context) {
-        return this.ruleset.eval(this.frames ? new contexts_1.default.Eval(context, this.frames.concat(context.frames)) : context);
     }
-});
-exports.default = DetachedRuleset;
-//# sourceMappingURL=detached-ruleset.js.map
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    callEval(context) {
+        return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
+    }
+}
+
+export default DetachedRuleset;

package/lib/less/tree/dimension.js

@@ -1,131 +1,182 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+// @ts-check
 /* eslint-disable no-prototype-builtins */
-var node_1 = tslib_1.__importDefault(require("./node"));
-var unit_conversions_1 = tslib_1.__importDefault(require("../data/unit-conversions"));
-var unit_1 = tslib_1.__importDefault(require("./unit"));
-var color_1 = tslib_1.__importDefault(require("./color"));
+import Node from './node.js';
+import unitConversions from '../data/unit-conversions.js';
+import Unit from './unit.js';
+import Color from './color.js';
+
+/** @import { EvalContext, CSSOutput } from './node.js' */
+
 //
 // A number with a unit
 //
-var Dimension = function (value, unit) {
-    this.value = parseFloat(value);
-    if (isNaN(this.value)) {
-        throw new Error('Dimension is not a number.');
+class Dimension extends Node {
+    get type() { return 'Dimension'; }
+
+    /**
+     * @param {number | string} value
+     * @param {Unit | string} [unit]
+     */
+    constructor(value, unit) {
+        super();
+        /** @type {number} */
+        this.value = parseFloat(/** @type {string} */ (value));
+        if (isNaN(this.value)) {
+            throw new Error('Dimension is not a number.');
+        }
+        /** @type {Unit} */
+        this.unit = (unit && unit instanceof Unit) ? unit :
+            new Unit(unit ? [/** @type {string} */ (unit)] : undefined);
+        this.setParent(this.unit, this);
+    }
+
+    /**
+     * @param {import('./node.js').TreeVisitor} visitor
+     */
+    accept(visitor) {
+        this.unit = /** @type {Unit} */ (visitor.visit(this.unit));
     }
-    this.unit = (unit && unit instanceof unit_1.default) ? unit :
-        new unit_1.default(unit ? [unit] : undefined);
-    this.setParent(this.unit, this);
-};
-Dimension.prototype = Object.assign(new node_1.default(), {
-    type: 'Dimension',
-    accept: function (visitor) {
-        this.unit = visitor.visit(this.unit);
-    },
+
     // remove when Nodes have JSDoc types
     // eslint-disable-next-line no-unused-vars
-    eval: function (context) {
+    /** @param {EvalContext} context */
+    eval(context) {
         return this;
-    },
-    toColor: function () {
-        return new color_1.default([this.value, this.value, this.value]);
-    },
-    genCSS: function (context, output) {
+    }
+
+    toColor() {
+        const v = /** @type {number} */ (this.value);
+        return new Color([v, v, v]);
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         if ((context && context.strictUnits) && !this.unit.isSingular()) {
-            throw new Error("Multiple units in dimension. Correct the units or use the unit function. Bad unit: ".concat(this.unit.toString()));
+            throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`);
         }
-        var value = this.fround(context, this.value);
-        var strValue = String(value);
+
+        const value = this.fround(context, /** @type {number} */ (this.value));
+        let strValue = String(value);
+
         if (value !== 0 && value < 0.000001 && value > -0.000001) {
             // would be output 1e-6 etc.
             strValue = value.toFixed(20).replace(/0+$/, '');
         }
+
         if (context && context.compress) {
             // Zero values doesn't need a unit
             if (value === 0 && this.unit.isLength()) {
                 output.add(strValue);
                 return;
             }
+
             // Float values doesn't need a leading zero
             if (value > 0 && value < 1) {
-                strValue = (strValue).substr(1);
+                strValue = (strValue).slice(1);
             }
         }
+
         output.add(strValue);
         this.unit.genCSS(context, output);
-    },
+    }
+
     // In an operation between two Dimensions,
     // we default to the first Dimension's unit,
     // so `1px + 2` will yield `3px`.
-    operate: function (context, op, other) {
+    /**
+     * @param {EvalContext} context
+     * @param {string} op
+     * @param {Dimension} other
+     */
+    operate(context, op, other) {
         /* jshint noempty:false */
-        var value = this._operate(context, op, this.value, other.value);
-        var unit = this.unit.clone();
+        let value = this._operate(context, op, /** @type {number} */ (this.value), /** @type {number} */ (other.value));
+        let unit = this.unit.clone();
+
         if (op === '+' || op === '-') {
             if (unit.numerator.length === 0 && unit.denominator.length === 0) {
                 unit = other.unit.clone();
                 if (this.unit.backupUnit) {
                     unit.backupUnit = this.unit.backupUnit;
                 }
-            }
-            else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
+            } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
                 // do nothing
-            }
-            else {
+            } else {
                 other = other.convertTo(this.unit.usedUnits());
+
                 if (context.strictUnits && other.unit.toString() !== unit.toString()) {
                     throw new Error('Incompatible units. Change the units or use the unit function. '
-                        + "Bad units: '".concat(unit.toString(), "' and '").concat(other.unit.toString(), "'."));
+                        + `Bad units: '${unit.toString()}' and '${other.unit.toString()}'.`);
                 }
-                value = this._operate(context, op, this.value, other.value);
+
+                value = this._operate(context, op, /** @type {number} */ (this.value), /** @type {number} */ (other.value));
             }
-        }
-        else if (op === '*') {
+        } else if (op === '*') {
             unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
             unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
             unit.cancel();
-        }
-        else if (op === '/') {
+        } else if (op === '/') {
             unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
             unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
             unit.cancel();
         }
-        return new Dimension(value, unit);
-    },
-    compare: function (other) {
-        var a, b;
+        return new Dimension(/** @type {number} */ (value), unit);
+    }
+
+    /**
+     * @param {Node} other
+     * @returns {number | undefined}
+     */
+    compare(other) {
+        let a, b;
+
         if (!(other instanceof Dimension)) {
             return undefined;
         }
+
         if (this.unit.isEmpty() || other.unit.isEmpty()) {
             a = this;
             b = other;
-        }
-        else {
+        } else {
             a = this.unify();
             b = other.unify();
             if (a.unit.compare(b.unit) !== 0) {
                 return undefined;
             }
         }
-        return node_1.default.numericCompare(a.value, b.value);
-    },
-    unify: function () {
+
+        return Node.numericCompare(/** @type {number} */ (a.value), /** @type {number} */ (b.value));
+    }
+
+    unify() {
         return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
-    },
-    convertTo: function (conversions) {
-        var value = this.value;
-        var unit = this.unit.clone();
-        var i;
-        var groupName;
-        var group;
-        var targetUnit;
-        var derivedConversions = {};
-        var applyUnit;
+    }
+
+    /**
+     * @param {string | { [groupName: string]: string }} conversions
+     * @returns {Dimension}
+     */
+    convertTo(conversions) {
+        let value = /** @type {number} */ (this.value);
+        const unit = this.unit.clone();
+        let i;
+        /** @type {string} */
+        let groupName;
+        /** @type {{ [unitName: string]: number }} */
+        let group;
+        /** @type {string} */
+        let targetUnit;
+        /** @type {{ [groupName: string]: string }} */
+        let derivedConversions = {};
+        /** @type {(atomicUnit: string, denominator: boolean) => string} */
+        let applyUnit;
+
         if (typeof conversions === 'string') {
-            for (i in unit_conversions_1.default) {
-                if (unit_conversions_1.default[i].hasOwnProperty(conversions)) {
+            for (i in unitConversions) {
+                if (unitConversions[/** @type {keyof typeof unitConversions} */ (i)].hasOwnProperty(conversions)) {
                     derivedConversions = {};
                     derivedConversions[i] = conversions;
                 }
@@ -136,24 +187,29 @@ Dimension.prototype = Object.assign(new node_1.default(), {
             if (group.hasOwnProperty(atomicUnit)) {
                 if (denominator) {
                     value = value / (group[atomicUnit] / group[targetUnit]);
-                }
-                else {
+                } else {
                     value = value * (group[atomicUnit] / group[targetUnit]);
                 }
+
                 return targetUnit;
             }
+
             return atomicUnit;
         };
+
         for (groupName in conversions) {
             if (conversions.hasOwnProperty(groupName)) {
                 targetUnit = conversions[groupName];
-                group = unit_conversions_1.default[groupName];
+                group = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);
+
                 unit.map(applyUnit);
             }
         }
+
         unit.cancel();
+
         return new Dimension(value, unit);
     }
-});
-exports.default = Dimension;
-//# sourceMappingURL=dimension.js.map
+}
+
+export default Dimension;

package/lib/less/tree/element.js

@@ -1,63 +1,93 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var paren_1 = tslib_1.__importDefault(require("./paren"));
-var combinator_1 = tslib_1.__importDefault(require("./combinator"));
-var Element = function (combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
-    this.combinator = combinator instanceof combinator_1.default ?
-        combinator : new combinator_1.default(combinator);
-    if (typeof value === 'string') {
-        this.value = value.trim();
-    }
-    else if (value) {
-        this.value = value;
-    }
-    else {
-        this.value = '';
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+import Node from './node.js';
+import Paren from './paren.js';
+import Combinator from './combinator.js';
+
+class Element extends Node {
+    get type() { return 'Element'; }
+
+    /**
+     * @param {Combinator | string} combinator
+     * @param {string | Node} value
+     * @param {boolean} [isVariable]
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
+        super();
+        this.combinator = combinator instanceof Combinator ?
+            combinator : new Combinator(combinator);
+
+        if (typeof value === 'string') {
+            this.value = value.trim();
+        } else if (value) {
+            this.value = value;
+        } else {
+            this.value = '';
+        }
+        /** @type {boolean | undefined} */
+        this.isVariable = isVariable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.combinator, this);
     }
-    this.isVariable = isVariable;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.combinator, this);
-};
-Element.prototype = Object.assign(new node_1.default(), {
-    type: 'Element',
-    accept: function (visitor) {
-        var value = this.value;
-        this.combinator = visitor.visit(this.combinator);
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        const value = this.value;
+        this.combinator = /** @type {Combinator} */ (visitor.visit(this.combinator));
         if (typeof value === 'object') {
-            this.value = visitor.visit(value);
+            this.value = visitor.visit(/** @type {Node} */ (value));
         }
-    },
-    eval: function (context) {
-        return new Element(this.combinator, this.value.eval ? this.value.eval(context) : this.value, this.isVariable, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    },
-    clone: function () {
-        return new Element(this.combinator, this.value, this.isVariable, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    },
-    genCSS: function (context, output) {
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        return new Element(this.combinator,
+            /** @type {Node} */ (this.value).eval ? /** @type {Node} */ (this.value).eval(context) : /** @type {string} */ (this.value),
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
+    }
+
+    clone() {
+        return new Element(this.combinator,
+            /** @type {string | Node} */ (this.value),
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
-    },
-    toCSS: function (context) {
-        context = context || {};
-        var value = this.value;
-        var firstSelector = context.firstSelector;
-        if (value instanceof paren_1.default) {
+    }
+
+    /** @param {EvalContext} [context] */
+    toCSS(context) {
+        /** @type {EvalContext & { firstSelector?: boolean }} */
+        const ctx = context || {};
+        let value = this.value;
+        const firstSelector = ctx.firstSelector;
+        if (value instanceof Paren) {
             // selector in parens should not be affected by outer selector
             // flags (breaks only interpolated selectors - see #1973)
-            context.firstSelector = true;
+            ctx.firstSelector = true;
         }
-        value = value.toCSS ? value.toCSS(context) : value;
-        context.firstSelector = firstSelector;
+        value = /** @type {Node} */ (value).toCSS ? /** @type {Node} */ (value).toCSS(ctx) : /** @type {string} */ (value);
+        ctx.firstSelector = firstSelector;
         if (value === '' && this.combinator.value.charAt(0) === '&') {
             return '';
-        }
-        else {
-            return this.combinator.toCSS(context) + value;
+        } else {
+            return this.combinator.toCSS(ctx) + value;
         }
     }
-});
-exports.default = Element;
-//# sourceMappingURL=element.js.map
+}
+
+export default Element;

package/lib/less/tree/expression.js

@@ -1,75 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var paren_1 = tslib_1.__importDefault(require("./paren"));
-var comment_1 = tslib_1.__importDefault(require("./comment"));
-var dimension_1 = tslib_1.__importDefault(require("./dimension"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var Expression = function (value, noSpacing) {
-    this.value = value;
-    this.noSpacing = noSpacing;
-    if (!value) {
-        throw new Error('Expression requires an array parameter');
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
+import Node from './node.js';
+import Paren from './paren.js';
+import Comment from './comment.js';
+import Dimension from './dimension.js';
+import Anonymous from './anonymous.js';
+
+class Expression extends Node {
+    get type() { return 'Expression'; }
+
+    /**
+     * @param {Node[]} value
+     * @param {boolean} [noSpacing]
+     */
+    constructor(value, noSpacing) {
+        super();
+        this.value = value;
+        /** @type {boolean | undefined} */
+        this.noSpacing = noSpacing;
+        /** @type {boolean | undefined} */
+        this.parens = undefined;
+        /** @type {boolean | undefined} */
+        this.parensInOp = undefined;
+        if (!value) {
+            throw new Error('Expression requires an array parameter');
+        }
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));
     }
-};
-Expression.prototype = Object.assign(new node_1.default(), {
-    type: 'Expression',
-    accept: function (visitor) {
-        this.value = visitor.visitArray(this.value);
-    },
-    eval: function (context) {
-        var noSpacing = this.noSpacing;
-        var returnValue;
-        var mathOn = context.isMathOn();
-        var inParenthesis = this.parens;
-        var doubleParen = false;
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        const noSpacing = this.noSpacing;
+        /** @type {Node | Expression} */
+        let returnValue;
+        const mathOn = context.isMathOn();
+        const inParenthesis = this.parens;
+
+        let doubleParen = false;
         if (inParenthesis) {
             context.inParenthesis();
         }
-        if (this.value.length > 1) {
-            returnValue = new Expression(this.value.map(function (e) {
+        const value = /** @type {Node[]} */ (this.value);
+        if (value.length > 1) {
+            returnValue = new Expression(value.map(function (e) {
                 if (!e.eval) {
                     return e;
                 }
                 return e.eval(context);
             }), this.noSpacing);
-        }
-        else if (this.value.length === 1) {
-            if (this.value[0].parens && !this.value[0].parensInOp && !context.inCalc) {
+        } else if (value.length === 1) {
+            const first = /** @type {Expression} */ (value[0]);
+            if (first.parens && !first.parensInOp && !context.inCalc) {
                 doubleParen = true;
             }
-            returnValue = this.value[0].eval(context);
-        }
-        else {
+            returnValue = value[0].eval(context);
+        } else {
             returnValue = this;
         }
         if (inParenthesis) {
             context.outOfParenthesis();
         }
         if (this.parens && this.parensInOp && !mathOn && !doubleParen
-            && (!(returnValue instanceof dimension_1.default))) {
-            returnValue = new paren_1.default(returnValue);
+            && (!(returnValue instanceof Dimension))) {
+            returnValue = new Paren(returnValue);
         }
-        returnValue.noSpacing = returnValue.noSpacing || noSpacing;
+        /** @type {Expression} */ (returnValue).noSpacing =
+            /** @type {Expression} */ (returnValue).noSpacing || noSpacing;
         return returnValue;
-    },
-    genCSS: function (context, output) {
-        for (var i = 0; i < this.value.length; i++) {
-            this.value[i].genCSS(context, output);
-            if (!this.noSpacing && i + 1 < this.value.length) {
-                if (i + 1 < this.value.length && !(this.value[i + 1] instanceof anonymous_1.default) ||
-                    this.value[i + 1] instanceof anonymous_1.default && this.value[i + 1].value !== ',') {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        const value = /** @type {Node[]} */ (this.value);
+        for (let i = 0; i < value.length; i++) {
+            value[i].genCSS(context, output);
+            if (!this.noSpacing && i + 1 < value.length) {
+                if (!(value[i + 1] instanceof Anonymous) ||
+                    value[i + 1] instanceof Anonymous && /** @type {string} */ (value[i + 1].value) !== ',') {
                     output.add(' ');
                 }
             }
         }
-    },
-    throwAwayComments: function () {
-        this.value = this.value.filter(function (v) {
-            return !(v instanceof comment_1.default);
+    }
+
+    throwAwayComments() {
+        this.value = /** @type {Node[]} */ (this.value).filter(function(v) {
+            return !(v instanceof Comment);
         });
     }
-});
-exports.default = Expression;
-//# sourceMappingURL=expression.js.map
+}
+
+export default Expression;