less 4.8.1 → 5.0.0-alpha.1

package/lib/less/tree/import.js

@@ -1,299 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
-import Node from './node.js';
-import Media from './media.js';
-import URL from './url.js';
-import Quoted from './quoted.js';
-import Ruleset from './ruleset.js';
-import Anonymous from './anonymous.js';
-import Expression from './expression.js';
-import * as utils from '../utils.js';
-import LessError from '../less-error.js';
-
-/**
- * @typedef {object} ImportOptions
- * @property {boolean} [less]
- * @property {boolean} [inline]
- * @property {boolean} [isPlugin]
- * @property {boolean} [reference]
- */
-
-//
-// CSS @import node
-//
-// The general strategy here is that we don't want to wait
-// for the parsing to be completed, before we start importing
-// the file. That's because in the context of a browser,
-// most of the time will be spent waiting for the server to respond.
-//
-// On creation, we push the import path to our import queue, though
-// `import,push`, we also pass it a callback, which it'll call once
-// the file has been fetched, and parsed.
-//
-class Import extends Node {
-    get type() { return 'Import'; }
-
-    /**
-     * @param {Node} path
-     * @param {Node | null} features
-     * @param {ImportOptions} options
-     * @param {number} index
-     * @param {FileInfo} [currentFileInfo]
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    constructor(path, features, options, index, currentFileInfo, visibilityInfo) {
-        super();
-        /** @type {ImportOptions} */
-        this.options = options;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        this.path = path;
-        /** @type {Node | null} */
-        this.features = features;
-        /** @type {boolean} */
-        this.allowRoot = true;
-
-        /** @type {boolean | undefined} */
-        this.css = undefined;
-        /** @type {boolean | undefined} */
-        this.layerCss = undefined;
-        /** @type {(Ruleset & { imports?: object, filename?: string, functions?: object, functionRegistry?: { addMultiple: (fns: object) => void } }) | undefined} */
-        this.root = undefined;
-        /** @type {string | undefined} */
-        this.importedFilename = undefined;
-        /** @type {boolean | (() => boolean) | undefined} */
-        this.skip = undefined;
-        /** @type {{ message: string, index: number, filename: string } | undefined} */
-        this.error = undefined;
-
-        if (this.options.less !== undefined || this.options.inline) {
-            this.css = !this.options.less || this.options.inline;
-        } else {
-            const pathValue = this.getPath();
-            if (pathValue && /[#.&?]css([?;].*)?$/.test(pathValue)) {
-                this.css = true;
-            }
-        }
-        this.copyVisibilityInfo(visibilityInfo);
-        if (this.features) {
-            this.setParent(this.features, /** @type {Node} */ (this));
-        }
-        this.setParent(this.path, /** @type {Node} */ (this));
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        if (this.features) {
-            this.features = visitor.visit(this.features);
-        }
-        this.path = visitor.visit(this.path);
-        if (!this.options.isPlugin && !this.options.inline && this.root) {
-            this.root = /** @type {Ruleset} */ (visitor.visit(this.root));
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        if (this.css && this.path._fileInfo.reference === undefined) {
-            output.add('@import ', this._fileInfo, this._index);
-            this.path.genCSS(context, output);
-            if (this.features) {
-                output.add(' ');
-                this.features.genCSS(context, output);
-            }
-            output.add(';');
-        }
-    }
-
-    /** @returns {string | undefined} */
-    getPath() {
-        return (this.path instanceof URL) ?
-            /** @type {string} */ (/** @type {Node} */ (this.path.value).value) :
-            /** @type {string | undefined} */ (this.path.value);
-    }
-
-    /** @returns {boolean | RegExpMatchArray | null} */
-    isVariableImport() {
-        let path = this.path;
-        if (path instanceof URL) {
-            path = /** @type {Node} */ (path.value);
-        }
-        if (path instanceof Quoted) {
-            return path.containsVariables();
-        }
-
-        return true;
-    }
-
-    /** @param {EvalContext} context */
-    evalForImport(context) {
-        let path = this.path;
-
-        if (path instanceof URL) {
-            path = /** @type {Node} */ (path.value);
-        }
-
-        return new Import(path.eval(context), this.features, this.options, this._index || 0, this._fileInfo, this.visibilityInfo());
-    }
-
-    /** @param {EvalContext} context */
-    evalPath(context) {
-        const path = this.path.eval(context);
-        const fileInfo = this._fileInfo;
-
-        if (!(path instanceof URL)) {
-            // Add the rootpath if the URL requires a rewrite
-            const pathValue = /** @type {string} */ (path.value);
-            if (fileInfo &&
-                pathValue &&
-                context.pathRequiresRewrite(pathValue)) {
-                path.value = context.rewritePath(pathValue, fileInfo.rootpath);
-            } else {
-                path.value = context.normalizePath(/** @type {string} */ (path.value));
-            }
-        }
-
-        return path;
-    }
-
-    /** @param {EvalContext} context */
-    // @ts-ignore - Import.eval returns Node | Node[] | Import (wider than Node.eval's Node return)
-    eval(context) {
-        const result = this.doEval(context);
-        if (this.options.reference || this.blocksVisibility()) {
-            if (Array.isArray(result)) {
-                result.forEach(function (node) {
-                    node.addVisibilityBlock();
-                });
-            } else {
-                /** @type {Node} */ (result).addVisibilityBlock();
-            }
-        }
-        return result;
-    }
-
-    /** @param {EvalContext} context */
-    doEval(context) {
-        /** @type {Ruleset | undefined} */
-        let ruleset;
-        const features = this.features && this.features.eval(context);
-
-        if (this.options.isPlugin) {
-            if (this.root && this.root.eval) {
-                try {
-                    this.root.eval(context);
-                }
-                catch (e) {
-                    const err = /** @type {{ message: string }} */ (e);
-                    err.message = 'Plugin error during evaluation';
-                    throw new LessError(
-                        /** @type {{ message: string, index?: number, filename?: string }} */ (e),
-                        /** @type {{ imports: object }} */ (/** @type {unknown} */ (this.root)).imports,
-                        /** @type {{ filename: string }} */ (/** @type {unknown} */ (this.root)).filename
-                    );
-                }
-            }
-            const frame0 = /** @type {Ruleset & { functionRegistry?: { addMultiple: (fns: object) => void } }} */ (context.frames[0]);
-            const registry = frame0 && frame0.functionRegistry;
-            if (registry && this.root && this.root.functions) {
-                registry.addMultiple(this.root.functions);
-            }
-
-            return [];
-        }
-
-        if (this.skip) {
-            if (typeof this.skip === 'function') {
-                this.skip = this.skip();
-            }
-            if (this.skip) {
-                return [];
-            }
-        }
-        if (this.features) {
-            let featureValue = /** @type {Node[]} */ (this.features.value);
-            if (Array.isArray(featureValue) && featureValue.length >= 1) {
-                const expr = featureValue[0];
-                if (expr.type === 'Expression' && Array.isArray(expr.value) && /** @type {Node[]} */ (expr.value).length >= 2) {
-                    featureValue = /** @type {Node[]} */ (expr.value);
-                    const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
-                        && featureValue[1].type === 'Paren';
-                    if (isLayer) {
-                        this.css = false;
-                    }
-                }
-            }
-        }
-        if (this.options.inline) {
-            const contents = new Anonymous(
-                /** @type {string} */ (/** @type {unknown} */ (this.root)),
-                0,
-                {
-                    filename: this.importedFilename,
-                    reference: this.path._fileInfo && this.path._fileInfo.reference
-                },
-                true,
-                true
-            );
-
-            return this.features ? new Media([contents], /** @type {Node[]} */ (this.features.value)) : [contents];
-        } else if (this.css || this.layerCss) {
-            const newImport = new Import(this.evalPath(context), features, this.options, this._index || 0);
-            if (this.layerCss) {
-                newImport.css = this.layerCss;
-                newImport.path._fileInfo = this._fileInfo;
-            }
-            if (!newImport.css && this.error) {
-                throw this.error;
-            }
-            return newImport;
-        } else if (this.root) {
-            if (this.features) {
-                let featureValue = /** @type {Node[]} */ (this.features.value);
-                if (Array.isArray(featureValue) && featureValue.length === 1) {
-                    const expr = featureValue[0];
-                    if (expr.type === 'Expression' && Array.isArray(expr.value) && /** @type {Node[]} */ (expr.value).length >= 2) {
-                        featureValue = /** @type {Node[]} */ (expr.value);
-                        const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
-                            && featureValue[1].type === 'Paren';
-                        if (isLayer) {
-                            this.layerCss = true;
-                            featureValue[0] = new Expression(/** @type {Node[]} */ (featureValue.slice(0, 2)));
-                            featureValue.splice(1, 1);
-                            /** @type {Expression} */ (featureValue[0]).noSpacing = true;
-                            return this;
-                        }
-                    }
-                }
-            }
-            ruleset = new Ruleset(null, utils.copyArray(this.root.rules));
-            ruleset.evalImports(context);
-
-            return this.features ? new Media(ruleset.rules, /** @type {Node[]} */ (this.features.value)) : ruleset.rules;
-        } else {
-            if (this.features) {
-                let featureValue = /** @type {Node[]} */ (this.features.value);
-                if (Array.isArray(featureValue) && featureValue.length >= 1) {
-                    featureValue = /** @type {Node[]} */ (featureValue[0].value);
-                    if (Array.isArray(featureValue) && featureValue.length >= 2) {
-                        const isLayer = featureValue[0].type === 'Keyword' && featureValue[0].value === 'layer'
-                            && featureValue[1].type === 'Paren';
-                        if (isLayer) {
-                            this.css = true;
-                            featureValue[0] = new Expression(/** @type {Node[]} */ (featureValue.slice(0, 2)));
-                            featureValue.splice(1, 1);
-                            /** @type {Expression} */ (featureValue[0]).noSpacing = true;
-                            return this;
-                        }
-                    }
-                }
-            }
-            return [];
-        }
-    }
-}
-
-export default Import;

package/lib/less/tree/index.js

@@ -1,56 +0,0 @@
-// @ts-check
-import Node from './node.js';
-import Color from './color.js';
-import AtRule from './atrule.js';
-import DetachedRuleset from './detached-ruleset.js';
-import Operation from './operation.js';
-import Dimension from './dimension.js';
-import Unit from './unit.js';
-import Keyword from './keyword.js';
-import Variable from './variable.js';
-import Property from './property.js';
-import Ruleset from './ruleset.js';
-import Element from './element.js';
-import Attribute from './attribute.js';
-import Combinator from './combinator.js';
-import Selector from './selector.js';
-import Quoted from './quoted.js';
-import Expression from './expression.js';
-import Declaration from './declaration.js';
-import Call from './call.js';
-import URL from './url.js';
-import Import from './import.js';
-import Comment from './comment.js';
-import Anonymous from './anonymous.js';
-import Value from './value.js';
-import JavaScript from './javascript.js';
-import Assignment from './assignment.js';
-import Condition from './condition.js';
-import QueryInParens from './query-in-parens.js';
-import Paren from './paren.js';
-import Media from './media.js';
-import Container from './container.js';
-import UnicodeDescriptor from './unicode-descriptor.js';
-import Negative from './negative.js';
-import Extend from './extend.js';
-import VariableCall from './variable-call.js';
-import NamespaceValue from './namespace-value.js';
-
-// mixins
-import MixinCall from './mixin-call.js';
-import MixinDefinition from './mixin-definition.js';
-
-export default {
-    Node, Color, AtRule, DetachedRuleset, Operation,
-    Dimension, Unit, Keyword, Variable, Property,
-    Ruleset, Element, Attribute, Combinator, Selector,
-    Quoted, Expression, Declaration, Call, URL, Import,
-    Comment, Anonymous, Value, JavaScript, Assignment,
-    Condition, Paren, Media, Container, QueryInParens,
-    UnicodeDescriptor, Negative, Extend, VariableCall,
-    NamespaceValue,
-    mixin: {
-        Call: MixinCall,
-        Definition: MixinDefinition
-    }
-};

package/lib/less/tree/javascript.js

@@ -1,45 +0,0 @@
-// @ts-check
-/** @import { EvalContext, FileInfo } from './node.js' */
-import JsEvalNode from './js-eval-node.js';
-import Dimension from './dimension.js';
-import Quoted from './quoted.js';
-import Anonymous from './anonymous.js';
-
-class JavaScript extends JsEvalNode {
-    get type() { return 'JavaScript'; }
-
-    /**
-     * @param {string} string
-     * @param {boolean} escaped
-     * @param {number} index
-     * @param {FileInfo} currentFileInfo
-     */
-    constructor(string, escaped, index, currentFileInfo) {
-        super();
-        this.escaped = escaped;
-        this.expression = string;
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Dimension | Quoted | Anonymous}
-     */
-    eval(context) {
-        const result = this.evaluateJavaScript(this.expression, context);
-        const type = typeof result;
-
-        if (type === 'number' && !isNaN(/** @type {number} */ (result))) {
-            return new Dimension(/** @type {number} */ (result));
-        } else if (type === 'string') {
-            return new Quoted(`"${result}"`, /** @type {string} */ (result), this.escaped, this._index);
-        } else if (Array.isArray(result)) {
-            return new Anonymous(/** @type {string[]} */ (result).join(', '));
-        } else {
-            return new Anonymous(/** @type {string} */ (result));
-        }
-    }
-}
-
-export default JavaScript;

package/lib/less/tree/js-eval-node.js

@@ -1,74 +0,0 @@
-// @ts-check
-/** @import { EvalContext } from './node.js' */
-import Node from './node.js';
-import Variable from './variable.js';
-
-class JsEvalNode extends Node {
-    /**
-     * @param {string} expression
-     * @param {EvalContext} context
-     * @returns {string | number | boolean}
-     */
-    evaluateJavaScript(expression, context) {
-        let result;
-        const that = this;
-        /** @type {Record<string, { value: Node, toJS: () => string }>} */
-        const evalContext = {};
-
-        if (!context.javascriptEnabled) {
-            throw { message: 'Inline JavaScript is not enabled. Is it set in your options?',
-                filename: this.fileInfo().filename,
-                index: this.getIndex() };
-        }
-
-        expression = expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
-            return that.jsify(new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context));
-        });
-
-        /** @type {Function} */
-        let expressionFunc;
-        try {
-            expressionFunc = new Function(`return (${expression})`);
-        } catch (e) {
-            throw { message: `JavaScript evaluation error: ${/** @type {Error} */ (e).message} from \`${expression}\`` ,
-                filename: this.fileInfo().filename,
-                index: this.getIndex() };
-        }
-
-        const variables = /** @type {Node & { variables: () => Record<string, { value: Node }> }} */ (context.frames[0]).variables();
-        for (const k in variables) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (variables.hasOwnProperty(k)) {
-                evalContext[k.slice(1)] = {
-                    value: variables[k].value,
-                    toJS: function () {
-                        return this.value.eval(context).toCSS(context);
-                    }
-                };
-            }
-        }
-
-        try {
-            result = expressionFunc.call(evalContext);
-        } catch (e) {
-            throw { message: `JavaScript evaluation error: '${/** @type {Error} */ (e).name}: ${/** @type {Error} */ (e).message.replace(/["]/g, '\'')}'` ,
-                filename: this.fileInfo().filename,
-                index: this.getIndex() };
-        }
-        return result;
-    }
-
-    /**
-     * @param {Node} obj
-     * @returns {string}
-     */
-    jsify(obj) {
-        if (Array.isArray(obj.value) && (obj.value.length > 1)) {
-            return `[${obj.value.map(function (v) { return v.toCSS(/** @type {EvalContext} */ (undefined)); }).join(', ')}]`;
-        } else {
-            return obj.toCSS(/** @type {EvalContext} */ (undefined));
-        }
-    }
-}
-
-export default JsEvalNode;

