less 4.5.1 → 4.6.0

package/lib/less/tree/extend.js

@@ -1,46 +1,73 @@
-"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 Extend = function (selector, option, index, currentFileInfo, visibilityInfo) {
-    this.selector = selector;
-    this.option = option;
-    this.object_id = Extend.next_id++;
-    this.parent_ids = [this.object_id];
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-    switch (option) {
-        case '!all':
-        case 'all':
-            this.allowBefore = true;
-            this.allowAfter = true;
-            break;
-        default:
-            this.allowBefore = false;
-            this.allowAfter = false;
-            break;
+// @ts-check
+/** @import { EvalContext, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+import Node from './node.js';
+import Selector from './selector.js';
+
+class Extend extends Node {
+    get type() { return 'Extend'; }
+
+    /**
+     * @param {Selector} selector
+     * @param {string} option
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(selector, option, index, currentFileInfo, visibilityInfo) {
+        super();
+        this.selector = selector;
+        this.option = option;
+        this.object_id = Extend.next_id++;
+        /** @type {number[]} */
+        this.parent_ids = [this.object_id];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        /** @type {boolean} */
+        this.allowRoot = true;
+        /** @type {boolean} */
+        this.allowBefore = false;
+        /** @type {boolean} */
+        this.allowAfter = false;
+
+        switch (option) {
+            case '!all':
+            case 'all':
+                this.allowBefore = true;
+                this.allowAfter = true;
+                break;
+            default:
+                this.allowBefore = false;
+                this.allowAfter = false;
+                break;
+        }
+        this.setParent(this.selector, this);
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        this.selector = /** @type {Selector} */ (visitor.visit(this.selector));
     }
