less 4.9.1 → 5.0.0-alpha.10

package/lib/less/tree/declaration.js

@@ -1,142 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, FileInfo } from './node.js' */
-import Node from './node.js';
-import Value from './value.js';
-import Keyword from './keyword.js';
-import Anonymous from './anonymous.js';
-import * as Constants from '../constants.js';
-const MATH = Constants.Math;
-
-/**
- * @param {EvalContext} context
- * @param {Node[]} name
- * @returns {string}
- */
-function evalName(context, name) {
-    let value = '';
-    let i;
-    const n = name.length;
-    /** @type {CSSOutput} */
-    const output = {add: function (s) {value += s;}, isEmpty: function() { return value === ''; }};
-    for (i = 0; i < n; i++) {
-        name[i].eval(context).genCSS(context, output);
-    }
-    return value;
-}
-
-class Declaration extends Node {
-    get type() { return 'Declaration'; }
-
-    /**
-     * @param {string | Node[]} name
-     * @param {Node | string | null} value
-     * @param {string} [important]
-     * @param {string} [merge]
-     * @param {number} [index]
-     * @param {FileInfo} [currentFileInfo]
-     * @param {boolean} [inline]
-     * @param {boolean} [variable]
-     */
-    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()}` : '';
-        /** @type {string | undefined} */
-        this.merge = merge;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        /** @type {boolean} */
-        this.inline = inline || false;
-        /** @type {boolean} */
-        this.variable = (variable !== undefined) ? variable
-            : (typeof name === 'string' && name.charAt(0) === '@');
-        /** @type {boolean} */
-        this.allowRoot = true;
-        this.setParent(this.value, this);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add(/** @type {string} */ (this.name) + (context.compress ? ':' : ': '), this.fileInfo(), this.getIndex());
-        try {
-            /** @type {Node} */ (this.value).genCSS(context, output);
-        }
-        catch (e) {
-            const err = /** @type {{ index?: number, filename?: string }} */ (e);
-            err.index = this._index;
-            err.filename = this._fileInfo && this._fileInfo.filename;
-            throw e;
-        }
-        output.add(this.important + ((this.inline || (context.lastRule && context.compress)) ? '' : ';'), this._fileInfo, this._index);
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        let mathBypass = false, prevMath, name = this.name, evaldValue, variable = this.variable;
-        if (typeof name !== 'string') {
-            // expand 'primitive' name directly to get
-            // things faster (~10% for benchmark.less):
-            name = (/** @type {Node[]} */ (name).length === 1) && (/** @type {Node[]} */ (name)[0] instanceof Keyword) ?
-                /** @type {string} */ (/** @type {Node[]} */ (name)[0].value) : evalName(context, /** @type {Node[]} */ (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 = /** @type {Node} */ (this.value).eval(context);
-
-            // A mixin call used as a property value (without a lookup) evaluates
-            // to its ruleset, which arrives here as an array of rules; without
-            // this guard it renders as `[object Object]`.
-            if (!this.variable && (evaldValue.type === 'DetachedRuleset' || Array.isArray(evaldValue))) {
-                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 && importantResult.important) {
-                important = importantResult.important;
-            }
-
-            return new Declaration(/** @type {string} */ (name),
-                evaldValue,
-                important,
-                this.merge,
-                this.getIndex(), this.fileInfo(), this.inline,
-                variable);
-        }
-        catch (e) {
-            const err = /** @type {{ index?: number, filename?: string }} */ (e);
-            if (typeof err.index !== 'number') {
-                err.index = this.getIndex();
-                err.filename = this.fileInfo().filename;
-            }
-            throw e;
-        }
-        finally {
-            if (mathBypass) {
-                context.math = prevMath;
-            }
-        }
-    }
-
-    makeImportant() {
-        return new Declaration(this.name,
-            /** @type {Node} */ (this.value),
-            '!important',
-            this.merge,
-            this.getIndex(), this.fileInfo(), this.inline);
-    }
-}
-
-export default Declaration;

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

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

package/lib/less/tree/dimension.js

@@ -1,215 +0,0 @@
-// @ts-check
-/* eslint-disable no-prototype-builtins */
-import Node from './node.js';
-import unitConversions from '../data/unit-conversions.js';
-import Unit from './unit.js';
-import Color from './color.js';
-
-/** @import { EvalContext, CSSOutput } from './node.js' */
-
-//
-// A number with a unit
-//
-class Dimension extends Node {
-    get type() { return 'Dimension'; }
-
-    /**
-     * @param {number | string} value
-     * @param {Unit | string} [unit]
-     */
-    constructor(value, unit) {
-        super();
-        /** @type {number} */
-        this.value = parseFloat(/** @type {string} */ (value));
-        if (isNaN(this.value)) {
-            throw new Error('Dimension is not a number.');
-        }
-        /** @type {Unit} */
-        this.unit = (unit && unit instanceof Unit) ? unit :
-            new Unit(unit ? [/** @type {string} */ (unit)] : undefined);
-        this.setParent(this.unit, this);
-    }
-
-    /**
-     * @param {import('./node.js').TreeVisitor} visitor
-     */
-    accept(visitor) {
-        this.unit = /** @type {Unit} */ (visitor.visit(this.unit));
-    }
-
-    // remove when Nodes have JSDoc types
-    // eslint-disable-next-line no-unused-vars
-    /** @param {EvalContext} context */
-    eval(context) {
-        return this;
-    }
-
-    toColor() {
-        const v = /** @type {number} */ (this.value);
-        return new Color([v, v, v]);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    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, /** @type {number} */ (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).slice(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`.
-    /**
-     * @param {EvalContext} context
-     * @param {string} op
-     * @param {Dimension} other
-     */
-    operate(context, op, other) {
-        /* jshint noempty:false */
-        let value = this._operate(context, op, /** @type {number} */ (this.value), /** @type {number} */ (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, /** @type {number} */ (this.value), /** @type {number} */ (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(/** @type {number} */ (value), unit);
-    }
-
-    /**
-     * @param {Node} other
-     * @returns {number | undefined}
-     */
-    compare(other) {
-        let a, 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(/** @type {number} */ (a.value), /** @type {number} */ (b.value));
-    }
-
-    unify() {
-        return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
-    }
-
-    /**
-     * @param {string | { [groupName: string]: string }} conversions
-     * @returns {Dimension}
-     */
-    convertTo(conversions) {
-        let value = /** @type {number} */ (this.value);
-        const unit = this.unit.clone();
-        let i;
-        /** @type {string} */
-        let groupName;
-        /** @type {{ [unitName: string]: number }} */
-        let group;
-        /** @type {string} */
-        let targetUnit;
-        /** @type {{ [groupName: string]: string }} */
-        let derivedConversions = {};
-        /** @type {(atomicUnit: string, denominator: boolean) => string} */
-        let applyUnit;
-
-        if (typeof conversions === 'string') {
-            for (i in unitConversions) {
-                if (unitConversions[/** @type {keyof typeof unitConversions} */ (i)].hasOwnProperty(conversions)) {
-                    derivedConversions = {};
-                    derivedConversions[i] = conversions;
-                }
-            }
-            conversions = derivedConversions;
-        }
-        applyUnit = function (atomicUnit, denominator) {
-            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 = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);
-
-                unit.map(applyUnit);
-            }
-        }
-
-        unit.cancel();
-
-        return new Dimension(value, unit);
-    }
-}
-
-export default Dimension;

