less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/node.js

@@ -0,0 +1,178 @@
+class Node {
+    constructor() {
+        this.parent = null;
+        this.visibilityBlocks = undefined;
+        this.nodeVisible = undefined;
+        this.rootNode = null;
+        this.parsed = null;
+
+        const self = this;
+        Object.defineProperty(this, 'currentFileInfo', {
+            get: function() { return self.fileInfo(); }
+        });
+        Object.defineProperty(this, 'index', {
+            get: function() { return self.getIndex(); }
+        });
+
+    }
+
+    setParent(nodes, parent) {
+        function set(node) {
+            if (node && node instanceof Node) {
+                node.parent = parent;
+            }
+        }
+        if (Array.isArray(nodes)) {
+            nodes.forEach(set);
+        }
+        else {
+            set(nodes);
+        }
+    }
+
+    getIndex() {
+        return this._index || (this.parent && this.parent.getIndex()) || 0;
+    }
+
+    fileInfo() {
+        return this._fileInfo || (this.parent && this.parent.fileInfo()) || {};
+    }
+
+    isRulesetLike() {
+        return false;
+    }
+
+    toCSS(context) {
+        const strs = [];
+        this.genCSS(context, {
+            add: function(chunk, fileInfo, index) {
+                strs.push(chunk);
+            },
+            isEmpty: function () {
+                return strs.length === 0;
+            }
+        });
+        return strs.join('');
+    }
+
+    genCSS(context, output) {
+        output.add(this.value);
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    eval() { return this; }
+
+    _operate(context, op, a, b) {
+        switch (op) {
+            case '+': return a + b;
+            case '-': return a - b;
+            case '*': return a * b;
+            case '/': return a / b;
+        }
+    }
+
+    fround(context, value) {
+        const precision = context && context.numPrecision;
+        // add "epsilon" to ensure numbers like 1.000000005 (represented as 1.000000004999...) are properly rounded:
+        return (precision) ? Number((value + 2e-16).toFixed(precision)) : value;
+    }
+
+    // Returns true if this node represents root of ast imported by reference
+    blocksVisibility() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        return this.visibilityBlocks !== 0;
+    }
+
+    addVisibilityBlock() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        this.visibilityBlocks = this.visibilityBlocks + 1;
+    }
+
+    removeVisibilityBlock() {
+        if (this.visibilityBlocks == null) {
+            this.visibilityBlocks = 0;
+        }
+        this.visibilityBlocks = this.visibilityBlocks - 1;
+    }
+
+    // Turns on node visibility - if called node will be shown in output regardless
+    // of whether it comes from import by reference or not
+    ensureVisibility() {
+        this.nodeVisible = true;
+    }
+
+    // Turns off node visibility - if called node will NOT be shown in output regardless
+    // of whether it comes from import by reference or not
+    ensureInvisibility() {
+        this.nodeVisible = false;
+    }
+
+    // return values:
+    // false - the node must not be visible
+    // true - the node must be visible
+    // undefined or null - the node has the same visibility as its parent
+    isVisible() {
+        return this.nodeVisible;
+    }
+
+    visibilityInfo() {
+        return {
+            visibilityBlocks: this.visibilityBlocks,
+            nodeVisible: this.nodeVisible
+        };
+    }
+
+    copyVisibilityInfo(info) {
+        if (!info) {
+            return;
+        }
+        this.visibilityBlocks = info.visibilityBlocks;
+        this.nodeVisible = info.nodeVisible;
+    }
+}
+
+Node.compare = (a, b) => {
+    /* returns:
+     -1: a < b
+     0: a = b
+     1: a > b
+     and *any* other value for a != b (e.g. undefined, NaN, -2 etc.) */
+
+    if ((a.compare) &&
+        // for "symmetric results" force toCSS-based comparison
+        // of Quoted or Anonymous if either value is one of those
+        !(b.type === 'Quoted' || b.type === 'Anonymous')) {
+        return a.compare(b);
+    } else if (b.compare) {
+        return -b.compare(a);
+    } else if (a.type !== b.type) {
+        return undefined;
+    }
+
+    a = a.value;
+    b = b.value;
+    if (!Array.isArray(a)) {
+        return a === b ? 0 : undefined;
+    }
+    if (a.length !== b.length) {
+        return undefined;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (Node.compare(a[i], b[i]) !== 0) {
+            return undefined;
+        }
+    }
+    return 0;
+};
+
+Node.numericCompare = (a, b) => a  <  b ? -1
+    : a === b ?  0
+        : a  >  b ?  1 : undefined;
+export default Node;

package/lib/less/tree/operation.js

@@ -0,0 +1,62 @@
+import Node from './node';
+import Color from './color';
+import Dimension from './dimension';
+import * as Constants from '../constants';
+const MATH = Constants.Math;
+
+
+class Operation extends Node {
+    constructor(op, operands, isSpaced) {
+        super();
+
+        this.op = op.trim();
+        this.operands = operands;
+        this.isSpaced = isSpaced;
+    }
+
+    accept(visitor) {
+        this.operands = visitor.visitArray(this.operands);
+    }
+
+    eval(context) {
+        let a = this.operands[0].eval(context);
+        let b = this.operands[1].eval(context);
+        let op;
+
+        if (context.isMathOn(this.op)) {
+            op = this.op === './' ? '/' : this.op;
+            if (a instanceof Dimension && b instanceof Color) {
+                a = a.toColor();
+            }
+            if (b instanceof Dimension && a instanceof Color) {
+                b = b.toColor();
+            }
+            if (!a.operate) {
+                if (a instanceof Operation && a.op === '/' && context.math === MATH.PARENS_DIVISION) {
+                    return new Operation(this.op, [a, b], this.isSpaced);
+                }
+                throw { type: 'Operation',
+                    message: 'Operation on an invalid type' };
+            }
+
+            return a.operate(context, op, b);
+        } else {
+            return new Operation(this.op, [a, b], this.isSpaced);
+        }
+    }
+
+    genCSS(context, output) {
+        this.operands[0].genCSS(context, output);
+        if (this.isSpaced) {
+            output.add(' ');
+        }
+        output.add(this.op);
+        if (this.isSpaced) {
+            output.add(' ');
+        }
+        this.operands[1].genCSS(context, output);
+    }
+}
+
+Operation.prototype.type = 'Operation';
+export default Operation;

