less 4.8.1 → 5.0.0-alpha.1

package/lib/less/tree/selector.js

@@ -1,201 +0,0 @@
-// @ts-check
-import Node from './node.js';
-import Element from './element.js';
-import LessError from '../less-error.js';
-import * as utils from '../utils.js';
-import Parser from '../parser/parser.js';
-
-/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo, TreeVisitor } from './node.js' */
-
-class Selector extends Node {
-    get type() { return 'Selector'; }
-
-    /**
-     * @param {(Element | Selector)[] | string} [elements]
-     * @param {Node[] | null} [extendList]
-     * @param {Node | null} [condition]
-     * @param {number} [index]
-     * @param {FileInfo} [currentFileInfo]
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    constructor(elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
-        super();
-        /** @type {Node[] | null | undefined} */
-        this.extendList = extendList;
-        /** @type {Node | null | undefined} */
-        this.condition = condition;
-        /** @type {boolean | Node} */
-        this.evaldCondition = !condition;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        /** @type {Element[]} */
-        this.elements = this.getElements(elements);
-        /** @type {string[] | undefined} */
-        this.mixinElements_ = undefined;
-        /** @type {boolean | undefined} */
-        this.mediaEmpty = undefined;
-        this.copyVisibilityInfo(visibilityInfo);
-        this.setParent(this.elements, this);
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        if (this.elements) {
-            this.elements = /** @type {Element[]} */ (visitor.visitArray(this.elements));
-        }
-        if (this.extendList) {
-            this.extendList = visitor.visitArray(this.extendList);
-        }
-        if (this.condition) {
-            this.condition = visitor.visit(this.condition);
-        }
-    }
-
-    /**
-     * @param {Element[]} elements
-     * @param {Node[] | null} [extendList]
-     * @param {boolean | Node} [evaldCondition]
-     */
-    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 = (!utils.isNullOrUndefined(evaldCondition)) ? evaldCondition : this.evaldCondition;
-        newSelector.mediaEmpty = this.mediaEmpty;
-        return newSelector;
-    }
-
-    /**
-     * @param {(Element | Selector)[] | string | null | undefined} els
-     * @returns {Element[]}
-     */
-    getElements(els) {
-        if (!els) {
-            return [new Element('', '&', false, this._index, this._fileInfo)];
-        }
-        if (typeof els === 'string') {
-            const fileInfo = this._fileInfo;
-            const parse = this.parse;
-            new (/** @type {new (...args: unknown[]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(parse.context, parse.importManager, fileInfo, this._index).parseNode(
-                els,
-                ['selector'],
-                function(/** @type {{ index: number, message: string } | null} */ err, /** @type {Selector[]} */ result) {
-                    if (err) {
-                        throw new LessError({
-                            index: err.index,
-                            message: err.message
-                        }, parse.imports, /** @type {string} */ (/** @type {FileInfo} */ (fileInfo).filename));
-                    }
-                    els = result[0].elements;
-                });
-        }
-        return /** @type {Element[]} */ (els);
-    }
-
-    createEmptySelectors() {
-        const el = new Element('', '&', false, this._index, this._fileInfo), sels = [new Selector([el], null, null, this._index, this._fileInfo)];
-        sels[0].mediaEmpty = true;
-        return sels;
-    }
-
-    /**
-     * @param {Selector} other
-     * @returns {number}
-     */
-    match(other) {
-        const elements = this.elements;
-        const len = elements.length;
-        let olen;
-        let i;
-
-        /** @type {string[]} */
-        const mixinEls = other.mixinElements();
-        olen = mixinEls.length;
-        if (olen === 0 || len < olen) {
-            return 0;
-        } else {
-            for (i = 0; i < olen; i++) {
-                if (elements[i].value !== mixinEls[i]) {
-                    return 0;
-                }
-            }
-        }
-
-        return olen; // return number of matched elements
-    }
-
-    /** @returns {string[]} */
-    mixinElements() {
-        if (this.mixinElements_) {
-            return this.mixinElements_;
-        }
-
-        /** @type {string[] | null} */
-        let elements = this.elements.map( function(v) {
-            return /** @type {string} */ (v.combinator.value) + (/** @type {{ value: string }} */ (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 === '');
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        const evaldCondition = this.condition && this.condition.eval(context);
-        let elements = this.elements;
-        /** @type {Node[] | null | undefined} */
-        let extendList = this.extendList;
-
-        if (elements) {
-            const evaldElements = new Array(elements.length);
-            for (let i = 0; i < elements.length; i++) {
-                evaldElements[i] = elements[i].eval(context);
-            }
-            elements = evaldElements;
-        }
-        if (extendList) {
-            const evaldExtends = new Array(extendList.length);
-            for (let i = 0; i < extendList.length; i++) {
-                evaldExtends[i] = extendList[i].eval(context);
-            }
-            extendList = evaldExtends;
-        }
-
-        return this.createDerived(elements, extendList, evaldCondition);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        let i, element;
-        if ((!context || !/** @type {EvalContext & { firstSelector?: boolean }} */ (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;
-    }
-}
-
-export default Selector;

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

@@ -1,14 +0,0 @@
-// @ts-check
-import Node from './node.js';
-
-class UnicodeDescriptor extends Node {
-    get type() { return 'UnicodeDescriptor'; }
-
-    /** @param {string} value */
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-}
-
-export default UnicodeDescriptor;

package/lib/less/tree/unit.js

@@ -1,170 +0,0 @@
-// @ts-check
-import Node from './node.js';
-import unitConversions from '../data/unit-conversions.js';
-import * as utils from '../utils.js';
-
-/** @import { EvalContext, CSSOutput } from './node.js' */
-
-class Unit extends Node {
-    get type() { return 'Unit'; }
-
-    /**
-     * @param {string[]} [numerator]
-     * @param {string[]} [denominator]
-     * @param {string} [backupUnit]
-     */
-    constructor(numerator, denominator, backupUnit) {
-        super();
-        /** @type {string[]} */
-        this.numerator = numerator ? utils.copyArray(numerator).sort() : [];
-        /** @type {string[]} */
-        this.denominator = denominator ? utils.copyArray(denominator).sort() : [];
-        if (backupUnit) {
-            /** @type {string | undefined} */
-            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);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    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, returnStr = this.numerator.join('*');
-        for (i = 0; i < this.denominator.length; i++) {
-            returnStr += `/${this.denominator[i]}`;
-        }
-        return returnStr;
-    }
-
-    /**
-     * @param {Unit} other
-     * @returns {0 | undefined}
-     */
-    compare(other) {
-        return this.is(other.toString()) ? 0 : undefined;
-    }
-
-    /** @param {string} unitString */
-    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(/** @type {import('./node.js').EvalContext} */ ({})));
-    }
-
-    isEmpty() {
-        return this.numerator.length === 0 && this.denominator.length === 0;
-    }
-
-    isSingular() {
-        return this.numerator.length <= 1 && this.denominator.length === 0;
-    }
-
-    /** @param {(atomicUnit: string, denominator: boolean) => string} callback */
-    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);
-        }
-    }
-
-    /** @returns {{ [groupName: string]: string }} */
-    usedUnits() {
-        /** @type {{ [unitName: string]: number }} */
-        let group;
-        /** @type {{ [groupName: string]: string }} */
-        const result = {};
-        /** @type {(atomicUnit: string) => string} */
-        let mapUnit;
-        /** @type {string} */
-        let groupName;
-
-        mapUnit = function (atomicUnit) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
-                result[groupName] = atomicUnit;
-            }
-
-            return atomicUnit;
-        };
-
-        for (groupName in unitConversions) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (unitConversions.hasOwnProperty(groupName)) {
-                group = /** @type {{ [unitName: string]: number }} */ (unitConversions[/** @type {keyof typeof unitConversions} */ (groupName)]);
-
-                this.map(mapUnit);
-            }
-        }
-
-        return result;
-    }
-
-    cancel() {
-        /** @type {{ [unit: string]: number }} */
-        const counter = {};
-        /** @type {string} */
-        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) {
-            // eslint-disable-next-line no-prototype-builtins
-            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();
-    }
-}
-
-export default Unit;

