less 4.4.2 → 4.6.0

package/lib/less/tree/nested-at-rule.js

@@ -1,72 +1,140 @@
-"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 anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var expression_1 = tslib_1.__importDefault(require("./expression"));
-var utils = tslib_1.__importStar(require("../utils"));
-var NestableAtRulePrototype = {
-    isRulesetLike: function () {
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+import Ruleset from './ruleset.js';
+import Value from './value.js';
+import Selector from './selector.js';
+import Anonymous from './anonymous.js';
+import Expression from './expression.js';
+import * as utils from '../utils.js';
+import Node from './node.js';
+
+/**
+ * @typedef {object} FunctionRegistry
+ * @property {(name: string, func: Function) => void} add
+ * @property {(functions: Object) => void} addMultiple
+ * @property {(name: string) => Function} get
+ * @property {() => Object} getLocalFunctions
+ * @property {() => FunctionRegistry} inherit
+ * @property {(base: FunctionRegistry) => FunctionRegistry} create
+ */
+
+/**
+ * @typedef {Node & {
+ *   features: Value,
+ *   rules: Ruleset[],
+ *   type: string,
+ *   functionRegistry?: FunctionRegistry,
+ *   multiMedia?: boolean,
+ *   debugInfo?: { lineNumber: number, fileName: string },
+ *   allowRoot?: boolean,
+ *   _evaluated?: boolean,
+ *   evalFunction: () => void,
+ *   evalTop: (context: EvalContext) => Node | Ruleset,
+ *   evalNested: (context: EvalContext) => Node | Ruleset,
+ *   permute: (arr: Node[][]) => Node[][],
+ *   bubbleSelectors: (selectors: Selector[] | undefined) => void,
+ *   outputRuleset: (context: EvalContext, output: CSSOutput, rules: Node[]) => void
+ * }} NestableAtRuleThis
+ */
+
+const NestableAtRulePrototype = {
+
+    isRulesetLike() {
         return true;
     },
-    accept: function (visitor) {
-        if (this.features) {
-            this.features = visitor.visit(this.features);
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        /** @type {NestableAtRuleThis} */
+        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
+        if (self.features) {
+            self.features = /** @type {Value} */ (visitor.visit(self.features));
         }
-        if (this.rules) {
-            this.rules = visitor.visitArray(this.rules);
+        if (self.rules) {
+            self.rules = /** @type {Ruleset[]} */ (visitor.visitArray(self.rules));
         }
     },
+
     evalFunction: function () {
-        if (!this.features || !Array.isArray(this.features.value) || this.features.value.length < 1) {
+        /** @type {NestableAtRuleThis} */
+        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
+        if (!self.features || !Array.isArray(self.features.value) || self.features.value.length < 1) {
             return;
         }
-        var exprValues = this.features.value;
-        var expr, paren;
-        for (var index = 0; index < exprValues.length; ++index) {
+
+        const exprValues = /** @type {Node[]} */ (self.features.value);
+        /** @type {Node | undefined} */
+        let expr;
+        /** @type {Node | undefined} */
+        let paren;
+
+        for (let index = 0; index < exprValues.length; ++index) {
             expr = exprValues[index];
-            if (expr.type === 'Keyword' && index + 1 < exprValues.length && (expr.noSpacing || expr.noSpacing == null)) {
-                paren = exprValues[index + 1];
-                if (paren.type === 'Paren' && paren.noSpacing) {
-                    exprValues[index] = new expression_1.default([expr, paren]);
+
+            if ((expr.type === 'Keyword' || expr.type === 'Variable')
+                && index + 1 < exprValues.length
+                && (/** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing || /** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing == null)) {
+                paren =  exprValues[index + 1];
+
+                if (paren.type ===  'Paren' && /** @type {Node & { noSpacing?: boolean }} */ (paren).noSpacing) {
+                    exprValues[index]= new Expression([expr, paren]);
                     exprValues.splice(index + 1, 1);
-                    exprValues[index].noSpacing = true;
+                    /** @type {Node & { noSpacing?: boolean }} */ (exprValues[index]).noSpacing = true;
                 }
             }
         }
     },
-    evalTop: function (context) {
-        this.evalFunction();
-        var result = this;
+
+    /** @param {EvalContext} context */
+    evalTop(context) {
+        /** @type {NestableAtRuleThis} */
+        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
+        self.evalFunction();
+
+        /** @type {Node | Ruleset} */
+        let result = self;
+
         // Render all dependent Media blocks.
         if (context.mediaBlocks.length > 1) {
-            var selectors = (new selector_1.default([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
-            result = new ruleset_1.default(selectors, context.mediaBlocks);
-            result.multiMedia = true;
-            result.copyVisibilityInfo(this.visibilityInfo());
-            this.setParent(result, this);
+            const selectors = (new Selector([], null, null, self.getIndex(), self.fileInfo())).createEmptySelectors();
+            result = new Ruleset(selectors, context.mediaBlocks);
+            /** @type {Ruleset & { multiMedia?: boolean }} */ (result).multiMedia = true;
+            result.copyVisibilityInfo(self.visibilityInfo());
+            self.setParent(result, self);
         }
+
         delete context.mediaBlocks;
         delete context.mediaPath;
+
         return result;
     },
-    evalNested: function (context) {
-        this.evalFunction();
-        var i;
-        var value;
-        var path = context.mediaPath.concat([this]);
+
+    /** @param {EvalContext} context */
+    evalNested(context) {
+        /** @type {NestableAtRuleThis} */
+        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
+        self.evalFunction();
+
+        let i;
+        /** @type {Node | Node[]} */
+        let value;
+        const path = context.mediaPath.concat([self]);
+
         // Extract the media-query conditions separated with `,` (OR).
         for (i = 0; i < path.length; i++) {
-            if (path[i].type !== this.type) {
-                context.mediaBlocks.splice(i, 1);
-                return this;
+            if (path[i].type !== self.type) {
+                const blockIndex = context.mediaBlocks.indexOf(self);
+                if (blockIndex > -1) {
+                    context.mediaBlocks.splice(blockIndex, 1);
+                }
+                return self;
             }
-            value = path[i].features instanceof value_1.default ?
-                path[i].features.value : path[i].features;
-            path[i] = Array.isArray(value) ? value : [value];
+
+            value = /** @type {NestableAtRuleThis} */ (path[i]).features instanceof Value ?
+                /** @type {Node[]} */ (/** @type {NestableAtRuleThis} */ (path[i]).features.value) : /** @type {NestableAtRuleThis} */ (path[i]).features;
+            path[i] = /** @type {Node} */ (/** @type {unknown} */ (Array.isArray(value) ? value : [value]));
         }
+
         // Trace all permutations to generate the resulting media-query.
         //
         // (a, b and c) with nested (d, e) ->
@@ -74,42 +142,57 @@ var NestableAtRulePrototype = {
         //    a and e
         //    b and c and d
         //    b and c and e
-        this.features = new value_1.default(this.permute(path).map(function (path) {
-            path = path.map(function (fragment) { return fragment.toCSS ? fragment : new anonymous_1.default(fragment); });
-            for (i = path.length - 1; i > 0; i--) {
-                path.splice(i, 0, new anonymous_1.default('and'));
+        self.features = new Value(self.permute(/** @type {Node[][]} */ (/** @type {unknown} */ (path))).map(
+            /** @param {Node | Node[]} path */
+            path => {
+            path = /** @type {Node[]} */ (path).map(
+                /** @param {Node & { toCSS?: Function }} fragment */
+                fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
+
+            for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
+                /** @type {Node[]} */ (path).splice(i, 0, new Anonymous('and'));
             }
-            return new expression_1.default(path);
+
+            return new Expression(/** @type {Node[]} */ (path));
         }));
-        this.setParent(this.features, this);
+        self.setParent(self.features, self);
+
         // Fake a tree-node that doesn't output anything.
-        return new ruleset_1.default([], []);
+        return new Ruleset([], []);
     },
-    permute: function (arr) {
+
+    /**
+     * @param {Node[][]} arr
+     * @returns {Node[][]}
+     */
+    permute(arr) {
         if (arr.length === 0) {
             return [];
-        }
-        else if (arr.length === 1) {
-            return arr[0];
-        }
-        else {
-            var result = [];
-            var rest = this.permute(arr.slice(1));
-            for (var i = 0; i < rest.length; i++) {
-                for (var j = 0; j < arr[0].length; j++) {
+        } else if (arr.length === 1) {
+            return /** @type {Node[][]} */ (/** @type {unknown} */ (arr[0]));
+        } else {
+            /** @type {Node[][]} */
+            const result = [];
+            const rest = this.permute(arr.slice(1));
+            for (let i = 0; i < rest.length; i++) {
+                for (let j = 0; j < arr[0].length; j++) {
                     result.push([arr[0][j]].concat(rest[i]));
                 }
             }
             return result;
         }
     },
-    bubbleSelectors: function (selectors) {
+
+    /** @param {Selector[] | undefined} selectors */
+    bubbleSelectors(selectors) {
+        /** @type {NestableAtRuleThis} */
+        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
         if (!selectors) {
             return;
         }
-        this.rules = [new ruleset_1.default(utils.copyArray(selectors), [this.rules[0]])];
-        this.setParent(this.rules, this);
+        self.rules = [new Ruleset(utils.copyArray(selectors), [self.rules[0]])];
+        self.setParent(self.rules, self);
     }
 };
-exports.default = NestableAtRulePrototype;
-//# sourceMappingURL=nested-at-rule.js.map
+
+export default NestableAtRulePrototype;

package/lib/less/tree/node.js

@@ -1,34 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-check
+/**
+ * @typedef {object} FileInfo
+ * @property {string} [filename]
+ * @property {string} [rootpath]
+ * @property {string} [currentDirectory]
+ * @property {string} [rootFilename]
+ * @property {string} [entryPath]
+ * @property {boolean} [reference]
+ */
+
+/**
+ * @typedef {object} VisibilityInfo
+ * @property {number} [visibilityBlocks]
+ * @property {boolean} [nodeVisible]
+ */
+
+/**
+ * @typedef {object} CSSOutput
+ * @property {(chunk: string, fileInfo?: FileInfo, index?: number, mapLines?: boolean) => void} add
+ * @property {() => boolean} isEmpty
+ */
+
+/**
+ * @typedef {object} EvalContext
+ * @property {number} [numPrecision]
+ * @property {(op?: string) => boolean} [isMathOn]
+ * @property {number} [math]
+ * @property {Node[]} [frames]
+ * @property {Array<{important?: string}>} [importantScope]
+ * @property {string[]} [paths]
+ * @property {boolean} [compress]
+ * @property {boolean} [strictUnits]
+ * @property {boolean} [sourceMap]
+ * @property {boolean} [importMultiple]
+ * @property {string} [urlArgs]
+ * @property {boolean} [javascriptEnabled]
+ * @property {object} [pluginManager]
+ * @property {number} [rewriteUrls]
+ * @property {boolean} [inCalc]
+ * @property {boolean} [mathOn]
+ * @property {boolean[]} [calcStack]
+ * @property {boolean[]} [parensStack]
+ * @property {Node[]} [mediaBlocks]
+ * @property {Node[]} [mediaPath]
+ * @property {() => void} [inParenthesis]
+ * @property {() => void} [outOfParenthesis]
+ * @property {() => void} [enterCalc]
+ * @property {() => void} [exitCalc]
+ * @property {(path: string) => boolean} [pathRequiresRewrite]
+ * @property {(path: string, rootpath?: string) => string} [rewritePath]
+ * @property {(path: string) => string} [normalizePath]
+ * @property {number} [tabLevel]
+ * @property {boolean} [lastRule]
+ */
+
+/**
+ * @typedef {object} TreeVisitor
+ * @property {(node: Node) => Node} visit
+ * @property {(nodes: Node[], nonReplacing?: boolean) => Node[]} visitArray
+ */
+
 /**
  * The reason why Node is a class and other nodes simply do not extend
  * from Node (since we're transpiling) is due to this issue:
  *
  * @see https://github.com/less/less.js/issues/3434
  */
-var Node = /** @class */ (function () {
-    function Node() {
+class Node {
+    get type() { return ''; }
+
+    constructor() {
+        /** @type {Node | null} */
         this.parent = null;
+        /** @type {number | undefined} */
         this.visibilityBlocks = undefined;
+        /** @type {boolean | undefined} */
         this.nodeVisible = undefined;
+        /** @type {Node | null} */
         this.rootNode = null;
+        /** @type {Node | null} */
         this.parsed = null;
+
+        /** @type {Node | Node[] | string | number | undefined} */
+        this.value = undefined;
+        /** @type {number | undefined} */
+        this._index = undefined;
+        /** @type {FileInfo | undefined} */
+        this._fileInfo = undefined;
+    }
+
+    get currentFileInfo() {
+        return this.fileInfo();
+    }
+
+    get index() {
+        return this.getIndex();
     }
-    Object.defineProperty(Node.prototype, "currentFileInfo", {
-        get: function () {
-            return this.fileInfo();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Node.prototype, "index", {
-        get: function () {
-            return this.getIndex();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Node.prototype.setParent = function (nodes, parent) {
+
+    /**
+     * @param {Node | Node[]} nodes
+     * @param {Node} parent
+     */
+    setParent(nodes, parent) {
+        /** @param {Node} node */
         function set(node) {
             if (node && node instanceof Node) {
                 node.parent = parent;
@@ -40,20 +114,30 @@ var Node = /** @class */ (function () {
         else {
             set(nodes);
         }
-    };
-    Node.prototype.getIndex = function () {
+    }
+
+    /** @returns {number} */
+    getIndex() {
         return this._index || (this.parent && this.parent.getIndex()) || 0;
-    };
-    Node.prototype.fileInfo = function () {
+    }
+
+    /** @returns {FileInfo} */
+    fileInfo() {
         return this._fileInfo || (this.parent && this.parent.fileInfo()) || {};
-    };
-    Node.prototype.isRulesetLike = function () { return false; };
-    Node.prototype.toCSS = function (context) {
-        var strs = [];
+    }
+
+    /** @returns {boolean} */
+    isRulesetLike() { return false; }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {string}
+     */
+    toCSS(context) {
+        /** @type {string[]} */
+        const strs = [];
         this.genCSS(context, {
-            // remove when genCSS has JSDoc types
-            // eslint-disable-next-line no-unused-vars
-            add: function (chunk, fileInfo, index) {
+            add: function(chunk, fileInfo, index) {
                 strs.push(chunk);
             },
             isEmpty: function () {
@@ -61,115 +145,166 @@ var Node = /** @class */ (function () {
             }
         });
         return strs.join('');
-    };
-    Node.prototype.genCSS = function (context, output) {
-        output.add(this.value);
-    };
-    Node.prototype.accept = function (visitor) {
-        this.value = visitor.visit(this.value);
-    };
-    Node.prototype.eval = function () { return this; };
-    Node.prototype._operate = function (context, op, a, b) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        output.add(/** @type {string} */ (this.value));
+    }
+
+    /**
+     * @param {TreeVisitor} visitor
+     */
+    accept(visitor) {
+        this.value = visitor.visit(/** @type {Node} */ (this.value));
+    }
+
+    /**
+     * @param {EvalContext} [context]
+     * @returns {Node}
+     */
+    eval(context) { return this; }
+
+    /**
+     * @param {EvalContext} context
+     * @param {string} op
+     * @param {number} a
+     * @param {number} b
+     * @returns {number | undefined}
+     */
+    _operate(context, op, a, b) {
         switch (op) {
             case '+': return a + b;
             case '-': return a - b;
             case '*': return a * b;
             case '/': return a / b;
         }
-    };
-    Node.prototype.fround = function (context, value) {
-        var precision = context && context.numPrecision;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {number} value
+     * @returns {number}
+     */
+    fround(context, value) {
+        const precision = context && context.numPrecision;
         // add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999...) are properly rounded:
         return (precision) ? Number((value + 2e-16).toFixed(precision)) : value;
-    };
-    Node.compare = function (a, b) {
+    }
+
+    /**
+     * @param {Node & { compare?: (other: Node) => number | undefined }} a
+     * @param {Node & { compare?: (other: Node) => number | undefined }} b
+     * @returns {number | undefined}
+     */
+    static compare(a, b) {
         /* returns:
          -1: a < b
          0: a = b
          1: a > b
          and *any* other value for a != b (e.g. undefined, NaN, -2 etc.) */
+
         if ((a.compare) &&
             // for "symmetric results" force toCSS-based comparison
             // of Quoted or Anonymous if either value is one of those
             !(b.type === 'Quoted' || b.type === 'Anonymous')) {
             return a.compare(b);
-        }
-        else if (b.compare) {
+        } else if (b.compare) {
             return -b.compare(a);
-        }
-        else if (a.type !== b.type) {
+        } else if (a.type !== b.type) {
             return undefined;
         }
-        a = a.value;
-        b = b.value;
-        if (!Array.isArray(a)) {
-            return a === b ? 0 : undefined;
+
+        let aVal = a.value;
+        let bVal = b.value;
+        if (!Array.isArray(aVal)) {
+            return aVal === bVal ? 0 : undefined;
         }
-        if (a.length !== b.length) {
+        if (!Array.isArray(bVal)) {
             return undefined;
         }
-        for (var i = 0; i < a.length; i++) {
-            if (Node.compare(a[i], b[i]) !== 0) {
+        if (aVal.length !== bVal.length) {
+            return undefined;
+        }
+        for (let i = 0; i < aVal.length; i++) {
+            if (Node.compare(aVal[i], bVal[i]) !== 0) {
                 return undefined;
             }
         }
         return 0;
-    };
-    Node.numericCompare = function (a, b) {
-        return a < b ? -1
-            : a === b ? 0
-                : a > b ? 1 : undefined;
-    };
-    // Returns true if this node represents root of ast imported by reference
-    Node.prototype.blocksVisibility = function () {
+    }
+
+    /**
+     * @param {number | string} a
+     * @param {number | string} b
+     * @returns {number | undefined}
+     */
+    static numericCompare(a, b) {
+        return a  <  b ? -1
+            : a === b ?  0
+                : a  >  b ?  1 : undefined;
+    }
+
+    /** @returns {boolean} */
+    blocksVisibility() {
         if (this.visibilityBlocks === undefined) {
             this.visibilityBlocks = 0;
         }
         return this.visibilityBlocks !== 0;
-    };
-    Node.prototype.addVisibilityBlock = function () {
+    }
+
+    addVisibilityBlock() {
         if (this.visibilityBlocks === undefined) {
             this.visibilityBlocks = 0;
         }
         this.visibilityBlocks = this.visibilityBlocks + 1;
-    };
-    Node.prototype.removeVisibilityBlock = function () {
+    }
+
+    removeVisibilityBlock() {
         if (this.visibilityBlocks === undefined) {
             this.visibilityBlocks = 0;
         }
         this.visibilityBlocks = this.visibilityBlocks - 1;
-    };
-    // Turns on node visibility - if called node will be shown in output regardless
-    // of whether it comes from import by reference or not
-    Node.prototype.ensureVisibility = function () {
+    }
+
+    ensureVisibility() {
         this.nodeVisible = true;
-    };
-    // Turns off node visibility - if called node will NOT be shown in output regardless
-    // of whether it comes from import by reference or not
-    Node.prototype.ensureInvisibility = function () {
+    }
+
+    ensureInvisibility() {
         this.nodeVisible = false;
-    };
-    // return values:
-    // false - the node must not be visible
-    // true - the node must be visible
-    // undefined or null - the node has the same visibility as its parent
-    Node.prototype.isVisible = function () {
+    }
+
+    /** @returns {boolean | undefined} */
+    isVisible() {
         return this.nodeVisible;
-    };
-    Node.prototype.visibilityInfo = function () {
+    }
+
+    /** @returns {VisibilityInfo} */
+    visibilityInfo() {
         return {
             visibilityBlocks: this.visibilityBlocks,
             nodeVisible: this.nodeVisible
         };
-    };
-    Node.prototype.copyVisibilityInfo = function (info) {
+    }
+
+    /** @param {VisibilityInfo} info */
+    copyVisibilityInfo(info) {
         if (!info) {
             return;
         }
         this.visibilityBlocks = info.visibilityBlocks;
         this.nodeVisible = info.nodeVisible;
-    };
-    return Node;
-}());
-exports.default = Node;
-//# sourceMappingURL=node.js.map
+    }
+}
+
+/**
+ * Set by the parser at runtime on Node.prototype.
+ * @type {{ context: EvalContext, importManager: object, imports: object } | undefined}
+ */
+Node.prototype.parse = undefined;
+
+export default Node;