less 4.5.1 → 4.6.0

package/lib/less/tree/mixin-definition.js

@@ -1,70 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var element_1 = tslib_1.__importDefault(require("./element"));
-var ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var declaration_1 = tslib_1.__importDefault(require("./declaration"));
-var detached_ruleset_1 = tslib_1.__importDefault(require("./detached-ruleset"));
-var expression_1 = tslib_1.__importDefault(require("./expression"));
-var contexts_1 = tslib_1.__importDefault(require("../contexts"));
-var utils = tslib_1.__importStar(require("../utils"));
-var Definition = function (name, params, rules, condition, variadic, frames, visibilityInfo) {
-    this.name = name || 'anonymous mixin';
-    this.selectors = [new selector_1.default([new element_1.default(null, name, false, this._index, this._fileInfo)])];
-    this.params = params;
-    this.condition = condition;
-    this.variadic = variadic;
-    this.arity = params.length;
-    this.rules = rules;
-    this._lookups = {};
-    var optionalParameters = [];
-    this.required = params.reduce(function (count, p) {
-        if (!p.name || (p.name && !p.value)) {
-            return count + 1;
-        }
-        else {
-            optionalParameters.push(p.name);
-            return count;
-        }
-    }, 0);
-    this.optionalParameters = optionalParameters;
-    this.frames = frames;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-};
-Definition.prototype = Object.assign(new ruleset_1.default(), {
-    type: 'MixinDefinition',
-    evalFirst: true,
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, TreeVisitor, VisibilityInfo } from './node.js' */
+/** @import { FunctionRegistry } from './nested-at-rule.js' */
+/** @import { MixinArg } from './mixin-call.js' */
+import Node from './node.js';
+import Selector from './selector.js';
+import Element from './element.js';
+import Ruleset from './ruleset.js';
+import Declaration from './declaration.js';
+import DetachedRuleset from './detached-ruleset.js';
+import Expression from './expression.js';
+import contexts from '../contexts.js';
+import * as utils from '../utils.js';
+
+/**
+ * @typedef {object} MixinParam
+ * @property {string} [name]
+ * @property {Node} [value]
+ * @property {boolean} [variadic]
+ */
+
+/**
+ * @typedef {Ruleset & {
+ *   functionRegistry?: FunctionRegistry,
+ *   originalRuleset?: Node
+ * }} RulesetWithRegistry
+ */
+
+class Definition extends Ruleset {
+    get type() { return 'MixinDefinition'; }
+
+    /**
+     * @param {string | undefined} name
+     * @param {MixinParam[]} params
+     * @param {Node[]} rules
+     * @param {Node | null} [condition]
+     * @param {boolean} [variadic]
+     * @param {Node[] | null} [frames]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(name, params, rules, condition, variadic, frames, visibilityInfo) {
+        super(null, null);
+        /** @type {string} */
+        this.name = name || 'anonymous mixin';
+        this.selectors = [new Selector([new Element(null, name, false, this._index, this._fileInfo)])];
+        /** @type {MixinParam[]} */
+        this.params = params;
+        /** @type {Node | null | undefined} */
+        this.condition = condition;
+        /** @type {boolean | undefined} */
+        this.variadic = variadic;
+        /** @type {number} */
+        this.arity = params.length;
+        this.rules = rules;
+        this._lookups = {};
+        /** @type {string[]} */
+        const optionalParameters = [];
+        /** @type {number} */
+        this.required = params.reduce(function (/** @type {number} */ count, /** @type {MixinParam} */ p) {
+            if (!p.name || (p.name && !p.value)) {
+                return count + 1;
+            }
+            else {
+                optionalParameters.push(p.name);
+                return count;
+            }
+        }, 0);
+        /** @type {string[]} */
+        this.optionalParameters = optionalParameters;
+        /** @type {Node[] | null | undefined} */
+        this.frames = frames;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+        /** @type {boolean} */
+        this.evalFirst = true;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.params && this.params.length) {
-            this.params = visitor.visitArray(this.params);
+            this.params = /** @type {MixinParam[]} */ (/** @type {unknown} */ (visitor.visitArray(/** @type {Node[]} */ (/** @type {unknown} */ (this.params)))));
         }
         this.rules = visitor.visitArray(this.rules);
         if (this.condition) {
             this.condition = visitor.visit(this.condition);
         }
-    },
-    evalParams: function (context, mixinEnv, args, evaldArguments) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {EvalContext} mixinEnv
+     * @param {MixinArg[] | null} args
+     * @param {Node[]} evaldArguments
+     * @returns {Ruleset}
+     */
+    evalParams(context, mixinEnv, args, evaldArguments) {
         /* jshint boss:true */
-        var frame = new ruleset_1.default(null, null);
-        var varargs;
-        var arg;
-        var params = utils.copyArray(this.params);
-        var i;
-        var j;
-        var val;
-        var name;
-        var isNamedFound;
-        var argIndex;
-        var argsLength = 0;
-        if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
-            frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
+        const frame = new Ruleset(null, null);
+
+        /** @type {Node[] | undefined} */
+        let varargs;
+        /** @type {MixinArg | undefined} */
+        let arg;
+        const params = /** @type {MixinParam[]} */ (utils.copyArray(this.params));
+        /** @type {number} */
+        let i;
+        /** @type {number} */
+        let j;
+        /** @type {Node | undefined} */
+        let val;
+        /** @type {string | undefined} */
+        let name;
+        /** @type {boolean} */
+        let isNamedFound;
+        /** @type {number} */
+        let argIndex;
+        let argsLength = 0;
+
+        if (mixinEnv.frames && mixinEnv.frames[0] && /** @type {RulesetWithRegistry} */ (mixinEnv.frames[0]).functionRegistry) {
+            /** @type {RulesetWithRegistry} */ (frame).functionRegistry = /** @type {FunctionRegistry} */ (/** @type {RulesetWithRegistry} */ (mixinEnv.frames[0]).functionRegistry).inherit();
         }
-        mixinEnv = new contexts_1.default.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
+        mixinEnv = new contexts.Eval(mixinEnv, /** @type {Node[]} */ ([frame]).concat(/** @type {Node[]} */ (mixinEnv.frames)));
+
         if (args) {
-            args = utils.copyArray(args);
+            args = /** @type {MixinArg[]} */ (utils.copyArray(args));
             argsLength = args.length;
+
             for (i = 0; i < argsLength; i++) {
                 arg = args[i];
                 if (name = (arg && arg.name)) {
@@ -72,7 +132,7 @@ Definition.prototype = Object.assign(new ruleset_1.default(), {
                     for (j = 0; j < params.length; j++) {
                         if (!evaldArguments[j] && name === params[j].name) {
                             evaldArguments[j] = arg.value.eval(context);
-                            frame.prependRule(new declaration_1.default(name, arg.value.eval(context)));
+                            frame.prependRule(new Declaration(name, arg.value.eval(context)));
                             isNamedFound = true;
                             break;
                         }
@@ -81,49 +141,47 @@ Definition.prototype = Object.assign(new ruleset_1.default(), {
                         args.splice(i, 1);
                         i--;
                         continue;
-                    }
-                    else {
-                        throw { type: 'Runtime', message: "Named argument for ".concat(this.name, " ").concat(args[i].name, " not found") };
+                    } else {
+                        throw { type: 'Runtime', message: `Named argument for ${this.name} ${args[i].name} not found` };
                     }
                 }
             }
         }
         argIndex = 0;
         for (i = 0; i < params.length; i++) {
-            if (evaldArguments[i]) {
-                continue;
-            }
+            if (evaldArguments[i]) { continue; }
+
             arg = args && args[argIndex];
+
             if (name = params[i].name) {
                 if (params[i].variadic) {
                     varargs = [];
                     for (j = argIndex; j < argsLength; j++) {
-                        varargs.push(args[j].value.eval(context));
+                        varargs.push(/** @type {MixinArg[]} */ (args)[j].value.eval(context));
                     }
-                    frame.prependRule(new declaration_1.default(name, new expression_1.default(varargs).eval(context)));
-                }
-                else {
+                    frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
+                } else {
                     val = arg && arg.value;
                     if (val) {
                         // This was a mixin call, pass in a detached ruleset of it's eval'd rules
                         if (Array.isArray(val)) {
-                            val = new detached_ruleset_1.default(new ruleset_1.default('', val));
+                            val = /** @type {Node} */ (/** @type {unknown} */ (new DetachedRuleset(new Ruleset(null, /** @type {Node[]} */ (val)))));
                         }
                         else {
                             val = val.eval(context);
                         }
-                    }
-                    else if (params[i].value) {
-                        val = params[i].value.eval(mixinEnv);
+                    } else if (params[i].value) {
+                        val = /** @type {Node} */ (params[i].value).eval(mixinEnv);
                         frame.resetCache();
+                    } else {
+                        throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${argsLength} for ${this.arity})` };
                     }
-                    else {
-                        throw { type: 'Runtime', message: "wrong number of arguments for ".concat(this.name, " (").concat(argsLength, " for ").concat(this.arity, ")") };
-                    }
-                    frame.prependRule(new declaration_1.default(name, val));
+
+                    frame.prependRule(new Declaration(name, val));
                     evaldArguments[i] = val;
                 }
             }
+
             if (params[i].variadic && args) {
                 for (j = argIndex; j < argsLength; j++) {
                     evaldArguments[j] = args[j].value.eval(context);
@@ -131,59 +189,94 @@ Definition.prototype = Object.assign(new ruleset_1.default(), {
             }
             argIndex++;
         }
+
         return frame;
-    },
-    makeImportant: function () {
-        var rules = !this.rules ? this.rules : this.rules.map(function (r) {
+    }
+
+    /** @returns {Ruleset} */
+    makeImportant() {
+        const rules = !this.rules ? this.rules : this.rules.map(function (/** @type {Node & { makeImportant?: (important?: boolean) => Node }} */ r) {
             if (r.makeImportant) {
                 return r.makeImportant(true);
-            }
-            else {
+            } else {
                 return r;
             }
         });
-        var result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
-        return result;
-    },
-    eval: function (context) {
+        const result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
+        return /** @type {Ruleset} */ (/** @type {unknown} */ (result));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Definition}
+     */
+    eval(context) {
         return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || utils.copyArray(context.frames));
-    },
-    evalCall: function (context, args, important) {
-        var _arguments = [];
-        var mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames;
-        var frame = this.evalParams(context, new contexts_1.default.Eval(context, mixinFrames), args, _arguments);
-        var rules;
-        var ruleset;
-        frame.prependRule(new declaration_1.default('@arguments', new expression_1.default(_arguments).eval(context)));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {MixinArg[]} args
+     * @param {string | undefined} important
+     * @returns {Ruleset}
+     */
+    evalCall(context, args, important) {
+        /** @type {Node[]} */
+        const _arguments = [];
+        const mixinFrames = this.frames ? /** @type {Node[]} */ (this.frames).concat(/** @type {Node[]} */ (context.frames)) : /** @type {Node[]} */ (context.frames);
+        const frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments);
+        /** @type {Node[]} */
+        let rules;
+        /** @type {Ruleset} */
+        let ruleset;
+
+        frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
+
         rules = utils.copyArray(this.rules);
-        ruleset = new ruleset_1.default(null, rules);
-        ruleset.originalRuleset = this;
-        ruleset = ruleset.eval(new contexts_1.default.Eval(context, [this, frame].concat(mixinFrames)));
+
+        ruleset = new Ruleset(null, rules);
+        /** @type {RulesetWithRegistry} */ (ruleset).originalRuleset = this;
+        ruleset = /** @type {Ruleset} */ (ruleset.eval(new contexts.Eval(context, /** @type {Node[]} */ ([this, frame]).concat(mixinFrames))));
         if (important) {
-            ruleset = ruleset.makeImportant();
+            ruleset = /** @type {Ruleset} */ (ruleset.makeImportant());
         }
         return ruleset;
-    },
-    matchCondition: function (args, context) {
-        if (this.condition && !this.condition.eval(new contexts_1.default.Eval(context, [this.evalParams(context, /* the parameter variables */ new contexts_1.default.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])]
-            .concat(this.frames || []) // the parent namespace/mixin frames
-            .concat(context.frames)))) { // the current environment frames
+    }
+
+    /**
+     * @param {MixinArg[] | null} args
+     * @param {EvalContext} context
+     * @returns {boolean}
+     */
+    matchCondition(args, context) {
+        if (this.condition && !this.condition.eval(
+            new contexts.Eval(context,
+                /** @type {Node[]} */ ([this.evalParams(context, /* the parameter variables */
+                    new contexts.Eval(context, this.frames ? /** @type {Node[]} */ (this.frames).concat(/** @type {Node[]} */ (context.frames)) : context.frames), args, [])])
+                    .concat(/** @type {Node[]} */ (this.frames || [])) // the parent namespace/mixin frames
+                    .concat(/** @type {Node[]} */ (context.frames))))) { // the current environment frames
             return false;
         }
         return true;
-    },
-    matchArgs: function (args, context) {
-        var allArgsCnt = (args && args.length) || 0;
-        var len;
-        var optionalParameters = this.optionalParameters;
-        var requiredArgsCnt = !args ? 0 : args.reduce(function (count, p) {
+    }
+
+    /**
+     * @param {MixinArg[] | null} args
+     * @param {EvalContext} [context]
+     * @returns {boolean}
+     */
+    matchArgs(args, context) {
+        const allArgsCnt = (args && args.length) || 0;
+        let len;
+        const optionalParameters = this.optionalParameters;
+        const requiredArgsCnt = !args ? 0 : args.reduce(function (/** @type {number} */ count, /** @type {MixinArg} */ p) {
             if (optionalParameters.indexOf(p.name) < 0) {
                 return count + 1;
-            }
-            else {
+            } else {
                 return count;
             }
         }, 0);
+
         if (!this.variadic) {
             if (requiredArgsCnt < this.required) {
                 return false;
@@ -191,23 +284,24 @@ Definition.prototype = Object.assign(new ruleset_1.default(), {
             if (allArgsCnt > this.params.length) {
                 return false;
             }
-        }
-        else {
+        } else {
             if (requiredArgsCnt < (this.required - 1)) {
                 return false;
             }
         }
+
         // check patterns
         len = Math.min(requiredArgsCnt, this.arity);
-        for (var i = 0; i < len; i++) {
+
+        for (let i = 0; i < len; i++) {
             if (!this.params[i].name && !this.params[i].variadic) {
-                if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
+                if (/** @type {MixinArg[]} */ (args)[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
                     return false;
                 }
             }
         }
         return true;
     }
-});
-exports.default = Definition;
-//# sourceMappingURL=mixin-definition.js.map
+}
+
+export default Definition;

package/lib/less/tree/namespace-value.js

@@ -1,76 +1,95 @@
-"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 ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var NamespaceValue = function (ruleCall, lookups, index, fileInfo) {
-    this.value = ruleCall;
-    this.lookups = lookups;
-    this._index = index;
-    this._fileInfo = fileInfo;
-};
-NamespaceValue.prototype = Object.assign(new node_1.default(), {
-    type: 'NamespaceValue',
-    eval: function (context) {
-        var i, name, rules = this.value.eval(context);
+// @ts-check
+/** @import { EvalContext, FileInfo } from './node.js' */
+import Node from './node.js';
+import Variable from './variable.js';
+import Ruleset from './ruleset.js';
+import Selector from './selector.js';
+
+class NamespaceValue extends Node {
+    get type() { return 'NamespaceValue'; }
+
+    /**
+     * @param {Node} ruleCall
+     * @param {string[]} lookups
+     * @param {number} index
+     * @param {FileInfo} fileInfo
+     */
+    constructor(ruleCall, lookups, index, fileInfo) {
+        super();
+        this.value = ruleCall;
+        this.lookups = lookups;
+        this._index = index;
+        this._fileInfo = fileInfo;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let i, name;
+        /** @type {Ruleset | Node | Node[]} */
+        let rules = this.value.eval(context);
+
         for (i = 0; i < this.lookups.length; i++) {
             name = this.lookups[i];
-            /**
-             * Eval'd DRs return rulesets.
-             * Eval'd mixins return rules, so let's make a ruleset if we need it.
-             * We need to do this because of late parsing of values
-             */
+
             if (Array.isArray(rules)) {
-                rules = new ruleset_1.default([new selector_1.default()], rules);
+                rules = new Ruleset([new Selector()], rules);
             }
+
+            const rs = /** @type {Ruleset} */ (rules);
+
             if (name === '') {
-                rules = rules.lastDeclaration();
+                rules = rs.lastDeclaration();
             }
             else if (name.charAt(0) === '@') {
                 if (name.charAt(1) === '@') {
-                    name = "@".concat(new variable_1.default(name.substr(1)).eval(context).value);
+                    name = `@${new Variable(name.slice(1)).eval(context).value}`;
                 }
-                if (rules.variables) {
-                    rules = rules.variable(name);
+                if (rs.variables) {
+                    rules = rs.variable(name);
                 }
+
                 if (!rules) {
                     throw { type: 'Name',
-                        message: "variable ".concat(name, " not found"),
+                        message: `variable ${name} not found`,
                         filename: this.fileInfo().filename,
                         index: this.getIndex() };
                 }
             }
             else {
                 if (name.substring(0, 2) === '$@') {
-                    name = "$".concat(new variable_1.default(name.substr(1)).eval(context).value);
+                    name = `$${new Variable(name.slice(1)).eval(context).value}`;
                 }
                 else {
-                    name = name.charAt(0) === '$' ? name : "$".concat(name);
+                    name = name.charAt(0) === '$' ? name : `$${name}`;
                 }
-                if (rules.properties) {
-                    rules = rules.property(name);
+                if (rs.properties) {
+                    rules = rs.property(name);
                 }
+
                 if (!rules) {
                     throw { type: 'Name',
-                        message: "property \"".concat(name.substr(1), "\" not found"),
+                        message: `property "${name.slice(1)}" not found`,
                         filename: this.fileInfo().filename,
                         index: this.getIndex() };
                 }
-                // Properties are an array of values, since a ruleset can have multiple props.
-                // We pick the last one (the "cascaded" value)
-                rules = rules[rules.length - 1];
+                const rulesArr = /** @type {Node[]} */ (rules);
+                rules = rulesArr[rulesArr.length - 1];
             }
-            if (rules.value) {
-                rules = rules.eval(context).value;
+
+            const current = /** @type {Node} */ (rules);
+            if (current.value) {
+                rules = /** @type {Node} */ (current.eval(context).value);
             }
-            if (rules.ruleset) {
-                rules = rules.ruleset.eval(context);
+            const currentNode = /** @type {Node & { ruleset?: Node }} */ (rules);
+            if (currentNode.ruleset) {
+                rules = currentNode.ruleset.eval(context);
             }
         }
-        return rules;
+        return /** @type {Node} */ (rules);
     }
-});
-exports.default = NamespaceValue;
-//# sourceMappingURL=namespace-value.js.map
+}
+
+export default NamespaceValue;

package/lib/less/tree/negative.js

@@ -1,24 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var operation_1 = tslib_1.__importDefault(require("./operation"));
-var dimension_1 = tslib_1.__importDefault(require("./dimension"));
-var Negative = function (node) {
-    this.value = node;
-};
-Negative.prototype = Object.assign(new node_1.default(), {
-    type: 'Negative',
-    genCSS: function (context, output) {
+// @ts-check
+/** @import { EvalContext, CSSOutput } from './node.js' */
+import Node from './node.js';
+import Operation from './operation.js';
+import Dimension from './dimension.js';
+
+class Negative extends Node {
+    get type() { return 'Negative'; }
+
+    /** @param {Node} node */
+    constructor(node) {
+        super();
+        this.value = node;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add('-');
-        this.value.genCSS(context, output);
-    },
-    eval: function (context) {
-        if (context.isMathOn()) {
-            return (new operation_1.default('*', [new dimension_1.default(-1), this.value])).eval(context);
+        /** @type {Node} */ (this.value).genCSS(context, output);
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        if (context.isMathOn('*')) {
+            return (new Operation('*', [new Dimension(-1), /** @type {Node} */ (this.value)], false)).eval(context);
         }
-        return new Negative(this.value.eval(context));
+        return new Negative(/** @type {Node} */ (this.value).eval(context));
     }
-});
-exports.default = Negative;
-//# sourceMappingURL=negative.js.map
+}
+
+export default Negative;