less 4.9.0 → 5.0.0-alpha.2

package/lib/less/functions/list.js

@@ -1,158 +0,0 @@
-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
-    const items = Array.isArray(node.value) ?
-        node.value : Array(node);
-
-    return items;
-};
-
-export default {
-    _SELF: function(n) {
-        return n;
-    },
-    '~': function(...expr) {
-        if (expr.length === 1) {
-            return expr[0];
-        }
-        return new Value(expr);
-    },
-    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;
-
-        const tryEval = val => {
-            if (val instanceof Node) {
-                return val.eval(this.context);
-            }
-            return val;
-        };
-
-        if (list.value && !(list instanceof Quote)) {
-            if (Array.isArray(list.value)) {
-                iterator = list.value.map(tryEval);
-            } else {
-                iterator = [tryEval(list.value)];
-            }
-        } else if (list.ruleset) {
-            iterator = tryEval(list.ruleset).rules;
-        } else if (list.rules) {
-            iterator = list.rules.map(tryEval);
-        } else if (Array.isArray(list)) {
-            iterator = list.map(tryEval);
-        } else {
-            iterator = [tryEval(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

@@ -1,22 +0,0 @@
-import Dimension from '../tree/dimension.js';
-
-const MathHelper = (fn, unit, cssEvaluable, n) => {
-    if (!(n instanceof Dimension)) {
-        // A runtime CSS value such as var()/env() stays an unevaluated call and
-        // cannot be resolved to a number at compile time. Only functions with a
-        // CSS equivalent may be left for the browser; the rest (percentage, ceil,
-        // floor, round) have no CSS form and keep erroring on such input.
-        if (cssEvaluable && n && n.type === 'Call') {
-            return undefined;
-        }
-        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

@@ -1,30 +0,0 @@
-import mathHelper from './math-helper.js';
-
-const mathFunctions = {
-    // name:  [unit, has a CSS equivalent that the browser can evaluate]
-    ceil:  [null, false],
-    floor: [null, false],
-    sqrt:  [null, true],
-    abs:   [null, true],
-    tan:   ['', true],
-    sin:   ['', true],
-    cos:   ['', true],
-    atan:  ['rad', true],
-    asin:  ['rad', true],
-    acos:  ['rad', true]
-};
-
-for (const f in mathFunctions) {
-    // eslint-disable-next-line no-prototype-builtins
-    if (mathFunctions.hasOwnProperty(f)) {
-        const [unit, cssEvaluable] = mathFunctions[f];
-        mathFunctions[f] = mathHelper.bind(null, Math[f], unit, cssEvaluable);
-    }
-}
-
-mathFunctions.round = (n, f) => {
-    const fraction = typeof f === 'undefined' ? 0 : f.value;
-    return mathHelper(num => num.toFixed(fraction), null, false, n);
-};
-
-export default mathFunctions;

package/lib/less/functions/number.js

@@ -1,95 +0,0 @@
-import Dimension from '../tree/dimension.js';
-import Anonymous from '../tree/anonymous.js';
-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;
-            } else {
-                throw { type: 'Argument', message: 'incompatible types' };
-            }
-        }
-        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(a => { return a.toCSS(this.context); }).join(this.context.compress ? ',' : ', ');
-    return new Anonymous(`${isMin ? 'min' : 'max'}(${args})`);
-};
-
-export default {
-    min: function(...args) {
-        try {
-            return minMax.call(this, true, args);
-        } catch (e) {}
-    },
-    max: function(...args) {
-        try {
-            return minMax.call(this, false, args);
-        } catch (e) {}
-    },
-    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, '%', false, n);
-
-        return result;
-    }
-};

package/lib/less/functions/string.js

@@ -1,39 +0,0 @@
-import Quoted from '../tree/quoted.js';
-import Anonymous from '../tree/anonymous.js';
-import JavaScript from '../tree/javascript.js';
-
-export default {
-    e: function (str) {
-        return new Quoted('"', str instanceof JavaScript ? str.evaluated : str.value, true);
-    },
-    escape: function (str) {
-        const escapedValue = encodeURI(str.value).replace(/=/g, '%3D').replace(/:/g, '%3A').replace(/#/g, '%23').replace(/;/g, '%3B')
-            .replace(/\(/g, '%28').replace(/\)/g, '%29');
-        const escaped = new Anonymous(escapedValue);
-        // Percent escapes are literal CSS, not Less source.
-        escaped._preventReparse = escapedValue.includes('%');
-        return escaped;
-    },
-    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/style.js

@@ -1,29 +0,0 @@
-import Variable from '../tree/variable.js';
-import Anonymous from '../tree/anonymous.js';
-
-/** @param {*[]} args */
-const styleExpression = function (args) {
-    args = Array.prototype.slice.call(args);
-    if (args.length === 0) {
-        throw { type: 'Argument', message: 'one or more arguments required' };
-    }
-
-    const entityList = [new Variable(args[0].value, this.index, this.currentFileInfo).eval(this.context)];
-
-    const result = entityList.map(a => { return a.toCSS(this.context); }).join(this.context.compress ? ',' : ', ');
-
-    return new Anonymous(`style(${result})`);
-};
-
-export default {
-    /** @param {...*} args */
-    style: function(...args) {
-        try {
-            return styleExpression.call(this, args);
-        } catch (e) {
-            // When style() is used as a CSS function (e.g. @container style(--responsive: true)),
-            // arguments won't be valid Less variables. Return undefined to let the
-            // parser fall through and treat it as plain CSS.
-        }
-    },
-};

package/lib/less/functions/svg.js

@@ -1,87 +0,0 @@
-import Dimension from '../tree/dimension.js';
-import Color from '../tree/color.js';
-import Expression from '../tree/expression.js';
-import Quoted from '../tree/quoted.js';
-import URL from '../tree/url.js';
-
-export default () => {
-    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

@@ -1,70 +0,0 @@
-import Keyword from '../tree/keyword.js';
-import DetachedRuleset from '../tree/detached-ruleset.js';
-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 URL from '../tree/url.js';
-import Operation from '../tree/operation.js';
-
-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);
-    }
-};