less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/atrule.js

@@ -0,0 +1,165 @@
+import Node from './node';
+import Selector from './selector';
+import Ruleset from './ruleset';
+import Anonymous from './anonymous';
+
+class AtRule extends Node {
+    constructor(
+        name,
+        value,
+        rules,
+        index,
+        currentFileInfo,
+        debugInfo,
+        isRooted,
+        visibilityInfo
+    ) {
+        super();
+
+        let i;
+
+        this.name  = name;
+        this.value = (value instanceof Node) ? value : (value ? new Anonymous(value) : value);
+        if (rules) {
+            if (Array.isArray(rules)) {
+                this.rules = rules;
+            } else {
+                this.rules = [rules];
+                this.rules[0].selectors = (new Selector([], null, null, index, currentFileInfo)).createEmptySelectors();
+            }
+            for (i = 0; i < this.rules.length; i++) {
+                this.rules[i].allowImports = true;
+            }
+            this.setParent(this.rules, this);
+        }
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.debugInfo = debugInfo;
+        this.isRooted = isRooted || false;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+    }
+
+    accept(visitor) {
+        const value = this.value;
+        const rules = this.rules;
+        if (rules) {
+            this.rules = visitor.visitArray(rules);
+        }
+        if (value) {
+            this.value = visitor.visit(value);
+        }
+    }
+
+    isRulesetLike() {
+        return this.rules || !this.isCharset();
+    }
+
+    isCharset() {
+        return '@charset' === this.name;
+    }
+
+    genCSS(context, output) {
+        const value = this.value;
+        const rules = this.rules;
+        output.add(this.name, this.fileInfo(), this.getIndex());
+        if (value) {
+            output.add(' ');
+            value.genCSS(context, output);
+        }
+        if (rules) {
+            this.outputRuleset(context, output, rules);
+        } else {
+            output.add(';');
+        }
+    }
+
+    eval(context) {
+        let mediaPathBackup;
+        let mediaBlocksBackup;
+        let value = this.value;
+        let rules = this.rules;
+
+        // media stored inside other atrule should not bubble over it
+        // backpup media bubbling information
+        mediaPathBackup = context.mediaPath;
+        mediaBlocksBackup = context.mediaBlocks;
+        // deleted media bubbling information
+        context.mediaPath = [];
+        context.mediaBlocks = [];
+
+        if (value) {
+            value = value.eval(context);
+        }
+        if (rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            rules = [rules[0].eval(context)];
+            rules[0].root = true;
+        }
+        // restore media bubbling information
+        context.mediaPath = mediaPathBackup;
+        context.mediaBlocks = mediaBlocksBackup;
+
+        return new AtRule(this.name, value, rules,
+            this.getIndex(), this.fileInfo(), this.debugInfo, this.isRooted, this.visibilityInfo());
+    }
+
+    variable(name) {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.variable.call(this.rules[0], name);
+        }
+    }
+
+    find(...args) {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.find.apply(this.rules[0], args);
+        }
+    }
+
+    rulesets() {
+        if (this.rules) {
+            // assuming that there is only one rule at this point - that is how parser constructs the rule
+            return Ruleset.prototype.rulesets.apply(this.rules[0]);
+        }
+    }
+
+    outputRuleset(context, output, rules) {
+        const ruleCnt = rules.length;
+        let i;
+        context.tabLevel = (context.tabLevel | 0) + 1;
+
+        // Compressed
+        if (context.compress) {
+            output.add('{');
+            for (i = 0; i < ruleCnt; i++) {
+                rules[i].genCSS(context, output);
+            }
+            output.add('}');
+            context.tabLevel--;
+            return;
+        }
+
+        // Non-compressed
+        const tabSetStr = `\n${Array(context.tabLevel).join('  ')}`;
+
+        const tabRuleStr = `${tabSetStr}  `;
+        if (!ruleCnt) {
+            output.add(` {${tabSetStr}}`);
+        } else {
+            output.add(` {${tabRuleStr}`);
+            rules[0].genCSS(context, output);
+            for (i = 1; i < ruleCnt; i++) {
+                output.add(tabRuleStr);
+                rules[i].genCSS(context, output);
+            }
+            output.add(`${tabSetStr}}`);
+        }
+
+        context.tabLevel--;
+    }
+}
+
+AtRule.prototype.type = 'AtRule';
+export default AtRule;

package/lib/less/tree/attribute.js