package/lib/less/tree/paren.js

@@ -0,0 +1,22 @@
+import Node from './node';
+
+class Paren extends Node {
+    constructor(node) {
+        super();
+
+        this.value = node;
+    }
+
+    genCSS(context, output) {
+        output.add('(');
+        this.value.genCSS(context, output);
+        output.add(')');
+    }
+
+    eval(context) {
+        return new Paren(this.value.eval(context));
+    }
+}
+
+Paren.prototype.type = 'Paren';
+export default Paren;

package/lib/less/tree/property.js

@@ -0,0 +1,77 @@
+import Node from './node';
+import Declaration from './declaration';
+
+class Property extends Node {
+    constructor(name, index, currentFileInfo) {
+        super();
+
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    eval(context) {
+        let property;
+        const name = this.name;
+        // TODO: shorten this reference
+        const mergeRules = context.pluginManager.less.visitors.ToCSSVisitor.prototype._mergeRules;
+
+        if (this.evaluating) {
+            throw { type: 'Name',
+                message: `Recursive property reference for ${name}`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+
+        this.evaluating = true;
+
+        property = this.find(context.frames, frame => {
+            let v;
+            const vArr = frame.property(name);
+            if (vArr) {
+                for (let i = 0; i < vArr.length; i++) {
+                    v = vArr[i];
+
+                    vArr[i] = new Declaration(v.name,
+                        v.value,
+                        v.important,
+                        v.merge,
+                        v.index,
+                        v.currentFileInfo,
+                        v.inline,
+                        v.variable
+                    );
+                }
+                mergeRules(vArr);
+
+                v = vArr[vArr.length - 1];
+                if (v.important) {
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
+                    importantScope.important = v.important;
+                }
+                v = v.value.eval(context);
+                return v;
+            }
+        });
+        if (property) {
+            this.evaluating = false;
+            return property;
+        } else {
+            throw { type: 'Name',
+                message: `Property '${name}' is undefined`,
+                filename: this.currentFileInfo.filename,
+                index: this.index };
+        }
+    }
+
+    find(obj, fun) {
+        for (let i = 0, r; i < obj.length; i++) {
+            r = fun.call(obj, obj[i]);
+            if (r) { return r; }
+        }
+        return null;
+    }
+}
+
+Property.prototype.type = 'Property';
+export default Property;

package/lib/less/tree/quoted.js

@@ -0,0 +1,70 @@
+import Node from './node';
+import Variable from './variable';
+import Property from './property';
+
+
+class Quoted extends Node {
+    constructor(str, content, escaped, index, currentFileInfo) {
+        super();
+
+        this.escaped = (escaped == null) ? true : escaped;
+        this.value = content || '';
+        this.quote = str.charAt(0);
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.variableRegex = /@\{([\w-]+)\}/g;
+        this.propRegex = /\$\{([\w-]+)\}/g;
+        this.allowRoot = escaped;
+    }
+
+    genCSS(context, output) {
+        if (!this.escaped) {
+            output.add(this.quote, this.fileInfo(), this.getIndex());
+        }
+        output.add(this.value);
+        if (!this.escaped) {
+            output.add(this.quote);
+        }
+    }
+
+    containsVariables() {
+        return this.value.match(this.variableRegex);
+    }
+
+    eval(context) {
+        const that = this;
+        let value = this.value;
+        const variableReplacement = (_, name) => {
+            const v = new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context, true);
+            return (v instanceof Quoted) ? v.value : v.toCSS();
+        };
+        const propertyReplacement = (_, name) => {
+            const v = new Property(`$${name}`, that.getIndex(), that.fileInfo()).eval(context, true);
+            return (v instanceof Quoted) ? v.value : v.toCSS();
+        };
+        function iterativeReplace(value, regexp, replacementFnc) {
+            let evaluatedValue = value;
+            do {
+                value = evaluatedValue.toString();
+                evaluatedValue = value.replace(regexp, replacementFnc);
+            } while (value !== evaluatedValue);
+            return evaluatedValue;
+        }
+        value = iterativeReplace(value, this.variableRegex, variableReplacement);
+        value = iterativeReplace(value, this.propRegex, propertyReplacement);
+
+        return new Quoted(this.quote + value + this.quote, value, this.escaped, this.getIndex(), this.fileInfo());
+    }
+
+    compare(other) {
+        // when comparing quoted strings allow the quote to differ
+        if (other.type === 'Quoted' && !this.escaped && !other.escaped) {
+            return Node.numericCompare(this.value, other.value);
+        } else {
+            return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
+        }
+    }
+}
+
+Quoted.prototype.type = 'Quoted';
+export default Quoted;