less 4.4.2 → 4.6.0

package/lib/less/tree/operation.js

@@ -1,46 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var color_1 = tslib_1.__importDefault(require("./color"));
-var dimension_1 = tslib_1.__importDefault(require("./dimension"));
-var Constants = tslib_1.__importStar(require("../constants"));
-var MATH = Constants.Math;
-var Operation = function (op, operands, isSpaced) {
-    this.op = op.trim();
-    this.operands = operands;
-    this.isSpaced = isSpaced;
-};
-Operation.prototype = Object.assign(new node_1.default(), {
-    type: 'Operation',
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
+import Node from './node.js';
+import Color from './color.js';
+import Dimension from './dimension.js';
+import * as Constants from '../constants.js';
+const MATH = Constants.Math;
+
+class Operation extends Node {
+    get type() { return 'Operation'; }
+
+    /**
+     * @param {string} op
+     * @param {Node[]} operands
+     * @param {boolean} isSpaced
+     */
+    constructor(op, operands, isSpaced) {
+        super();
+        this.op = op.trim();
+        this.operands = operands;
+        this.isSpaced = isSpaced;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         this.operands = visitor.visitArray(this.operands);
-    },
-    eval: function (context) {
-        var a = this.operands[0].eval(context), b = this.operands[1].eval(context), op;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let a = this.operands[0].eval(context), b = this.operands[1].eval(context), op;
+
         if (context.isMathOn(this.op)) {
             op = this.op === './' ? '/' : this.op;
-            if (a instanceof dimension_1.default && b instanceof color_1.default) {
-                a = a.toColor();
+            if (a instanceof Dimension && b instanceof Color) {
+                a = /** @type {Dimension} */ (a).toColor();
             }
-            if (b instanceof dimension_1.default && a instanceof color_1.default) {
-                b = b.toColor();
+            if (b instanceof Dimension && a instanceof Color) {
+                b = /** @type {Dimension} */ (b).toColor();
             }
-            if (!a.operate || !b.operate) {
-                if ((a instanceof Operation || b instanceof Operation)
-                    && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
+            if (!/** @type {Dimension | Color} */ (a).operate || !/** @type {Dimension | Color} */ (b).operate) {
+                if (
+                    (a instanceof Operation || b instanceof Operation)
+                    && /** @type {Operation} */ (a).op === '/' && context.math === MATH.PARENS_DIVISION
+                ) {
                     return new Operation(this.op, [a, b], this.isSpaced);
                 }
                 throw { type: 'Operation',
                     message: 'Operation on an invalid type' };
             }
-            return a.operate(context, op, b);
-        }
-        else {
+
+            if (a instanceof Dimension) {
+                return a.operate(context, op, /** @type {Dimension} */ (b));
+            }
+            return /** @type {Color} */ (a).operate(context, op, /** @type {Color} */ (b));
+        } else {
             return new Operation(this.op, [a, b], this.isSpaced);
         }
-    },
-    genCSS: function (context, output) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         this.operands[0].genCSS(context, output);
         if (this.isSpaced) {
             output.add(' ');
@@ -51,6 +76,6 @@ Operation.prototype = Object.assign(new node_1.default(), {
         }
         this.operands[1].genCSS(context, output);
     }
-});
-exports.default = Operation;
-//# sourceMappingURL=operation.js.map
+}
+
+export default Operation;

package/lib/less/tree/paren.js

@@ -1,24 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var Paren = function (node) {
-    this.value = node;
-};
-Paren.prototype = Object.assign(new node_1.default(), {
-    type: 'Paren',
-    genCSS: function (context, output) {
+// @ts-check
+/** @import { EvalContext, CSSOutput } from './node.js' */
+import Node from './node.js';
+
+class Paren extends Node {
+    get type() { return 'Paren'; }
+
+    /** @param {Node} node */
+    constructor(node) {
+        super();
+        this.value = node;
+        /** @type {boolean | undefined} */
+        this.noSpacing = undefined;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add('(');
-        this.value.genCSS(context, output);
+        /** @type {Node} */ (this.value).genCSS(context, output);
         output.add(')');
-    },
-    eval: function (context) {
-        var paren = new Paren(this.value.eval(context));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Paren}
+     */
+    eval(context) {
+        const paren = new Paren(/** @type {Node} */ (this.value).eval(context));
+
         if (this.noSpacing) {
             paren.noSpacing = true;
         }
+
         return paren;
     }
-});
-exports.default = Paren;
-//# sourceMappingURL=paren.js.map
+}
+
+export default Paren;

package/lib/less/tree/property.js

@@ -1,39 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var declaration_1 = tslib_1.__importDefault(require("./declaration"));
-var Property = function (name, index, currentFileInfo) {
-    this.name = name;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Property.prototype = Object.assign(new node_1.default(), {
-    type: 'Property',
-    eval: function (context) {
-        var property;
-        var name = this.name;
+// @ts-check
+/** @import { EvalContext, FileInfo } from './node.js' */
+import Node from './node.js';
+import Declaration from './declaration.js';
+import Ruleset from './ruleset.js';
+
+class Property extends Node {
+    get type() { return 'Property'; }
+
+    /**
+     * @param {string} name
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     */
+    constructor(name, index, currentFileInfo) {
+        super();
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {boolean | undefined} */
+        this.evaluating = undefined;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let property;
+        const name = this.name;
         // TODO: shorten this reference
-        var mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
+        const mergeRules = /** @type {{ less: { visitors: { ToCSSVisitor: { prototype: { _mergeRules: (rules: Declaration[]) => void } } } } }} */ (context.pluginManager).less.visitors.ToCSSVisitor.prototype._mergeRules;
+
         if (this.evaluating) {
             throw { type: 'Name',
-                message: "Recursive property reference for ".concat(name),
+                message: `Recursive property reference for ${name}`,
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
+
         this.evaluating = true;
-        property = this.find(context.frames, function (frame) {
-            var v;
-            var vArr = frame.property(name);
+
+        property = this.find(context.frames, function (/** @type {Node} */ frame) {
+            let v;
+            const vArr = /** @type {Ruleset} */ (frame).property(name);
             if (vArr) {
-                for (var i = 0; i < vArr.length; i++) {
+                for (let i = 0; i < vArr.length; i++) {
                     v = vArr[i];
-                    vArr[i] = new declaration_1.default(v.name, v.value, v.important, v.merge, v.index, v.currentFileInfo, v.inline, v.variable);
+
+                    vArr[i] = new Declaration(v.name,
+                        v.value,
+                        v.important,
+                        v.merge,
+                        v.index,
+                        v.currentFileInfo,
+                        v.inline,
+                        v.variable
+                    );
                 }
                 mergeRules(vArr);
+
                 v = vArr[vArr.length - 1];
                 if (v.important) {
-                    var importantScope = context.importantScope[context.importantScope.length - 1];
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
                     importantScope.important = v.important;
                 }
                 v = v.value.eval(context);
@@ -43,23 +71,26 @@ Property.prototype = Object.assign(new node_1.default(), {
         if (property) {
             this.evaluating = false;
             return property;
-        }
-        else {
+        } else {
             throw { type: 'Name',
-                message: "Property '".concat(name, "' is undefined"),
+                message: `Property '${name}' is undefined`,
                 filename: this.currentFileInfo.filename,
                 index: this.index };
         }
-    },
-    find: function (obj, fun) {
-        for (var i = 0, r = void 0; i < obj.length; i++) {
+    }
+
+    /**
+     * @param {Node[]} obj
+     * @param {(frame: Node) => Node | undefined} fun
+     * @returns {Node | null}
+     */
+    find(obj, fun) {
+        for (let i = 0, r; i < obj.length; i++) {
             r = fun.call(obj, obj[i]);
-            if (r) {
-                return r;
-            }
+            if (r) { return r; }
         }
         return null;
     }
-});
-exports.default = Property;
-//# sourceMappingURL=property.js.map
+}
+
+export default Property;

package/lib/less/tree/query-in-parens.js

@@ -1,72 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var copy_anything_1 = require("copy-anything");
-var declaration_1 = tslib_1.__importDefault(require("./declaration"));
-var node_1 = tslib_1.__importDefault(require("./node"));
-var QueryInParens = function (op, l, m, op2, r, i) {
-    this.op = op.trim();
-    this.lvalue = l;
-    this.mvalue = m;
-    this.op2 = op2 ? op2.trim() : null;
-    this.rvalue = r;
-    this._index = i;
-    this.mvalues = [];
-};
-QueryInParens.prototype = Object.assign(new node_1.default(), {
-    type: 'QueryInParens',
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
+import Node from './node.js';
+
+class QueryInParens extends Node {
+    get type() { return 'QueryInParens'; }
+
+    /**
+     * @param {string} op
+     * @param {Node} l
+     * @param {Node} m
+     * @param {string | null} op2
+     * @param {Node | null} r
+     * @param {number} i
+     */
+    constructor(op, l, m, op2, r, i) {
+        super();
+        this.op = op.trim();
+        this.lvalue = l;
+        this.mvalue = m;
+        this.op2 = op2 ? op2.trim() : null;
+        /** @type {Node | null} */
+        this.rvalue = r;
+        this._index = i;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         this.lvalue = visitor.visit(this.lvalue);
         this.mvalue = visitor.visit(this.mvalue);
         if (this.rvalue) {
             this.rvalue = visitor.visit(this.rvalue);
         }
-    },
-    eval: function (context) {
-        this.lvalue = this.lvalue.eval(context);
-        var variableDeclaration;
-        var rule;
-        for (var i = 0; (rule = context.frames[i]); i++) {
-            if (rule.type === 'Ruleset') {
-                variableDeclaration = rule.rules.find(function (r) {
-                    if ((r instanceof declaration_1.default) && r.variable) {
-                        return true;
-                    }
-                    return false;
-                });
-                if (variableDeclaration) {
-                    break;
-                }
-            }
-        }
-        if (!this.mvalueCopy) {
-            this.mvalueCopy = (0, copy_anything_1.copy)(this.mvalue);
-        }
-        if (variableDeclaration) {
-            this.mvalue = this.mvalueCopy;
-            this.mvalue = this.mvalue.eval(context);
-            this.mvalues.push(this.mvalue);
-        }
-        else {
-            this.mvalue = this.mvalue.eval(context);
-        }
-        if (this.rvalue) {
-            this.rvalue = this.rvalue.eval(context);
-        }
-        return this;
-    },
-    genCSS: function (context, output) {
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        const node = new QueryInParens(
+            this.op,
+            this.lvalue.eval(context),
+            this.mvalue.eval(context),
+            this.op2,
+            this.rvalue ? this.rvalue.eval(context) : null,
+            this._index || 0
+        );
+        return node;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         this.lvalue.genCSS(context, output);
         output.add(' ' + this.op + ' ');
-        if (this.mvalues.length > 0) {
-            this.mvalue = this.mvalues.shift();
-        }
         this.mvalue.genCSS(context, output);
         if (this.rvalue) {
             output.add(' ' + this.op2 + ' ');
             this.rvalue.genCSS(context, output);
         }
-    },
-});
-exports.default = QueryInParens;
-//# sourceMappingURL=query-in-parens.js.map
+    }
+}
+
+export default QueryInParens;

package/lib/less/tree/quoted.js

@@ -1,46 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var variable_1 = tslib_1.__importDefault(require("./variable"));
-var property_1 = tslib_1.__importDefault(require("./property"));
-var Quoted = function (str, content, escaped, index, currentFileInfo) {
-    this.escaped = (escaped === undefined) ? true : escaped;
-    this.value = content || '';
-    this.quote = str.charAt(0);
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.variableRegex = /@\{([\w-]+)\}/g;
-    this.propRegex = /\$\{([\w-]+)\}/g;
-    this.allowRoot = escaped;
-};
-Quoted.prototype = Object.assign(new node_1.default(), {
-    type: 'Quoted',
-    genCSS: function (context, output) {
+// @ts-check
+/** @import { EvalContext, CSSOutput, FileInfo } from './node.js' */
+import Node from './node.js';
+import Variable from './variable.js';
+import Property from './property.js';
+
+class Quoted extends Node {
+    get type() { return 'Quoted'; }
+
+    /**
+     * @param {string} str
+     * @param {string} [content]
+     * @param {boolean} [escaped]
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     */
+    constructor(str, content, escaped, index, currentFileInfo) {
+        super();
+        /** @type {boolean} */
+        this.escaped = (escaped === undefined) ? true : escaped;
+        /** @type {string} */
+        this.value = content || '';
+        /** @type {string} */
+        this.quote = str.charAt(0);
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {RegExp} */
+        this.variableRegex = /@\{([\w-]+)\}/g;
+        /** @type {RegExp} */
+        this.propRegex = /\$\{([\w-]+)\}/g;
+        /** @type {boolean | undefined} */
+        this.allowRoot = escaped;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         if (!this.escaped) {
             output.add(this.quote, this.fileInfo(), this.getIndex());
         }
-        output.add(this.value);
+        output.add(/** @type {string} */ (this.value));
         if (!this.escaped) {
             output.add(this.quote);
         }
-    },
-    containsVariables: function () {
-        return this.value.match(this.variableRegex);
-    },
-    eval: function (context) {
-        var that = this;
-        var value = this.value;
-        var variableReplacement = function (_, name1, name2) {
-            var v = new variable_1.default("@".concat(name1 !== null && name1 !== void 0 ? name1 : name2), that.getIndex(), that.fileInfo()).eval(context, true);
-            return (v instanceof Quoted) ? v.value : v.toCSS();
+    }
+
+    /** @returns {RegExpMatchArray | null} */
+    containsVariables() {
+        return /** @type {string} */ (this.value).match(this.variableRegex);
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        const that = this;
+        let value = /** @type {string} */ (this.value);
+        /**
+         * @param {string} _
+         * @param {string} name1
+         * @param {string} name2
+         * @returns {string}
+         */
+        const variableReplacement = function (_, name1, name2) {
+            const v = new Variable(`@${name1 ?? name2}`, that.getIndex(), that.fileInfo()).eval(context);
+            return (v instanceof Quoted) ? /** @type {string} */ (v.value) : v.toCSS(context);
         };
-        var propertyReplacement = function (_, name1, name2) {
-            var v = new property_1.default("$".concat(name1 !== null && name1 !== void 0 ? name1 : name2), that.getIndex(), that.fileInfo()).eval(context, true);
-            return (v instanceof Quoted) ? v.value : v.toCSS();
+        /**
+         * @param {string} _
+         * @param {string} name1
+         * @param {string} name2
+         * @returns {string}
+         */
+        const propertyReplacement = function (_, name1, name2) {
+            const v = new Property(`$${name1 ?? name2}`, that.getIndex(), that.fileInfo()).eval(context);
+            return (v instanceof Quoted) ? /** @type {string} */ (v.value) : v.toCSS(context);
         };
+        /**
+         * @param {string} value
+         * @param {RegExp} regexp
+         * @param {(substring: string, ...args: string[]) => string} replacementFnc
+         * @returns {string}
+         */
         function iterativeReplace(value, regexp, replacementFnc) {
-            var evaluatedValue = value;
+            let evaluatedValue = value;
             do {
                 value = evaluatedValue.toString();
                 evaluatedValue = value.replace(regexp, replacementFnc);
@@ -50,16 +92,23 @@ Quoted.prototype = Object.assign(new node_1.default(), {
         value = iterativeReplace(value, this.variableRegex, variableReplacement);
         value = iterativeReplace(value, this.propRegex, propertyReplacement);
         return new Quoted(this.quote + value + this.quote, value, this.escaped, this.getIndex(), this.fileInfo());
-    },
-    compare: function (other) {
+    }
+
+    /**
+     * @param {Node} other
+     * @returns {number | undefined}
+     */
+    compare(other) {
         // when comparing quoted strings allow the quote to differ
-        if (other.type === 'Quoted' && !this.escaped && !other.escaped) {
-            return node_1.default.numericCompare(this.value, other.value);
-        }
-        else {
-            return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
+        if (other.type === 'Quoted' && !this.escaped && !/** @type {Quoted} */ (other).escaped) {
+            return Node.numericCompare(
+                /** @type {string} */ (this.value),
+                /** @type {string} */ (other.value)
+            );
+        } else {
+            return other.toCSS && this.toCSS(/** @type {EvalContext} */ ({})) === other.toCSS(/** @type {EvalContext} */ ({})) ? 0 : undefined;
         }
     }
-});
-exports.default = Quoted;
-//# sourceMappingURL=quoted.js.map
+}
+
+export default Quoted;