less 3.10.0-beta.2 → 3.10.3

package/lib/less/functions/list.js

@@ -0,0 +1,143 @@
+import Comment from '../tree/comment';
+import Dimension from '../tree/dimension';
+import Declaration from '../tree/declaration';
+import Expression from '../tree/expression';
+import Ruleset from '../tree/ruleset';
+import Selector from '../tree/selector';
+import Element from '../tree/element';
+import Quote from '../tree/quoted';
+
+const getItemsFromNode = node => {
+    // handle non-array values as an array of length 1
+    // return 'undefined' if index is invalid
+    const items = Array.isArray(node.value) ?
+        node.value : Array(node);
+
+    return items;
+};
+
+export default {
+    _SELF: function(n) {
+        return n;
+    },
+    extract: function(values, index) {
+        // (1-based index)
+        index = index.value - 1;
+
+        return getItemsFromNode(values)[index];
+    },
+    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] 
+     */
+    range: function(start, end, step) {
+        let from;
+        let to;
+        let stepValue = 1;
+        const list = [];
+        if (end) {
+            to = end;
+            from = start.value;
+            if (step) {
+                stepValue = step.value;
+            }
+        }
+        else {
+            from = 1;
+            to = start;
+        }
+
+        for (let i = from; i <= to.value; i += stepValue) {
+            list.push(new Dimension(i, to.unit));
+        }
+
+        return new Expression(list);
+    },
+    each: function(list, rs) {
+        const rules = [];
+        let newRules;
+        let iterator;
+
+        if (list.value && !(list instanceof Quote)) {
+            if (Array.isArray(list.value)) {
+                iterator = list.value;
+            } else {
+                iterator = [list.value];
+            }
+        } else if (list.ruleset) {
+            iterator = list.ruleset.rules;
+        } else if (list.rules) {
+            iterator = list.rules;
+        } else if (Array.isArray(list)) {
+            iterator = list;
+        } else {
+            iterator = [list];
+        }
+
+        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 {
+            rs = rs.ruleset;
+        }
+
+        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(i + 1);
+                value = item;
+            }
+
+            if (item instanceof Comment) {
+                continue;
+            }
+
+            newRules = rs.rules.slice(0);
+            if (valueName) {
+                newRules.push(new Declaration(valueName,
+                    value,
+                    false, false, this.index, this.currentFileInfo));
+            }
+            if (indexName) {
+                newRules.push(new Declaration(indexName,
+                    new Dimension(i + 1),
+                    false, false, this.index, this.currentFileInfo));
+            }
+            if (keyName) {
+                newRules.push(new Declaration(keyName,
+                    key,
+                    false, false, this.index, this.currentFileInfo));
+            }
+
+            rules.push(new Ruleset([ new(Selector)([ new Element("", '&') ]) ],
+                newRules,
+                rs.strictImports,
+                rs.visibilityInfo()
+            ));
+        }
+
+        return new Ruleset([ new(Selector)([ new Element("", '&') ]) ],
+            rules,
+            rs.strictImports,
+            rs.visibilityInfo()
+        ).eval(this.context);
+    }
+};

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

@@ -0,0 +1,15 @@
+import Dimension from '../tree/dimension';
+
+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 {
+        n = n.unify();
+    }
+    return new Dimension(fn(parseFloat(n.value)), unit);
+};
+
+export default MathHelper;

package/lib/less/functions/math.js

@@ -0,0 +1,28 @@
+import mathHelper from './math-helper.js';
+
+const mathFunctions = {
+    // name,  unit
+    ceil:  null,
+    floor: null,
+    sqrt:  null,
+    abs:   null,
+    tan:   '',
+    sin:   '',
+    cos:   '',
+    atan:  'rad',
+    asin:  'rad',
+    acos:  'rad'
+};
+
+for (const f in mathFunctions) {
+    if (mathFunctions.hasOwnProperty(f)) {
+        mathFunctions[f] = mathHelper.bind(null, Math[f], mathFunctions[f]);
+    }
+}
+
+mathFunctions.round = (n, f) => {
+    const fraction = typeof f === 'undefined' ? 0 : f.value;
+    return mathHelper(num => num.toFixed(fraction), null, n);
+};
+
+export default mathFunctions;