@@ -0,0 +1,34 @@
+import Node from './node';
+
+class Attribute extends Node {
+    constructor(key, op, value) {
+        super();
+
+        this.key = key;
+        this.op = op;
+        this.value = value;
+    }
+
+    eval(context) {
+        return new Attribute(this.key.eval ? this.key.eval(context) : this.key,
+            this.op, (this.value && this.value.eval) ? this.value.eval(context) : this.value);
+    }
+
+    genCSS(context, output) {
+        output.add(this.toCSS(context));
+    }
+
+    toCSS(context) {
+        let value = this.key.toCSS ? this.key.toCSS(context) : this.key;
+
+        if (this.op) {
+            value += this.op;
+            value += (this.value.toCSS ? this.value.toCSS(context) : this.value);
+        }
+
+        return `[${value}]`;
+    }
+}
+
+Attribute.prototype.type = 'Attribute';
+export default Attribute;

package/lib/less/tree/call.js

@@ -0,0 +1,105 @@
+import Node from './node';
+import Anonymous from './anonymous';
+import FunctionCaller from '../functions/function-caller';
+
+//
+// A function call node.
+//
+class Call extends Node {
+    constructor(name, args, index, currentFileInfo) {
+        super();
+
+        this.name = name;
+        this.args = args;
+        this.calc = name === 'calc';
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    accept(visitor) {
+        if (this.args) {
+            this.args = visitor.visitArray(this.args);
+        }
+    }
+
+    //
+    // When evaluating a function call,
+    // we either find the function in the functionRegistry,
+    // in which case we call it, passing the  evaluated arguments,
+    // if this returns null or we cannot find the function, we
+    // simply print it out as it appeared originally [2].
+    //
+    // The reason why we evaluate the arguments, is in the case where
+    // we try to pass a variable to a function, like: `saturate(@color)`.
+    // The function should receive the value, not the variable.
+    //
+    eval(context) {
+        /**
+         * Turn off math for calc(), and switch back on for evaluating nested functions
+         */
+        const currentMathContext = context.mathOn;
+        context.mathOn = !this.calc;
+        if (this.calc || context.inCalc) {
+            context.enterCalc();
+        }
+        const args = this.args.map(a => a.eval(context));
+        if (this.calc || context.inCalc) {
+            context.exitCalc();
+        }
+        context.mathOn = currentMathContext;
+
+        let result;
+        const funcCaller = new FunctionCaller(this.name, context, this.getIndex(), this.fileInfo());
+
+        if (funcCaller.isValid()) {
+            try {
+                result = funcCaller.call(args);
+            } catch (e) {
+                throw { 
+                    type: e.type || 'Runtime',
+                    message: `error evaluating function \`${this.name}\`${e.message ? `: ${e.message}` : ''}`,
+                    index: this.getIndex(), 
+                    filename: this.fileInfo().filename,
+                    line: e.lineNumber,
+                    column: e.columnNumber
+                };
+            }
+
+            if (result !== null && result !== undefined) {
+                // Results that that are not nodes are cast as Anonymous nodes
+                // Falsy values or booleans are returned as empty nodes
+                if (!(result instanceof Node)) {
+                    if (!result || result === true) {
+                        result = new Anonymous(null); 
+                    }
+                    else {
+                        result = new Anonymous(result.toString()); 
+                    }
+                    
+                }
+                result._index = this._index;
+                result._fileInfo = this._fileInfo;
+                return result;
+            }
+
+        }
+
+        return new Call(this.name, args, this.getIndex(), this.fileInfo());
+    }
+
+    genCSS(context, output) {
+        output.add(`${this.name}(`, this.fileInfo(), this.getIndex());
+
+        for (let i = 0; i < this.args.length; i++) {
+            this.args[i].genCSS(context, output);
+            if (i + 1 < this.args.length) {
+                output.add(', ');
+            }
+        }
+
+        output.add(')');
+    }
+}
+
+Call.prototype.type = 'Call';
+export default Call;

package/lib/less/tree/color.js

@@ -0,0 +1,246 @@
+import Node from './node';
+import colors from '../data/colors';
+
+//
+// RGB Colors - #ff0014, #eee
+//
+class Color extends Node {
+    constructor(rgb, a, originalForm) {
+        super();
+
+        const self = this;
+        //
+        // The end goal here, is to parse the arguments
+        // into an integer triplet, such as `128, 255, 0`
+        //
+        // This facilitates operations and conversions.
+        //
+        if (Array.isArray(rgb)) {
+            this.rgb = rgb;
+        } else if (rgb.length >= 6) {
+            this.rgb = [];
+            rgb.match(/.{2}/g).map((c, i) => {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c, 16));
+                } else {
+                    self.alpha = (parseInt(c, 16)) / 255;
+                }
+            });
+        } else {
+            this.rgb = [];
+            rgb.split('').map((c, i) => {
+                if (i < 3) {
+                    self.rgb.push(parseInt(c + c, 16));
+                } else {
+                    self.alpha = (parseInt(c + c, 16)) / 255;
+                }
+            });
+        }
+        this.alpha = this.alpha || (typeof a === 'number' ? a : 1);
+        if (typeof originalForm !== 'undefined') {
+            this.value = originalForm;
+        }
+    }
+
+    luma() {
+        let r = this.rgb[0] / 255;
+        let g = this.rgb[1] / 255;
+        let b = this.rgb[2] / 255;
+
+        r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
+        g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
+        b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
+
+        return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    }
+
+    genCSS(context, output) {
+        output.add(this.toCSS(context));
+    }
+
+    toCSS(context, doNotCompress) {
+        const compress = context && context.compress && !doNotCompress;
+        let color;
+        let alpha;
+        let colorFunction;
+        let args = [];
+
+        // `value` is set if this color was originally
+        // converted from a named color string so we need
+        // to respect this and try to output named color too.
+        alpha = this.fround(context, this.alpha);
+
+        if (this.value) {
+            if (this.value.indexOf('rgb') === 0) {
+                if (alpha < 1) {
+                    colorFunction = 'rgba';
+                }
+            } else if (this.value.indexOf('hsl') === 0) {
+                if (alpha < 1) {
+                    colorFunction = 'hsla';
+                } else {
+                    colorFunction = 'hsl';
+                }
+            } else {
+                return this.value;
+            }
+        } else {
+            if (alpha < 1) {
+                colorFunction = 'rgba';
+            }
+        }
+
+        switch (colorFunction) {
+            case 'rgba':
+                args = this.rgb.map(c => clamp(Math.round(c), 255)).concat(clamp(alpha, 1));
+                break;
+            case 'hsla':
+                args.push(clamp(alpha, 1));
+            case 'hsl':
+                color = this.toHSL();
+                args = [
+                    this.fround(context, color.h),
+                    `${this.fround(context, color.s * 100)}%`,
+                    `${this.fround(context, color.l * 100)}%`
+                ].concat(args);
+        }
+
+        if (colorFunction) {
+            // Values are capped between `0` and `255`, rounded and zero-padded.
+            return `${colorFunction}(${args.join(`,${compress ? '' : ' '}`)})`;
+        }
+
+        color = this.toRGB();
+
+        if (compress) {
+            const splitcolor = color.split('');
+
+            // Convert color to short format
+            if (splitcolor[1] === splitcolor[2] && splitcolor[3] === splitcolor[4] && splitcolor[5] === splitcolor[6]) {
+                color = `#${splitcolor[1]}${splitcolor[3]}${splitcolor[5]}`;
+            }
+        }
+
+        return color;
+    }
+
+    //
+    // Operations have to be done per-channel, if not,
+    // channels will spill onto each other. Once we have
+    // our result, in the form of an integer triplet,
+    // we create a new Color node to hold the result.
+    //
+    operate(context, op, other) {
+        const rgb = new Array(3);
+        const alpha = this.alpha * (1 - other.alpha) + other.alpha;
+        for (let c = 0; c < 3; c++) {
+            rgb[c] = this._operate(context, op, this.rgb[c], other.rgb[c]);
+        }
+        return new Color(rgb, alpha);
+    }
+
+    toRGB() {
+        return toHex(this.rgb);
+    }
+
+    toHSL() {
+        const r = this.rgb[0] / 255;
+        const g = this.rgb[1] / 255;
+        const b = this.rgb[2] / 255;
+        const a = this.alpha;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        let h;
+        let s;
+        const l = (max + min) / 2;
+        const d = max - min;
+
+        if (max === min) {
+            h = s = 0;
+        } else {
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2;               break;
+                case b: h = (r - g) / d + 4;               break;
+            }
+            h /= 6;
+        }
+        return { h: h * 360, s, l, a };
+    }
+
+    // Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+    toHSV() {
+        const r = this.rgb[0] / 255;
+        const g = this.rgb[1] / 255;
+        const b = this.rgb[2] / 255;
+        const a = this.alpha;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        let h;
+        let s;
+        const v = max;
+
+        const d = max - min;
+        if (max === 0) {
+            s = 0;
+        } else {
+            s = d / max;
+        }
+
+        if (max === min) {
+            h = 0;
+        } else {
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+            h /= 6;
+        }
+        return { h: h * 360, s, v, a };
+    }
+
+    toARGB() {
+        return toHex([this.alpha * 255].concat(this.rgb));
+    }
+
+    compare(x) {
+        return (x.rgb &&
+            x.rgb[0] === this.rgb[0] &&
+            x.rgb[1] === this.rgb[1] &&
+            x.rgb[2] === this.rgb[2] &&
+            x.alpha  === this.alpha) ? 0 : undefined;
+    }
+}
+
+Color.prototype.type = 'Color';
+
+function clamp(v, max) {
+    return Math.min(Math.max(v, 0), max);
+}
+
+function toHex(v) {
+    return `#${v.map(c => {
+        c = clamp(Math.round(c), 255);
+        return (c < 16 ? '0' : '') + c.toString(16);
+    }).join('')}`;
+}
+
+Color.fromKeyword = keyword => {
+    let c;
+    const key = keyword.toLowerCase();
+    if (colors.hasOwnProperty(key)) {
+        c = new Color(colors[key].slice(1));
+    }
+    else if (key === 'transparent') {
+        c = new Color([0, 0, 0], 0);
+    }
+
+    if (c) {
+        c.value = keyword;
+        return c;
+    }
+};
+export default Color;

