less 4.5.1 → 4.6.0

package/lib/less/tree/value.js

@@ -1,44 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var Value = function (value) {
-    if (!value) {
-        throw new Error('Value requires an array argument');
-    }
-    if (!Array.isArray(value)) {
-        this.value = [value];
-    }
-    else {
-        this.value = value;
-    }
-};
-Value.prototype = Object.assign(new node_1.default(), {
-    type: 'Value',
-    accept: function (visitor) {
-        if (this.value) {
-            this.value = visitor.visitArray(this.value);
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
+import Node from './node.js';
+
+class Value extends Node {
+    get type() { return 'Value'; }
+
+    /** @param {Node[] | Node} value */
+    constructor(value) {
+        super();
+        if (!value) {
+            throw new Error('Value requires an array argument');
         }
-    },
-    eval: function (context) {
-        if (this.value.length === 1) {
-            return this.value[0].eval(context);
+        if (!Array.isArray(value)) {
+            this.value = [ value ];
         }
         else {
-            return new Value(this.value.map(function (v) {
+            this.value = value;
+        }
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
+        if (this.value) {
+            this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));
+        }
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        const value = /** @type {Node[]} */ (this.value);
+        if (value.length === 1) {
+            return value[0].eval(context);
+        } else {
+            return new Value(value.map(function (v) {
                 return v.eval(context);
             }));
         }
-    },
-    genCSS: function (context, output) {
-        var i;
-        for (i = 0; i < this.value.length; i++) {
-            this.value[i].genCSS(context, output);
-            if (i + 1 < this.value.length) {
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        const value = /** @type {Node[]} */ (this.value);
+        let i;
+        for (i = 0; i < value.length; i++) {
+            value[i].genCSS(context, output);
+            if (i + 1 < value.length) {
                 output.add((context && context.compress) ? ',' : ', ');
             }
         }
     }
-});
-exports.default = Value;
-//# sourceMappingURL=value.js.map
+}
+
+export default Value;

package/lib/less/tree/variable-call.js

@@ -1,43 +1,60 @@
-"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 ruleset_1 = tslib_1.__importDefault(require("./ruleset"));
-var detached_ruleset_1 = tslib_1.__importDefault(require("./detached-ruleset"));
-var less_error_1 = tslib_1.__importDefault(require("../less-error"));
-var VariableCall = function (variable, index, currentFileInfo) {
-    this.variable = variable;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.allowRoot = true;
-};
-VariableCall.prototype = Object.assign(new node_1.default(), {
-    type: 'VariableCall',
-    eval: function (context) {
-        var rules;
-        var detachedRuleset = new variable_1.default(this.variable, this.getIndex(), this.fileInfo()).eval(context);
-        var error = new less_error_1.default({ message: "Could not evaluate variable call ".concat(this.variable) });
-        if (!detachedRuleset.ruleset) {
-            if (detachedRuleset.rules) {
+// @ts-check
+/** @import { EvalContext, FileInfo } from './node.js' */
+import Node from './node.js';
+import Variable from './variable.js';
+import Ruleset from './ruleset.js';
+import DetachedRuleset from './detached-ruleset.js';
+import LessError from '../less-error.js';
+
+class VariableCall extends Node {
+    get type() { return 'VariableCall'; }
+
+    /**
+     * @param {string} variable
+     * @param {number} index
+     * @param {FileInfo} currentFileInfo
+     */
+    constructor(variable, index, currentFileInfo) {
+        super();
+        this.variable = variable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.allowRoot = true;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let rules;
+        /** @type {DetachedRuleset | Node} */
+        let detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);
+        const error = new LessError({message: `Could not evaluate variable call ${this.variable}`});
+
+        if (!(/** @type {DetachedRuleset} */ (detachedRuleset)).ruleset) {
+            const dr = /** @type {Node & { rules?: Node[] }} */ (detachedRuleset);
+            if (dr.rules) {
                 rules = detachedRuleset;
             }
             else if (Array.isArray(detachedRuleset)) {
-                rules = new ruleset_1.default('', detachedRuleset);
+                rules = new Ruleset(null, detachedRuleset);
             }
             else if (Array.isArray(detachedRuleset.value)) {
-                rules = new ruleset_1.default('', detachedRuleset.value);
+                rules = new Ruleset(null, detachedRuleset.value);
             }
             else {
                 throw error;
             }
-            detachedRuleset = new detached_ruleset_1.default(rules);
+            detachedRuleset = new DetachedRuleset(rules);
         }
-        if (detachedRuleset.ruleset) {
-            return detachedRuleset.callEval(context);
+
+        const dr = /** @type {DetachedRuleset} */ (detachedRuleset);
+        if (dr.ruleset) {
+            return dr.callEval(context);
         }
         throw error;
     }
-});
-exports.default = VariableCall;
-//# sourceMappingURL=variable-call.js.map
+}
+
+export default VariableCall;

package/lib/less/tree/variable.js

@@ -1,37 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var call_1 = tslib_1.__importDefault(require("./call"));
-var Variable = function (name, index, currentFileInfo) {
-    this.name = name;
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-};
-Variable.prototype = Object.assign(new node_1.default(), {
-    type: 'Variable',
-    eval: function (context) {
-        var variable, name = this.name;
+// @ts-check
+/** @import { EvalContext, FileInfo } from './node.js' */
+import Node from './node.js';
+import Call from './call.js';
+import Ruleset from './ruleset.js';
+
+class Variable extends Node {
+    get type() { return 'Variable'; }
+
+    /**
+     * @param {string} name
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     */
+    constructor(name, index, currentFileInfo) {
+        super();
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {boolean | undefined} */
+        this.evaluating = undefined;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        let variable, name = this.name;
+
         if (name.indexOf('@@') === 0) {
-            name = "@".concat(new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value);
+            name = `@${new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value}`;
         }
+
         if (this.evaluating) {
             throw { type: 'Name',
-                message: "Recursive variable definition for ".concat(name),
+                message: `Recursive variable definition for ${name}`,
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
+
         this.evaluating = true;
+
         variable = this.find(context.frames, function (frame) {
-            var v = frame.variable(name);
+            const v = /** @type {Ruleset} */ (frame).variable(name);
             if (v) {
                 if (v.important) {
-                    var importantScope = context.importantScope[context.importantScope.length - 1];
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
                     importantScope.important = v.important;
                 }
                 // If in calc, wrap vars in a function call to cascade evaluate args first
                 if (context.inCalc) {
-                    return (new call_1.default('_SELF', [v.value])).eval(context);
+                    return (new Call('_SELF', [v.value], 0, undefined)).eval(context);
                 }
                 else {
                     return v.value.eval(context);
@@ -41,23 +60,26 @@ Variable.prototype = Object.assign(new node_1.default(), {
         if (variable) {
             this.evaluating = false;
             return variable;
-        }
-        else {
+        } else {
             throw { type: 'Name',
-                message: "variable ".concat(name, " is undefined"),
+                message: `variable ${name} is undefined`,
                 filename: this.fileInfo().filename,
                 index: this.getIndex() };
         }
-    },
-    find: function (obj, fun) {
-        for (var i = 0, r = void 0; i < obj.length; i++) {
+    }
+
+    /**
+     * @param {Node[]} obj
+     * @param {(frame: Node) => Node | undefined} fun
+     * @returns {Node | null}
+     */
+    find(obj, fun) {
+        for (let i = 0, r; i < obj.length; i++) {
             r = fun.call(obj, obj[i]);
-            if (r) {
-                return r;
-            }
+            if (r) { return r; }
         }
         return null;
     }
-});
-exports.default = Variable;
-//# sourceMappingURL=variable.js.map
+}
+
+export default Variable;

package/lib/less/utils.js

@@ -1,63 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNullOrUndefined = exports.flattenArray = exports.merge = exports.copyOptions = exports.defaults = exports.clone = exports.copyArray = exports.getLocation = void 0;
-var tslib_1 = require("tslib");
 /* jshint proto: true */
-var Constants = tslib_1.__importStar(require("./constants"));
-var copy_anything_1 = require("copy-anything");
-function getLocation(index, inputStream) {
-    var n = index + 1;
-    var line = null;
-    var column = -1;
+import * as Constants from './constants.js';
+import { copy } from 'copy-anything';
+
+export function getLocation(index, inputStream) {
+    let n = index + 1;
+    let line = null;
+    let column = -1;
+
     while (--n >= 0 && inputStream.charAt(n) !== '\n') {
         column++;
     }
+
     if (typeof index === 'number') {
         line = (inputStream.slice(0, index).match(/\n/g) || '').length;
     }
+
     return {
-        line: line,
-        column: column
+        line,
+        column
     };
 }
-exports.getLocation = getLocation;
-function copyArray(arr) {
-    var i;
-    var length = arr.length;
-    var copy = new Array(length);
+
+export function copyArray(arr) {
+    let i;
+    const length = arr.length;
+    const copy = new Array(length);
+
     for (i = 0; i < length; i++) {
         copy[i] = arr[i];
     }
     return copy;
 }
-exports.copyArray = copyArray;
-function clone(obj) {
-    var cloned = {};
-    for (var prop in obj) {
+
+export function clone(obj) {
+    const cloned = {};
+    for (const prop in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, prop)) {
             cloned[prop] = obj[prop];
         }
     }
     return cloned;
 }
-exports.clone = clone;
-function defaults(obj1, obj2) {
-    var newObj = obj2 || {};
+
+export function defaults(obj1, obj2) {
+    let newObj = obj2 || {};
     if (!obj2._defaults) {
         newObj = {};
-        var defaults_1 = (0, copy_anything_1.copy)(obj1);
-        newObj._defaults = defaults_1;
-        var cloned = obj2 ? (0, copy_anything_1.copy)(obj2) : {};
-        Object.assign(newObj, defaults_1, cloned);
+        const defaults = copy(obj1);
+        newObj._defaults = defaults;
+        const cloned = obj2 ? copy(obj2) : {};
+        Object.assign(newObj, defaults, cloned);
     }
     return newObj;
 }
-exports.defaults = defaults;
-function copyOptions(obj1, obj2) {
+
+export function copyOptions(obj1, obj2) {
     if (obj2 && obj2._defaults) {
         return obj2;
     }
-    var opts = defaults(obj1, obj2);
+    const opts = defaults(obj1, obj2);
     if (opts.strictMath) {
         opts.math = Constants.Math.PARENS;
     }
@@ -96,24 +97,22 @@ function copyOptions(obj1, obj2) {
     }
     return opts;
 }
-exports.copyOptions = copyOptions;
-function merge(obj1, obj2) {
-    for (var prop in obj2) {
+
+export function merge(obj1, obj2) {
+    for (const prop in obj2) {
         if (Object.prototype.hasOwnProperty.call(obj2, prop)) {
             obj1[prop] = obj2[prop];
         }
     }
     return obj1;
 }
-exports.merge = merge;
-function flattenArray(arr, result) {
-    if (result === void 0) { result = []; }
-    for (var i = 0, length_1 = arr.length; i < length_1; i++) {
-        var value = arr[i];
+
+export function flattenArray(arr, result = []) {
+    for (let i = 0, length = arr.length; i < length; i++) {
+        const value = arr[i];
         if (Array.isArray(value)) {
             flattenArray(value, result);
-        }
-        else {
+        } else {
             if (value !== undefined) {
                 result.push(value);
             }
@@ -121,9 +120,7 @@ function flattenArray(arr, result) {
     }
     return result;
 }
-exports.flattenArray = flattenArray;
-function isNullOrUndefined(val) {
-    return val === null || val === undefined;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
-//# sourceMappingURL=utils.js.map
+
+export function isNullOrUndefined(val) {
+    return val === null || val === undefined
+}