less 4.4.2 → 4.6.0

package/lib/less/functions/default.js

@@ -1,17 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var keyword_1 = tslib_1.__importDefault(require("../tree/keyword"));
-var utils = tslib_1.__importStar(require("../utils"));
-var defaultFunc = {
+import Keyword from '../tree/keyword.js';
+import * as utils from '../utils.js';
+
+const defaultFunc = {
     eval: function () {
-        var v = this.value_;
-        var e = this.error_;
+        const v = this.value_;
+        const e = this.error_;
         if (e) {
             throw e;
         }
         if (!utils.isNullOrUndefined(v)) {
-            return v ? keyword_1.default.True : keyword_1.default.False;
+            return v ? Keyword.True : Keyword.False;
         }
     },
     value: function (v) {
@@ -24,5 +22,5 @@ var defaultFunc = {
         this.value_ = this.error_ = null;
     }
 };
-exports.default = defaultFunc;
-//# sourceMappingURL=default.js.map
+
+export default defaultFunc;

package/lib/less/functions/function-caller.js

@@ -1,54 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var expression_1 = tslib_1.__importDefault(require("../tree/expression"));
-var functionCaller = /** @class */ (function () {
-    function functionCaller(name, context, index, currentFileInfo) {
+import Expression from '../tree/expression.js';
+
+class functionCaller {
+    constructor(name, context, index, currentFileInfo) {
         this.name = name.toLowerCase();
         this.index = index;
         this.context = context;
         this.currentFileInfo = currentFileInfo;
+
         this.func = context.frames[0].functionRegistry.get(this.name);
     }
-    functionCaller.prototype.isValid = function () {
+
+    isValid() {
         return Boolean(this.func);
-    };
-    functionCaller.prototype.call = function (args) {
-        var _this = this;
+    }
+
+    call(args) {
         if (!(Array.isArray(args))) {
             args = [args];
         }
-        var evalArgs = this.func.evalArgs;
+        const evalArgs = this.func.evalArgs;
         if (evalArgs !== false) {
-            args = args.map(function (a) { return a.eval(_this.context); });
+            args = args.map(a => a.eval(this.context));
         }
-        var commentFilter = function (item) { return !(item.type === 'Comment'); };
+        const commentFilter = item => !(item.type === 'Comment');
+
         // This code is terrible and should be replaced as per this issue...
         // https://github.com/less/less.js/issues/2477
         args = args
             .filter(commentFilter)
-            .map(function (item) {
-            if (item.type === 'Expression') {
-                var subNodes = item.value.filter(commentFilter);
-                if (subNodes.length === 1) {
-                    // https://github.com/less/less.js/issues/3616
-                    if (item.parens && subNodes[0].op === '/') {
-                        return item;
+            .map(item => {
+                if (item.type === 'Expression') {
+                    const subNodes = item.value.filter(commentFilter);
+                    if (subNodes.length === 1) {
+                        // https://github.com/less/less.js/issues/3616
+                        if (item.parens && subNodes[0].op === '/') {
+                            return item;
+                        }
+                        return subNodes[0];
+                    } else {
+                        return new Expression(subNodes);
                     }
-                    return subNodes[0];
-                }
-                else {
-                    return new expression_1.default(subNodes);
                 }
-            }
-            return item;
-        });
+                return item;
+            });
+
         if (evalArgs === false) {
-            return this.func.apply(this, tslib_1.__spreadArray([this.context], args, false));
+            return this.func(this.context, ...args);
         }
-        return this.func.apply(this, args);
-    };
-    return functionCaller;
-}());
-exports.default = functionCaller;
-//# sourceMappingURL=function-caller.js.map
+
+        return this.func(...args);
+    }
+}
+
+export default functionCaller;

package/lib/less/functions/function-registry.js

@@ -1,37 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function makeRegistry(base) {
+function makeRegistry( base ) {
     return {
         _data: {},
-        add: function (name, func) {
+        add: function(name, func) {
             // precautionary case conversion, as later querying of
             // the registry by function-caller uses lower case as well.
             name = name.toLowerCase();
+
             // eslint-disable-next-line no-prototype-builtins
             if (this._data.hasOwnProperty(name)) {
                 // TODO warn
             }
             this._data[name] = func;
         },
-        addMultiple: function (functions) {
-            var _this = this;
-            Object.keys(functions).forEach(function (name) {
-                _this.add(name, functions[name]);
-            });
+        addMultiple: function(functions) {
+            Object.keys(functions).forEach(
+                name => {
+                    this.add(name, functions[name]);
+                });
         },
-        get: function (name) {
-            return this._data[name] || (base && base.get(name));
+        get: function(name) {
+            return this._data[name] || ( base && base.get( name ));
         },
-        getLocalFunctions: function () {
+        getLocalFunctions: function() {
             return this._data;
         },
-        inherit: function () {
-            return makeRegistry(this);
+        inherit: function() {
+            return makeRegistry( this );
         },
-        create: function (base) {
+        create: function(base) {
             return makeRegistry(base);
         }
     };
 }
-exports.default = makeRegistry(null);
-//# sourceMappingURL=function-registry.js.map
+
+export default makeRegistry( null );

package/lib/less/functions/index.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var function_registry_1 = tslib_1.__importDefault(require("./function-registry"));
-var function_caller_1 = tslib_1.__importDefault(require("./function-caller"));
-var boolean_1 = tslib_1.__importDefault(require("./boolean"));
-var default_1 = tslib_1.__importDefault(require("./default"));
-var color_1 = tslib_1.__importDefault(require("./color"));
-var color_blending_1 = tslib_1.__importDefault(require("./color-blending"));
-var data_uri_1 = tslib_1.__importDefault(require("./data-uri"));
-var list_1 = tslib_1.__importDefault(require("./list"));
-var math_1 = tslib_1.__importDefault(require("./math"));
-var number_1 = tslib_1.__importDefault(require("./number"));
-var string_1 = tslib_1.__importDefault(require("./string"));
-var svg_1 = tslib_1.__importDefault(require("./svg"));
-var types_1 = tslib_1.__importDefault(require("./types"));
-var style_1 = tslib_1.__importDefault(require("./style"));
-exports.default = (function (environment) {
-    var functions = { functionRegistry: function_registry_1.default, functionCaller: function_caller_1.default };
+import functionRegistry from './function-registry.js';
+import functionCaller from './function-caller.js';
+
+import boolean from './boolean.js';
+import defaultFunc from './default.js';
+import color from './color.js';
+import colorBlending from './color-blending.js';
+import dataUri from './data-uri.js';
+import list from './list.js';
+import math from './math.js';
+import number from './number.js';
+import string from './string.js';
+import svg from './svg.js';
+import types from './types.js';
+import style from './style.js';
+
+export default environment => {
+    const functions = { functionRegistry, functionCaller };
+
     // register functions
-    function_registry_1.default.addMultiple(boolean_1.default);
-    function_registry_1.default.add('default', default_1.default.eval.bind(default_1.default));
-    function_registry_1.default.addMultiple(color_1.default);
-    function_registry_1.default.addMultiple(color_blending_1.default);
-    function_registry_1.default.addMultiple((0, data_uri_1.default)(environment));
-    function_registry_1.default.addMultiple(list_1.default);
-    function_registry_1.default.addMultiple(math_1.default);
-    function_registry_1.default.addMultiple(number_1.default);
-    function_registry_1.default.addMultiple(string_1.default);
-    function_registry_1.default.addMultiple((0, svg_1.default)(environment));
-    function_registry_1.default.addMultiple(types_1.default);
-    function_registry_1.default.addMultiple(style_1.default);
+    functionRegistry.addMultiple(boolean);
+    functionRegistry.add('default', defaultFunc.eval.bind(defaultFunc));
+    functionRegistry.addMultiple(color);
+    functionRegistry.addMultiple(colorBlending);
+    functionRegistry.addMultiple(dataUri(environment));
+    functionRegistry.addMultiple(list);
+    functionRegistry.addMultiple(math);
+    functionRegistry.addMultiple(number);
+    functionRegistry.addMultiple(string);
+    functionRegistry.addMultiple(svg(environment));
+    functionRegistry.addMultiple(types);
+    functionRegistry.addMultiple(style);
+
     return functions;
-});
-//# sourceMappingURL=index.js.map
+};

package/lib/less/functions/list.js

@@ -1,58 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var comment_1 = tslib_1.__importDefault(require("../tree/comment"));
-var node_1 = tslib_1.__importDefault(require("../tree/node"));
-var dimension_1 = tslib_1.__importDefault(require("../tree/dimension"));
-var declaration_1 = tslib_1.__importDefault(require("../tree/declaration"));
-var expression_1 = tslib_1.__importDefault(require("../tree/expression"));
-var ruleset_1 = tslib_1.__importDefault(require("../tree/ruleset"));
-var selector_1 = tslib_1.__importDefault(require("../tree/selector"));
-var element_1 = tslib_1.__importDefault(require("../tree/element"));
-var quoted_1 = tslib_1.__importDefault(require("../tree/quoted"));
-var value_1 = tslib_1.__importDefault(require("../tree/value"));
-var getItemsFromNode = function (node) {
+import Comment from '../tree/comment.js';
+import Node from '../tree/node.js';
+import Dimension from '../tree/dimension.js';
+import Declaration from '../tree/declaration.js';
+import Expression from '../tree/expression.js';
+import Ruleset from '../tree/ruleset.js';
+import Selector from '../tree/selector.js';
+import Element from '../tree/element.js';
+import Quote from '../tree/quoted.js';
+import Value from '../tree/value.js';
+
+const getItemsFromNode = node => {
     // handle non-array values as an array of length 1
     // return 'undefined' if index is invalid
-    var items = Array.isArray(node.value) ?
+    const items = Array.isArray(node.value) ?
         node.value : Array(node);
+
     return items;
 };
-exports.default = {
-    _SELF: function (n) {
+
+export default {
+    _SELF: function(n) {
         return n;
     },
-    '~': function () {
-        var expr = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            expr[_i] = arguments[_i];
-        }
+    '~': function(...expr) {
         if (expr.length === 1) {
             return expr[0];
         }
-        return new value_1.default(expr);
+        return new Value(expr);
     },
-    extract: function (values, index) {
+    extract: function(values, index) {
         // (1-based index)
         index = index.value - 1;
+
         return getItemsFromNode(values)[index];
     },
-    length: function (values) {
-        return new dimension_1.default(getItemsFromNode(values).length);
+    length: function(values) {
+        return new Dimension(getItemsFromNode(values).length);
     },
     /**
      * Creates a Less list of incremental values.
      * Modeled after Lodash's range function, also exists natively in PHP
-     *
+     * 
      * @param {Dimension} [start=1]
      * @param {Dimension} end  - e.g. 10 or 10px - unit is added to output
-     * @param {Dimension} [step=1]
+     * @param {Dimension} [step=1] 
      */
-    range: function (start, end, step) {
-        var from;
-        var to;
-        var stepValue = 1;
-        var list = [];
+    range: function(start, end, step) {
+        let from;
+        let to;
+        let stepValue = 1;
+        const list = [];
         if (end) {
             to = end;
             from = start.value;
@@ -64,82 +61,98 @@ exports.default = {
             from = 1;
             to = start;
         }
-        for (var i = from; i <= to.value; i += stepValue) {
-            list.push(new dimension_1.default(i, to.unit));
+
+        for (let i = from; i <= to.value; i += stepValue) {
+            list.push(new Dimension(i, to.unit));
         }
-        return new expression_1.default(list);
+
+        return new Expression(list);
     },
-    each: function (list, rs) {
-        var _this = this;
-        var rules = [];
-        var newRules;
-        var iterator;
-        var tryEval = function (val) {
-            if (val instanceof node_1.default) {
-                return val.eval(_this.context);
+    each: function(list, rs) {
+        const rules = [];
+        let newRules;
+        let iterator;
+
+        const tryEval = val => {
+            if (val instanceof Node) {
+                return val.eval(this.context);
             }
             return val;
         };
-        if (list.value && !(list instanceof quoted_1.default)) {
+
+        if (list.value && !(list instanceof Quote)) {
             if (Array.isArray(list.value)) {
                 iterator = list.value.map(tryEval);
-            }
-            else {
+            } else {
                 iterator = [tryEval(list.value)];
             }
-        }
-        else if (list.ruleset) {
+        } else if (list.ruleset) {
             iterator = tryEval(list.ruleset).rules;
-        }
-        else if (list.rules) {
+        } else if (list.rules) {
             iterator = list.rules.map(tryEval);
-        }
-        else if (Array.isArray(list)) {
+        } else if (Array.isArray(list)) {
             iterator = list.map(tryEval);
-        }
-        else {
+        } else {
             iterator = [tryEval(list)];
         }
-        var valueName = '@value';
-        var keyName = '@key';
-        var indexName = '@index';
+
+        let valueName = '@value';
+        let keyName = '@key';
+        let indexName = '@index';
+
         if (rs.params) {
             valueName = rs.params[0] && rs.params[0].name;
             keyName = rs.params[1] && rs.params[1].name;
             indexName = rs.params[2] && rs.params[2].name;
             rs = rs.rules;
-        }
-        else {
+        } else {
             rs = rs.ruleset;
         }
-        for (var i = 0; i < iterator.length; i++) {
-            var key = void 0;
-            var value = void 0;
-            var item = iterator[i];
-            if (item instanceof declaration_1.default) {
+
+        for (let i = 0; i < iterator.length; i++) {
+            let key;
+            let value;
+            const item = iterator[i];
+            if (item instanceof Declaration) {
                 key = typeof item.name === 'string' ? item.name : item.name[0].value;
                 value = item.value;
-            }
-            else {
-                key = new dimension_1.default(i + 1);
+            } else {
+                key = new Dimension(i + 1);
                 value = item;
             }
-            if (item instanceof comment_1.default) {
+
+            if (item instanceof Comment) {
                 continue;
             }
+
             newRules = rs.rules.slice(0);
             if (valueName) {
-                newRules.push(new declaration_1.default(valueName, value, false, false, this.index, this.currentFileInfo));
+                newRules.push(new Declaration(valueName,
+                    value,
+                    false, false, this.index, this.currentFileInfo));
             }
             if (indexName) {
-                newRules.push(new declaration_1.default(indexName, new dimension_1.default(i + 1), false, false, this.index, this.currentFileInfo));
+                newRules.push(new Declaration(indexName,
+                    new Dimension(i + 1),
+                    false, false, this.index, this.currentFileInfo));
             }
             if (keyName) {
-                newRules.push(new declaration_1.default(keyName, key, false, false, this.index, this.currentFileInfo));
+                newRules.push(new Declaration(keyName,
+                    key,
+                    false, false, this.index, this.currentFileInfo));
             }
-            rules.push(new ruleset_1.default([new (selector_1.default)([new element_1.default('', '&')])], newRules, rs.strictImports, rs.visibilityInfo()));
+
+            rules.push(new Ruleset([ new(Selector)([ new Element('', '&') ]) ],
+                newRules,
+                rs.strictImports,
+                rs.visibilityInfo()
+            ));
         }
-        return new ruleset_1.default([new (selector_1.default)([new element_1.default('', '&')])], rules, rs.strictImports, rs.visibilityInfo()).eval(this.context);
+
+        return new Ruleset([ new(Selector)([ new Element('', '&') ]) ],
+            rules,
+            rs.strictImports,
+            rs.visibilityInfo()
+        ).eval(this.context);
     }
 };
-//# sourceMappingURL=list.js.map

package/lib/less/functions/math-helper.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var dimension_1 = tslib_1.__importDefault(require("../tree/dimension"));
-var MathHelper = function (fn, unit, n) {
-    if (!(n instanceof dimension_1.default)) {
+import Dimension from '../tree/dimension.js';
+
+const MathHelper = (fn, unit, n) => {
+    if (!(n instanceof Dimension)) {
         throw { type: 'Argument', message: 'argument must be a number' };
     }
     if (unit === null) {
         unit = n.unit;
-    }
-    else {
+    } else {
         n = n.unify();
     }
-    return new dimension_1.default(fn(parseFloat(n.value)), unit);
+    return new Dimension(fn(parseFloat(n.value)), unit);
 };
-exports.default = MathHelper;
-//# sourceMappingURL=math-helper.js.map
+
+export default MathHelper;

package/lib/less/functions/math.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var math_helper_js_1 = tslib_1.__importDefault(require("./math-helper.js"));
-var mathFunctions = {
+import mathHelper from './math-helper.js';
+
+const mathFunctions = {
     // name,  unit
-    ceil: null,
+    ceil:  null,
     floor: null,
-    sqrt: null,
-    abs: null,
-    tan: '',
-    sin: '',
-    cos: '',
-    atan: 'rad',
-    asin: 'rad',
-    acos: 'rad'
+    sqrt:  null,
+    abs:   null,
+    tan:   '',
+    sin:   '',
+    cos:   '',
+    atan:  'rad',
+    asin:  'rad',
+    acos:  'rad'
 };
-for (var f in mathFunctions) {
+
+for (const f in mathFunctions) {
     // eslint-disable-next-line no-prototype-builtins
     if (mathFunctions.hasOwnProperty(f)) {
-        mathFunctions[f] = math_helper_js_1.default.bind(null, Math[f], mathFunctions[f]);
+        mathFunctions[f] = mathHelper.bind(null, Math[f], mathFunctions[f]);
     }
 }
-mathFunctions.round = function (n, f) {
-    var fraction = typeof f === 'undefined' ? 0 : f.value;
-    return (0, math_helper_js_1.default)(function (num) { return num.toFixed(fraction); }, null, n);
+
+mathFunctions.round = (n, f) => {
+    const fraction = typeof f === 'undefined' ? 0 : f.value;
+    return mathHelper(num => num.toFixed(fraction), null, n);
 };
-exports.default = mathFunctions;
-//# sourceMappingURL=math.js.map
+
+export default mathFunctions;