package/lib/less/tree/combinator.js

@@ -0,0 +1,29 @@
+import Node from './node';
+const _noSpaceCombinators = {
+    '': true,
+    ' ': true,
+    '|': true
+};
+
+class Combinator extends Node {
+    constructor(value) {
+        super();
+
+        if (value === ' ') {
+            this.value = ' ';
+            this.emptyOrWhitespace = true;
+        } else {
+            this.value = value ? value.trim() : '';
+            this.emptyOrWhitespace = this.value === '';
+        }
+    }
+
+    genCSS(context, output) {
+        const spaceOrEmpty = (context.compress || _noSpaceCombinators[this.value]) ? '' : ' ';
+        output.add(spaceOrEmpty + this.value + spaceOrEmpty);
+    }
+}
+
+Combinator.prototype.type = 'Combinator';
+
+export default Combinator;

package/lib/less/tree/comment.js

@@ -0,0 +1,29 @@
+import Node from './node';
+import getDebugInfo from './debug-info';
+
+class Comment extends Node {
+    constructor(value, isLineComment, index, currentFileInfo) {
+        super();
+
+        this.value = value;
+        this.isLineComment = isLineComment;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.allowRoot = true;
+    }
+
+    genCSS(context, output) {
+        if (this.debugInfo) {
+            output.add(getDebugInfo(context, this), this.fileInfo(), this.getIndex());
+        }
+        output.add(this.value);
+    }
+
+    isSilent(context) {
+        const isCompressed = context.compress && this.value[2] !== '!';
+        return this.isLineComment || isCompressed;
+    }
+}
+
+Comment.prototype.type = 'Comment';
+export default Comment;

