less 4.9.1 → 5.0.0-alpha.10

package/lib/less/tree/node.js

@@ -1,310 +0,0 @@
-// @ts-check
-/**
- * @typedef {object} FileInfo
- * @property {string} [filename]
- * @property {string} [rootpath]
- * @property {string} [currentDirectory]
- * @property {string} [rootFilename]
- * @property {string} [entryPath]
- * @property {boolean} [reference]
- */
-
-/**
- * @typedef {object} VisibilityInfo
- * @property {number} [visibilityBlocks]
- * @property {boolean} [nodeVisible]
- */
-
-/**
- * @typedef {object} CSSOutput
- * @property {(chunk: string, fileInfo?: FileInfo, index?: number, mapLines?: boolean) => void} add
- * @property {() => boolean} isEmpty
- */
-
-/**
- * @typedef {object} EvalContext
- * @property {number} [numPrecision]
- * @property {(op?: string) => boolean} [isMathOn]
- * @property {number} [math]
- * @property {Node[]} [frames]
- * @property {Array<{important?: string}>} [importantScope]
- * @property {string[]} [paths]
- * @property {boolean} [compress]
- * @property {boolean} [strictUnits]
- * @property {boolean} [sourceMap]
- * @property {boolean} [importMultiple]
- * @property {string} [urlArgs]
- * @property {boolean} [javascriptEnabled]
- * @property {object} [pluginManager]
- * @property {number} [rewriteUrls]
- * @property {boolean} [inCalc]
- * @property {boolean} [mathOn]
- * @property {boolean[]} [calcStack]
- * @property {boolean[]} [parensStack]
- * @property {Node[]} [mediaBlocks]
- * @property {Node[]} [mediaPath]
- * @property {() => void} [inParenthesis]
- * @property {() => void} [outOfParenthesis]
- * @property {() => void} [enterCalc]
- * @property {() => void} [exitCalc]
- * @property {(path: string) => boolean} [pathRequiresRewrite]
- * @property {(path: string, rootpath?: string) => string} [rewritePath]
- * @property {(path: string) => string} [normalizePath]
- * @property {number} [tabLevel]
- * @property {boolean} [lastRule]
- */
-
-/**
- * @typedef {object} TreeVisitor
- * @property {(node: Node) => Node} visit
- * @property {(nodes: Node[], nonReplacing?: boolean) => Node[]} visitArray
- */
-
-/**
- * The reason why Node is a class and other nodes simply do not extend
- * from Node (since we're transpiling) is due to this issue:
- *
- * @see https://github.com/less/less.js/issues/3434
- */
-class Node {
-    get type() { return ''; }
-
-    constructor() {
-        /** @type {Node | null} */
-        this.parent = null;
-        /** @type {number | undefined} */
-        this.visibilityBlocks = undefined;
-        /** @type {boolean | undefined} */
-        this.nodeVisible = undefined;
-        /** @type {Node | null} */
-        this.rootNode = null;
-        /** @type {Node | null} */
-        this.parsed = null;
-
-        /** @type {Node | Node[] | string | number | undefined} */
-        this.value = undefined;
-        /** @type {number | undefined} */
-        this._index = undefined;
-        /** @type {FileInfo | undefined} */
-        this._fileInfo = undefined;
-    }
-
-    get currentFileInfo() {
-        return this.fileInfo();
-    }
-
-    get index() {
-        return this.getIndex();
-    }
-
-    /**
-     * @param {Node | Node[]} nodes
-     * @param {Node} parent
-     */
-    setParent(nodes, parent) {
-        /** @param {Node} node */
-        function set(node) {
-            if (node && node instanceof Node) {
-                node.parent = parent;
-            }
-        }
-        if (Array.isArray(nodes)) {
-            nodes.forEach(set);
-        }
-        else {
-            set(nodes);
-        }
-    }
-
-    /** @returns {number} */
-    getIndex() {
-        return this._index || (this.parent && this.parent.getIndex()) || 0;
-    }
-
-    /** @returns {FileInfo} */
-    fileInfo() {
-        return this._fileInfo || (this.parent && this.parent.fileInfo()) || {};
-    }
-
-    /** @returns {boolean} */
-    isRulesetLike() { return false; }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {string}
-     */
-    toCSS(context) {
-        /** @type {string[]} */
-        const strs = [];
-        this.genCSS(context, {
-            add: function(chunk, fileInfo, index) {
-                strs.push(chunk);
-            },
-            isEmpty: function () {
-                return strs.length === 0;
-            }
-        });
-        return strs.join('');
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add(/** @type {string} */ (this.value));
-    }
-
-    /**
-     * @param {TreeVisitor} visitor
-     */
-    accept(visitor) {
-        this.value = visitor.visit(/** @type {Node} */ (this.value));
-    }
-
-    /**
-     * @param {EvalContext} [context]
-     * @returns {Node}
-     */
-    eval(context) { return this; }
-
-    /**
-     * @param {EvalContext} context
-     * @param {string} op
-     * @param {number} a
-     * @param {number} b
-     * @returns {number | undefined}
-     */
-    _operate(context, op, a, b) {
-        switch (op) {
-            case '+': return a + b;
-            case '-': return a - b;
-            case '*': return a * b;
-            case '/': return a / b;
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {number} value
-     * @returns {number}
-     */
-    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;
-    }
-
-    /**
-     * @param {Node & { compare?: (other: Node) => number | undefined }} a
-     * @param {Node & { compare?: (other: Node) => number | undefined }} b
-     * @returns {number | undefined}
-     */
-    static 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;
-        }
-
-        let aVal = a.value;
-        let bVal = b.value;
-        if (!Array.isArray(aVal)) {
-            return aVal === bVal ? 0 : undefined;
-        }
-        if (!Array.isArray(bVal)) {
-            return undefined;
-        }
-        if (aVal.length !== bVal.length) {
-            return undefined;
-        }
-        for (let i = 0; i < aVal.length; i++) {
-            if (Node.compare(aVal[i], bVal[i]) !== 0) {
-                return undefined;
-            }
-        }
-        return 0;
-    }
-
-    /**
-     * @param {number | string} a
-     * @param {number | string} b
-     * @returns {number | undefined}
-     */
-    static numericCompare(a, b) {
-        return a  <  b ? -1
-            : a === b ?  0
-                : a  >  b ?  1 : undefined;
-    }
-
-    /** @returns {boolean} */
-    blocksVisibility() {
-        if (this.visibilityBlocks === undefined) {
-            this.visibilityBlocks = 0;
-        }
-        return this.visibilityBlocks !== 0;
-    }
-
-    addVisibilityBlock() {
-        if (this.visibilityBlocks === undefined) {
-            this.visibilityBlocks = 0;
-        }
-        this.visibilityBlocks = this.visibilityBlocks + 1;
-    }
-
-    removeVisibilityBlock() {
-        if (this.visibilityBlocks === undefined) {
-            this.visibilityBlocks = 0;
-        }
-        this.visibilityBlocks = this.visibilityBlocks - 1;
-    }
-
-    ensureVisibility() {
-        this.nodeVisible = true;
-    }
-
-    ensureInvisibility() {
-        this.nodeVisible = false;
-    }
-
-    /** @returns {boolean | undefined} */
-    isVisible() {
-        return this.nodeVisible;
-    }
-
-    /** @returns {VisibilityInfo} */
-    visibilityInfo() {
-        return {
-            visibilityBlocks: this.visibilityBlocks,
-            nodeVisible: this.nodeVisible
-        };
-    }
-
-    /** @param {VisibilityInfo} info */
-    copyVisibilityInfo(info) {
-        if (!info) {
-            return;
-        }
-        this.visibilityBlocks = info.visibilityBlocks;
-        this.nodeVisible = info.nodeVisible;
-    }
-}
-
-/**
- * Set by the parser at runtime on Node.prototype.
- * @type {{ context: EvalContext, importManager: object, imports: object } | undefined}
- */
-Node.prototype.parse = undefined;
-
-export default Node;