package/lib/less/functions/number.js

@@ -0,0 +1,89 @@
+import Dimension from '../tree/dimension';
+import Anonymous from '../tree/anonymous';
+import mathHelper from './math-helper.js';
+
+const minMax = function (isMin, args) {
+    args = Array.prototype.slice.call(args);
+    switch (args.length) {
+        case 0: throw { type: 'Argument', message: 'one or more arguments required' };
+    }
+    let i; // key is the unit.toString() for unified Dimension values,
+    let j;
+    let current;
+    let currentUnified;
+    let referenceUnified;
+    let unit;
+    let unitStatic;
+    let unitClone;
+
+    const // elems only contains original argument values.
+        order  = [];
+
+    const values = {};
+    // value is the index into the order array.
+    for (i = 0; i < args.length; i++) {
+        current = args[i];
+        if (!(current instanceof Dimension)) {
+            if (Array.isArray(args[i].value)) {
+                Array.prototype.push.apply(args, Array.prototype.slice.call(args[i].value));
+            }
+            continue;
+        }
+        currentUnified = current.unit.toString() === '' && unitClone !== undefined ? new Dimension(current.value, unitClone).unify() : current.unify();
+        unit = currentUnified.unit.toString() === '' && unitStatic !== undefined ? unitStatic : currentUnified.unit.toString();
+        unitStatic = unit !== '' && unitStatic === undefined || unit !== '' && order[0].unify().unit.toString() === '' ? unit : unitStatic;
+        unitClone = unit !== '' && unitClone === undefined ? current.unit.toString() : unitClone;
+        j = values[''] !== undefined && unit !== '' && unit === unitStatic ? values[''] : values[unit];
+        if (j === undefined) {
+            if (unitStatic !== undefined && unit !== unitStatic) {
+                throw { type: 'Argument', message: 'incompatible types' };
+            }
+            values[unit] = order.length;
+            order.push(current);
+            continue;
+        }
+        referenceUnified = order[j].unit.toString() === '' && unitClone !== undefined ? new Dimension(order[j].value, unitClone).unify() : order[j].unify();
+        if ( isMin && currentUnified.value < referenceUnified.value ||
+            !isMin && currentUnified.value > referenceUnified.value) {
+            order[j] = current;
+        }
+    }
+    if (order.length == 1) {
+        return order[0];
+    }
+    args = order.map(function (a) { return a.toCSS(this.context); }).join(this.context.compress ? ',' : ', ');
+    return new Anonymous(`${isMin ? 'min' : 'max'}(${args})`);
+};
+
+export default {
+    min: function(...args) {
+        return minMax(true, args);
+    },
+    max: function(...args) {
+        return minMax(false, args);
+    },
+    convert: function (val, unit) {
+        return val.convertTo(unit.value);
+    },
+    pi: function () {
+        return new Dimension(Math.PI);
+    },
+    mod: function(a, b) {
+        return new Dimension(a.value % b.value, a.unit);
+    },
+    pow: function(x, y) {
+        if (typeof x === 'number' && typeof y === 'number') {
+            x = new Dimension(x);
+            y = new Dimension(y);
+        } else if (!(x instanceof Dimension) || !(y instanceof Dimension)) {
+            throw { type: 'Argument', message: 'arguments must be numbers' };
+        }
+
+        return new Dimension(Math.pow(x.value, y.value), x.unit);
+    },
+    percentage: function (n) {
+        const result = mathHelper(num => num * 100, '%', n);
+
+        return result;
+    }
+};

package/lib/less/functions/string.js

