less 4.8.1 → 5.0.0-alpha.1

package/lib/less/tree/negative.js

@@ -1,37 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput } from './node.js' */
-import Node from './node.js';
-import Operation from './operation.js';
-import Dimension from './dimension.js';
-
-class Negative extends Node {
-    get type() { return 'Negative'; }
-
-    /** @param {Node} node */
-    constructor(node) {
-        super();
-        this.value = node;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add('-');
-        /** @type {Node} */ (this.value).genCSS(context, output);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        if (context.isMathOn('*')) {
-            return (new Operation('*', [new Dimension(-1), /** @type {Node} */ (this.value)], false)).eval(context);
-        }
-        return new Negative(/** @type {Node} */ (this.value).eval(context));
-    }
-}
-
-export default Negative;

package/lib/less/tree/nested-at-rule.js

@@ -1,198 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
-import Ruleset from './ruleset.js';
-import Value from './value.js';
-import Selector from './selector.js';
-import Anonymous from './anonymous.js';
-import Expression from './expression.js';
-import * as utils from '../utils.js';
-import Node from './node.js';
-
-/**
- * @typedef {object} FunctionRegistry
- * @property {(name: string, func: Function) => void} add
- * @property {(functions: Object) => void} addMultiple
- * @property {(name: string) => Function} get
- * @property {() => Object} getLocalFunctions
- * @property {() => FunctionRegistry} inherit
- * @property {(base: FunctionRegistry) => FunctionRegistry} create
- */
-
-/**
- * @typedef {Node & {
- *   features: Value,
- *   rules: Ruleset[],
- *   type: string,
- *   functionRegistry?: FunctionRegistry,
- *   multiMedia?: boolean,
- *   debugInfo?: { lineNumber: number, fileName: string },
- *   allowRoot?: boolean,
- *   _evaluated?: boolean,
- *   evalFunction: () => void,
- *   evalTop: (context: EvalContext) => Node | Ruleset,
- *   evalNested: (context: EvalContext) => Node | Ruleset,
- *   permute: (arr: Node[][]) => Node[][],
- *   bubbleSelectors: (selectors: Selector[] | undefined) => void,
- *   outputRuleset: (context: EvalContext, output: CSSOutput, rules: Node[]) => void
- * }} NestableAtRuleThis
- */
-
-const NestableAtRulePrototype = {
-
-    isRulesetLike() {
-        return true;
-    },
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (self.features) {
-            self.features = /** @type {Value} */ (visitor.visit(self.features));
-        }
-        if (self.rules) {
-            self.rules = /** @type {Ruleset[]} */ (visitor.visitArray(self.rules));
-        }
-    },
-
-    evalFunction: function () {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (!self.features || !Array.isArray(self.features.value) || self.features.value.length < 1) {
-            return;
-        }
-
-        const exprValues = /** @type {Node[]} */ (self.features.value);
-        /** @type {Node | undefined} */
-        let expr;
-        /** @type {Node | undefined} */
-        let paren;
-
-        for (let index = 0; index < exprValues.length; ++index) {
-            expr = exprValues[index];
-
-            if ((expr.type === 'Keyword' || expr.type === 'Variable')
-                && index + 1 < exprValues.length
-                && (/** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing || /** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing == null)) {
-                paren =  exprValues[index + 1];
-
-                if (paren.type ===  'Paren' && /** @type {Node & { noSpacing?: boolean }} */ (paren).noSpacing) {
-                    exprValues[index]= new Expression([expr, paren]);
-                    exprValues.splice(index + 1, 1);
-                    /** @type {Node & { noSpacing?: boolean }} */ (exprValues[index]).noSpacing = true;
-                }
-            }
-        }
-    },
-
-    /** @param {EvalContext} context */
-    evalTop(context) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        self.evalFunction();
-
-        /** @type {Node | Ruleset} */
-        let result = self;
-
-        // Render all dependent Media blocks.
-        if (context.mediaBlocks.length > 1) {
-            const selectors = (new Selector([], null, null, self.getIndex(), self.fileInfo())).createEmptySelectors();
-            result = new Ruleset(selectors, context.mediaBlocks);
-            /** @type {Ruleset & { multiMedia?: boolean }} */ (result).multiMedia = true;
-            result.copyVisibilityInfo(self.visibilityInfo());
-            self.setParent(result, self);
-        }
-
-        delete context.mediaBlocks;
-        delete context.mediaPath;
-
-        return result;
-    },
-
-    /** @param {EvalContext} context */
-    evalNested(context) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        self.evalFunction();
-
-        let i;
-        /** @type {Node | Node[]} */
-        let value;
-        const path = context.mediaPath.concat([self]);
-
-        // Extract the media-query conditions separated with `,` (OR).
-        for (i = 0; i < path.length; i++) {
-            if (path[i].type !== self.type) {
-                const blockIndex = context.mediaBlocks.indexOf(self);
-                if (blockIndex > -1) {
-                    context.mediaBlocks.splice(blockIndex, 1);
-                }
-                return self;
-            }
-
-            value = /** @type {NestableAtRuleThis} */ (path[i]).features instanceof Value ?
-                /** @type {Node[]} */ (/** @type {NestableAtRuleThis} */ (path[i]).features.value) : /** @type {NestableAtRuleThis} */ (path[i]).features;
-            path[i] = /** @type {Node} */ (/** @type {unknown} */ (Array.isArray(value) ? value : [value]));
-        }
-
-        // Trace all permutations to generate the resulting media-query.
-        //
-        // (a, b and c) with nested (d, e) ->
-        //    a and d
-        //    a and e
-        //    b and c and d
-        //    b and c and e
-        self.features = new Value(self.permute(/** @type {Node[][]} */ (/** @type {unknown} */ (path))).map(
-            /** @param {Node | Node[]} path */
-            path => {
-                path = /** @type {Node[]} */ (path).map(
-                /** @param {Node & { toCSS?: Function }} fragment */
-                    fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
-
-                for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
-                /** @type {Node[]} */ (path).splice(i, 0, new Anonymous('and'));
-                }
-
-                return new Expression(/** @type {Node[]} */ (path));
-            }));
-        self.setParent(self.features, self);
-
-        // Fake a tree-node that doesn't output anything.
-        return new Ruleset([], []);
-    },
-
-    /**
-     * @param {Node[][]} arr
-     * @returns {Node[][]}
-     */
-    permute(arr) {
-        if (arr.length === 0) {
-            return [];
-        } else if (arr.length === 1) {
-            return /** @type {Node[][]} */ (/** @type {unknown} */ (arr[0]));
-        } else {
-            /** @type {Node[][]} */
-            const result = [];
-            const rest = this.permute(arr.slice(1));
-            for (let i = 0; i < rest.length; i++) {
-                for (let j = 0; j < arr[0].length; j++) {
-                    result.push([arr[0][j]].concat(rest[i]));
-                }
-            }
-            return result;
-        }
-    },
-
-    /** @param {Selector[] | undefined} selectors */
-    bubbleSelectors(selectors) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (!selectors) {
-            return;
-        }
-        self.rules = [new Ruleset(utils.copyArray(selectors), [self.rules[0]])];
-        self.setParent(self.rules, self);
-    }
-};
-
-export default NestableAtRulePrototype;

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;