less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/selector.js

@@ -0,0 +1,146 @@
+import Node from './node';
+import Element from './element';
+import LessError from '../less-error';
+
+class Selector extends Node {
+    constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.extendList = extendList;
+        this.condition = condition;
+        this.evaldCondition = !condition;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.elements = this.getElements(elements);
+        this.mixinElements_ = undefined;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.elements, this);
+    }
+
+    accept(visitor) {
+        if (this.elements) {
+            this.elements = visitor.visitArray(this.elements);
+        }
+        if (this.extendList) {
+            this.extendList = visitor.visitArray(this.extendList);
+        }
+        if (this.condition) {
+            this.condition = visitor.visit(this.condition);
+        }
+    }
+
+    createDerived(elements, extendList, evaldCondition) {
+        elements = this.getElements(elements);
+        const newSelector = new Selector(elements, extendList || this.extendList,
+            null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+        newSelector.evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
+        newSelector.mediaEmpty = this.mediaEmpty;
+        return newSelector;
+    }
+
+    getElements(els) {
+        if (!els) {
+            return [new Element('', '&', false, this._index, this._fileInfo)];
+        }
+        if (typeof els === 'string') {
+            this.parse.parseNode(
+                els, 
+                ['selector'],
+                this._index, 
+                this._fileInfo, 
+                function(err, result) {
+                    if (err) {
+                        throw new LessError({
+                            index: err.index,
+                            message: err.message
+                        }, this.parse.imports, this._fileInfo.filename);
+                    }
+                    els = result[0].elements;
+                });
+        }
+        return els;
+    }
+
+    createEmptySelectors() {
+        const el = new Element('', '&', false, this._index, this._fileInfo);
+        const sels = [new Selector([el], null, null, this._index, this._fileInfo)];
+        sels[0].mediaEmpty = true;
+        return sels;
+    }
+
+    match(other) {
+        const elements = this.elements;
+        const len = elements.length;
+        let olen;
+        let i;
+
+        other = other.mixinElements();
+        olen = other.length;
+        if (olen === 0 || len < olen) {
+            return 0;
+        } else {
+            for (i = 0; i < olen; i++) {
+                if (elements[i].value !== other[i]) {
+                    return 0;
+                }
+            }
+        }
+
+        return olen; // return number of matched elements
+    }
+
+    mixinElements() {
+        if (this.mixinElements_) {
+            return this.mixinElements_;
+        }
+
+        let elements = this.elements.map( v => v.combinator.value + (v.value.value || v.value)).join('').match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
+
+        if (elements) {
+            if (elements[0] === '&') {
+                elements.shift();
+            }
+        } else {
+            elements = [];
+        }
+
+        return (this.mixinElements_ = elements);
+    }
+
+    isJustParentSelector() {
+        return !this.mediaEmpty &&
+            this.elements.length === 1 &&
+            this.elements[0].value === '&' &&
+            (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === '');
+    }
+
+    eval(context) {
+        const evaldCondition = this.condition && this.condition.eval(context);
+        let elements = this.elements;
+        let extendList = this.extendList;
+
+        elements = elements && elements.map(e => e.eval(context));
+        extendList = extendList && extendList.map(extend => extend.eval(context));
+
+        return this.createDerived(elements, extendList, evaldCondition);
+    }
+
+    genCSS(context, output) {
+        let i;
+        let element;
+        if ((!context || !context.firstSelector) && this.elements[0].combinator.value === '') {
+            output.add(' ', this.fileInfo(), this.getIndex());
+        }
+        for (i = 0; i < this.elements.length; i++) {
+            element = this.elements[i];
+            element.genCSS(context, output);
+        }
+    }
+
+    getIsOutput() {
+        return this.evaldCondition;
+    }
+}
+
+Selector.prototype.type = 'Selector';
+export default Selector;

package/lib/less/tree/unicode-descriptor.js

@@ -0,0 +1,13 @@
+import Node from './node';
+
+class UnicodeDescriptor extends Node {
+    constructor(value) {
+        super();
+
+        this.value = value;
+    }
+}
+
+UnicodeDescriptor.prototype.type = 'UnicodeDescriptor';
+
+export default UnicodeDescriptor;

package/lib/less/tree/unit.js

