less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/declaration.js

@@ -0,0 +1,115 @@
+import Node from './node';
+import Value from './value';
+import Keyword from './keyword';
+import Anonymous from './anonymous';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
+
+
+class Declaration extends Node {
+    constructor(name, value, important, merge, index, currentFileInfo, inline, variable) {
+        super();
+
+        this.name = name;
+        this.value = (value instanceof Node) ? value : new Value([value ? new Anonymous(value) : null]);
+        this.important = important ? ` ${important.trim()}` : '';
+        this.merge = merge;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.inline = inline || false;
+        this.variable = (variable !== undefined) ? variable
+            : (name.charAt && (name.charAt(0) === '@'));
+        this.allowRoot = true;
+        this.setParent(this.value, this);
+    }
+
+    genCSS(context, output) {
+        output.add(this.name + (context.compress ? ':' : ': '), this.fileInfo(), this.getIndex());
+        try {
+            this.value.genCSS(context, output);
+        }
+        catch (e) {
+            e.index = this._index;
+            e.filename = this._fileInfo.filename;
+            throw e;
+        }
+        output.add(this.important + ((this.inline || (context.lastRule && context.compress)) ? '' : ';'), this._fileInfo, this._index);
+    }
+
+    eval(context) {
+        let mathBypass = false;
+        let prevMath;
+        let name = this.name;
+        let evaldValue;
+        let variable = this.variable;
+        if (typeof name !== 'string') {
+            // expand 'primitive' name directly to get
+            // things faster (~10% for benchmark.less):
+            name = (name.length === 1) && (name[0] instanceof Keyword) ?
+                name[0].value : evalName(context, name);
+            variable = false; // never treat expanded interpolation as new variable name
+        }
+
+        // @todo remove when parens-division is default
+        if (name === 'font' && context.math === MATH.ALWAYS) {
+            mathBypass = true;
+            prevMath = context.math;
+            context.math = MATH.PARENS_DIVISION;
+        }
+        try {
+            context.importantScope.push({});
+            evaldValue = this.value.eval(context);
+
+            if (!this.variable && evaldValue.type === 'DetachedRuleset') {
+                throw { message: 'Rulesets cannot be evaluated on a property.',
+                    index: this.getIndex(), filename: this.fileInfo().filename };
+            }
+            let important = this.important;
+            const importantResult = context.importantScope.pop();
+            if (!important && importantResult.important) {
+                important = importantResult.important;
+            }
+
+            return new Declaration(name,
+                evaldValue,
+                important,
+                this.merge,
+                this.getIndex(), this.fileInfo(), this.inline,
+                variable);
+        }
+        catch (e) {
+            if (typeof e.index !== 'number') {
+                e.index = this.getIndex();
+                e.filename = this.fileInfo().filename;
+            }
+            throw e;
+        }
+        finally {
+            if (mathBypass) {
+                context.math = prevMath;
+            }
+        }
+    }
+
+    makeImportant() {
+        return new Declaration(this.name,
+            this.value,
+            '!important',
+            this.merge,
+            this.getIndex(), this.fileInfo(), this.inline);
+    }
+}
+
+function evalName(context, name) {
+    let value = '';
+    let i;
+    const n = name.length;
+    const output = {add: function (s) {value += s;}};
+    for (i = 0; i < n; i++) {
+        name[i].eval(context).genCSS(context, output);
+    }
+    return value;
+}
+
+Declaration.prototype.type = 'Declaration';
+export default Declaration;

package/lib/less/tree/detached-ruleset.js

@@ -0,0 +1,30 @@
+import Node from './node';
+import contexts from '../contexts';
+import * as utils from '../utils';
+
+class DetachedRuleset extends Node {
+    constructor(ruleset, frames) {
+        super();
+
+        this.ruleset = ruleset;
+        this.frames = frames;
+        this.setParent(this.ruleset, this);
+    }
+
+    accept(visitor) {
+        this.ruleset = visitor.visit(this.ruleset);
+    }
+
+    eval(context) {
+        const frames = this.frames || utils.copyArray(context.frames);
+        return new DetachedRuleset(this.ruleset, frames);
+    }
+
+    callEval(context) {
+        return this.ruleset.eval(this.frames ? new contexts.Eval(context, this.frames.concat(context.frames)) : context);
+    }
+}
+
+DetachedRuleset.prototype.type = 'DetachedRuleset';
+DetachedRuleset.prototype.evalFirst = true;
+export default DetachedRuleset;

package/lib/less/tree/dimension.js

