less 4.5.1 → 4.6.0

package/lib/less/tree/atrule.js

@@ -1,111 +1,188 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var nested_at_rule_1 = tslib_1.__importDefault(require("./nested-at-rule"));
-var AtRule = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
-    var _this = this;
-    var i;
-    var selectors = (new selector_1.default([], null, null, this._index, this._fileInfo)).createEmptySelectors();
-    this.name = name;
-    this.value = (value instanceof node_1.default) ? value : (value ? new anonymous_1.default(value) : value);
-    if (rules) {
-        if (Array.isArray(rules)) {
-            var allDeclarations = this.declarationsBlock(rules);
-            var allRulesetDeclarations_1 = true;
-            rules.forEach(function (rule) {
-                if (rule.type === 'Ruleset' && rule.rules)
-                    allRulesetDeclarations_1 = allRulesetDeclarations_1 && _this.declarationsBlock(rule.rules, true);
-            });
-            if (allDeclarations && !isRooted) {
-                this.simpleBlock = true;
-                this.declarations = rules;
-            }
-            else if (allRulesetDeclarations_1 && rules.length === 1 && !isRooted && !value) {
-                this.simpleBlock = true;
-                this.declarations = rules[0].rules ? rules[0].rules : rules;
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+/** @import { FunctionRegistry } from './nested-at-rule.js' */
+import Node from './node.js';
+import Selector from './selector.js';
+import Ruleset from './ruleset.js';
+import Anonymous from './anonymous.js';
+import NestableAtRulePrototype from './nested-at-rule.js';
+import mergeRules from './merge-rules.js';
+
+/**
+ * @typedef {Node & {
+ *   rules?: Node[],
+ *   selectors?: Selector[],
+ *   root?: boolean,
+ *   allowImports?: boolean,
+ *   functionRegistry?: FunctionRegistry,
+ *   merge?: boolean,
+ *   debugInfo?: { lineNumber: number, fileName: string },
+ *   elements?: import('./element.js').default[]
+ * }} RulesetLikeNode
+ */
+
+class AtRule extends Node {
+    get type() { return 'AtRule'; }
+
+    /**
+     * @param {string} [name]
+     * @param {Node | string} [value]
+     * @param {Node[] | Ruleset} [rules]
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     * @param {{ lineNumber: number, fileName: string }} [debugInfo]
+     * @param {boolean} [isRooted]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(
+        name,
+        value,
+        rules,
+        index,
+        currentFileInfo,
+        debugInfo,
+        isRooted,
+        visibilityInfo
+    ) {
+        super();
+        let i;
+        var selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
+
+        /** @type {string | undefined} */
+        this.name  = name;
+        this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
+        /** @type {boolean | undefined} */
+        this.simpleBlock = undefined;
+        /** @type {RulesetLikeNode[] | undefined} */
+        this.declarations = undefined;
+        /** @type {RulesetLikeNode[] | undefined} */
+        this.rules = undefined;
+        if (rules) {
+            if (Array.isArray(rules)) {
+                const allDeclarations = this.declarationsBlock(rules);
+
+                let allRulesetDeclarations = true;
+                rules.forEach(rule => {
+                    if (rule.type === 'Ruleset' && /** @type {RulesetLikeNode} */ (rule).rules) allRulesetDeclarations = allRulesetDeclarations && this.declarationsBlock(/** @type {Node[]} */ (/** @type {RulesetLikeNode} */ (rule).rules), true);
+                });
+
+                if (allDeclarations && !isRooted) {
+                    this.simpleBlock = true;
+                    this.declarations = rules;
+                } else if (allRulesetDeclarations && rules.length === 1 && !isRooted && !value) {
+                    this.simpleBlock = true;
+                    this.declarations = /** @type {RulesetLikeNode} */ (rules[0]).rules ? /** @type {RulesetLikeNode} */ (rules[0]).rules : rules;
+                } else {
+                    this.rules = rules;
+                }
+            } else {
+                const allDeclarations = this.declarationsBlock(/** @type {Node[]} */ (rules.rules));
+
+                if (allDeclarations && !isRooted && !value) {
+                    this.simpleBlock = true;
+                    this.declarations = rules.rules;
+                } else {
+                    this.rules = [rules];
+                    /** @type {RulesetLikeNode} */ (this.rules[0]).selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
+                }
             }
-            else {
-                this.rules = rules;
+            if (!this.simpleBlock) {
+                for (i = 0; i < this.rules.length; i++) {
+                    /** @type {RulesetLikeNode} */ (this.rules[i]).allowImports = true;
+                }
             }
-        }
-        else {
-            var allDeclarations = this.declarationsBlock(rules.rules);
-            if (allDeclarations && !isRooted && !value) {
-                this.simpleBlock = true;
-                this.declarations = rules.rules;
+            if (this.declarations) {
+                this.setParent(this.declarations, /** @type {Node} */ (/** @type {unknown} */ (this)));
             }
-            else {
-                this.rules = [rules];
-                this.rules[0].selectors = (new selector_1.default([], null, null, index, currentFileInfo)).createEmptySelectors();
+            if (this.rules) {
+                this.setParent(this.rules, /** @type {Node} */ (/** @type {unknown} */ (this)));
             }
         }
-        if (!this.simpleBlock) {
-            for (i = 0; i < this.rules.length; i++) {
-                this.rules[i].allowImports = true;
-            }
-        }
-        this.setParent(selectors, this);
-        this.setParent(this.rules, this);
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {{ lineNumber: number, fileName: string } | undefined} */
+        this.debugInfo = debugInfo;
+        /** @type {boolean} */
+        this.isRooted = isRooted || false;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
     }
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.debugInfo = debugInfo;
-    this.isRooted = isRooted || false;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-};
-AtRule.prototype = Object.assign(new node_1.default(), tslib_1.__assign(tslib_1.__assign({ type: 'AtRule' }, nested_at_rule_1.default), { declarationsBlock: function (rules, mergeable) {
-        if (mergeable === void 0) { mergeable = false; }
+
+    /**
+     * @param {Node[]} rules
+     * @param {boolean} [mergeable]
+     * @returns {boolean}
+     */
+    declarationsBlock(rules, mergeable = false) {
         if (!mergeable) {
-            return rules.filter(function (node) { return (node.type === 'Declaration' || node.type === 'Comment') && !node.merge; }).length === rules.length;
-        }
-        else {
-            return rules.filter(function (node) { return (node.type === 'Declaration' || node.type === 'Comment'); }).length === rules.length;
+            return rules.filter(function (/** @type {Node & { merge?: boolean }} */ node) { return (node.type === 'Declaration' || node.type === 'Comment') && !node.merge}).length === rules.length;
+        } else {
+            return rules.filter(function (/** @type {Node} */ node) { return (node.type === 'Declaration' || node.type === 'Comment'); }).length === rules.length;
         }
-    }, keywordList: function (rules) {
+    }
+
+    /**
+     * @param {Node[]} rules
+     * @returns {boolean}
+     */
+    keywordList(rules) {
         if (!Array.isArray(rules)) {
             return false;
+        } else {
+            return rules.filter(function (/** @type {Node} */ node) { return (node.type === 'Keyword' || node.type === 'Comment'); }).length === rules.length;
         }
-        else {
-            return rules.filter(function (node) { return (node.type === 'Keyword' || node.type === 'Comment'); }).length === rules.length;
-        }
-    }, accept: function (visitor) {
-        var value = this.value, rules = this.rules, declarations = this.declarations;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        const value = this.value, rules = this.rules, declarations = this.declarations;
+
         if (rules) {
             this.rules = visitor.visitArray(rules);
-        }
-        else if (declarations) {
+        } else if (declarations) {
             this.declarations = visitor.visitArray(declarations);
         }
         if (value) {
-            this.value = visitor.visit(value);
+            this.value = visitor.visit(/** @type {Node} */ (value));
         }
-    }, isRulesetLike: function () {
-        return this.rules || !this.isCharset();
-    }, isCharset: function () {
+    }
+
+    /** @override @returns {boolean} */
+    isRulesetLike() {
+        return /** @type {boolean} */ (/** @type {unknown} */ (this.rules || !this.isCharset()));
+    }
+
+    isCharset() {
         return '@charset' === this.name;
-    }, genCSS: function (context, output) {
-        var value = this.value, rules = this.rules || this.declarations;
-        output.add(this.name, this.fileInfo(), this.getIndex());
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        const value = this.value, rules = this.rules || this.declarations;
+        output.add(/** @type {string} */ (this.name), this.fileInfo(), this.getIndex());
         if (value) {
             output.add(' ');
-            value.genCSS(context, output);
+            /** @type {Node} */ (value).genCSS(context, output);
         }
         if (this.simpleBlock) {
-            this.outputRuleset(context, output, this.declarations);
-        }
-        else if (rules) {
+            this.outputRuleset(context, output, /** @type {Node[]} */ (this.declarations));
+        } else if (rules) {
             this.outputRuleset(context, output, rules);
-        }
-        else {
+        } else {
             output.add(';');
         }
-    }, eval: function (context) {
-        var mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules || this.declarations;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let mediaPathBackup, mediaBlocksBackup, value = this.value, rules = this.rules || this.declarations;
+
         // media stored inside other atrule should not bubble over it
         // backpup media bubbling information
         mediaPathBackup = context.mediaPath;
@@ -113,96 +190,120 @@ AtRule.prototype = Object.assign(new node_1.default(), tslib_1.__assign(tslib_1.
         // deleted media bubbling information
         context.mediaPath = [];
         context.mediaBlocks = [];
+
         if (value) {
-            value = value.eval(context);
-            if (value.value && this.keywordList(value.value)) {
-                value = new anonymous_1.default(value.value.map(function (keyword) { return keyword.value; }).join(', '), this.getIndex(), this.fileInfo());
-            }
+            value = /** @type {Node} */ (value).eval(context);
         }
+
         if (rules) {
             rules = this.evalRoot(context, rules);
         }
-        if (Array.isArray(rules) && rules[0].rules && Array.isArray(rules[0].rules) && rules[0].rules.length) {
-            var allMergeableDeclarations = this.declarationsBlock(rules[0].rules, true);
+        if (Array.isArray(rules) && /** @type {RulesetLikeNode} */ (rules[0]).rules && Array.isArray(/** @type {RulesetLikeNode} */ (rules[0]).rules) && /** @type {Node[]} */ (/** @type {RulesetLikeNode} */ (rules[0]).rules).length) {
+            const allMergeableDeclarations = this.declarationsBlock(/** @type {Node[]} */ (/** @type {RulesetLikeNode} */ (rules[0]).rules), true);
             if (allMergeableDeclarations && !this.isRooted && !value) {
-                var mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
-                mergeRules(rules[0].rules);
-                rules = rules[0].rules;
-                rules.forEach(function (rule) { return rule.merge = false; });
+                mergeRules(/** @type {Node[]} */ (/** @type {RulesetLikeNode} */ (rules[0]).rules));
+                rules = /** @type {RulesetLikeNode[]} */ (/** @type {RulesetLikeNode} */ (rules[0]).rules);
+                rules.forEach(/** @param {RulesetLikeNode} rule */ rule => { rule.merge = false; });
             }
         }
         if (this.simpleBlock && rules) {
-            rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
-            rules = rules.map(function (rule) { return rule.eval(context); });
+            /** @type {RulesetLikeNode} */ (rules[0]).functionRegistry = /** @type {RulesetLikeNode} */ (context.frames[0]).functionRegistry.inherit();
+            rules = rules.map(function (/** @type {Node} */ rule) { return rule.eval(context); });
         }
+
         // restore media bubbling information
         context.mediaPath = mediaPathBackup;
         context.mediaBlocks = mediaBlocksBackup;
-        return new AtRule(this.name, value, rules, this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
-    }, evalRoot: function (context, rules) {
-        var ampersandCount = 0;
-        var noAmpersandCount = 0;
-        var noAmpersands = true;
-        var allAmpersands = false;
+        return /** @type {Node} */ (/** @type {unknown} */ (new AtRule(this.name, value, rules, this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo())));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {Node[]} rules
+     * @returns {Node[]}
+     */
+    evalRoot(context, rules) {
+        let ampersandCount = 0;
+        let noAmpersandCount = 0;
+        let noAmpersands = true;
+
         if (!this.simpleBlock) {
             rules = [rules[0].eval(context)];
         }
-        var precedingSelectors = [];
+
+        /** @type {Selector[]} */
+        let precedingSelectors = [];
         if (context.frames.length > 0) {
-            var _loop_1 = function (index) {
-                var frame = context.frames[index];
-                if (frame.type === 'Ruleset' &&
+            for (let index = 0; index < context.frames.length; index++) {
+                const frame = /** @type {RulesetLikeNode} */ (context.frames[index]);
+                if (
+                    frame.type === 'Ruleset' &&
                     frame.rules &&
-                    frame.rules.length > 0) {
+                    frame.rules.length > 0
+                ) {
                     if (frame && !frame.root && frame.selectors && frame.selectors.length > 0) {
                         precedingSelectors = precedingSelectors.concat(frame.selectors);
                     }
                 }
                 if (precedingSelectors.length > 0) {
-                    var value_1 = '';
-                    var output = { add: function (s) { value_1 += s; } };
-                    for (var i = 0; i < precedingSelectors.length; i++) {
-                        precedingSelectors[i].genCSS(context, output);
-                    }
-                    if (/^&+$/.test(value_1.replace(/\s+/g, ''))) {
+                    const allAmpersandElements = precedingSelectors.every(
+                        sel => sel.elements && sel.elements.length > 0 && sel.elements.every(
+                            /** @param {import('./element.js').default} el */
+                            el => el.value === '&'
+                        )
+                    );
+                    if (allAmpersandElements) {
                         noAmpersands = false;
                         noAmpersandCount++;
-                    }
-                    else {
-                        allAmpersands = false;
+                    } else {
                         ampersandCount++;
                     }
                 }
-            };
-            for (var index = 0; index < context.frames.length; index++) {
-                _loop_1(index);
             }
         }
-        var mixedAmpersands = ampersandCount > 0 && noAmpersandCount > 0 && !allAmpersands && !noAmpersands;
-        if ((this.isRooted && ampersandCount > 0 && noAmpersandCount === 0 && !allAmpersands && noAmpersands)
-            || !mixedAmpersands) {
-            rules[0].root = true;
+
+        const mixedAmpersands = ampersandCount > 0 && noAmpersandCount > 0 && !noAmpersands;
+        if (
+            (this.isRooted && ampersandCount > 0 && noAmpersandCount === 0 && noAmpersands)
+            || !mixedAmpersands
+        ) {
+            /** @type {RulesetLikeNode} */ (rules[0]).root = true;
         }
         return rules;
-    }, variable: function (name) {
+    }
+
+    /** @param {string} name */
+    variable(name) {
         if (this.rules) {
             // assuming that there is only one rule at this point - that is how parser constructs the rule
-            return ruleset_1.default.prototype.variable.call(this.rules[0], name);
+            return Ruleset.prototype.variable.call(this.rules[0], name);
         }
-    }, find: function () {
+    }
+
+    find() {
         if (this.rules) {
             // assuming that there is only one rule at this point - that is how parser constructs the rule
-            return ruleset_1.default.prototype.find.apply(this.rules[0], arguments);
+            return Ruleset.prototype.find.apply(this.rules[0], arguments);
         }
-    }, rulesets: function () {
+    }
+
+    rulesets() {
         if (this.rules) {
             // assuming that there is only one rule at this point - that is how parser constructs the rule
-            return ruleset_1.default.prototype.rulesets.apply(this.rules[0]);
+            return Ruleset.prototype.rulesets.apply(this.rules[0]);
         }
-    }, outputRuleset: function (context, output, rules) {
-        var ruleCnt = rules.length;
-        var i;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     * @param {Node[]} rules
+     */
+    outputRuleset(context, output, rules) {
+        const ruleCnt = rules.length;
+        let i;
         context.tabLevel = (context.tabLevel | 0) + 1;
+
         // Compressed
         if (context.compress) {
             output.add('{');
@@ -213,21 +314,27 @@ AtRule.prototype = Object.assign(new node_1.default(), tslib_1.__assign(tslib_1.
             context.tabLevel--;
             return;
         }
+
         // Non-compressed
-        var tabSetStr = "\n".concat(Array(context.tabLevel).join('  ')), tabRuleStr = "".concat(tabSetStr, "  ");
+        const tabSetStr = `\n${Array(context.tabLevel).join('  ')}`, tabRuleStr = `${tabSetStr}  `;
         if (!ruleCnt) {
-            output.add(" {".concat(tabSetStr, "}"));
-        }
-        else {
-            output.add(" {".concat(tabRuleStr));
+            output.add(` {${tabSetStr}}`);
+        } else {
+            output.add(` {${tabRuleStr}`);
             rules[0].genCSS(context, output);
             for (i = 1; i < ruleCnt; i++) {
                 output.add(tabRuleStr);
                 rules[i].genCSS(context, output);
             }
-            output.add("".concat(tabSetStr, "}"));
+            output.add(`${tabSetStr}}`);
         }
+
         context.tabLevel--;
-    } }));
-exports.default = AtRule;
-//# sourceMappingURL=atrule.js.map
+    }
+}
+
+// Apply shared methods from NestableAtRulePrototype that AtRule doesn't override
+const { evalFunction, evalTop, evalNested, permute, bubbleSelectors } = NestableAtRulePrototype;
+Object.assign(AtRule.prototype, { evalFunction, evalTop, evalNested, permute, bubbleSelectors });
+
+export default AtRule;

package/lib/less/tree/attribute.js

@@ -1,32 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var Attribute = function (key, op, value, cif) {
-    this.key = key;
-    this.op = op;
-    this.value = value;
-    this.cif = cif;
-};
-Attribute.prototype = Object.assign(new node_1.default(), {
-    type: 'Attribute',
-    eval: function (context) {
-        return new Attribute(this.key.eval ? this.key.eval(context) : this.key, this.op, (this.value && this.value.eval) ? this.value.eval(context) : this.value, this.cif);
-    },
-    genCSS: function (context, output) {
+// @ts-check
+/** @import { EvalContext, CSSOutput } from './node.js' */
+import Node from './node.js';
+
+class Attribute extends Node {
+    get type() { return 'Attribute'; }
+
+    /**
+     * @param {string | Node} key
+     * @param {string} op
+     * @param {string | Node} value
+     * @param {string} cif
+     */
+    constructor(key, op, value, cif) {
+        super();
+        this.key = key;
+        this.op = op;
+        this.value = value;
+        this.cif = cif;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Attribute}
+     */
+    eval(context) {
+        return new Attribute(
+            /** @type {Node} */ (this.key).eval ? /** @type {Node} */ (this.key).eval(context) : /** @type {string} */ (this.key),
+            this.op,
+            (this.value && /** @type {Node} */ (this.value).eval) ? /** @type {Node} */ (this.value).eval(context) : this.value,
+            this.cif
+        );
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add(this.toCSS(context));
-    },
-    toCSS: function (context) {
-        var value = this.key.toCSS ? this.key.toCSS(context) : this.key;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {string}
+     */
+    toCSS(context) {
+        let value = /** @type {Node} */ (this.key).toCSS ? /** @type {Node} */ (this.key).toCSS(context) : /** @type {string} */ (this.key);
+
         if (this.op) {
             value += this.op;
-            value += (this.value.toCSS ? this.value.toCSS(context) : this.value);
+            value += (/** @type {Node} */ (this.value).toCSS ? /** @type {Node} */ (this.value).toCSS(context) : /** @type {string} */ (this.value));
         }
+
         if (this.cif) {
             value = value + ' ' + this.cif;
         }
-        return "[".concat(value, "]");
+
+        return `[${value}]`;
     }
-});
-exports.default = Attribute;
-//# sourceMappingURL=attribute.js.map
+}
+
+export default Attribute;