package/lib/less/tree/operation.js

@@ -1,81 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
-import Node from './node.js';
-import Color from './color.js';
-import Dimension from './dimension.js';
-import * as Constants from '../constants.js';
-const MATH = Constants.Math;
-
-class Operation extends Node {
-    get type() { return 'Operation'; }
-
-    /**
-     * @param {string} op
-     * @param {Node[]} operands
-     * @param {boolean} isSpaced
-     */
-    constructor(op, operands, isSpaced) {
-        super();
-        this.op = op.trim();
-        this.operands = operands;
-        this.isSpaced = isSpaced;
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        this.operands = visitor.visitArray(this.operands);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        let a = this.operands[0].eval(context), b = this.operands[1].eval(context), op;
-
-        if (context.isMathOn(this.op)) {
-            op = this.op === './' ? '/' : this.op;
-            if (a instanceof Dimension && b instanceof Color) {
-                a = /** @type {Dimension} */ (a).toColor();
-            }
-            if (b instanceof Dimension && a instanceof Color) {
-                b = /** @type {Dimension} */ (b).toColor();
-            }
-            if (!/** @type {Dimension | Color} */ (a).operate || !/** @type {Dimension | Color} */ (b).operate) {
-                if (
-                    (a instanceof Operation || b instanceof Operation)
-                    && /** @type {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' };
-            }
-
-            if (a instanceof Dimension) {
-                return a.operate(context, op, /** @type {Dimension} */ (b));
-            }
-            return /** @type {Color} */ (a).operate(context, op, /** @type {Color} */ (b));
-        } else {
-            return new Operation(this.op, [a, b], this.isSpaced);
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    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);
-    }
-}
-
-export default Operation;

