less 4.5.1 → 4.6.0

package/lib/less/tree/index.js

@@ -1,85 +1,56 @@
-"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 atrule_1 = tslib_1.__importDefault(require("./atrule"));
-var detached_ruleset_1 = tslib_1.__importDefault(require("./detached-ruleset"));
-var operation_1 = tslib_1.__importDefault(require("./operation"));
-var dimension_1 = tslib_1.__importDefault(require("./dimension"));
-var unit_1 = tslib_1.__importDefault(require("./unit"));
-var keyword_1 = tslib_1.__importDefault(require("./keyword"));
-var variable_1 = tslib_1.__importDefault(require("./variable"));
-var property_1 = tslib_1.__importDefault(require("./property"));
-var ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var element_1 = tslib_1.__importDefault(require("./element"));
-var attribute_1 = tslib_1.__importDefault(require("./attribute"));
-var combinator_1 = tslib_1.__importDefault(require("./combinator"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var quoted_1 = tslib_1.__importDefault(require("./quoted"));
-var expression_1 = tslib_1.__importDefault(require("./expression"));
-var declaration_1 = tslib_1.__importDefault(require("./declaration"));
-var call_1 = tslib_1.__importDefault(require("./call"));
-var url_1 = tslib_1.__importDefault(require("./url"));
-var import_1 = tslib_1.__importDefault(require("./import"));
-var comment_1 = tslib_1.__importDefault(require("./comment"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var value_1 = tslib_1.__importDefault(require("./value"));
-var javascript_1 = tslib_1.__importDefault(require("./javascript"));
-var assignment_1 = tslib_1.__importDefault(require("./assignment"));
-var condition_1 = tslib_1.__importDefault(require("./condition"));
-var query_in_parens_1 = tslib_1.__importDefault(require("./query-in-parens"));
-var paren_1 = tslib_1.__importDefault(require("./paren"));
-var media_1 = tslib_1.__importDefault(require("./media"));
-var container_1 = tslib_1.__importDefault(require("./container"));
-var unicode_descriptor_1 = tslib_1.__importDefault(require("./unicode-descriptor"));
-var negative_1 = tslib_1.__importDefault(require("./negative"));
-var extend_1 = tslib_1.__importDefault(require("./extend"));
-var variable_call_1 = tslib_1.__importDefault(require("./variable-call"));
-var namespace_value_1 = tslib_1.__importDefault(require("./namespace-value"));
+// @ts-check
+import Node from './node.js';
+import Color from './color.js';
+import AtRule from './atrule.js';
+import DetachedRuleset from './detached-ruleset.js';
+import Operation from './operation.js';
+import Dimension from './dimension.js';
+import Unit from './unit.js';
+import Keyword from './keyword.js';
+import Variable from './variable.js';
+import Property from './property.js';
+import Ruleset from './ruleset.js';
+import Element from './element.js';
+import Attribute from './attribute.js';
+import Combinator from './combinator.js';
+import Selector from './selector.js';
+import Quoted from './quoted.js';
+import Expression from './expression.js';
+import Declaration from './declaration.js';
+import Call from './call.js';
+import URL from './url.js';
+import Import from './import.js';
+import Comment from './comment.js';
+import Anonymous from './anonymous.js';
+import Value from './value.js';
+import JavaScript from './javascript.js';
+import Assignment from './assignment.js';
+import Condition from './condition.js';
+import QueryInParens from './query-in-parens.js';
+import Paren from './paren.js';
+import Media from './media.js';
+import Container from './container.js';
+import UnicodeDescriptor from './unicode-descriptor.js';
+import Negative from './negative.js';
+import Extend from './extend.js';
+import VariableCall from './variable-call.js';
+import NamespaceValue from './namespace-value.js';
+
 // mixins
-var mixin_call_1 = tslib_1.__importDefault(require("./mixin-call"));
-var mixin_definition_1 = tslib_1.__importDefault(require("./mixin-definition"));
-exports.default = {
-    Node: node_1.default,
-    Color: color_1.default,
-    AtRule: atrule_1.default,
-    DetachedRuleset: detached_ruleset_1.default,
-    Operation: operation_1.default,
-    Dimension: dimension_1.default,
-    Unit: unit_1.default,
-    Keyword: keyword_1.default,
-    Variable: variable_1.default,
-    Property: property_1.default,
-    Ruleset: ruleset_1.default,
-    Element: element_1.default,
-    Attribute: attribute_1.default,
-    Combinator: combinator_1.default,
-    Selector: selector_1.default,
-    Quoted: quoted_1.default,
-    Expression: expression_1.default,
-    Declaration: declaration_1.default,
-    Call: call_1.default,
-    URL: url_1.default,
-    Import: import_1.default,
-    Comment: comment_1.default,
-    Anonymous: anonymous_1.default,
-    Value: value_1.default,
-    JavaScript: javascript_1.default,
-    Assignment: assignment_1.default,
-    Condition: condition_1.default,
-    Paren: paren_1.default,
-    Media: media_1.default,
-    Container: container_1.default,
-    QueryInParens: query_in_parens_1.default,
-    UnicodeDescriptor: unicode_descriptor_1.default,
-    Negative: negative_1.default,
-    Extend: extend_1.default,
-    VariableCall: variable_call_1.default,
-    NamespaceValue: namespace_value_1.default,
+import MixinCall from './mixin-call.js';
+import MixinDefinition from './mixin-definition.js';
+
+export default {
+    Node, Color, AtRule, DetachedRuleset, Operation,
+    Dimension, Unit, Keyword, Variable, Property,
+    Ruleset, Element, Attribute, Combinator, Selector,
+    Quoted, Expression, Declaration, Call, URL, Import,
+    Comment, Anonymous, Value, JavaScript, Assignment,
+    Condition, Paren, Media, Container, QueryInParens,
+    UnicodeDescriptor, Negative, Extend, VariableCall,
+    NamespaceValue,
     mixin: {
-        Call: mixin_call_1.default,
-        Definition: mixin_definition_1.default
+        Call: MixinCall,
+        Definition: MixinDefinition
     }
 };
-//# sourceMappingURL=index.js.map

package/lib/less/tree/javascript.js

@@ -1,34 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var js_eval_node_1 = tslib_1.__importDefault(require("./js-eval-node"));
-var dimension_1 = tslib_1.__importDefault(require("./dimension"));
-var quoted_1 = tslib_1.__importDefault(require("./quoted"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var JavaScript = function (string, escaped, index, currentFileInfo) {
-    this.escaped = escaped;
-    this.expression = string;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-JavaScript.prototype = Object.assign(new js_eval_node_1.default(), {
-    type: 'JavaScript',
-    eval: function (context) {
-        var result = this.evaluateJavaScript(this.expression, context);
-        var type = typeof result;
-        if (type === 'number' && !isNaN(result)) {
-            return new dimension_1.default(result);
-        }
-        else if (type === 'string') {
-            return new quoted_1.default("\"".concat(result, "\""), result, this.escaped, this._index);
-        }
-        else if (Array.isArray(result)) {
-            return new anonymous_1.default(result.join(', '));
-        }
-        else {
-            return new anonymous_1.default(result);
+// @ts-check
+/** @import { EvalContext, FileInfo } from './node.js' */
+import JsEvalNode from './js-eval-node.js';
+import Dimension from './dimension.js';
+import Quoted from './quoted.js';
+import Anonymous from './anonymous.js';
+
+class JavaScript extends JsEvalNode {
+    get type() { return 'JavaScript'; }
+
+    /**
+     * @param {string} string
+     * @param {boolean} escaped
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     */
+    constructor(string, escaped, index, currentFileInfo) {
+        super();
+        this.escaped = escaped;
+        this.expression = string;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Dimension | Quoted | Anonymous}
+     */
+    eval(context) {
+        const result = this.evaluateJavaScript(this.expression, context);
+        const type = typeof result;
+
+        if (type === 'number' && !isNaN(/** @type {number} */ (result))) {
+            return new Dimension(/** @type {number} */ (result));
+        } else if (type === 'string') {
+            return new Quoted(`"${result}"`, /** @type {string} */ (result), this.escaped, this._index);
+        } else if (Array.isArray(result)) {
+            return new Anonymous(/** @type {string[]} */ (result).join(', '));
+        } else {
+            return new Anonymous(/** @type {string} */ (result));
         }
     }
-});
-exports.default = JavaScript;
-//# sourceMappingURL=javascript.js.map
+}
+
+export default JavaScript;

package/lib/less/tree/js-eval-node.js

@@ -1,60 +1,74 @@
-"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 JsEvalNode = function () { };
-JsEvalNode.prototype = Object.assign(new node_1.default(), {
-    evaluateJavaScript: function (expression, context) {
-        var result;
-        var that = this;
-        var evalContext = {};
+// @ts-check
+/** @import { EvalContext } from './node.js' */
+import Node from './node.js';
+import Variable from './variable.js';
+
+class JsEvalNode extends Node {
+    /**
+     * @param {string} expression
+     * @param {EvalContext} context
+     * @returns {string | number | boolean}
+     */
+    evaluateJavaScript(expression, context) {
+        let result;
+        const that = this;
+        /** @type {Record<string, { value: Node, toJS: () => string }>} */
+        const evalContext = {};
+
         if (!context.javascriptEnabled) {
             throw { message: 'Inline JavaScript is not enabled. Is it set in your options?',
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
+
         expression = expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
-            return that.jsify(new variable_1.default("@".concat(name), that.getIndex(), that.fileInfo()).eval(context));
+            return that.jsify(new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context));
         });
+
+        /** @type {Function} */
+        let expressionFunc;
         try {
-            expression = new Function("return (".concat(expression, ")"));
-        }
-        catch (e) {
-            throw { message: "JavaScript evaluation error: ".concat(e.message, " from `").concat(expression, "`"),
+            expressionFunc = new Function(`return (${expression})`);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: ${/** @type {Error} */ (e).message} from \`${expression}\`` ,
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
-        var variables = context.frames[0].variables();
-        for (var k in variables) {
+
+        const variables = /** @type {Node & { variables: () => Record<string, { value: Node }> }} */ (context.frames[0]).variables();
+        for (const k in variables) {
             // eslint-disable-next-line no-prototype-builtins
             if (variables.hasOwnProperty(k)) {
                 evalContext[k.slice(1)] = {
                     value: variables[k].value,
                     toJS: function () {
-                        return this.value.eval(context).toCSS();
+                        return this.value.eval(context).toCSS(context);
                     }
                 };
             }
         }
+
         try {
-            result = expression.call(evalContext);
-        }
-        catch (e) {
-            throw { message: "JavaScript evaluation error: '".concat(e.name, ": ").concat(e.message.replace(/["]/g, '\''), "'"),
+            result = expressionFunc.call(evalContext);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: '${/** @type {Error} */ (e).name}: ${/** @type {Error} */ (e).message.replace(/["]/g, '\'')}'` ,
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
         return result;
-    },
-    jsify: function (obj) {
+    }
+
+    /**
+     * @param {Node} obj
+     * @returns {string}
+     */
+    jsify(obj) {
         if (Array.isArray(obj.value) && (obj.value.length > 1)) {
-            return "[".concat(obj.value.map(function (v) { return v.toCSS(); }).join(', '), "]");
-        }
-        else {
-            return obj.toCSS();
+            return `[${obj.value.map(function (v) { return v.toCSS(/** @type {EvalContext} */ (undefined)); }).join(', ')}]`;
+        } else {
+            return obj.toCSS(/** @type {EvalContext} */ (undefined));
         }
     }
-});
-exports.default = JsEvalNode;
-//# sourceMappingURL=js-eval-node.js.map
+}
+
+export default JsEvalNode;

package/lib/less/tree/keyword.js

@@ -1,20 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var Keyword = function (value) {
-    this.value = value;
-};
-Keyword.prototype = Object.assign(new node_1.default(), {
-    type: 'Keyword',
-    genCSS: function (context, output) {
-        if (this.value === '%') {
-            throw { type: 'Syntax', message: 'Invalid % without number' };
-        }
-        output.add(this.value);
+// @ts-check
+import Node from './node.js';
+
+/** @import { EvalContext, CSSOutput } from './node.js' */
+
+class Keyword extends Node {
+    get type() { return 'Keyword'; }
+
+    /** @param {string} value */
+    constructor(value) {
+        super();
+        this.value = value;
     }
-});
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        if (this.value === '%') { throw { type: 'Syntax', message: 'Invalid % without number' }; }
+        output.add(/** @type {string} */ (this.value));
+    }
+}
+
 Keyword.True = new Keyword('true');
 Keyword.False = new Keyword('false');
-exports.default = Keyword;
-//# sourceMappingURL=keyword.js.map
+
+export default Keyword;

package/lib/less/tree/media.js

@@ -1,48 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var value_1 = tslib_1.__importDefault(require("./value"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var atrule_1 = tslib_1.__importDefault(require("./atrule"));
-var nested_at_rule_1 = tslib_1.__importDefault(require("./nested-at-rule"));
-var Media = function (value, features, index, currentFileInfo, visibilityInfo) {
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    var selectors = (new selector_1.default([], null, null, this._index, this._fileInfo)).createEmptySelectors();
-    this.features = new value_1.default(features);
-    this.rules = [new ruleset_1.default(selectors, value)];
-    this.rules[0].allowImports = true;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-    this.setParent(selectors, this);
-    this.setParent(this.features, this);
-    this.setParent(this.rules, this);
-};
-Media.prototype = Object.assign(new atrule_1.default(), tslib_1.__assign(tslib_1.__assign({ type: 'Media' }, nested_at_rule_1.default), { genCSS: function (context, output) {
+// @ts-check
+/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo } from './node.js' */
+/** @import { NestableAtRuleThis } from './nested-at-rule.js' */
+/** @import { RulesetLikeNode } from './atrule.js' */
+import Node from './node.js';
+import Ruleset from './ruleset.js';
+import Value from './value.js';
+import Selector from './selector.js';
+import AtRule from './atrule.js';
+import NestableAtRulePrototype from './nested-at-rule.js';
+
+class Media extends AtRule {
+    get type() { return 'Media'; }
+
+    /**
+     * @param {Node[] | null} value
+     * @param {Node[]} features
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(value, features, index, currentFileInfo, visibilityInfo) {
+        super();
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+
+        const selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
+
+        /** @type {Value} */
+        this.features = new Value(features);
+        /** @type {RulesetLikeNode[]} */
+        this.rules = [new Ruleset(selectors, value)];
+        /** @type {RulesetLikeNode} */ (this.rules[0]).allowImports = true;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+        this.setParent(selectors, /** @type {Node} */ (/** @type {unknown} */ (this)));
+        this.setParent(this.features, /** @type {Node} */ (/** @type {unknown} */ (this)));
+        this.setParent(this.rules, /** @type {Node} */ (/** @type {unknown} */ (this)));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add('@media ', this._fileInfo, this._index);
         this.features.genCSS(context, output);
         this.outputRuleset(context, output, this.rules);
-    }, eval: function (context) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
         if (!context.mediaBlocks) {
             context.mediaBlocks = [];
             context.mediaPath = [];
         }
-        var media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
+
+        const media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
         if (this.debugInfo) {
-            this.rules[0].debugInfo = this.debugInfo;
+            /** @type {RulesetLikeNode} */ (this.rules[0]).debugInfo = this.debugInfo;
             media.debugInfo = this.debugInfo;
         }
-        media.features = this.features.eval(context);
-        context.mediaPath.push(media);
-        context.mediaBlocks.push(media);
-        this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
+
+        media.features = /** @type {Value} */ (this.features.eval(context));
+
+        context.mediaPath.push(/** @type {Node} */ (/** @type {unknown} */ (media)));
+        context.mediaBlocks.push(/** @type {Node} */ (/** @type {unknown} */ (media)));
+
+        const fr = /** @type {RulesetLikeNode} */ (context.frames[0]).functionRegistry;
+        if (fr) {
+            /** @type {RulesetLikeNode} */ (this.rules[0]).functionRegistry = fr.inherit();
+        }
         context.frames.unshift(this.rules[0]);
-        media.rules = [this.rules[0].eval(context)];
+        media.rules = [/** @type {RulesetLikeNode} */ (this.rules[0].eval(context))];
         context.frames.shift();
+
         context.mediaPath.pop();
-        return context.mediaPath.length === 0 ? media.evalTop(context) :
-            media.evalNested(context);
-    } }));
-exports.default = Media;
-//# sourceMappingURL=media.js.map
+
+        return context.mediaPath.length === 0 ? /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (media)).evalTop(context) :
+            /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (media)).evalNested(context);
+    }
+}
+
+// Apply NestableAtRulePrototype methods (accept, isRulesetLike override AtRule's versions)
+Object.assign(Media.prototype, NestableAtRulePrototype);
+
+export default Media;

package/lib/less/tree/merge-rules.js

@@ -0,0 +1,47 @@
+// @ts-check
+import Expression from './expression.js';
+import Value from './value.js';
+import Node from './node.js';
+
+/**
+ * Merges declarations with merge flags (+ or ,) into combined values.
+ * Used by both the ToCSSVisitor and AtRule eval.
+ * @param {Node[]} rules
+ */
+export default function mergeRules(rules) {
+    if (!rules) {
+        return;
+    }
+
+    /** @type {Record<string, Array<Node & { merge: string, name: string, value: Node, important: string }>>} */
+    const groups    = {};
+    /** @type {Array<Array<Node & { merge: string, name: string, value: Node, important: string }>>} */
+    const groupsArr = [];
+
+    for (let i = 0; i < rules.length; i++) {
+        const rule = /** @type {Node & { merge: string, name: string }} */ (rules[i]);
+        if (rule.merge) {
+            const key = rule.name;
+            groups[key] ? rules.splice(i--, 1) :
+                groupsArr.push(groups[key] = []);
+            groups[key].push(/** @type {Node & { merge: string, name: string, value: Node, important: string }} */ (rule));
+        }
+    }
+
+    groupsArr.forEach(group => {
+        if (group.length > 0) {
+            const result = group[0];
+            /** @type {Node[]} */
+            let space  = [];
+            const comma  = [new Expression(space)];
+            group.forEach(rule => {
+                if ((rule.merge === '+') && (space.length > 0)) {
+                    comma.push(new Expression(space = []));
+                }
+                space.push(rule.value);
+                result.important = result.important || rule.important;
+            });
+            result.value = new Value(comma);
+        }
+    });
+}