less 4.5.1 → 4.6.1

package/lib/less/functions/color.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var dimension_1 = tslib_1.__importDefault(require("../tree/dimension"));
-var color_1 = tslib_1.__importDefault(require("../tree/color"));
-var quoted_1 = tslib_1.__importDefault(require("../tree/quoted"));
-var anonymous_1 = tslib_1.__importDefault(require("../tree/anonymous"));
-var expression_1 = tslib_1.__importDefault(require("../tree/expression"));
-var operation_1 = tslib_1.__importDefault(require("../tree/operation"));
-var colorFunctions;
+import Dimension from '../tree/dimension.js';
+import Color from '../tree/color.js';
+import Quoted from '../tree/quoted.js';
+import Anonymous from '../tree/anonymous.js';
+import Expression from '../tree/expression.js';
+import Operation from '../tree/operation.js';
+let colorFunctions;
+
 function clamp(val) {
     return Math.min(1, Math.max(0, val));
 }
 function hsla(origColor, hsl) {
-    var color = colorFunctions.hsla(hsl.h, hsl.s, hsl.l, hsl.a);
+    const color = colorFunctions.hsla(hsl.h, hsl.s, hsl.l, hsl.a);
     if (color) {
-        if (origColor.value &&
+        if (origColor.value && 
             /^(rgb|hsl)/.test(origColor.value)) {
             color.value = origColor.value;
-        }
-        else {
+        } else {
             color.value = 'rgb';
         }
         return color;
@@ -27,27 +24,25 @@ function hsla(origColor, hsl) {
 function toHSL(color) {
     if (color.toHSL) {
         return color.toHSL();
-    }
-    else {
+    } else {
         throw new Error('Argument cannot be evaluated to a color');
     }
 }
+
 function toHSV(color) {
     if (color.toHSV) {
         return color.toHSV();
-    }
-    else {
+    } else {
         throw new Error('Argument cannot be evaluated to a color');
     }
 }
+
 function number(n) {
-    if (n instanceof dimension_1.default) {
+    if (n instanceof Dimension) {
         return parseFloat(n.unit.is('%') ? n.value / 100 : n.value);
-    }
-    else if (typeof n === 'number') {
+    } else if (typeof n === 'number') {
         return n;
-    }
-    else {
+    } else {
         throw {
             type: 'Argument',
             message: 'color functions take numbers as parameters'
@@ -55,36 +50,35 @@ function number(n) {
     }
 }
 function scaled(n, size) {
-    if (n instanceof dimension_1.default && n.unit.is('%')) {
+    if (n instanceof Dimension && n.unit.is('%')) {
         return parseFloat(n.value * size / 100);
-    }
-    else {
+    } else {
         return number(n);
     }
 }
 colorFunctions = {
     rgb: function (r, g, b) {
-        var a = 1;
+        let a = 1
         /**
          * Comma-less syntax
          *   e.g. rgb(0 128 255 / 50%)
          */
-        if (r instanceof expression_1.default) {
-            var val = r.value;
-            r = val[0];
-            g = val[1];
-            b = val[2];
-            /**
+        if (r instanceof Expression) {
+            const val = r.value
+            r = val[0]
+            g = val[1]
+            b = val[2]
+            /** 
              * @todo - should this be normalized in
              *   function caller? Or parsed differently?
              */
-            if (b instanceof operation_1.default) {
-                var op = b;
-                b = op.operands[0];
-                a = op.operands[1];
+            if (b instanceof Operation) {
+                const op = b
+                b = op.operands[0]
+                a = op.operands[1]
             }
         }
-        var color = colorFunctions.rgba(r, g, b, a);
+        const color = colorFunctions.rgba(r, g, b, a);
         if (color) {
             color.value = 'rgb';
             return color;
@@ -92,43 +86,44 @@ colorFunctions = {
     },
     rgba: function (r, g, b, a) {
         try {
-            if (r instanceof color_1.default) {
+            if (r instanceof Color) {
                 if (g) {
                     a = number(g);
-                }
-                else {
+                } else {
                     a = r.alpha;
                 }
-                return new color_1.default(r.rgb, a, 'rgba');
+                return new Color(r.rgb, a, 'rgba');
             }
-            var rgb = [r, g, b].map(function (c) { return scaled(c, 255); });
+            const rgb = [r, g, b].map(c => scaled(c, 255));
             a = number(a);
-            return new color_1.default(rgb, a, 'rgba');
+            return new Color(rgb, a, 'rgba');
         }
-        catch (e) { }
+        catch (e) {}
     },
     hsl: function (h, s, l) {
-        var a = 1;
-        if (h instanceof expression_1.default) {
-            var val = h.value;
-            h = val[0];
-            s = val[1];
-            l = val[2];
-            if (l instanceof operation_1.default) {
-                var op = l;
-                l = op.operands[0];
-                a = op.operands[1];
+        let a = 1
+        if (h instanceof Expression) {
+            const val = h.value
+            h = val[0]
+            s = val[1]
+            l = val[2]
+
+            if (l instanceof Operation) {
+                const op = l
+                l = op.operands[0]
+                a = op.operands[1]
             }
         }
-        var color = colorFunctions.hsla(h, s, l, a);
+        const color = colorFunctions.hsla(h, s, l, a);
         if (color) {
             color.value = 'hsl';
             return color;
         }
     },
     hsla: function (h, s, l, a) {
-        var m1;
-        var m2;
+        let m1;
+        let m2;
+
         function hue(h) {
             h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
             if (h * 6 < 1) {
@@ -144,94 +139,104 @@ colorFunctions = {
                 return m1;
             }
         }
+
         try {
-            if (h instanceof color_1.default) {
+            if (h instanceof Color) {
                 if (s) {
                     a = number(s);
-                }
-                else {
+                } else {
                     a = h.alpha;
                 }
-                return new color_1.default(h.rgb, a, 'hsla');
+                return new Color(h.rgb, a, 'hsla');
             }
+
             h = (number(h) % 360) / 360;
-            s = clamp(number(s));
-            l = clamp(number(l));
-            a = clamp(number(a));
+            s = clamp(number(s));l = clamp(number(l));a = clamp(number(a));
+
             m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
             m1 = l * 2 - m2;
-            var rgb = [
+
+            const rgb = [
                 hue(h + 1 / 3) * 255,
-                hue(h) * 255,
+                hue(h)       * 255,
                 hue(h - 1 / 3) * 255
             ];
             a = number(a);
-            return new color_1.default(rgb, a, 'hsla');
+            return new Color(rgb, a, 'hsla');
         }
-        catch (e) { }
+        catch (e) {}
     },
-    hsv: function (h, s, v) {
+
+    hsv: function(h, s, v) {
         return colorFunctions.hsva(h, s, v, 1.0);
     },
-    hsva: function (h, s, v, a) {
+
+    hsva: function(h, s, v, a) {
         h = ((number(h) % 360) / 360) * 360;
-        s = number(s);
-        v = number(v);
-        a = number(a);
-        var i;
-        var f;
+        s = number(s);v = number(v);a = number(a);
+
+        let i;
+        let f;
         i = Math.floor((h / 60) % 6);
         f = (h / 60) - i;
-        var vs = [v,
+
+        const vs = [v,
             v * (1 - s),
             v * (1 - f * s),
             v * (1 - (1 - f) * s)];
-        var perm = [[0, 3, 1],
+        const perm = [[0, 3, 1],
             [2, 0, 1],
             [1, 0, 3],
             [1, 2, 0],
             [3, 1, 0],
             [0, 1, 2]];
-        return colorFunctions.rgba(vs[perm[i][0]] * 255, vs[perm[i][1]] * 255, vs[perm[i][2]] * 255, a);
+
+        return colorFunctions.rgba(vs[perm[i][0]] * 255,
+            vs[perm[i][1]] * 255,
+            vs[perm[i][2]] * 255,
+            a);
     },
+
     hue: function (color) {
-        return new dimension_1.default(toHSL(color).h);
+        return new Dimension(toHSL(color).h);
     },
     saturation: function (color) {
-        return new dimension_1.default(toHSL(color).s * 100, '%');
+        return new Dimension(toHSL(color).s * 100, '%');
     },
     lightness: function (color) {
-        return new dimension_1.default(toHSL(color).l * 100, '%');
+        return new Dimension(toHSL(color).l * 100, '%');
     },
-    hsvhue: function (color) {
-        return new dimension_1.default(toHSV(color).h);
+    hsvhue: function(color) {
+        return new Dimension(toHSV(color).h);
     },
     hsvsaturation: function (color) {
-        return new dimension_1.default(toHSV(color).s * 100, '%');
+        return new Dimension(toHSV(color).s * 100, '%');
     },
     hsvvalue: function (color) {
-        return new dimension_1.default(toHSV(color).v * 100, '%');
+        return new Dimension(toHSV(color).v * 100, '%');
     },
     red: function (color) {
-        return new dimension_1.default(color.rgb[0]);
+        return new Dimension(color.rgb[0]);
     },
     green: function (color) {
-        return new dimension_1.default(color.rgb[1]);
+        return new Dimension(color.rgb[1]);
     },
     blue: function (color) {
-        return new dimension_1.default(color.rgb[2]);
+        return new Dimension(color.rgb[2]);
     },
     alpha: function (color) {
-        return new dimension_1.default(toHSL(color).a);
+        return new Dimension(toHSL(color).a);
     },
     luma: function (color) {
-        return new dimension_1.default(color.luma() * color.alpha * 100, '%');
+        return new Dimension(color.luma() * color.alpha * 100, '%');
     },
     luminance: function (color) {
-        var luminance = (0.2126 * color.rgb[0] / 255) +
-            (0.7152 * color.rgb[1] / 255) +
-            (0.0722 * color.rgb[2] / 255);
-        return new dimension_1.default(luminance * color.alpha * 100, '%');
+        const luminance =
+            (0.2126 * color.rgb[0] / 255) +
+                (0.7152 * color.rgb[1] / 255) +
+                (0.0722 * color.rgb[2] / 255);
+
+        return new Dimension(luminance * color.alpha * 100, '%');
     },
     saturate: function (color, amount, method) {
         // filter: saturate(3.2);
@@ -239,9 +244,10 @@ colorFunctions = {
         if (!color.rgb) {
             return null;
         }
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.s += hsl.s * amount.value / 100;
+            hsl.s +=  hsl.s * amount.value / 100;
         }
         else {
             hsl.s += amount.value / 100;
@@ -250,9 +256,10 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     desaturate: function (color, amount, method) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.s -= hsl.s * amount.value / 100;
+            hsl.s -=  hsl.s * amount.value / 100;
         }
         else {
             hsl.s -= amount.value / 100;
@@ -261,9 +268,10 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     lighten: function (color, amount, method) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.l += hsl.l * amount.value / 100;
+            hsl.l +=  hsl.l * amount.value / 100;
         }
         else {
             hsl.l += amount.value / 100;
@@ -272,9 +280,10 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     darken: function (color, amount, method) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.l -= hsl.l * amount.value / 100;
+            hsl.l -=  hsl.l * amount.value / 100;
         }
         else {
             hsl.l -= amount.value / 100;
@@ -283,9 +292,10 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     fadein: function (color, amount, method) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.a += hsl.a * amount.value / 100;
+            hsl.a +=  hsl.a * amount.value / 100;
         }
         else {
             hsl.a += amount.value / 100;
@@ -294,9 +304,10 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     fadeout: function (color, amount, method) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         if (typeof method !== 'undefined' && method.value === 'relative') {
-            hsl.a -= hsl.a * amount.value / 100;
+            hsl.a -=  hsl.a * amount.value / 100;
         }
         else {
             hsl.a -= amount.value / 100;
@@ -305,15 +316,18 @@ colorFunctions = {
         return hsla(color, hsl);
     },
     fade: function (color, amount) {
-        var hsl = toHSL(color);
+        const hsl = toHSL(color);
+
         hsl.a = amount.value / 100;
         hsl.a = clamp(hsl.a);
         return hsla(color, hsl);
     },
     spin: function (color, amount) {
-        var hsl = toHSL(color);
-        var hue = (hsl.h + amount.value) % 360;
+        const hsl = toHSL(color);
+        const hue = (hsl.h + amount.value) % 360;
+
         hsl.h = hue < 0 ? 360 + hue : hue;
+
         return hsla(color, hsl);
     },
     //
@@ -322,21 +336,25 @@ colorFunctions = {
     //
     mix: function (color1, color2, weight) {
         if (!weight) {
-            weight = new dimension_1.default(50);
-        }
-        var p = weight.value / 100.0;
-        var w = p * 2 - 1;
-        var a = toHSL(color1).a - toHSL(color2).a;
-        var w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
-        var w2 = 1 - w1;
-        var rgb = [color1.rgb[0] * w1 + color2.rgb[0] * w2,
+            weight = new Dimension(50);
+        }
+        const p = weight.value / 100.0;
+        const w = p * 2 - 1;
+        const a = toHSL(color1).a - toHSL(color2).a;
+
+        const w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+        const w2 = 1 - w1;
+
+        const rgb = [color1.rgb[0] * w1 + color2.rgb[0] * w2,
             color1.rgb[1] * w1 + color2.rgb[1] * w2,
             color1.rgb[2] * w1 + color2.rgb[2] * w2];
-        var alpha = color1.alpha * p + color2.alpha * (1 - p);
-        return new color_1.default(rgb, alpha);
+
+        const alpha = color1.alpha * p + color2.alpha * (1 - p);
+
+        return new Color(rgb, alpha);
     },
     greyscale: function (color) {
-        return colorFunctions.desaturate(color, new dimension_1.default(100));
+        return colorFunctions.desaturate(color, new Dimension(100));
     },
     contrast: function (color, dark, light, threshold) {
         // filter: contrast(3.2);
@@ -352,20 +370,18 @@ colorFunctions = {
         }
         // Figure out which is actually light and dark:
         if (dark.luma() > light.luma()) {
-            var t = light;
+            const t = light;
             light = dark;
             dark = t;
         }
         if (typeof threshold === 'undefined') {
             threshold = 0.43;
-        }
-        else {
+        } else {
             threshold = number(threshold);
         }
         if (color.luma() < threshold) {
             return light;
-        }
-        else {
+        } else {
             return dark;
         }
     },
@@ -408,29 +424,29 @@ colorFunctions = {
     //     }
     // },
     argb: function (color) {
-        return new anonymous_1.default(color.toARGB());
+        return new Anonymous(color.toARGB());
     },
-    color: function (c) {
-        if ((c instanceof quoted_1.default) &&
+    color: function(c) {
+        if ((c instanceof Quoted) &&
             (/^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3,4})$/i.test(c.value))) {
-            var val = c.value.slice(1);
-            return new color_1.default(val, undefined, "#".concat(val));
+            const val = c.value.slice(1);
+            return new Color(val, undefined, `#${val}`);
         }
-        if ((c instanceof color_1.default) || (c = color_1.default.fromKeyword(c.value))) {
+        if ((c instanceof Color) || (c = Color.fromKeyword(c.value))) {
             c.value = undefined;
             return c;
         }
         throw {
-            type: 'Argument',
+            type:    'Argument',
             message: 'argument must be a color keyword or 3|4|6|8 digit hex e.g. #FFF'
         };
     },
-    tint: function (color, amount) {
+    tint: function(color, amount) {
         return colorFunctions.mix(colorFunctions.rgb(255, 255, 255), color, amount);
     },
-    shade: function (color, amount) {
+    shade: function(color, amount) {
         return colorFunctions.mix(colorFunctions.rgb(0, 0, 0), color, amount);
     }
 };
-exports.default = colorFunctions;
-//# sourceMappingURL=color.js.map
+
+export default colorFunctions;

package/lib/less/functions/data-uri.js

@@ -1,65 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var quoted_1 = tslib_1.__importDefault(require("../tree/quoted"));
-var url_1 = tslib_1.__importDefault(require("../tree/url"));
-var utils = tslib_1.__importStar(require("../utils"));
-var logger_1 = tslib_1.__importDefault(require("../logger"));
-exports.default = (function (environment) {
-    var fallback = function (functionThis, node) { return new url_1.default(node, functionThis.index, functionThis.currentFileInfo).eval(functionThis.context); };
-    return { 'data-uri': function (mimetypeNode, filePathNode) {
-            if (!filePathNode) {
-                filePathNode = mimetypeNode;
-                mimetypeNode = null;
+import Quoted from '../tree/quoted.js';
+import URL from '../tree/url.js';
+import * as utils from '../utils.js';
+import logger from '../logger.js';
+
+export default environment => {
+    
+    const fallback = (functionThis, node) => new URL(node, functionThis.index, functionThis.currentFileInfo).eval(functionThis.context);    
+
+    return { 'data-uri': function(mimetypeNode, filePathNode) {
+
+        if (!filePathNode) {
+            filePathNode = mimetypeNode;
+            mimetypeNode = null;
+        }
+
+        let mimetype = mimetypeNode && mimetypeNode.value;
+        let filePath = filePathNode.value;
+        const currentFileInfo = this.currentFileInfo;
+        const currentDirectory = currentFileInfo.rewriteUrls ?
+            currentFileInfo.currentDirectory : currentFileInfo.entryPath;
+
+        const fragmentStart = filePath.indexOf('#');
+        let fragment = '';
+        if (fragmentStart !== -1) {
+            fragment = filePath.slice(fragmentStart);
+            filePath = filePath.slice(0, fragmentStart);
+        }
+        const context = utils.clone(this.context);
+        context.rawBuffer = true;
+
+        const fileManager = environment.getFileManager(filePath, currentDirectory, context, environment, true);
+
+        if (!fileManager) {
+            return fallback(this, filePathNode);
+        }
+
+        let useBase64 = false;
+
+        // detect the mimetype if not given
+        if (!mimetypeNode) {
+
+            mimetype = environment.mimeLookup(filePath);
+
+            if (mimetype === 'image/svg+xml') {
+                useBase64 = false;
+            } else {
+                // use base 64 unless it's an ASCII or UTF-8 format
+                const charset = environment.charsetLookup(mimetype);
+                useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0;
             }
-            var mimetype = mimetypeNode && mimetypeNode.value;
-            var filePath = filePathNode.value;
-            var currentFileInfo = this.currentFileInfo;
-            var currentDirectory = currentFileInfo.rewriteUrls ?
-                currentFileInfo.currentDirectory : currentFileInfo.entryPath;
-            var fragmentStart = filePath.indexOf('#');
-            var fragment = '';
-            if (fragmentStart !== -1) {
-                fragment = filePath.slice(fragmentStart);
-                filePath = filePath.slice(0, fragmentStart);
-            }
-            var context = utils.clone(this.context);
-            context.rawBuffer = true;
-            var fileManager = environment.getFileManager(filePath, currentDirectory, context, environment, true);
-            if (!fileManager) {
-                return fallback(this, filePathNode);
-            }
-            var useBase64 = false;
-            // detect the mimetype if not given
-            if (!mimetypeNode) {
-                mimetype = environment.mimeLookup(filePath);
-                if (mimetype === 'image/svg+xml') {
-                    useBase64 = false;
-                }
-                else {
-                    // use base 64 unless it's an ASCII or UTF-8 format
-                    var charset = environment.charsetLookup(mimetype);
-                    useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0;
-                }
-                if (useBase64) {
-                    mimetype += ';base64';
-                }
-            }
-            else {
-                useBase64 = /;base64$/.test(mimetype);
-            }
-            var fileSync = fileManager.loadFileSync(filePath, currentDirectory, context, environment);
-            if (!fileSync.contents) {
-                logger_1.default.warn("Skipped data-uri embedding of ".concat(filePath, " because file not found"));
-                return fallback(this, filePathNode || mimetypeNode);
-            }
-            var buf = fileSync.contents;
-            if (useBase64 && !environment.encodeBase64) {
-                return fallback(this, filePathNode);
-            }
-            buf = useBase64 ? environment.encodeBase64(buf) : encodeURIComponent(buf);
-            var uri = "data:".concat(mimetype, ",").concat(buf).concat(fragment);
-            return new url_1.default(new quoted_1.default("\"".concat(uri, "\""), uri, false, this.index, this.currentFileInfo), this.index, this.currentFileInfo);
-        } };
-});
-//# sourceMappingURL=data-uri.js.map
+            if (useBase64) { mimetype += ';base64'; }
+        }
+        else {
+            useBase64 = /;base64$/.test(mimetype);
+        }
+
+        const fileSync = fileManager.loadFileSync(filePath, currentDirectory, context, environment);
+        if (!fileSync.contents) {
+            logger.warn(`Skipped data-uri embedding of ${filePath} because file not found`);
+            return fallback(this, filePathNode || mimetypeNode);
+        }
+        let buf = fileSync.contents;
+        if (useBase64 && !environment.encodeBase64) {
+            return fallback(this, filePathNode);
+        }
+
+        buf = useBase64 ? environment.encodeBase64(buf) : encodeURIComponent(buf);
+
+        const uri = `data:${mimetype},${buf}${fragment}`;
+
+        return new URL(new Quoted(`"${uri}"`, uri, false, this.index, this.currentFileInfo), this.index, this.currentFileInfo);
+    }};
+};