package/lib/less/tree/element.js

@@ -1,93 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
-import Node from './node.js';
-import Paren from './paren.js';
-import Combinator from './combinator.js';
-
-class Element extends Node {
-    get type() { return 'Element'; }
-
-    /**
-     * @param {Combinator | string} combinator
-     * @param {string | Node} value
-     * @param {boolean} [isVariable]
-     * @param {number} [index]
-     * @param {FileInfo} [currentFileInfo]
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    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 = '';
-        }
-        /** @type {boolean | undefined} */
-        this.isVariable = isVariable;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        this.copyVisibilityInfo(visibilityInfo);
-        this.setParent(this.combinator, this);
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        const value = this.value;
-        this.combinator = /** @type {Combinator} */ (visitor.visit(this.combinator));
-        if (typeof value === 'object') {
-            this.value = visitor.visit(/** @type {Node} */ (value));
-        }
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        return new Element(this.combinator,
-            /** @type {Node} */ (this.value).eval ? /** @type {Node} */ (this.value).eval(context) : /** @type {string} */ (this.value),
-            this.isVariable,
-            this.getIndex(),
-            this.fileInfo(), this.visibilityInfo());
-    }
-
-    clone() {
-        return new Element(this.combinator,
-            /** @type {string | Node} */ (this.value),
-            this.isVariable,
-            this.getIndex(),
-            this.fileInfo(), this.visibilityInfo());
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add(this.toCSS(context), this.fileInfo(), this.getIndex());
-    }
-
-    /** @param {EvalContext} [context] */
-    toCSS(context) {
-        /** @type {EvalContext & { firstSelector?: boolean }} */
-        const ctx = context || {};
-        let value = this.value;
-        const firstSelector = ctx.firstSelector;
-        if (value instanceof Paren) {
-            // selector in parens should not be affected by outer selector
-            // flags (breaks only interpolated selectors - see #1973)
-            ctx.firstSelector = true;
-        }
-        value = /** @type {Node} */ (value).toCSS ? /** @type {Node} */ (value).toCSS(ctx) : /** @type {string} */ (value);
-        ctx.firstSelector = firstSelector;
-        if (value === '' && this.combinator.value.charAt(0) === '&') {
-            return '';
-        } else {
-            return this.combinator.toCSS(ctx) + value;
-        }
-    }
-}
-
-export default Element;