package/lib/less/tree/url.js

@@ -1,83 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo } from './node.js' */
-import Node from './node.js';
-
-/**
- * @param {string} path
- * @returns {string}
- */
-function escapePath(path) {
-    return path.replace(/[()'"\s]/g, function(match) { return `\\${match}`; });
-}
-
-class URL extends Node {
-    get type() { return 'Url'; }
-
-    /**
-     * @param {Node} val
-     * @param {number} index
-     * @param {FileInfo} currentFileInfo
-     * @param {boolean} [isEvald]
-     */
-    constructor(val, index, currentFileInfo, isEvald) {
-        super();
-        this.value = val;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        /** @type {boolean | undefined} */
-        this.isEvald = isEvald;
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        this.value = visitor.visit(/** @type {Node} */ (this.value));
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add('url(');
-        /** @type {Node} */ (this.value).genCSS(context, output);
-        output.add(')');
-    }
-
-    /** @param {EvalContext} context */
-    eval(context) {
-        const val = /** @type {Node} */ (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(/** @type {string} */ (val.value))) {
-                if (!/** @type {import('./quoted.js').default} */ (val).quote) {
-                    rootpath = escapePath(rootpath);
-                }
-                val.value = context.rewritePath(/** @type {string} */ (val.value), rootpath);
-            } else {
-                val.value = context.normalizePath(/** @type {string} */ (val.value));
-            }
-
-            // Add url args if enabled
-            if (context.urlArgs) {
-                if (!/** @type {string} */ (val.value).match(/^\s*data:/)) {
-                    const delimiter = /** @type {string} */ (val.value).indexOf('?') === -1 ? '?' : '&';
-                    const urlArgs = delimiter + context.urlArgs;
-                    if (/** @type {string} */ (val.value).indexOf('#') !== -1) {
-                        val.value = /** @type {string} */ (val.value).replace('#', `${urlArgs}#`);
-                    } else {
-                        val.value += urlArgs;
-                    }
-                }
-            }
-        }
-
-        return new URL(val, this.getIndex(), this.fileInfo(), true);
-    }
-}
-
-export default URL;

package/lib/less/tree/value.js

@@ -1,60 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor } from './node.js' */
-import Node from './node.js';
-
-class Value extends Node {
-    get type() { return 'Value'; }
-
-    /** @param {Node[] | Node} value */
-    constructor(value) {
-        super();
-        if (!value) {
-            throw new Error('Value requires an array argument');
-        }
-        if (!Array.isArray(value)) {
-            this.value = [ value ];
-        }
-        else {
-            this.value = value;
-        }
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        if (this.value) {
-            this.value = visitor.visitArray(/** @type {Node[]} */ (this.value));
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        const value = /** @type {Node[]} */ (this.value);
-        if (value.length === 1) {
-            return value[0].eval(context);
-        } else {
-            return new Value(value.map(function (v) {
-                return v.eval(context);
-            }));
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        const value = /** @type {Node[]} */ (this.value);
-        let i;
-        for (i = 0; i < value.length; i++) {
-            value[i].genCSS(context, output);
-            if (i + 1 < value.length) {
-                output.add((context && context.compress) ? ',' : ', ');
-            }
-        }
-    }
-}
-
-export default Value;

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

@@ -1,60 +0,0 @@
-// @ts-check
-/** @import { EvalContext, FileInfo } from './node.js' */
-import Node from './node.js';
-import Variable from './variable.js';
-import Ruleset from './ruleset.js';
-import DetachedRuleset from './detached-ruleset.js';
-import LessError from '../less-error.js';
-
-class VariableCall extends Node {
-    get type() { return 'VariableCall'; }
-
-    /**
-     * @param {string} variable
-     * @param {number} index
-     * @param {FileInfo} currentFileInfo
-     */
-    constructor(variable, index, currentFileInfo) {
-        super();
-        this.variable = variable;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        this.allowRoot = true;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        let rules;
-        /** @type {DetachedRuleset | Node} */
-        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 (!(/** @type {DetachedRuleset} */ (detachedRuleset)).ruleset) {
-            const dr = /** @type {Node & { rules?: Node[] }} */ (detachedRuleset);
-            if (dr.rules) {
-                rules = detachedRuleset;
-            }
-            else if (Array.isArray(detachedRuleset)) {
-                rules = new Ruleset(null, detachedRuleset);
-            }
-            else if (Array.isArray(detachedRuleset.value)) {
-                rules = new Ruleset(null, detachedRuleset.value);
-            }
-            else {
-                throw error;
-            }
-            detachedRuleset = new DetachedRuleset(rules);
-        }
-
-        const dr = /** @type {DetachedRuleset} */ (detachedRuleset);
-        if (dr.ruleset) {
-            return dr.callEval(context);
-        }
-        throw error;
-    }
-}
-
-export default VariableCall;

package/lib/less/tree/variable.js

@@ -1,85 +0,0 @@
-// @ts-check
-/** @import { EvalContext, FileInfo } from './node.js' */
-import Node from './node.js';
-import Call from './call.js';
-import Ruleset from './ruleset.js';
-
-class Variable extends Node {
-    get type() { return 'Variable'; }
-
-    /**
-     * @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 variable, 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, function (frame) {
-            const v = /** @type {Ruleset} */ (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], 0, undefined)).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() };
-        }
-    }
-
-    /**
-     * @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 Variable;