@@ -0,0 +1,36 @@
+import Quoted from '../tree/quoted';
+import Anonymous from '../tree/anonymous';
+import JavaScript from '../tree/javascript';
+
+export default {
+    e: function (str) {
+        return new Quoted('"', str instanceof JavaScript ? str.evaluated : str.value, true);
+    },
+    escape: function (str) {
+        return new Anonymous(
+            encodeURI(str.value).replace(/=/g, '%3D').replace(/:/g, '%3A').replace(/#/g, '%23').replace(/;/g, '%3B')
+                .replace(/\(/g, '%28').replace(/\)/g, '%29'));
+    },
+    replace: function (string, pattern, replacement, flags) {
+        let result = string.value;
+        replacement = (replacement.type === 'Quoted') ?
+            replacement.value : replacement.toCSS();
+        result = result.replace(new RegExp(pattern.value, flags ? flags.value : ''), replacement);
+        return new Quoted(string.quote || '', result, string.escaped);
+    },
+    '%': function (string /* arg, arg, ... */) {
+        const args = Array.prototype.slice.call(arguments, 1);
+        let result = string.value;
+
+        for (let i = 0; i < args.length; i++) {
+            /* jshint loopfunc:true */
+            result = result.replace(/%[sda]/i, token => {
+                const value = ((args[i].type === 'Quoted') &&
+                    token.match(/s/i)) ? args[i].value : args[i].toCSS();
+                return token.match(/[A-Z]$/) ? encodeURIComponent(value) : value;
+            });
+        }
+        result = result.replace(/%%/g, '%');
+        return new Quoted(string.quote || '', result, string.escaped);
+    }
+};

package/lib/less/functions/svg.js

@@ -0,0 +1,87 @@
+import Dimension from '../tree/dimension';
+import Color from '../tree/color';
+import Expression from '../tree/expression';
+import Quoted from '../tree/quoted';
+import URL from '../tree/url';
+
+export default environment => {
+    return { 'svg-gradient': function(direction) {
+        let stops;
+        let gradientDirectionSvg;
+        let gradientType = 'linear';
+        let rectangleDimension = 'x="0" y="0" width="1" height="1"';
+        const renderEnv = {compress: false};
+        let returner;
+        const directionValue = direction.toCSS(renderEnv);
+        let i;
+        let color;
+        let position;
+        let positionValue;
+        let alpha;
+
+        function throwArgumentDescriptor() {
+            throw { type: 'Argument',
+                message: 'svg-gradient expects direction, start_color [start_position], [color position,]...,' +
+                            ' end_color [end_position] or direction, color list' };
+        }
+
+        if (arguments.length == 2) {
+            if (arguments[1].value.length < 2) {
+                throwArgumentDescriptor();
+            }
+            stops = arguments[1].value;
+        } else if (arguments.length < 3) {
+            throwArgumentDescriptor();
+        } else {
+            stops = Array.prototype.slice.call(arguments, 1);
+        }
+
+        switch (directionValue) {
+            case 'to bottom':
+                gradientDirectionSvg = 'x1="0%" y1="0%" x2="0%" y2="100%"';
+                break;
+            case 'to right':
+                gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="0%"';
+                break;
+            case 'to bottom right':
+                gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="100%"';
+                break;
+            case 'to top right':
+                gradientDirectionSvg = 'x1="0%" y1="100%" x2="100%" y2="0%"';
+                break;
+            case 'ellipse':
+            case 'ellipse at center':
+                gradientType = 'radial';
+                gradientDirectionSvg = 'cx="50%" cy="50%" r="75%"';
+                rectangleDimension = 'x="-50" y="-50" width="101" height="101"';
+                break;
+            default:
+                throw { type: 'Argument', message: 'svg-gradient direction must be \'to bottom\', \'to right\',' +
+                    ' \'to bottom right\', \'to top right\' or \'ellipse at center\'' };
+        }
+        returner = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"><${gradientType}Gradient id="g" ${gradientDirectionSvg}>`;
+
+        for (i = 0; i < stops.length; i += 1) {
+            if (stops[i] instanceof Expression) {
+                color = stops[i].value[0];
+                position = stops[i].value[1];
+            } else {
+                color = stops[i];
+                position = undefined;
+            }
+
+            if (!(color instanceof Color) || (!((i === 0 || i + 1 === stops.length) && position === undefined) && !(position instanceof Dimension))) {
+                throwArgumentDescriptor();
+            }
+            positionValue = position ? position.toCSS(renderEnv) : i === 0 ? '0%' : '100%';
+            alpha = color.alpha;
+            returner += `<stop offset="${positionValue}" stop-color="${color.toRGB()}"${alpha < 1 ? ` stop-opacity="${alpha}"` : ''}/>`;
+        }
+        returner += `</${gradientType}Gradient><rect ${rectangleDimension} fill="url(#g)" /></svg>`;
+
+        returner = encodeURIComponent(returner);
+
+        returner = `data:image/svg+xml,${returner}`;
+        return new URL(new Quoted(`'${returner}'`, returner, false, this.index, this.currentFileInfo), this.index, this.currentFileInfo);
+    }};
+};

package/lib/less/functions/types.js

@@ -0,0 +1,70 @@
+import Keyword from '../tree/keyword';
+import DetachedRuleset from '../tree/detached-ruleset';
+import Dimension from '../tree/dimension';
+import Color from '../tree/color';
+import Quoted from '../tree/quoted';
+import Anonymous from '../tree/anonymous';
+import URL from '../tree/url';
+import Operation from '../tree/operation';
+
+const isa = (n, Type) => (n instanceof Type) ? Keyword.True : Keyword.False;
+const isunit = (n, unit) => {
+    if (unit === undefined) {
+        throw { type: 'Argument', message: 'missing the required second argument to isunit.' };
+    }
+    unit = typeof unit.value === 'string' ? unit.value : unit;
+    if (typeof unit !== 'string') {
+        throw { type: 'Argument', message: 'Second argument to isunit should be a unit or a string.' };
+    }
+    return (n instanceof Dimension) && n.unit.is(unit) ? Keyword.True : Keyword.False;
+};
+
+export default {
+    isruleset: function (n) {
+        return isa(n, DetachedRuleset);
+    },
+    iscolor: function (n) {
+        return isa(n, Color);
+    },
+    isnumber: function (n) {
+        return isa(n, Dimension);
+    },
+    isstring: function (n) {
+        return isa(n, Quoted);
+    },
+    iskeyword: function (n) {
+        return isa(n, Keyword);
+    },
+    isurl: function (n) {
+        return isa(n, URL);
+    },
+    ispixel: function (n) {
+        return isunit(n, 'px');
+    },
+    ispercentage: function (n) {
+        return isunit(n, '%');
+    },
+    isem: function (n) {
+        return isunit(n, 'em');
+    },
+    isunit,
+    unit: function (val, unit) {
+        if (!(val instanceof Dimension)) {
+            throw { type: 'Argument',
+                message: `the first argument to unit must be a number${val instanceof Operation ? '. Have you forgotten parenthesis?' : ''}` };
+        }
+        if (unit) {
+            if (unit instanceof Keyword) {
+                unit = unit.value;
+            } else {
+                unit = unit.toCSS();
+            }
+        } else {
+            unit = '';
+        }
+        return new Dimension(val.value, unit);
+    },
+    'get-unit': function (n) {
+        return new Anonymous(n.unit);
+    }
+};

package/lib/less/import-manager.js

@@ -0,0 +1,169 @@
+import contexts from './contexts';
+import Parser from './parser/parser';
+import LessError from './less-error';
+import * as utils from './utils';
+import logger from './logger';
+
+export default environment => {
+    // FileInfo = {
+    //  'rewriteUrls' - option - whether to adjust URL's to be relative
+    //  'filename' - full resolved filename of current file
+    //  'rootpath' - path to append to normal URLs for this node
+    //  'currentDirectory' - path to the current file, absolute
+    //  'rootFilename' - filename of the base file
+    //  'entryPath' - absolute path to the entry file
+    //  'reference' - whether the file should not be output and only output parts that are referenced
+
+    class ImportManager {
+        constructor(less, context, rootFileInfo) {
+            this.less = less;
+            this.rootFilename = rootFileInfo.filename;
+            this.paths = context.paths || [];  // Search paths, when importing
+            this.contents = {};             // map - filename to contents of all the files
+            this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
+            this.mime = context.mime;
+            this.error = null;
+            this.context = context;
+            // Deprecated? Unused outside of here, could be useful.
+            this.queue = [];        // Files which haven't been imported yet
+            this.files = {};        // Holds the imported parse trees.
+        }
+
+        /**
+         * Add an import to be imported
+         * @param path - the raw path
+         * @param tryAppendExtension - whether to try appending a file extension (.less or .js if the path has no extension)
+         * @param currentFileInfo - the current file info (used for instance to work out relative paths)
+         * @param importOptions - import options
+         * @param callback - callback for when it is imported
+         */
+        push(path, tryAppendExtension, currentFileInfo, importOptions, callback) {
+            const importManager = this;
+            const pluginLoader = this.context.pluginManager.Loader;
+
+            this.queue.push(path);
+
+            const fileParsedFunc = (e, root, fullPath) => {
+                importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
+
+                const importedEqualsRoot = fullPath === importManager.rootFilename;
+                if (importOptions.optional && e) {
+                    callback(null, {rules:[]}, false, null);
+                    logger.info(`The file ${fullPath} was skipped because it was not found and the import was marked optional.`);
+                }
+                else {
+                    // Inline imports aren't cached here.
+                    // If we start to cache them, please make sure they won't conflict with non-inline imports of the
+                    // same name as they used to do before this comment and the condition below have been added.
+                    if (!importManager.files[fullPath] && !importOptions.inline) {
+                        importManager.files[fullPath] = { root, options: importOptions };
+                    }
+                    if (e && !importManager.error) { importManager.error = e; }
+                    callback(e, root, importedEqualsRoot, fullPath);
+                }
+            };
+
+            const newFileInfo = {
+                rewriteUrls: this.context.rewriteUrls,
+                entryPath: currentFileInfo.entryPath,
+                rootpath: currentFileInfo.rootpath,
+                rootFilename: currentFileInfo.rootFilename
+            };
+
+            const fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
+
+            if (!fileManager) {
+                fileParsedFunc({ message: `Could not find a file-manager for ${path}` });
+                return;
+            }
+
+            const loadFileCallback = loadedFile => {
+                let plugin;
+                const resolvedFilename = loadedFile.filename;
+                const contents = loadedFile.contents.replace(/^\uFEFF/, '');
+
+                // Pass on an updated rootpath if path of imported file is relative and file
+                // is in a (sub|sup) directory
+                //
+                // Examples:
+                // - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
+                //   then rootpath should become 'less/module/nav/'
+                // - If path of imported file is '../mixins.less' and rootpath is 'less/',
+                //   then rootpath should become 'less/../'
+                newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
+                if (newFileInfo.rewriteUrls) {
+                    newFileInfo.rootpath = fileManager.join(
+                        (importManager.context.rootpath || ''),
+                        fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
+
+                    if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
+                        newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
+                    }
+                }
+                newFileInfo.filename = resolvedFilename;
+
+                const newEnv = new contexts.Parse(importManager.context);
+
+                newEnv.processImports = false;
+                importManager.contents[resolvedFilename] = contents;
+
+                if (currentFileInfo.reference || importOptions.reference) {
+                    newFileInfo.reference = true;
+                }
+
+                if (importOptions.isPlugin) {
+                    plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
+                    if (plugin instanceof LessError) {
+                        fileParsedFunc(plugin, null, resolvedFilename);
+                    }
+                    else {
+                        fileParsedFunc(null, plugin, resolvedFilename);
+                    }
+                } else if (importOptions.inline) {
+                    fileParsedFunc(null, contents, resolvedFilename);
+                } else {
+
+                    // import (multiple) parse trees apparently get altered and can't be cached.
+                    // TODO: investigate why this is
+                    if (importManager.files[resolvedFilename]
+                        && !importManager.files[resolvedFilename].options.multiple
+                        && !importOptions.multiple) {
+
+                        fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
+                    }
+                    else {
+                        new Parser(newEnv, importManager, newFileInfo).parse(contents, (e, root) => {
+                            fileParsedFunc(e, root, resolvedFilename);
+                        });
+                    }
+                }
+            };
+            let promise;
+            const context = utils.clone(this.context);
+
+            if (tryAppendExtension) {
+                context.ext = importOptions.isPlugin ? '.js' : '.less';
+            }
+
+            if (importOptions.isPlugin) {
+                context.mime = 'application/javascript';
+                promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
+            }
+            else {
+                promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment,
+                    (err, loadedFile) => {
+                        if (err) {
+                            fileParsedFunc(err);
+                        } else {
+                            loadFileCallback(loadedFile);
+                        }
+                    });
+            }
+            if (promise) {
+                promise.then(loadFileCallback, fileParsedFunc);
+            }
+        }
+    }
+
+    return ImportManager;
+};