@@ -0,0 +1,179 @@
+import Node from './node';
+import unitConversions from '../data/unit-conversions';
+import Unit from './unit';
+import Color from './color';
+
+//
+// A number with a unit
+//
+class Dimension extends Node {
+    constructor(value, unit) {
+        super();
+
+        this.value = parseFloat(value);
+        if (isNaN(this.value)) {
+            throw new Error('Dimension is not a number.');
+        }
+        this.unit = (unit && unit instanceof Unit) ? unit :
+            new Unit(unit ? [unit] : undefined);
+        this.setParent(this.unit, this);
+    }
+
+    accept(visitor) {
+        this.unit = visitor.visit(this.unit);
+    }
+
+    eval(context) {
+        return this;
+    }
+
+    toColor() {
+        return new Color([this.value, this.value, this.value]);
+    }
+
+    genCSS(context, output) {
+        if ((context && context.strictUnits) && !this.unit.isSingular()) {
+            throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`);
+        }
+
+        const value = this.fround(context, this.value);
+        let strValue = String(value);
+
+        if (value !== 0 && value < 0.000001 && value > -0.000001) {
+            // would be output 1e-6 etc.
+            strValue = value.toFixed(20).replace(/0+$/, '');
+        }
+
+        if (context && context.compress) {
+            // Zero values doesn't need a unit
+            if (value === 0 && this.unit.isLength()) {
+                output.add(strValue);
+                return;
+            }
+
+            // Float values doesn't need a leading zero
+            if (value > 0 && value < 1) {
+                strValue = (strValue).substr(1);
+            }
+        }
+
+        output.add(strValue);
+        this.unit.genCSS(context, output);
+    }
+
+    // In an operation between two Dimensions,
+    // we default to the first Dimension's unit,
+    // so `1px + 2` will yield `3px`.
+    operate(context, op, other) {
+        /* jshint noempty:false */
+        let value = this._operate(context, op, this.value, other.value);
+
+        let unit = this.unit.clone();
+
+        if (op === '+' || op === '-') {
+            if (unit.numerator.length === 0 && unit.denominator.length === 0) {
+                unit = other.unit.clone();
+                if (this.unit.backupUnit) {
+                    unit.backupUnit = this.unit.backupUnit;
+                }
+            } else if (other.unit.numerator.length === 0 && unit.denominator.length === 0) {
+                // do nothing
+            } else {
+                other = other.convertTo(this.unit.usedUnits());
+
+                if (context.strictUnits && other.unit.toString() !== unit.toString()) {
+                    throw new Error(`Incompatible units. Change the units or use the unit function. ` + 
+                        `Bad units: '${unit.toString()}' and '${other.unit.toString()}'.`);
+                }
+
+                value = this._operate(context, op, this.value, other.value);
+            }
+        } else if (op === '*') {
+            unit.numerator = unit.numerator.concat(other.unit.numerator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.denominator).sort();
+            unit.cancel();
+        } else if (op === '/') {
+            unit.numerator = unit.numerator.concat(other.unit.denominator).sort();
+            unit.denominator = unit.denominator.concat(other.unit.numerator).sort();
+            unit.cancel();
+        }
+        return new Dimension(value, unit);
+    }
+
+    compare(other) {
+        let a;
+        let b;
+
+        if (!(other instanceof Dimension)) {
+            return undefined;
+        }
+
+        if (this.unit.isEmpty() || other.unit.isEmpty()) {
+            a = this;
+            b = other;
+        } else {
+            a = this.unify();
+            b = other.unify();
+            if (a.unit.compare(b.unit) !== 0) {
+                return undefined;
+            }
+        }
+
+        return Node.numericCompare(a.value, b.value);
+    }
+
+    unify() {
+        return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
+    }
+
+    convertTo(conversions) {
+        let value = this.value;
+        const unit = this.unit.clone();
+        let i;
+        let groupName;
+        let group;
+        let targetUnit;
+        let derivedConversions = {};
+        let applyUnit;
+
+        if (typeof conversions === 'string') {
+            for (i in unitConversions) {
+                if (unitConversions[i].hasOwnProperty(conversions)) {
+                    derivedConversions = {};
+                    derivedConversions[i] = conversions;
+                }
+            }
+            conversions = derivedConversions;
+        }
+        applyUnit = (atomicUnit, denominator) => {
+            /* jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit)) {
+                if (denominator) {
+                    value = value / (group[atomicUnit] / group[targetUnit]);
+                } else {
+                    value = value * (group[atomicUnit] / group[targetUnit]);
+                }
+
+                return targetUnit;
+            }
+
+            return atomicUnit;
+        };
+
+        for (groupName in conversions) {
+            if (conversions.hasOwnProperty(groupName)) {
+                targetUnit = conversions[groupName];
+                group = unitConversions[groupName];
+
+                unit.map(applyUnit);
+            }
+        }
+
+        unit.cancel();
+
+        return new Dimension(value, unit);
+    }
+}
+
+Dimension.prototype.type = 'Dimension';
+export default Dimension;

package/lib/less/tree/element.js

@@ -0,0 +1,73 @@
+import Node from './node';
+import Paren from './paren';
+import Combinator from './combinator';
+
+class Element extends Node {
+    constructor(combinator, value, isVariable, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.combinator = combinator instanceof Combinator ?
+            combinator : new Combinator(combinator);
+
+        if (typeof value === 'string') {
+            this.value = value.trim();
+        } else if (value) {
+            this.value = value;
+        } else {
+            this.value = '';
+        }
+        this.isVariable = isVariable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.combinator, this);
+    }
+
+    accept(visitor) {
+        const value = this.value;
+        this.combinator = visitor.visit(this.combinator);
+        if (typeof value === 'object') {
+            this.value = visitor.visit(value);
+        }
+    }
+
+    eval(context) {
+        return new Element(this.combinator,
+            this.value.eval ? this.value.eval(context) : this.value,
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
+    }
+
+    clone() {
+        return new Element(this.combinator,
+            this.value,
+            this.isVariable,
+            this.getIndex(),
+            this.fileInfo(), this.visibilityInfo());
+    }
+
+    genCSS(context, output) {
+        output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
+    }
+
+    toCSS(context = {}) {
+        let value = this.value;
+        const firstSelector = context.firstSelector;
+        if (value instanceof Paren) {
+            // selector in parens should not be affected by outer selector
+            // flags (breaks only interpolated selectors - see #1973)
+            context.firstSelector = true;
+        }
+        value = value.toCSS ? value.toCSS(context) : value;
+        context.firstSelector = firstSelector;
+        if (value === '' && this.combinator.value.charAt(0) === '&') {
+            return '';
+        } else {
+            return this.combinator.toCSS(context) + value;
+        }
+    }
+}
+
+Element.prototype.type = 'Element';
+export default Element;

package/lib/less/tree/expression.js

@@ -0,0 +1,74 @@
+import Node from './node';
+import Paren from './paren';
+import Comment from './comment';
+import Dimension from './dimension';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
+
+class Expression extends Node {
+    constructor(value, noSpacing) {
+        super();
+
+        this.value = value;
+        this.noSpacing = noSpacing;
+        if (!value) {
+            throw new Error('Expression requires an array parameter');
+        }
+    }
+
+    accept(visitor) {
+        this.value = visitor.visitArray(this.value);
+    }
+
+    eval(context) {
+        let returnValue;
+        const mathOn = context.isMathOn();
+
+        const inParenthesis = this.parens && 
+            (context.math !== MATH.STRICT_LEGACY || !this.parensInOp);
+
+        let doubleParen = false;
+        if (inParenthesis) {
+            context.inParenthesis();
+        }
+        if (this.value.length > 1) {
+            returnValue = new Expression(this.value.map(e => {
+                if (!e.eval) {
+                    return e;
+                }
+                return e.eval(context);
+            }), this.noSpacing);
+        } else if (this.value.length === 1) {
+            if (this.value[0].parens && !this.value[0].parensInOp && !context.inCalc) {
+                doubleParen = true;
+            }
+            returnValue = this.value[0].eval(context);
+        } else {
+            returnValue = this;
+        }
+        if (inParenthesis) {
+            context.outOfParenthesis();
+        }
+        if (this.parens && this.parensInOp && !mathOn && !doubleParen 
+            && (!(returnValue instanceof Dimension))) {
+            returnValue = new Paren(returnValue);
+        }
+        return returnValue;
+    }
+
+    genCSS(context, output) {
+        for (let i = 0; i < this.value.length; i++) {
+            this.value[i].genCSS(context, output);
+            if (!this.noSpacing && i + 1 < this.value.length) {
+                output.add(' ');
+            }
+        }
+    }
+
+    throwAwayComments() {
+        this.value = this.value.filter(v => !(v instanceof Comment));
+    }
+}
+
+Expression.prototype.type = 'Expression';
+export default Expression;

package/lib/less/tree/extend.js

@@ -0,0 +1,66 @@
+import Node from './node';
+import Selector from './selector';
+
+class Extend extends Node {
+    constructor(selector, option, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.selector = selector;
+        this.option = option;
+        this.object_id = Extend.next_id++;
+        this.parent_ids = [this.object_id];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+
+        switch (option) {
+            case 'all':
+                this.allowBefore = true;
+                this.allowAfter = true;
+                break;
+            default:
+                this.allowBefore = false;
+                this.allowAfter = false;
+                break;
+        }
+        this.setParent(this.selector, this);
+    }
+
+    accept(visitor) {
+        this.selector = visitor.visit(this.selector);
+    }
+
+    eval(context) {
+        return new Extend(this.selector.eval(context), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    }
+
+    clone(context) {
+        return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    }
+
+    // it concatenates (joins) all selectors in selector array
+    findSelfSelectors(selectors) {
+        let selfElements = [];
+        let i;
+        let selectorElements;
+
+        for (i = 0; i < selectors.length; i++) {
+            selectorElements = selectors[i].elements;
+            // duplicate the logic in genCSS function inside the selector node.
+            // future TODO - move both logics into the selector joiner visitor
+            if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === '') {
+                selectorElements[0].combinator.value = ' ';
+            }
+            selfElements = selfElements.concat(selectors[i].elements);
+        }
+
+        this.selfSelectors = [new Selector(selfElements)];
+        this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
+    }
+}
+
+Extend.next_id = 0;
+
+Extend.prototype.type = 'Extend';
+export default Extend;