package/lib/less/tree/keyword.js

@@ -1,28 +0,0 @@
-// @ts-check
-import Node from './node.js';
-
-/** @import { EvalContext, CSSOutput } from './node.js' */
-
-class Keyword extends Node {
-    get type() { return 'Keyword'; }
-
-    /** @param {string} value */
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        if (this.value === '%') { throw { type: 'Syntax', message: 'Invalid % without number' }; }
-        output.add(/** @type {string} */ (this.value));
-    }
-}
-
-Keyword.True = new Keyword('true');
-Keyword.False = new Keyword('false');
-
-export default Keyword;

package/lib/less/tree/media.js

@@ -1,90 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, FileInfo, VisibilityInfo } from './node.js' */
-/** @import { NestableAtRuleThis } from './nested-at-rule.js' */
-/** @import { RulesetLikeNode } from './atrule.js' */
-import Node from './node.js';
-import Ruleset from './ruleset.js';
-import Value from './value.js';
-import Selector from './selector.js';
-import AtRule from './atrule.js';
-import NestableAtRulePrototype from './nested-at-rule.js';
-
-class Media extends AtRule {
-    get type() { return 'Media'; }
-
-    /**
-     * @param {Node[] | null} value
-     * @param {Node[]} features
-     * @param {number} [index]
-     * @param {FileInfo} [currentFileInfo]
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    constructor(value, features, index, currentFileInfo, visibilityInfo) {
-        super();
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-
-        const selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
-
-        /** @type {Value} */
-        this.features = new Value(features);
-        /** @type {RulesetLikeNode[]} */
-        this.rules = [new Ruleset(selectors, value)];
-        /** @type {RulesetLikeNode} */ (this.rules[0]).allowImports = true;
-        this.copyVisibilityInfo(visibilityInfo);
-        this.allowRoot = true;
-        this.setParent(selectors, /** @type {Node} */ (/** @type {unknown} */ (this)));
-        this.setParent(this.features, /** @type {Node} */ (/** @type {unknown} */ (this)));
-        this.setParent(this.rules, /** @type {Node} */ (/** @type {unknown} */ (this)));
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {CSSOutput} output
-     */
-    genCSS(context, output) {
-        output.add('@media ', this._fileInfo, this._index);
-        this.features.genCSS(context, output);
-        this.outputRuleset(context, output, this.rules);
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        if (!context.mediaBlocks) {
-            context.mediaBlocks = [];
-            context.mediaPath = [];
-        }
-
-        const media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
-        if (this.debugInfo) {
-            /** @type {RulesetLikeNode} */ (this.rules[0]).debugInfo = this.debugInfo;
-            media.debugInfo = this.debugInfo;
-        }
-
-        media.features = /** @type {Value} */ (this.features.eval(context));
-
-        context.mediaPath.push(/** @type {Node} */ (/** @type {unknown} */ (media)));
-        context.mediaBlocks.push(/** @type {Node} */ (/** @type {unknown} */ (media)));
-
-        const fr = /** @type {RulesetLikeNode} */ (context.frames[0]).functionRegistry;
-        if (fr) {
-            /** @type {RulesetLikeNode} */ (this.rules[0]).functionRegistry = fr.inherit();
-        }
-        context.frames.unshift(this.rules[0]);
-        media.rules = [/** @type {RulesetLikeNode} */ (this.rules[0].eval(context))];
-        context.frames.shift();
-
-        context.mediaPath.pop();
-
-        return context.mediaPath.length === 0 ? /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (media)).evalTop(context) :
-            /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (media)).evalNested(context);
-    }
-}
-
-// Apply NestableAtRulePrototype methods (accept, isRulesetLike override AtRule's versions)
-Object.assign(Media.prototype, NestableAtRulePrototype);
-
-export default Media;