package/lib/less/tree/paren.js

@@ -1,41 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput } from './node.js' */
-import Node from './node.js';
-
-class Paren extends Node {
-    get type() { return 'Paren'; }
-
-    /** @param {Node} node */
-    constructor(node) {
-        super();
-        this.value = node;
-        /** @type {boolean | undefined} */
-        this.noSpacing = undefined;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add('(');
-        /** @type {Node} */ (this.value).genCSS(context, output);
-        output.add(')');
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Paren}
-     */
-    eval(context) {
-        const paren = new Paren(/** @type {Node} */ (this.value).eval(context));
-
-        if (this.noSpacing) {
-            paren.noSpacing = true;
-        }
-
-        return paren;
-    }
-}
-
-export default Paren;

package/lib/less/tree/property.js

@@ -1,96 +0,0 @@
-// @ts-check
-/** @import { EvalContext, FileInfo } from './node.js' */
-import Node from './node.js';
-import Declaration from './declaration.js';
-import Ruleset from './ruleset.js';
-
-class Property extends Node {
-    get type() { return 'Property'; }
-
-    /**
-     * @param {string} name
-     * @param {number} index
-     * @param {FileInfo} currentFileInfo
-     */
-    constructor(name, index, currentFileInfo) {
-        super();
-        this.name = name;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        /** @type {boolean | undefined} */
-        this.evaluating = undefined;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        let property;
-        const name = this.name;
-        // TODO: shorten this reference
-        const mergeRules = /** @type {{ less: { visitors: { ToCSSVisitor: { prototype: { _mergeRules: (rules: Declaration[]) => void } } } } }} */ (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, function (/** @type {Node} */ frame) {
-            let v;
-            const vArr = /** @type {Ruleset} */ (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 };
-        }
-    }
-
-    /**
-     * @param {Node[]} obj
-     * @param {(frame: Node) => Node | undefined} fun
-     * @returns {Node | null}
-     */
-    find(obj, fun) {
-        for (let i = 0, r; i < obj.length; i++) {
-            r = fun.call(obj, obj[i]);
-            if (r) { return r; }
-        }
-        return null;
-    }
-}
-
-export default Property;

package/lib/less/tree/query-in-parens.js

@@ -1,64 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
-import Node from './node.js';
-
-class QueryInParens extends Node {
-    get type() { return 'QueryInParens'; }
-
-    /**
-     * @param {string} op
-     * @param {Node} l
-     * @param {Node} m
-     * @param {string | null} op2
-     * @param {Node | null} r
-     * @param {number} i
-     */
-    constructor(op, l, m, op2, r, i) {
-        super();
-        this.op = op.trim();
-        this.lvalue = l;
-        this.mvalue = m;
-        this.op2 = op2 ? op2.trim() : null;
-        /** @type {Node | null} */
-        this.rvalue = r;
-        this._index = i;
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        this.lvalue = visitor.visit(this.lvalue);
-        this.mvalue = visitor.visit(this.mvalue);
-        if (this.rvalue) {
-            this.rvalue = visitor.visit(this.rvalue);
-        }
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        const node = new QueryInParens(
-            this.op,
-            this.lvalue.eval(context),
-            this.mvalue.eval(context),
-            this.op2,
-            this.rvalue ? this.rvalue.eval(context) : null,
-            this._index || 0
-        );
-        return node;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        this.lvalue.genCSS(context, output);
-        output.add(' ' + this.op + ' ');
-        this.mvalue.genCSS(context, output);
-        if (this.rvalue) {
-            output.add(' ' + this.op2 + ' ');
-            this.rvalue.genCSS(context, output);
-        }
-    }
-}
-
-export default QueryInParens;