-    this.setParent(this.selector, this);
-};
-Extend.prototype = Object.assign(new node_1.default(), {
-    type: 'Extend',
-    accept: function (visitor) {
-        this.selector = visitor.visit(this.selector);
-    },
-    eval: function (context) {
-        return new Extend(this.selector.eval(context), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    },
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        return new Extend(/** @type {Selector} */ (this.selector.eval(context)), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    }
+
     // remove when Nodes have JSDoc types
     // eslint-disable-next-line no-unused-vars
-    clone: function (context) {
+    /** @param {EvalContext} [context] */
+    clone(context) {
         return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    },
+    }
+
     // it concatenates (joins) all selectors in selector array
-    findSelfSelectors: function (selectors) {
-        var selfElements = [], i, selectorElements;
+    /** @param {Selector[]} selectors */
+    findSelfSelectors(selectors) {
+        /** @type {import('./element.js').default[]} */
+        let selfElements = [];
+        let i, selectorElements;
+
         for (i = 0; i < selectors.length; i++) {
             selectorElements = selectors[i].elements;
             // duplicate the logic in genCSS function inside the selector node.
@@ -50,10 +77,12 @@ Extend.prototype = Object.assign(new node_1.default(), {
             }
             selfElements = selfElements.concat(selectors[i].elements);
         }
-        this.selfSelectors = [new selector_1.default(selfElements)];
+
+        /** @type {Selector[]} */
+        this.selfSelectors = [new Selector(selfElements)];
         this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
     }
-});
+}
+
 Extend.next_id = 0;
-exports.default = Extend;
-//# sourceMappingURL=extend.js.map
+export default Extend;

package/lib/less/tree/import.js

@@ -1,15 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var media_1 = tslib_1.__importDefault(require("./media"));
-var url_1 = tslib_1.__importDefault(require("./url"));
-var quoted_1 = tslib_1.__importDefault(require("./quoted"));
-var ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var utils = tslib_1.__importStar(require("../utils"));
-var less_error_1 = tslib_1.__importDefault(require("../less-error"));
-var expression_1 = tslib_1.__importDefault(require("./expression"));
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+import Node from './node.js';
+import Media from './media.js';
+import URL from './url.js';
+import Quoted from './quoted.js';
+import Ruleset from './ruleset.js';
+import Anonymous from './anonymous.js';
+import Expression from './expression.js';
+import * as utils from '../utils.js';
+import LessError from '../less-error.js';
+
+/**
+ * @typedef {object} ImportOptions
+ * @property {boolean} [less]
+ * @property {boolean} [inline]
+ * @property {boolean} [isPlugin]
+ * @property {boolean} [reference]
+ */
+
 //
 // CSS @import node
 //
@@ -22,38 +30,73 @@ var expression_1 = tslib_1.__importDefault(require("./expression"));
 // `import,push`, we also pass it a callback, which it'll call once
 // the file has been fetched, and parsed.
 //
-var Import = function (path, features, options, index, currentFileInfo, visibilityInfo) {
-    this.options = options;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.path = path;
-    this.features = features;
-    this.allowRoot = true;
-    if (this.options.less !== undefined || this.options.inline) {
-        this.css = !this.options.less || this.options.inline;
-    }
-    else {
-        var pathValue = this.getPath();
-        if (pathValue && /[#.&?]css([?;].*)?$/.test(pathValue)) {
-            this.css = true;
+class Import extends Node {
+    get type() { return 'Import'; }
+
+    /**
+     * @param {Node} path
+     * @param {Node | null} features
+     * @param {ImportOptions} options
+     * @param {number} index
+     * @param {FileInfo} [currentFileInfo]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(path, features, options, index, currentFileInfo, visibilityInfo) {
+        super();
+        /** @type {ImportOptions} */
+        this.options = options;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.path = path;
+        /** @type {Node | null} */
+        this.features = features;
+        /** @type {boolean} */
+        this.allowRoot = true;
+
+        /** @type {boolean | undefined} */
+        this.css = undefined;
+        /** @type {boolean | undefined} */
+        this.layerCss = undefined;
+        /** @type {(Ruleset & { imports?: object, filename?: string, functions?: object, functionRegistry?: { addMultiple: (fns: object) => void } }) | undefined} */
+        this.root = undefined;
+        /** @type {string | undefined} */
+        this.importedFilename = undefined;
+        /** @type {boolean | (() => boolean) | undefined} */
+        this.skip = undefined;
+        /** @type {{ message: string, index: number, filename: string } | undefined} */
+        this.error = undefined;
+
+        if (this.options.less !== undefined || this.options.inline) {
+            this.css = !this.options.less || this.options.inline;
+        } else {
+            const pathValue = this.getPath();
+            if (pathValue && /[#.&?]css([?;].*)?$/.test(pathValue)) {
+                this.css = true;
+            }
+        }
+        this.copyVisibilityInfo(visibilityInfo);
+        if (this.features) {
+            this.setParent(this.features, /** @type {Node} */ (this));
         }
+        this.setParent(this.path, /** @type {Node} */ (this));
     }
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.features, this);
-    this.setParent(this.path, this);
-};
-Import.prototype = Object.assign(new node_1.default(), {
-    type: 'Import',
-    accept: function (visitor) {
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.features) {
             this.features = visitor.visit(this.features);
         }
         this.path = visitor.visit(this.path);
         if (!this.options.isPlugin && !this.options.inline && this.root) {
-            this.root = visitor.visit(this.root);
+            this.root = /** @type {Ruleset} */ (visitor.visit(this.root));
         }
-    },
-    genCSS: function (context, output) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         if (this.css && this.path._fileInfo.reference === undefined) {
             output.add('@import ', this._fileInfo, this._index);
             this.path.genCSS(context, output);
@@ -63,79 +106,105 @@ Import.prototype = Object.assign(new node_1.default(), {
             }
             output.add(';');
         }
-    },
-    getPath: function () {
-        return (this.path instanceof url_1.default) ?
-            this.path.value.value : this.path.value;
-    },
-    isVariableImport: function () {
-        var path = this.path;
-        if (path instanceof url_1.default) {
-            path = path.value;
+    }
+
+    /** @returns {string | undefined} */
+    getPath() {
+        return (this.path instanceof URL) ?
+            /** @type {string} */ (/** @type {Node} */ (this.path.value).value) :
+            /** @type {string | undefined} */ (this.path.value);
+    }
+
+    /** @returns {boolean | RegExpMatchArray | null} */
+    isVariableImport() {
+        let path = this.path;
+        if (path instanceof URL) {
+            path = /** @type {Node} */ (path.value);
         }
-        if (path instanceof quoted_1.default) {
+        if (path instanceof Quoted) {
             return path.containsVariables();
         }
+
         return true;
-    },
-    evalForImport: function (context) {
-        var path = this.path;
-        if (path instanceof url_1.default) {
-            path = path.value;
+    }
+
+    /** @param {EvalContext} context */
+    evalForImport(context) {
+        let path = this.path;
+
+        if (path instanceof URL) {
+            path = /** @type {Node} */ (path.value);
         }
-        return new Import(path.eval(context), this.features, this.options, this._index, this._fileInfo, this.visibilityInfo());
-    },
-    evalPath: function (context) {
-        var path = this.path.eval(context);
-        var fileInfo = this._fileInfo;
-        if (!(path instanceof url_1.default)) {
+
+        return new Import(path.eval(context), this.features, this.options, this._index || 0, this._fileInfo, this.visibilityInfo());
+    }
+
+    /** @param {EvalContext} context */
+    evalPath(context) {
+        const path = this.path.eval(context);
+        const fileInfo = this._fileInfo;
+
+        if (!(path instanceof URL)) {
             // Add the rootpath if the URL requires a rewrite
-            var pathValue = path.value;
+            const pathValue = /** @type {string} */ (path.value);
             if (fileInfo &&
                 pathValue &&
                 context.pathRequiresRewrite(pathValue)) {
                 path.value = context.rewritePath(pathValue, fileInfo.rootpath);
-            }
-            else {
-                path.value = context.normalizePath(path.value);
+            } else {
+                path.value = context.normalizePath(/** @type {string} */ (path.value));
             }
         }
+
         return path;
-    },
-    eval: function (context) {
-        var result = this.doEval(context);
+    }
+
+    /** @param {EvalContext} context */
+    // @ts-ignore - Import.eval returns Node | Node[] | Import (wider than Node.eval's Node return)
+    eval(context) {
+        const result = this.doEval(context);
         if (this.options.reference || this.blocksVisibility()) {
-            if (result.length || result.length === 0) {
+            if (Array.isArray(result)) {
                 result.forEach(function (node) {
                     node.addVisibilityBlock();
                 });
-            }
-            else {
-                result.addVisibilityBlock();
+            } else {
+                /** @type {Node} */ (result).addVisibilityBlock();
             }
         }
         return result;
-    },
-    doEval: function (context) {
-        var ruleset;
-        var registry;
-        var features = this.features && this.features.eval(context);
+    }
+
+    /** @param {EvalContext} context */
+    doEval(context) {
+        /** @type {Ruleset | undefined} */
+        let ruleset;
+        const features = this.features && this.features.eval(context);
+
         if (this.options.isPlugin) {
             if (this.root && this.root.eval) {
                 try {
                     this.root.eval(context);
                 }
                 catch (e) {
-                    e.message = 'Plugin error during evaluation';
-                    throw new less_error_1.default(e, this.root.imports, this.root.filename);
+                    const err = /** @type {{ message: string }} */ (e);
+                    err.message = 'Plugin error during evaluation';
+                    throw new LessError(
+                        /** @type {{ message: string, index?: number, filename?: string }} */ (e),
+                        /** @type {{ imports: object }} */ (/** @type {unknown} */ (this.root)).imports,
+                        /** @type {{ filename: string }} */ (/** @type {unknown} */ (this.root)).filename
+                    );
                 }
             }
-            registry = context.frames[0] && context.frames[0].functionRegistry;
+            const frame0 = /** @type {Ruleset & { functionRegistry?: { addMultiple: (fns: object) => void } }} */ (context.frames[0]);
+            const registry = frame0 && frame0.functionRegistry;
             if (registry && this.root && this.root.functions) {
                 registry.addMultiple(this.root.functions);
             }
+
             return [];
         }
+
         if (this.skip) {
             if (typeof this.skip === 'function') {
                 this.skip = this.skip();
@@ -145,12 +214,12 @@ Import.prototype = Object.assign(new node_1.default(), {
             }
         }
         if (this.features) {
-            var featureValue = this.features.value;
+            let featureValue = /** @type {Node[]} */ (this.features.value);
             if (Array.isArray(featureValue) && featureValue.length >= 1) {
-                var expr = featureValue[0];
-                if (expr.type === 'Expression' && Array.isArray(expr.value) && expr.value.length >= 2) {
-                    featureValue = expr.value;
-                    var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                const expr = featureValue[0];
+                if (expr.type === 'Expression' && Array.isArray(expr.value) && /** @type {Node[]} */ (expr.value).length >= 2) {
+                    featureValue = /** @type {Node[]} */ (expr.value);
+                    const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
                         && featureValue[1].type === 'Paren';
                     if (isLayer) {
                         this.css = false;
@@ -159,14 +228,20 @@ Import.prototype = Object.assign(new node_1.default(), {
             }
         }
         if (this.options.inline) {
-            var contents = new anonymous_1.default(this.root, 0, {
-                filename: this.importedFilename,
-                reference: this.path._fileInfo && this.path._fileInfo.reference
-            }, true, true);
-            return this.features ? new media_1.default([contents], this.features.value) : [contents];
-        }
-        else if (this.css || this.layerCss) {
-            var newImport = new Import(this.evalPath(context), features, this.options, this._index);
+            const contents = new Anonymous(
+                /** @type {string} */ (/** @type {unknown} */ (this.root)),
+                0,
+                {
+                    filename: this.importedFilename,
+                    reference: this.path._fileInfo && this.path._fileInfo.reference
+                },
+                true,
+                true
+            );
+
+            return this.features ? new Media([contents], /** @type {Node[]} */ (this.features.value)) : [contents];
+        } else if (this.css || this.layerCss) {
+            const newImport = new Import(this.evalPath(context), features, this.options, this._index || 0);
             if (this.layerCss) {
                 newImport.css = this.layerCss;
                 newImport.path._fileInfo = this._fileInfo;
@@ -175,43 +250,42 @@ Import.prototype = Object.assign(new node_1.default(), {
                 throw this.error;
             }
             return newImport;
-        }
-        else if (this.root) {
+        } else if (this.root) {
             if (this.features) {
-                var featureValue = this.features.value;
+                let featureValue = /** @type {Node[]} */ (this.features.value);
                 if (Array.isArray(featureValue) && featureValue.length === 1) {
-                    var expr = featureValue[0];
-                    if (expr.type === 'Expression' && Array.isArray(expr.value) && expr.value.length >= 2) {
-                        featureValue = expr.value;
-                        var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                    const expr = featureValue[0];
+                    if (expr.type === 'Expression' && Array.isArray(expr.value) && /** @type {Node[]} */ (expr.value).length >= 2) {
+                        featureValue = /** @type {Node[]} */ (expr.value);
+                        const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
                             && featureValue[1].type === 'Paren';
                         if (isLayer) {
                             this.layerCss = true;
-                            featureValue[0] = new expression_1.default(featureValue.slice(0, 2));
+                            featureValue[0] = new Expression(/** @type {Node[]} */ (featureValue.slice(0, 2)));
                             featureValue.splice(1, 1);
-                            featureValue[0].noSpacing = true;
+                            /** @type {Expression} */ (featureValue[0]).noSpacing = true;
                             return this;
                         }
                     }
                 }
             }
-            ruleset = new ruleset_1.default(null, utils.copyArray(this.root.rules));
+            ruleset = new Ruleset(null, utils.copyArray(this.root.rules));
             ruleset.evalImports(context);
-            return this.features ? new media_1.default(ruleset.rules, this.features.value) : ruleset.rules;
-        }
-        else {
+
+            return this.features ? new Media(ruleset.rules, /** @type {Node[]} */ (this.features.value)) : ruleset.rules;
+        } else {
             if (this.features) {
-                var featureValue = this.features.value;
+                let featureValue = /** @type {Node[]} */ (this.features.value);
                 if (Array.isArray(featureValue) && featureValue.length >= 1) {
-                    featureValue = featureValue[0].value;
+                    featureValue = /** @type {Node[]} */ (featureValue[0].value);
                     if (Array.isArray(featureValue) && featureValue.length >= 2) {
-                        var isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
+                        const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
                             && featureValue[1].type === 'Paren';
                         if (isLayer) {
                             this.css = true;
-                            featureValue[0] = new expression_1.default(featureValue.slice(0, 2));
+                            featureValue[0] = new Expression(/** @type {Node[]} */ (featureValue.slice(0, 2)));
                             featureValue.splice(1, 1);
-                            featureValue[0].noSpacing = true;
+                            /** @type {Expression} */ (featureValue[0]).noSpacing = true;
                             return this;
                         }
                     }
@@ -220,6 +294,6 @@ Import.prototype = Object.assign(new node_1.default(), {
             return [];
         }
     }
-});
-exports.default = Import;
-//# sourceMappingURL=import.js.map
+}
+
+export default Import;