package/lib/less/tree/condition.js

@@ -0,0 +1,43 @@
+import Node from './node';
+
+class Condition extends Node {
+    constructor(op, l, r, i, negate) {
+        super();
+
+        this.op = op.trim();
+        this.lvalue = l;
+        this.rvalue = r;
+        this._index = i;
+        this.negate = negate;
+    }
+
+    accept(visitor) {
+        this.lvalue = visitor.visit(this.lvalue);
+        this.rvalue = visitor.visit(this.rvalue);
+    }
+
+    eval(context) {
+        const result = ((op, a, b) => {
+            switch (op) {
+                case 'and': return a && b;
+                case 'or':  return a || b;
+                default:
+                    switch (Node.compare(a, b)) {
+                        case -1:
+                            return op === '<' || op === '=<' || op === '<=';
+                        case 0:
+                            return op === '=' || op === '>=' || op === '=<' || op === '<=';
+                        case 1:
+                            return op === '>' || op === '>=';
+                        default:
+                            return false;
+                    }
+            }
+        })(this.op, this.lvalue.eval(context), this.rvalue.eval(context));
+
+        return this.negate ? !result : result;
+    }
+}
+
+Condition.prototype.type = 'Condition';
+export default Condition;

package/lib/less/tree/debug-info.js

@@ -0,0 +1,34 @@
+const debugInfo = (context, ctx, lineSeparator) => {
+    let result = '';
+    if (context.dumpLineNumbers && !context.compress) {
+        switch (context.dumpLineNumbers) {
+            case 'comments':
+                result = debugInfo.asComment(ctx);
+                break;
+            case 'mediaquery':
+                result = debugInfo.asMediaQuery(ctx);
+                break;
+            case 'all':
+                result = debugInfo.asComment(ctx) + (lineSeparator || '') + debugInfo.asMediaQuery(ctx);
+                break;
+        }
+    }
+    return result;
+};
+
+debugInfo.asComment = ctx => `/* line ${ctx.debugInfo.lineNumber}, ${ctx.debugInfo.fileName} */\n`;
+
+debugInfo.asMediaQuery = ctx => {
+    let filenameWithProtocol = ctx.debugInfo.fileName;
+    if (!/^[a-z]+:\/\//i.test(filenameWithProtocol)) {
+        filenameWithProtocol = `file://${filenameWithProtocol}`;
+    }
+    return `@media -sass-debug-info{filename{font-family:${filenameWithProtocol.replace(/([.:\/\\])/g, a => {
+        if (a == '\\') {
+            a = '\/';
+        }
+        return `\\${a}`;
+    })}}line{font-family:\\00003${ctx.debugInfo.lineNumber}}}\n`;
+};
+
+export default debugInfo;