@@ -0,0 +1,141 @@
+import Node from './node';
+import unitConversions from '../data/unit-conversions';
+import * as utils from '../utils';
+
+class Unit extends Node {
+    constructor(numerator, denominator, backupUnit) {
+        super();
+
+        this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
+        this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
+        if (backupUnit) {
+            this.backupUnit = backupUnit;
+        } else if (numerator && numerator.length) {
+            this.backupUnit = numerator[0];
+        }
+    }
+
+    clone() {
+        return new Unit(utils.copyArray(this.numerator), utils.copyArray(this.denominator), this.backupUnit);
+    }
+
+    genCSS(context, output) {
+        // Dimension checks the unit is singular and throws an error if in strict math mode.
+        const strictUnits = context && context.strictUnits;
+        if (this.numerator.length === 1) {
+            output.add(this.numerator[0]); // the ideal situation
+        } else if (!strictUnits && this.backupUnit) {
+            output.add(this.backupUnit);
+        } else if (!strictUnits && this.denominator.length) {
+            output.add(this.denominator[0]);
+        }
+    }
+
+    toString() {
+        let i;
+        let returnStr = this.numerator.join('*');
+        for (i = 0; i < this.denominator.length; i++) {
+            returnStr += `/${this.denominator[i]}`;
+        }
+        return returnStr;
+    }
+
+    compare(other) {
+        return this.is(other.toString()) ? 0 : undefined;
+    }
+
+    is(unitString) {
+        return this.toString().toUpperCase() === unitString.toUpperCase();
+    }
+
+    isLength() {
+        return RegExp('^(px|em|ex|ch|rem|in|cm|mm|pc|pt|ex|vw|vh|vmin|vmax)$', 'gi').test(this.toCSS());
+    }
+
+    isEmpty() {
+        return this.numerator.length === 0 && this.denominator.length === 0;
+    }
+
+    isSingular() {
+        return this.numerator.length <= 1 && this.denominator.length === 0;
+    }
+
+    map(callback) {
+        let i;
+
+        for (i = 0; i < this.numerator.length; i++) {
+            this.numerator[i] = callback(this.numerator[i], false);
+        }
+
+        for (i = 0; i < this.denominator.length; i++) {
+            this.denominator[i] = callback(this.denominator[i], true);
+        }
+    }
+
+    usedUnits() {
+        let group;
+        const result = {};
+        let mapUnit;
+        let groupName;
+
+        mapUnit = atomicUnit => {
+            /* jshint loopfunc:true */
+            if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
+                result[groupName] = atomicUnit;
+            }
+
+            return atomicUnit;
+        };
+
+        for (groupName in unitConversions) {
+            if (unitConversions.hasOwnProperty(groupName)) {
+                group = unitConversions[groupName];
+
+                this.map(mapUnit);
+            }
+        }
+
+        return result;
+    }
+
+    cancel() {
+        const counter = {};
+        let atomicUnit;
+        let i;
+
+        for (i = 0; i < this.numerator.length; i++) {
+            atomicUnit = this.numerator[i];
+            counter[atomicUnit] = (counter[atomicUnit] || 0) + 1;
+        }
+
+        for (i = 0; i < this.denominator.length; i++) {
+            atomicUnit = this.denominator[i];
+            counter[atomicUnit] = (counter[atomicUnit] || 0) - 1;
+        }
+
+        this.numerator = [];
+        this.denominator = [];
+
+        for (atomicUnit in counter) {
+            if (counter.hasOwnProperty(atomicUnit)) {
+                const count = counter[atomicUnit];
+
+                if (count > 0) {
+                    for (i = 0; i < count; i++) {
+                        this.numerator.push(atomicUnit);
+                    }
+                } else if (count < 0) {
+                    for (i = 0; i < -count; i++) {
+                        this.denominator.push(atomicUnit);
+                    }
+                }
+            }
+        }
+
+        this.numerator.sort();
+        this.denominator.sort();
+    }
+}
+
+Unit.prototype.type = 'Unit';
+export default Unit;

package/lib/less/tree/url.js