package/lib/less/tree/expression.js

@@ -1,100 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
-import Node from './node.js';
-import Paren from './paren.js';
-import Comment from './comment.js';
-import Dimension from './dimension.js';
-import Anonymous from './anonymous.js';
-
-class Expression extends Node {
-    get type() { return 'Expression'; }
-
-    /**
-     * @param {Node[]} value
-     * @param {boolean} [noSpacing]
-     */
-    constructor(value, noSpacing) {
-        super();
-        this.value = value;
-        /** @type {boolean | undefined} */
-        this.noSpacing = noSpacing;
-        /** @type {boolean | undefined} */
-        this.parens = undefined;
-        /** @type {boolean | undefined} */
-        this.parensInOp = undefined;
-        if (!value) {
-            throw new Error('Expression requires an array parameter');
-        }
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        const noSpacing = this.noSpacing;
-        /** @type {Node | Expression} */
-        let returnValue;
-        const mathOn = context.isMathOn();
-        const inParenthesis = this.parens;
-
-        let doubleParen = false;
-        if (inParenthesis) {
-            context.inParenthesis();
-        }
-        const value = /** @type {Node[]} */ (this.value);
-        if (value.length > 1) {
-            returnValue = new Expression(value.map(function (e) {
-                if (!e.eval) {
-                    return e;
-                }
-                return e.eval(context);
-            }), this.noSpacing);
-        } else if (value.length === 1) {
-            const first = /** @type {Expression} */ (value[0]);
-            if (first.parens && !first.parensInOp && !context.inCalc) {
-                doubleParen = true;
-            }
-            returnValue = 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);
-        }
-        /** @type {Expression} */ (returnValue).noSpacing =
-            /** @type {Expression} */ (returnValue).noSpacing || noSpacing;
-        return returnValue;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        const value = /** @type {Node[]} */ (this.value);
-        for (let i = 0; i < value.length; i++) {
-            value[i].genCSS(context, output);
-            if (!this.noSpacing && i + 1 < value.length) {
-                if (!(value[i + 1] instanceof Anonymous) ||
-                    value[i + 1] instanceof Anonymous && /** @type {string} */ (value[i + 1].value) !== ',') {
-                    output.add(' ');
-                }
-            }
-        }
-    }
-
-    throwAwayComments() {
-        this.value = /** @type {Node[]} */ (this.value).filter(function(v) {
-            return !(v instanceof Comment);
-        });
-    }
-}
-
-export default Expression;

package/lib/less/tree/extend.js

@@ -1,88 +0,0 @@
-// @ts-check
-/** @import { EvalContext, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
-import Node from './node.js';
-import Selector from './selector.js';
-
-class Extend extends Node {
-    get type() { return 'Extend'; }
-
-    /**
-     * @param {Selector} selector
-     * @param {string} option
-     * @param {number} index
-     * @param {FileInfo} currentFileInfo
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    constructor(selector, option, index, currentFileInfo, visibilityInfo) {
-        super();
-        this.selector = selector;
-        this.option = option;
-        this.object_id = Extend.next_id++;
-        /** @type {number[]} */
-        this.parent_ids = [this.object_id];
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        this.copyVisibilityInfo(visibilityInfo);
-        /** @type {boolean} */
-        this.allowRoot = true;
-        /** @type {boolean} */
-        this.allowBefore = false;
-        /** @type {boolean} */
-        this.allowAfter = false;
-
-        switch (option) {
-            case '!all':
-            case 'all':
-                this.allowBefore = true;
-                this.allowAfter = true;
-                break;
-            default:
-                this.allowBefore = false;
-                this.allowAfter = false;
-                break;
-        }
-        this.setParent(this.selector, this);
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        this.selector = /** @type {Selector} */ (visitor.visit(this.selector));
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        return new Extend(/** @type {Selector} */ (this.selector.eval(context)), this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    }
-
-    // remove when Nodes have JSDoc types
-    // eslint-disable-next-line no-unused-vars
-    /** @param {EvalContext} [context] */
-    clone(context) {
-        return new Extend(this.selector, this.option, this.getIndex(), this.fileInfo(), this.visibilityInfo());
-    }
-
-    // it concatenates (joins) all selectors in selector array
-    /** @param {Selector[]} selectors */
-    findSelfSelectors(selectors) {
-        /** @type {import('./element.js').default[]} */
-        let selfElements = [];
-        let i, 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);
-        }
-
-        /** @type {Selector[]} */
-        this.selfSelectors = [new Selector(selfElements)];
-        this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
-    }
-}
-
-Extend.next_id = 0;
-export default Extend;