package/lib/less/tree/merge-rules.js

@@ -1,47 +0,0 @@
-// @ts-check
-import Expression from './expression.js';
-import Value from './value.js';
-import Node from './node.js';
-
-/**
- * Merges declarations with merge flags (+ or ,) into combined values.
- * Used by both the ToCSSVisitor and AtRule eval.
- * @param {Node[]} rules
- */
-export default function mergeRules(rules) {
-    if (!rules) {
-        return;
-    }
-
-    /** @type {Record<string, Array<Node & { merge: string, name: string, value: Node, important: string }>>} */
-    const groups    = {};
-    /** @type {Array<Array<Node & { merge: string, name: string, value: Node, important: string }>>} */
-    const groupsArr = [];
-
-    for (let i = 0; i < rules.length; i++) {
-        const rule = /** @type {Node & { merge: string, name: string }} */ (rules[i]);
-        if (rule.merge) {
-            const key = rule.name;
-            groups[key] ? rules.splice(i--, 1) :
-                groupsArr.push(groups[key] = []);
-            groups[key].push(/** @type {Node & { merge: string, name: string, value: Node, important: string }} */ (rule));
-        }
-    }
-
-    groupsArr.forEach(group => {
-        if (group.length > 0) {
-            const result = group[0];
-            /** @type {Node[]} */
-            let space  = [];
-            const comma  = [new Expression(space)];
-            group.forEach(rule => {
-                if ((rule.merge === '+') && (space.length > 0)) {
-                    comma.push(new Expression(space = []));
-                }
-                space.push(rule.value);
-                result.important = result.important || rule.important;
-            });
-            result.value = new Value(comma);
-        }
-    });
-}