@@ -0,0 +1,65 @@
+import Node from './node';
+
+class URL extends Node {
+    constructor(val, index, currentFileInfo, isEvald) {
+        super();
+
+        this.value = val;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.isEvald = isEvald;
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    genCSS(context, output) {
+        output.add('url(');
+        this.value.genCSS(context, output);
+        output.add(')');
+    }
+
+    eval(context) {
+        const val = this.value.eval(context);
+        let rootpath;
+
+        if (!this.isEvald) {
+            // Add the rootpath if the URL requires a rewrite
+            rootpath = this.fileInfo() && this.fileInfo().rootpath;
+            if (typeof rootpath === 'string' &&
+                typeof val.value === 'string' &&
+                context.pathRequiresRewrite(val.value)) {
+                if (!val.quote) {
+                    rootpath = escapePath(rootpath);
+                }
+                val.value = context.rewritePath(val.value, rootpath);
+            } else {
+                val.value = context.normalizePath(val.value);
+            }
+
+            // Add url args if enabled
+            if (context.urlArgs) {
+                if (!val.value.match(/^\s*data:/)) {
+                    const delimiter = val.value.indexOf('?') === -1 ? '?' : '&';
+                    const urlArgs = delimiter + context.urlArgs;
+                    if (val.value.indexOf('#') !== -1) {
+                        val.value = val.value.replace('#', `${urlArgs}#`);
+                    } else {
+                        val.value += urlArgs;
+                    }
+                }
+            }
+        }
+
+        return new URL(val, this.getIndex(), this.fileInfo(), true);
+    }
+}
+
+URL.prototype.type = 'Url';
+
+function escapePath(path) {
+    return path.replace(/[\(\)'"\s]/g, match => `\\${match}`);
+}
+
+export default URL;

package/lib/less/tree/value.js

@@ -0,0 +1,44 @@
+import Node from './node';
+
+class Value extends Node {
+    constructor(value) {
+        super();
+
+        if (!value) {
+            throw new Error('Value requires an array argument');
+        }
+        if (!Array.isArray(value)) {
+            this.value = [ value ];
+        }
+        else {
+            this.value = value;
+        }
+    }
+
+    accept(visitor) {
+        if (this.value) {
+            this.value = visitor.visitArray(this.value);
+        }
+    }
+
+    eval(context) {
+        if (this.value.length === 1) {
+            return this.value[0].eval(context);
+        } else {
+            return new Value(this.value.map(v => v.eval(context)));
+        }
+    }
+
+    genCSS(context, output) {
+        let i;
+        for (i = 0; i < this.value.length; i++) {
+            this.value[i].genCSS(context, output);
+            if (i + 1 < this.value.length) {
+                output.add((context && context.compress) ? ',' : ', ');
+            }
+        }
+    }
+}
+
+Value.prototype.type = 'Value';
+export default Value;

package/lib/less/tree/variable-call.js

@@ -0,0 +1,46 @@
+import Node from './node';
+import Variable from './variable';
+import Ruleset from './ruleset';
+import DetachedRuleset from './detached-ruleset';
+import LessError from '../less-error';
+
+class VariableCall extends Node {
+    constructor(variable, index, currentFileInfo) {
+        super();
+
+        this.variable = variable;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.allowRoot = true;
+    }
+
+    eval(context) {
+        let rules;
+        let detachedRuleset = new Variable(this.variable, this.getIndex(), this.fileInfo()).eval(context);
+        const error = new LessError({message: `Could not evaluate variable call ${this.variable}`});
+
+        if (!detachedRuleset.ruleset) {
+            if (detachedRuleset.rules) {
+                rules = detachedRuleset;
+            }
+            else if (Array.isArray(detachedRuleset)) {
+                rules = new Ruleset('', detachedRuleset);
+            }
+            else if (Array.isArray(detachedRuleset.value)) {
+                rules = new Ruleset('', detachedRuleset.value);
+            }
+            else {
+                throw error;
+            }
+            detachedRuleset = new DetachedRuleset(rules);
+        }
+
+        if (detachedRuleset.ruleset) {
+            return detachedRuleset.callEval(context);
+        }
+        throw error;
+    }
+}
+
+VariableCall.prototype.type = 'VariableCall';
+export default VariableCall;

package/lib/less/tree/variable.js

@@ -0,0 +1,67 @@
+import Node from './node';
+import Call from './call';
+
+class Variable extends Node {
+    constructor(name, index, currentFileInfo) {
+        super();
+
+        this.name = name;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    eval(context) {
+        let variable;
+        let name = this.name;
+
+        if (name.indexOf('@@') === 0) {
+            name = `@${new Variable(name.slice(1), this.getIndex(), this.fileInfo()).eval(context).value}`;
+        }
+
+        if (this.evaluating) {
+            throw { type: 'Name',
+                message: `Recursive variable definition for ${name}`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+
+        this.evaluating = true;
+
+        variable = this.find(context.frames, frame => {
+            const v = frame.variable(name);
+            if (v) {
+                if (v.important) {
+                    const importantScope = context.importantScope[context.importantScope.length - 1];
+                    importantScope.important = v.important;
+                }
+                // If in calc, wrap vars in a function call to cascade evaluate args first
+                if (context.inCalc) {
+                    return (new Call('_SELF', [v.value])).eval(context);
+                }
+                else {
+                    return v.value.eval(context);
+                }
+            }
+        });
+        if (variable) {
+            this.evaluating = false;
+            return variable;
+        } else {
+            throw { type: 'Name',
+                message: `variable ${name} is undefined`,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+    }
+
+    find(obj, fun) {
+        for (let i = 0, r; i < obj.length; i++) {
+            r = fun.call(obj, obj[i]);
+            if (r) { return r; }
+        }
+        return null;
+    }
+}
+
+Variable.prototype.type = 'Variable';
+export default Variable;

package/lib/less/utils.js

@@ -0,0 +1,122 @@
+/* jshint proto: true */
+import * as Constants from './constants';
+import CloneHelper from 'clone';
+
+export function getLocation(index, inputStream) {
+    let n = index + 1;
+    let line = null;
+    let column = -1;
+
+    while (--n >= 0 && inputStream.charAt(n) !== '\n') {
+        column++;
+    }
+
+    if (typeof index === 'number') {
+        line = (inputStream.slice(0, index).match(/\n/g) || '').length;
+    }
+
+    return {
+        line,
+        column
+    };
+}
+
+export function copyArray(arr) {
+    let i;
+    const length = arr.length;
+    const copy = new Array(length);
+
+    for (i = 0; i < length; i++) {
+        copy[i] = arr[i];
+    }
+    return copy;
+}
+
+export function clone(obj) {
+    const cloned = {};
+    for (const prop in obj) {
+        if (obj.hasOwnProperty(prop)) {
+            cloned[prop] = obj[prop];
+        }
+    }
+    return cloned;
+}
+
+export function defaults(obj1, obj2) {
+    let newObj = obj2 || {};
+    if (!obj2._defaults) {
+        newObj = {};
+        const defaults = CloneHelper(obj1);
+        newObj._defaults = defaults;
+        const cloned = obj2 ? CloneHelper(obj2) : {};
+        Object.assign(newObj, defaults, cloned);
+    }
+    return newObj;
+}
+
+export function copyOptions(obj1, obj2) {
+    if (obj2 && obj2._defaults) {
+        return obj2;
+    }
+    const opts = defaults(obj1, obj2);
+    if (opts.strictMath) {
+        opts.math = Constants.Math.STRICT_LEGACY;
+    }
+    // Back compat with changed relativeUrls option
+    if (opts.relativeUrls) {
+        opts.rewriteUrls = Constants.RewriteUrls.ALL;
+    }
+    if (typeof opts.math === 'string') {
+        switch (opts.math.toLowerCase()) {
+            case 'always':
+                opts.math = Constants.Math.ALWAYS;
+                break;
+            case 'parens-division':
+                opts.math = Constants.Math.PARENS_DIVISION;
+                break;
+            case 'strict':
+            case 'parens':
+                opts.math = Constants.Math.PARENS;
+                break;
+            case 'strict-legacy':
+                opts.math = Constants.Math.STRICT_LEGACY;
+        }
+    }
+    if (typeof opts.rewriteUrls === 'string') {
+        switch (opts.rewriteUrls.toLowerCase()) {
+            case 'off':
+                opts.rewriteUrls = Constants.RewriteUrls.OFF;
+                break;
+            case 'local':
+                opts.rewriteUrls = Constants.RewriteUrls.LOCAL;
+                break;
+            case 'all':
+                opts.rewriteUrls = Constants.RewriteUrls.ALL;
+                break;
+        }
+    }
+    return opts;
+}
+
+export function merge(obj1, obj2) {
+    for (const prop in obj2) {
+        if (obj2.hasOwnProperty(prop)) {
+            obj1[prop] = obj2[prop];
+        }
+    }
+    return obj1;
+}
+
+export function flattenArray(arr, result = []) {
+    for (let i = 0, length = arr.length; i < length; i++) {
+        const value = arr[i];
+        if (Array.isArray(value)) {
+            flattenArray(value, result);
+        } else {
+            if (value !== undefined) {
+                result.push(value);
+            }
+        }
+    }
+    return result;
+}