less 4.9.0 → 5.0.0-alpha.2

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/interpolated-variable.js

@@ -1,106 +0,0 @@
-// @ts-check
-/** @import { FileInfo } from './node.js' */
-/** @import Node from './node.js' */
-import Variable from './variable.js';
-import Property from './property.js';
-import VariableCall from './variable-call.js';
-import NamespaceValue from './namespace-value.js';
-import { LOOKUP_KEY, VARIABLE_WITH_LOOKUPS } from '../parser/lookup-pattern.js';
-
-/**
- * Interpolation resolved by string replacement at eval time.
- *
- * The parser consumes `@{name[key]}` structurally via `entities.variableCurly`,
- * but `Quoted` and inline JavaScript hold their contents as raw text and can only
- * substitute at eval time. Both share this module so the two evaluation paths build
- * identical nodes from identical patterns.
- */
-
-/** Matches `@{name}` and `@{name[a][b]}`, capturing the reference. */
-export const VARIABLE_INTERPOLATION = new RegExp(`@\\{(${VARIABLE_WITH_LOOKUPS})\\}`, 'g');
-
-/**
- * Matches `${name}`, capturing the reference.
- *
- * Deliberately narrower than {@link VARIABLE_INTERPOLATION}: a lookup chain is not
- * part of the property grammar. `entities.property` parses `$name` with no lookup
- * handling, so `$map[key]` is a property reference followed by the literal text
- * `[key]`, and a property cannot hold a ruleset to look into in the first place
- * (`prop: { … }` is a parse error in every scope). Accepting `${map[key]}` here
- * would invent syntax the language does not have.
- */
-export const PROPERTY_INTERPOLATION = /\$\{([\w-]+)\}/g;
-
-const LOOKUP_SEGMENT = new RegExp(`\\[(${LOOKUP_KEY})\\]`, 'g');
-
-// Non-global twins for membership tests. `RegExp.test` on a /g regex advances
-// `lastIndex` and so returns alternating results across calls on shared instances.
-const HAS_VARIABLE_INTERPOLATION = new RegExp(VARIABLE_INTERPOLATION.source);
-const HAS_PROPERTY_INTERPOLATION = new RegExp(PROPERTY_INTERPOLATION.source);
-
-/**
- * Whether text contains an `@{...}` or `${...}` interpolation.
- *
- * @param {string} text
- * @returns {boolean}
- */
-export function hasInterpolation(text) {
-    return HAS_VARIABLE_INTERPOLATION.test(text) || HAS_PROPERTY_INTERPOLATION.test(text);
-}
-
-/**
- * Split a `name[a][b]` reference into its name and lookup keys.
- *
- * `lookups` is null for a plain reference, so callers keep using the cheaper
- * `Variable`/`Property` node when there is no lookup to resolve.
- *
- * @param {string} raw
- * @returns {{ name: string, lookups: string[] | null }}
- */
-export function splitLookups(raw) {
-    const open = raw.indexOf('[');
-    if (open === -1) {
-        return { name: raw, lookups: null };
-    }
-    /** @type {string[]} */
-    const lookups = [];
-    const re = new RegExp(LOOKUP_SEGMENT.source, 'g');
-    let match;
-    while ((match = re.exec(raw)) !== null) {
-        lookups.push(match[1]);
-    }
-    return { name: raw.slice(0, open), lookups };
-}
-
-/**
- * Build the node for an interpolated `@variable` reference, with or without lookups.
- *
- * @param {string} raw - the reference text inside `@{...}`
- * @param {number} index
- * @param {FileInfo} fileInfo
- * @returns {Node}
- */
-export function resolveInterpolatedVariable(raw, index, fileInfo) {
-    const { name, lookups } = splitLookups(raw);
-    if (!lookups) {
-        return new Variable(`@${name}`, index, fileInfo);
-    }
-    return new NamespaceValue(
-        new VariableCall(`@${name}`, index, fileInfo), lookups, index, fileInfo
-    );
-}
-
-/**
- * Build the node for an interpolated `$property` reference.
- *
- * No lookup handling: see {@link PROPERTY_INTERPOLATION}. Properties have no lookup
- * grammar, so `raw` is always a bare name here.
- *
- * @param {string} raw - the reference text inside `${...}`
- * @param {number} index
- * @param {FileInfo} fileInfo
- * @returns {Node}
- */
-export function resolveInterpolatedProperty(raw, index, fileInfo) {
-    return new Property(`$${raw}`, index, fileInfo);
-}

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,80 +0,0 @@
-// @ts-check
-/** @import { EvalContext } from './node.js' */
-import Node from './node.js';
-import Variable from './variable.js';
-import {
-    VARIABLE_INTERPOLATION,
-    resolveInterpolatedVariable
-} from './interpolated-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(VARIABLE_INTERPOLATION, function (_, raw) {
-            return that.jsify(resolveInterpolatedVariable(
-                raw, 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;