less 4.4.2 → 4.6.0

package/lib/less/tree/selector.js

@@ -1,27 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var element_1 = tslib_1.__importDefault(require("./element"));
-var less_error_1 = tslib_1.__importDefault(require("../less-error"));
-var utils = tslib_1.__importStar(require("../utils"));
-var parser_1 = tslib_1.__importDefault(require("../parser/parser"));
-var Selector = function (elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
-    this.extendList = extendList;
-    this.condition = condition;
-    this.evaldCondition = !condition;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.elements = this.getElements(elements);
-    this.mixinElements_ = undefined;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.setParent(this.elements, this);
-};
-Selector.prototype = Object.assign(new node_1.default(), {
-    type: 'Selector',
-    accept: function (visitor) {
+// @ts-check
+import Node from './node.js';
+import Element from './element.js';
+import LessError from '../less-error.js';
+import * as utils from '../utils.js';
+import Parser from '../parser/parser.js';
+
+/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo, TreeVisitor } from './node.js' */
+
+class Selector extends Node {
+    get type() { return 'Selector'; }
+
+    /**
+     * @param {(Element | Selector)[] | string} [elements]
+     * @param {Node[] | null} [extendList]
+     * @param {Node | null} [condition]
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
+        super();
+        /** @type {Node[] | null | undefined} */
+        this.extendList = extendList;
+        /** @type {Node | null | undefined} */
+        this.condition = condition;
+        /** @type {boolean | Node} */
+        this.evaldCondition = !condition;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {Element[]} */
+        this.elements = this.getElements(elements);
+        /** @type {string[] | undefined} */
+        this.mixinElements_ = undefined;
+        /** @type {boolean | undefined} */
+        this.mediaEmpty = undefined;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.elements, this);
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.elements) {
-            this.elements = visitor.visitArray(this.elements);
+            this.elements = /** @type {Element[]} */ (visitor.visitArray(this.elements));
         }
         if (this.extendList) {
             this.extendList = visitor.visitArray(this.extendList);
@@ -29,99 +49,153 @@ Selector.prototype = Object.assign(new node_1.default(), {
         if (this.condition) {
             this.condition = visitor.visit(this.condition);
         }
-    },
-    createDerived: function (elements, extendList, evaldCondition) {
+    }
+
+    /**
+     * @param {Element[]} elements
+     * @param {Node[] | null} [extendList]
+     * @param {boolean | Node} [evaldCondition]
+     */
+    createDerived(elements, extendList, evaldCondition) {
         elements = this.getElements(elements);
-        var newSelector = new Selector(elements, extendList || this.extendList, null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+        const newSelector = new Selector(elements, extendList || this.extendList,
+            null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
         newSelector.evaldCondition = (!utils.isNullOrUndefined(evaldCondition)) ? evaldCondition : this.evaldCondition;
         newSelector.mediaEmpty = this.mediaEmpty;
         return newSelector;
-    },
-    getElements: function (els) {
+    }
+
+    /**
+     * @param {(Element | Selector)[] | string | null | undefined} els
+     * @returns {Element[]}
+     */
+    getElements(els) {
         if (!els) {
-            return [new element_1.default('', '&', false, this._index, this._fileInfo)];
+            return [new Element('', '&', false, this._index, this._fileInfo)];
         }
         if (typeof els === 'string') {
-            new parser_1.default(this.parse.context, this.parse.importManager, this._fileInfo, this._index).parseNode(els, ['selector'], function (err, result) {
-                if (err) {
-                    throw new less_error_1.default({
-                        index: err.index,
-                        message: err.message
-                    }, this.parse.imports, this._fileInfo.filename);
-                }
-                els = result[0].elements;
-            });
+            const fileInfo = this._fileInfo;
+            const parse = this.parse;
+            new (/** @type {new (...args: unknown[]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(parse.context, parse.importManager, fileInfo, this._index).parseNode(
+                els,
+                ['selector'],
+                function(/** @type {{ index: number, message: string } | null} */ err, /** @type {Selector[]} */ result) {
+                    if (err) {
+                        throw new LessError({
+                            index: err.index,
+                            message: err.message
+                        }, parse.imports, /** @type {string} */ (/** @type {FileInfo} */ (fileInfo).filename));
+                    }
+                    els = result[0].elements;
+                });
         }
-        return els;
-    },
-    createEmptySelectors: function () {
-        var el = new element_1.default('', '&', false, this._index, this._fileInfo), sels = [new Selector([el], null, null, this._index, this._fileInfo)];
+        return /** @type {Element[]} */ (els);
+    }
+
+    createEmptySelectors() {
+        const el = new Element('', '&', false, this._index, this._fileInfo), sels = [new Selector([el], null, null, this._index, this._fileInfo)];
         sels[0].mediaEmpty = true;
         return sels;
-    },
-    match: function (other) {
-        var elements = this.elements;
-        var len = elements.length;
-        var olen;
-        var i;
-        other = other.mixinElements();
-        olen = other.length;
+    }
+
+    /**
+     * @param {Selector} other
+     * @returns {number}
+     */
+    match(other) {
+        const elements = this.elements;
+        const len = elements.length;
+        let olen;
+        let i;
+
+        /** @type {string[]} */
+        const mixinEls = other.mixinElements();
+        olen = mixinEls.length;
         if (olen === 0 || len < olen) {
             return 0;
-        }
-        else {
+        } else {
             for (i = 0; i < olen; i++) {
-                if (elements[i].value !== other[i]) {
+                if (elements[i].value !== mixinEls[i]) {
                     return 0;
                 }
             }
         }
+
         return olen; // return number of matched elements
-    },
-    mixinElements: function () {
+    }
+
+    /** @returns {string[]} */
+    mixinElements() {
         if (this.mixinElements_) {
             return this.mixinElements_;
         }
-        var elements = this.elements.map(function (v) {
-            return v.combinator.value + (v.value.value || v.value);
+
+        /** @type {string[] | null} */
+        let elements = this.elements.map( function(v) {
+            return /** @type {string} */ (v.combinator.value) + (/** @type {{ value: string }} */ (v.value).value || v.value);
         }).join('').match(/[,&#*.\w-]([\w-]|(\\.))*/g);
+
         if (elements) {
             if (elements[0] === '&') {
                 elements.shift();
             }
-        }
-        else {
+        } else {
             elements = [];
         }
+
         return (this.mixinElements_ = elements);
-    },
-    isJustParentSelector: function () {
+    }
+
+    isJustParentSelector() {
         return !this.mediaEmpty &&
             this.elements.length === 1 &&
             this.elements[0].value === '&' &&
             (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
-    },
-    eval: function (context) {
-        var evaldCondition = this.condition && this.condition.eval(context);
-        var elements = this.elements;
-        var extendList = this.extendList;
-        elements = elements && elements.map(function (e) { return e.eval(context); });
-        extendList = extendList && extendList.map(function (extend) { return extend.eval(context); });
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        const evaldCondition = this.condition && this.condition.eval(context);
+        let elements = this.elements;
+        /** @type {Node[] | null | undefined} */
+        let extendList = this.extendList;
+
+        if (elements) {
+            const evaldElements = new Array(elements.length);
+            for (let i = 0; i < elements.length; i++) {
+                evaldElements[i] = elements[i].eval(context);
+            }
+            elements = evaldElements;
+        }
+        if (extendList) {
+            const evaldExtends = new Array(extendList.length);
+            for (let i = 0; i < extendList.length; i++) {
+                evaldExtends[i] = extendList[i].eval(context);
+            }
+            extendList = evaldExtends;
+        }
+
         return this.createDerived(elements, extendList, evaldCondition);
-    },
-    genCSS: function (context, output) {
-        var i, element;
-        if ((!context || !context.firstSelector) && this.elements[0].combinator.value === '') {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        let i, element;
+        if ((!context || !/** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector) && this.elements[0].combinator.value === '') {
             output.add(' ', this.fileInfo(), this.getIndex());
         }
         for (i = 0; i < this.elements.length; i++) {
             element = this.elements[i];
             element.genCSS(context, output);
         }
-    },
-    getIsOutput: function () {
+    }
+
+    getIsOutput() {
         return this.evaldCondition;
     }
-});
-exports.default = Selector;
-//# sourceMappingURL=selector.js.map
+}
+
+export default Selector;

package/lib/less/tree/unicode-descriptor.js

@@ -1,12 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var UnicodeDescriptor = function (value) {
-    this.value = value;
-};
-UnicodeDescriptor.prototype = Object.assign(new node_1.default(), {
-    type: 'UnicodeDescriptor'
-});
-exports.default = UnicodeDescriptor;
-//# sourceMappingURL=unicode-descriptor.js.map
+// @ts-check
+import Node from './node.js';
+
+class UnicodeDescriptor extends Node {
+    get type() { return 'UnicodeDescriptor'; }
+
+    /** @param {string} value */
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}
+
+export default UnicodeDescriptor;

package/lib/less/tree/unit.js

@@ -1,122 +1,170 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var unit_conversions_1 = tslib_1.__importDefault(require("../data/unit-conversions"));
-var utils = tslib_1.__importStar(require("../utils"));
-var Unit = function (numerator, denominator, backupUnit) {
-    this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
-    this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
-    if (backupUnit) {
-        this.backupUnit = backupUnit;
-    }
-    else if (numerator && numerator.length) {
-        this.backupUnit = numerator[0];
+// @ts-check
+import Node from './node.js';
+import unitConversions from '../data/unit-conversions.js';
+import * as utils from '../utils.js';
+
+/** @import { EvalContext, CSSOutput } from './node.js' */
+
+class Unit extends Node {
+    get type() { return 'Unit'; }
+
+    /**
+     * @param {string[]} [numerator]
+     * @param {string[]} [denominator]
+     * @param {string} [backupUnit]
+     */
+    constructor(numerator, denominator, backupUnit) {
+        super();
+        /** @type {string[]} */
+        this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
+        /** @type {string[]} */
+        this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
+        if (backupUnit) {
+            /** @type {string | undefined} */
+            this.backupUnit = backupUnit;
+        } else if (numerator && numerator.length) {
+            this.backupUnit = numerator[0];
+        }
     }
-};
-Unit.prototype = Object.assign(new node_1.default(), {
-    type: 'Unit',
-    clone: function () {
+
+    clone() {
         return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);
-    },
-    genCSS: function (context, output) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         // Dimension checks the unit is singular and throws an error if in strict math mode.
-        var strictUnits = context && context.strictUnits;
+        const strictUnits = context && context.strictUnits;
         if (this.numerator.length === 1) {
             output.add(this.numerator[0]); // the ideal situation
-        }
-        else if (!strictUnits && this.backupUnit) {
+        } else if (!strictUnits && this.backupUnit) {
             output.add(this.backupUnit);
-        }
-        else if (!strictUnits && this.denominator.length) {
+        } else if (!strictUnits && this.denominator.length) {
             output.add(this.denominator[0]);
         }
-    },
-    toString: function () {
-        var i, returnStr = this.numerator.join('*');
+    }
+
+    toString() {
+        let i, returnStr = this.numerator.join('*');
         for (i = 0; i < this.denominator.length; i++) {
-            returnStr += "/".concat(this.denominator[i]);
+            returnStr += `/${this.denominator[i]}`;
         }
         return returnStr;
-    },
-    compare: function (other) {
+    }
+
+    /**
+     * @param {Unit} other
+     * @returns {0 | undefined}
+     */
+    compare(other) {
         return this.is(other.toString()) ? 0 : undefined;
-    },
-    is: function (unitString) {
+    }
+
+    /** @param {string} unitString */
+    is(unitString) {
         return this.toString().toUpperCase() === unitString.toUpperCase();
-    },
-    isLength: function () {
-        return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS());
-    },
-    isEmpty: function () {
+    }
+
+    isLength() {
+        return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS(/** @type {import('./node.js').EvalContext} */ ({})));
+    }
+
+    isEmpty() {
         return this.numerator.length === 0 && this.denominator.length === 0;
-    },
-    isSingular: function () {
+    }
+
+    isSingular() {
         return this.numerator.length <= 1 && this.denominator.length === 0;
-    },
-    map: function (callback) {
-        var i;
+    }
+
+    /** @param {(atomicUnit: string, denominator: boolean) => string} callback */
+    map(callback) {
+        let i;
+
         for (i = 0; i < this.numerator.length; i++) {
             this.numerator[i] = callback(this.numerator[i], false);
         }
+
         for (i = 0; i < this.denominator.length; i++) {
             this.denominator[i] = callback(this.denominator[i], true);
         }
-    },
-    usedUnits: function () {
-        var group;
-        var result = {};
-        var mapUnit;
-        var groupName;
+    }
+
+    /** @returns {{ [groupName: string]: string }} */
+    usedUnits() {
+        /** @type {{ [unitName: string]: number }} */
+        let group;
+        /** @type {{ [groupName: string]: string }} */
+        const result = {};
+        /** @type {(atomicUnit: string) => string} */
+        let mapUnit;
+        /** @type {string} */
+        let groupName;
+
         mapUnit = function (atomicUnit) {
             // eslint-disable-next-line no-prototype-builtins
             if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
                 result[groupName] = atomicUnit;
             }
+
             return atomicUnit;
         };
-        for (groupName in unit_conversions_1.default) {
+
+        for (groupName in unitConversions) {
             // eslint-disable-next-line no-prototype-builtins
-            if (unit_conversions_1.default.hasOwnProperty(groupName)) {
-                group = unit_conversions_1.default[groupName];
+            if (unitConversions.hasOwnProperty(groupName)) {
+                group = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);
+
                 this.map(mapUnit);
             }
         }
+
         return result;
-    },
-    cancel: function () {
-        var counter = {};
-        var atomicUnit;
-        var i;
+    }
+
+    cancel() {
+        /** @type {{ [unit: string]: number }} */
+        const counter = {};
+        /** @type {string} */
+        let atomicUnit;
+        let i;
+
         for (i = 0; i < this.numerator.length; i++) {
             atomicUnit = this.numerator[i];
             counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
         }
+
         for (i = 0; i < this.denominator.length; i++) {
             atomicUnit = this.denominator[i];
             counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
         }
+
         this.numerator = [];
         this.denominator = [];
+
         for (atomicUnit in counter) {
             // eslint-disable-next-line no-prototype-builtins
             if (counter.hasOwnProperty(atomicUnit)) {
-                var count = counter[atomicUnit];
+                const count = counter[atomicUnit];
+
                 if (count > 0) {
                     for (i = 0; i < count; i++) {
                         this.numerator.push(atomicUnit);
                     }
-                }
-                else if (count < 0) {
+                } else if (count < 0) {
                     for (i = 0; i < -count; i++) {
                         this.denominator.push(atomicUnit);
                     }
                 }
             }
         }
+
         this.numerator.sort();
         this.denominator.sort();
     }
-});
-exports.default = Unit;
-//# sourceMappingURL=unit.js.map
+}
+
+export default Unit;

package/lib/less/tree/url.js

@@ -1,59 +1,83 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo } from './node.js' */
+import Node from './node.js';
+
+/**
+ * @param {string} path
+ * @returns {string}
+ */
 function escapePath(path) {
-    return path.replace(/[()'"\s]/g, function (match) { return "\\".concat(match); });
+    return path.replace(/[()'"\s]/g, function(match) { return `\\${match}`; });
 }
-var URL = function (val, index, currentFileInfo, isEvald) {
-    this.value = val;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.isEvald = isEvald;
-};
-URL.prototype = Object.assign(new node_1.default(), {
-    type: 'Url',
-    accept: function (visitor) {
-        this.value = visitor.visit(this.value);
-    },
-    genCSS: function (context, output) {
+
+class URL extends Node {
+    get type() { return 'Url'; }
+
+    /**
+     * @param {Node} val
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     * @param {boolean} [isEvald]
+     */
+    constructor(val, index, currentFileInfo, isEvald) {
+        super();
+        this.value = val;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {boolean | undefined} */
+        this.isEvald = isEvald;
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        this.value = visitor.visit(/** @type {Node} */ (this.value));
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
         output.add('url(');
-        this.value.genCSS(context, output);
+        /** @type {Node} */ (this.value).genCSS(context, output);
         output.add(')');
-    },
-    eval: function (context) {
-        var val = this.value.eval(context);
-        var rootpath;
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        const val = /** @type {Node} */ (this.value).eval(context);
+        let rootpath;
+
         if (!this.isEvald) {
             // Add the rootpath if the URL requires a rewrite
             rootpath = this.fileInfo() && this.fileInfo().rootpath;
             if (typeof rootpath === 'string' &&
                 typeof val.value === 'string' &&
-                context.pathRequiresRewrite(val.value)) {
-                if (!val.quote) {
+                context.pathRequiresRewrite(/** @type {string} */ (val.value))) {
+                if (!/** @type {import('./quoted.js').default} */ (val).quote) {
                     rootpath = escapePath(rootpath);
                 }
-                val.value = context.rewritePath(val.value, rootpath);
-            }
-            else {
-                val.value = context.normalizePath(val.value);
+                val.value = context.rewritePath(/** @type {string} */ (val.value), rootpath);
+            } else {
+                val.value = context.normalizePath(/** @type {string} */ (val.value));
             }
+
             // Add url args if enabled
             if (context.urlArgs) {
-                if (!val.value.match(/^\s*data:/)) {
-                    var delimiter = val.value.indexOf('?') === -1 ? '?' : '&';
-                    var urlArgs = delimiter + context.urlArgs;
-                    if (val.value.indexOf('#') !== -1) {
-                        val.value = val.value.replace('#', "".concat(urlArgs, "#"));
-                    }
-                    else {
+                if (!/** @type {string} */ (val.value).match(/^\s*data:/)) {
+                    const delimiter = /** @type {string} */ (val.value).indexOf('?') === -1 ? '?' : '&';
+                    const urlArgs = delimiter + context.urlArgs;
+                    if (/** @type {string} */ (val.value).indexOf('#') !== -1) {
+                        val.value = /** @type {string} */ (val.value).replace('#', `${urlArgs}#`);
+                    } else {
                         val.value += urlArgs;
                     }
                 }
             }
         }
+
         return new URL(val, this.getIndex(), this.fileInfo(), true);
     }
-});
-exports.default = URL;
-//# sourceMappingURL=url.js.map
+}
+
+export default URL;