less 4.8.1 → 5.0.0-alpha.1

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

@@ -1,283 +0,0 @@
-// @ts-check
-/** @import { EvalContext, TreeVisitor, FileInfo } from './node.js' */
-/** @import { FunctionRegistry } from './nested-at-rule.js' */
-import Node from './node.js';
-import Selector from './selector.js';
-import MixinDefinition from './mixin-definition.js';
-import defaultFunc from '../functions/default.js';
-
-/**
- * @typedef {{ name?: string, value: Node, expand?: boolean }} MixinArg
- */
-
-/**
- * @typedef {Node & {
- *   rules?: Node[],
- *   selectors?: Selector[],
- *   originalRuleset?: Node,
- *   matchArgs: (args: MixinArg[] | null, context: EvalContext) => boolean,
- *   matchCondition?: (args: MixinArg[] | null, context: EvalContext) => boolean,
- *   find: (selector: Selector, self?: Node | null, filter?: (rule: Node) => boolean) => Array<{ rule: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, path: Node[] }>,
- *   functionRegistry?: FunctionRegistry
- * }} MixinSearchFrame
- */
-
-class MixinCall extends Node {
-    get type() { return 'MixinCall'; }
-
-    /**
-     * @param {import('./element.js').default[]} elements
-     * @param {MixinArg[]} [args]
-     * @param {number} [index]
-     * @param {FileInfo} [currentFileInfo]
-     * @param {string} [important]
-     */
-    constructor(elements, args, index, currentFileInfo, important) {
-        super();
-        /** @type {Selector} */
-        this.selector = new Selector(elements);
-        /** @type {MixinArg[]} */
-        this.arguments = args || [];
-        this._index = index;
-        this._fileInfo = currentFileInfo;
-        /** @type {string | undefined} */
-        this.important = important;
-        this.allowRoot = true;
-        this.setParent(this.selector, /** @type {Node} */ (/** @type {unknown} */ (this)));
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        if (this.selector) {
-            this.selector = /** @type {Selector} */ (visitor.visit(this.selector));
-        }
-        if (this.arguments.length) {
-            this.arguments = /** @type {MixinArg[]} */ (/** @type {unknown} */ (visitor.visitArray(/** @type {Node[]} */ (/** @type {unknown} */ (this.arguments)))));
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        /** @type {{ rule: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, path: Node[] }[] | undefined} */
-        let mixins;
-        /** @type {Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }} */
-        let mixin;
-        /** @type {Node[]} */
-        let mixinPath;
-        /** @type {MixinArg[]} */
-        const args = [];
-        /** @type {MixinArg} */
-        let arg;
-        /** @type {Node} */
-        let argValue;
-        /** @type {Node[]} */
-        const rules = [];
-        let match = false;
-        /** @type {number} */
-        let i;
-        /** @type {number} */
-        let m;
-        /** @type {number} */
-        let f;
-        /** @type {boolean} */
-        let isRecursive;
-        /** @type {boolean | undefined} */
-        let isOneFound;
-        /** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number }[]} */
-        const candidates = [];
-        /** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number } | number} */
-        let candidate;
-        /** @type {boolean[]} */
-        const conditionResult = [];
-        /** @type {number | undefined} */
-        let defaultResult;
-        const defFalseEitherCase = -1;
-        const defNone = 0;
-        const defTrue = 1;
-        const defFalse = 2;
-        /** @type {number[]} */
-        let count;
-        /** @type {Node | undefined} */
-        let originalRuleset;
-        /** @type {((rule: MixinSearchFrame) => boolean) | undefined} */
-        let noArgumentsFilter;
-
-        this.selector = /** @type {Selector} */ (this.selector.eval(context));
-
-        /**
-         * @param {Node & { matchCondition?: Function }} mixin
-         * @param {Node[]} mixinPath
-         */
-        function calcDefGroup(mixin, mixinPath) {
-            /** @type {number} */
-            let f;
-            /** @type {number} */
-            let p;
-            /** @type {Node & { matchCondition?: Function }} */
-            let namespace;
-
-            for (f = 0; f < 2; f++) {
-                conditionResult[f] = true;
-                defaultFunc.value(f);
-                for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
-                    namespace = mixinPath[p];
-                    if (namespace.matchCondition) {
-                        conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
-                    }
-                }
-                if (mixin.matchCondition) {
-                    conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
-                }
-            }
-            if (conditionResult[0] || conditionResult[1]) {
-                if (conditionResult[0] != conditionResult[1]) {
-                    return conditionResult[1] ?
-                        defTrue : defFalse;
-                }
-
-                return defNone;
-            }
-            return defFalseEitherCase;
-        }
-
-        for (i = 0; i < this.arguments.length; i++) {
-            arg = this.arguments[i];
-            argValue = arg.value.eval(context);
-            if (arg.expand && Array.isArray(argValue.value)) {
-                const expandedValues = /** @type {Node[]} */ (argValue.value);
-                for (m = 0; m < expandedValues.length; m++) {
-                    args.push({value: expandedValues[m]});
-                }
-            } else if (argValue.type === 'Expression' && Array.isArray(argValue.value) && argValue.value.length === 0) {
-                // an unset variadic holds no captured args; omit it so the callee
-                // falls through to its own parameter defaults instead of receiving empty
-
-            } else {
-                args.push({name: arg.name, value: argValue});
-            }
-        }
-
-        noArgumentsFilter = function(/** @type {MixinSearchFrame} */ rule) {return rule.matchArgs(null, context);};
-
-        for (i = 0; i < context.frames.length; i++) {
-            if ((mixins = /** @type {MixinSearchFrame} */ (context.frames[i]).find(this.selector, null, /** @type {(rule: Node) => boolean} */ (/** @type {unknown} */ (noArgumentsFilter)))).length > 0) {
-                isOneFound = true;
-
-                // To make `default()` function independent of definition order we have two "subpasses" here.
-                // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
-                // and build candidate list with corresponding flags. Then, when we know all possible matches,
-                // we make a final decision.
-
-                for (m = 0; m < mixins.length; m++) {
-                    mixin = mixins[m].rule;
-                    mixinPath = mixins[m].path;
-                    isRecursive = false;
-                    for (f = 0; f < context.frames.length; f++) {
-                        if ((!(mixin instanceof MixinDefinition)) && mixin === (/** @type {Node & { originalRuleset?: Node }} */ (context.frames[f]).originalRuleset || context.frames[f])) {
-                            isRecursive = true;
-                            break;
-                        }
-                    }
-                    if (isRecursive) {
-                        continue;
-                    }
-
-                    if (mixin.matchArgs(args, context)) {
-                        candidate = {mixin, group: calcDefGroup(mixin, mixinPath)};
-
-                        if (/** @type {{ mixin: Node, group: number }} */ (candidate).group !== defFalseEitherCase) {
-                            candidates.push(/** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number }} */ (candidate));
-                        }
-
-                        match = true;
-                    }
-                }
-
-                defaultFunc.reset();
-
-                count = [0, 0, 0];
-                for (m = 0; m < candidates.length; m++) {
-                    count[candidates[m].group]++;
-                }
-
-                if (count[defNone] > 0) {
-                    defaultResult = defFalse;
-                } else {
-                    defaultResult = defTrue;
-                    if ((count[defTrue] + count[defFalse]) > 1) {
-                        throw { type: 'Runtime',
-                            message: `Ambiguous use of \`default()\` found when matching for \`${this.format(args)}\``,
-                            index: this.getIndex(), filename: this.fileInfo().filename };
-                    }
-                }
-
-                for (m = 0; m < candidates.length; m++) {
-                    candidate = candidates[m].group;
-                    if ((candidate === defNone) || (candidate === defaultResult)) {
-                        try {
-                            mixin = candidates[m].mixin;
-                            if (!(mixin instanceof MixinDefinition)) {
-                                originalRuleset = /** @type {Node & { originalRuleset?: Node }} */ (mixin).originalRuleset || mixin;
-                                mixin = new MixinDefinition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
-                                /** @type {Node & { originalRuleset?: Node }} */ (mixin).originalRuleset = originalRuleset;
-                            }
-                            const newRules = /** @type {MixinDefinition} */ (mixin).evalCall(context, args, this.important).rules;
-                            this._setVisibilityToReplacement(newRules);
-                            Array.prototype.push.apply(rules, newRules);
-                        } catch (e) {
-                            throw { .../** @type {object} */ (e), index: this.getIndex(), filename: this.fileInfo().filename };
-                        }
-                    }
-                }
-
-                if (match) {
-                    return /** @type {Node} */ (/** @type {unknown} */ (rules));
-                }
-            }
-        }
-        if (isOneFound) {
-            throw { type:    'Runtime',
-                message: `No matching definition was found for \`${this.format(args)}\``,
-                index:   this.getIndex(), filename: this.fileInfo().filename };
-        } else {
-            throw { type:    'Name',
-                message: `${this.selector.toCSS(/** @type {EvalContext} */ ({})).trim()} is undefined`,
-                index:   this.getIndex(), filename: this.fileInfo().filename };
-        }
-    }
-
-    /** @param {Node[]} replacement */
-    _setVisibilityToReplacement(replacement) {
-        /** @type {number} */
-        let i;
-        /** @type {Node} */
-        let rule;
-        if (this.blocksVisibility()) {
-            for (i = 0; i < replacement.length; i++) {
-                rule = replacement[i];
-                rule.addVisibilityBlock();
-            }
-        }
-    }
-
-    /** @param {MixinArg[]} args */
-    format(args) {
-        return `${this.selector.toCSS(/** @type {EvalContext} */ ({})).trim()}(${args ? args.map(function (/** @type {MixinArg} */ a) {
-            let argValue = '';
-            if (a.name) {
-                argValue += `${a.name}:`;
-            }
-            if (a.value.toCSS) {
-                argValue += a.value.toCSS(/** @type {EvalContext} */ ({}));
-            } else {
-                argValue += '???';
-            }
-            return argValue;
-        }).join(', ') : ''})`;
-    }
-}
-
-export default MixinCall;

package/lib/less/tree/mixin-definition.js

@@ -1,319 +0,0 @@
-// @ts-check
-/** @import { EvalContext, TreeVisitor, VisibilityInfo } from './node.js' */
-/** @import { FunctionRegistry } from './nested-at-rule.js' */
-/** @import { MixinArg } from './mixin-call.js' */
-import Node from './node.js';
-import Selector from './selector.js';
-import Element from './element.js';
-import Ruleset from './ruleset.js';
-import Declaration from './declaration.js';
-import DetachedRuleset from './detached-ruleset.js';
-import Expression from './expression.js';
-import contexts from '../contexts.js';
-import * as utils from '../utils.js';
-
-/**
- * @typedef {object} MixinParam
- * @property {string} [name]
- * @property {Node} [value]
- * @property {boolean} [variadic]
- */
-
-/**
- * @typedef {Ruleset & {
- *   functionRegistry?: FunctionRegistry,
- *   originalRuleset?: Node
- * }} RulesetWithRegistry
- */
-
-class Definition extends Ruleset {
-    get type() { return 'MixinDefinition'; }
-
-    /**
-     * @param {string | undefined} name
-     * @param {MixinParam[]} params
-     * @param {Node[]} rules
-     * @param {Node | null} [condition]
-     * @param {boolean} [variadic]
-     * @param {Node[] | null} [frames]
-     * @param {VisibilityInfo} [visibilityInfo]
-     */
-    constructor(name, params, rules, condition, variadic, frames, visibilityInfo) {
-        super(null, null);
-        /** @type {string} */
-        this.name = name || 'anonymous mixin';
-        this.selectors = [new Selector([new Element(null, name, false, this._index, this._fileInfo)])];
-        /** @type {MixinParam[]} */
-        this.params = params;
-        /** @type {Node | null | undefined} */
-        this.condition = condition;
-        /** @type {boolean | undefined} */
-        this.variadic = variadic;
-        /** @type {number} */
-        this.arity = params.length;
-        this.rules = rules;
-        this._lookups = {};
-        /** @type {string[]} */
-        const optionalParameters = [];
-        /** @type {number} */
-        this.required = params.reduce(function (/** @type {number} */ count, /** @type {MixinParam} */ p) {
-            if (!p.name || (p.name && !p.value)) {
-                return count + 1;
-            }
-            else {
-                optionalParameters.push(p.name);
-                return count;
-            }
-        }, 0);
-        /** @type {string[]} */
-        this.optionalParameters = optionalParameters;
-        /** @type {Node[] | null | undefined} */
-        this.frames = frames;
-        this.copyVisibilityInfo(visibilityInfo);
-        this.allowRoot = true;
-        /** @type {boolean} */
-        this.evalFirst = true;
-    }
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        if (this.params && this.params.length) {
-            this.params = /** @type {MixinParam[]} */ (/** @type {unknown} */ (visitor.visitArray(/** @type {Node[]} */ (/** @type {unknown} */ (this.params)))));
-        }
-        this.rules = visitor.visitArray(this.rules);
-        if (this.condition) {
-            this.condition = visitor.visit(this.condition);
-        }
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {EvalContext} mixinEnv
-     * @param {MixinArg[] | null} args
-     * @param {Node[]} evaldArguments
-     * @returns {Ruleset}
-     */
-    evalParams(context, mixinEnv, args, evaldArguments) {
-        /* jshint boss:true */
-        const frame = new Ruleset(null, null);
-
-        /** @type {Node[] | undefined} */
-        let varargs;
-        /** @type {MixinArg | undefined} */
-        let arg;
-        const params = /** @type {MixinParam[]} */ (utils.copyArray(this.params));
-        /** @type {number} */
-        let i;
-        /** @type {number} */
-        let j;
-        /** @type {Node | undefined} */
-        let val;
-        /** @type {string | undefined} */
-        let name;
-        /** @type {boolean} */
-        let isNamedFound;
-        /** @type {number} */
-        let argIndex;
-        let argsLength = 0;
-
-        if (mixinEnv.frames && mixinEnv.frames[0] && /** @type {RulesetWithRegistry} */ (mixinEnv.frames[0]).functionRegistry) {
-            /** @type {RulesetWithRegistry} */ (frame).functionRegistry = /** @type {FunctionRegistry} */ (/** @type {RulesetWithRegistry} */ (mixinEnv.frames[0]).functionRegistry).inherit();
-        }
-        mixinEnv = new contexts.Eval(mixinEnv, /** @type {Node[]} */ ([frame]).concat(/** @type {Node[]} */ (mixinEnv.frames)));
-
-        if (args) {
-            args = /** @type {MixinArg[]} */ (utils.copyArray(args));
-            argsLength = args.length;
-
-            for (i = 0; i < argsLength; i++) {
-                arg = args[i];
-                if (name = (arg && arg.name)) {
-                    isNamedFound = false;
-                    for (j = 0; j < params.length; j++) {
-                        if (!evaldArguments[j] && name === params[j].name) {
-                            evaldArguments[j] = arg.value.eval(context);
-                            frame.prependRule(new Declaration(name, arg.value.eval(context)));
-                            isNamedFound = true;
-                            break;
-                        }
-                    }
-                    if (isNamedFound) {
-                        args.splice(i, 1);
-                        i--;
-                        continue;
-                    } else {
-                        throw { type: 'Runtime', message: `Named argument for ${this.name} ${args[i].name} not found` };
-                    }
-                }
-            }
-        }
-        argIndex = 0;
-        for (i = 0; i < params.length; i++) {
-            if (evaldArguments[i]) { continue; }
-
-            arg = args && args[argIndex];
-
-            if (name = params[i].name) {
-                if (params[i].variadic) {
-                    varargs = [];
-                    for (j = argIndex; j < argsLength; j++) {
-                        varargs.push(/** @type {MixinArg[]} */ (args)[j].value.eval(context));
-                    }
-                    frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
-                } else {
-                    val = arg && arg.value;
-                    if (val) {
-                        // This was a mixin call, pass in a detached ruleset of it's eval'd rules
-                        if (Array.isArray(val)) {
-                            val = /** @type {Node} */ (/** @type {unknown} */ (new DetachedRuleset(new Ruleset(null, /** @type {Node[]} */ (val)))));
-                        }
-                        else {
-                            val = val.eval(context);
-                        }
-                    } else if (params[i].value) {
-                        val = /** @type {Node} */ (params[i].value).eval(mixinEnv);
-                        frame.resetCache();
-                    } else {
-                        throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${argsLength} for ${this.arity})` };
-                    }
-
-                    frame.prependRule(new Declaration(name, val));
-                    evaldArguments[i] = val;
-                }
-            }
-
-            if (params[i].variadic && args) {
-                for (j = argIndex; j < argsLength; j++) {
-                    evaldArguments[j] = args[j].value.eval(context);
-                }
-            }
-            argIndex++;
-        }
-
-        return frame;
-    }
-
-    /** @returns {Ruleset} */
-    makeImportant() {
-        const rules = !this.rules ? this.rules : this.rules.map(function (/** @type {Node & { makeImportant?: (important?: boolean) => Node }} */ r) {
-            if (r.makeImportant) {
-                return r.makeImportant(true);
-            } else {
-                return r;
-            }
-        });
-        const result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
-        return /** @type {Ruleset} */ (/** @type {unknown} */ (result));
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Definition}
-     */
-    eval(context) {
-        return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || utils.copyArray(context.frames));
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @param {MixinArg[]} args
-     * @param {string | undefined} important
-     * @returns {Ruleset}
-     */
-    evalCall(context, args, important) {
-        /** @type {Node[]} */
-        const _arguments = [];
-        const mixinFrames = this.frames ? /** @type {Node[]} */ (this.frames).concat(/** @type {Node[]} */ (context.frames)) : /** @type {Node[]} */ (context.frames);
-        const frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments);
-        /** @type {Node[]} */
-        let rules;
-        /** @type {Ruleset} */
-        let ruleset;
-
-        frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
-
-        rules = utils.copyArray(this.rules);
-
-        ruleset = new Ruleset(null, rules);
-        /** @type {RulesetWithRegistry} */ (ruleset).originalRuleset = this;
-        ruleset = /** @type {Ruleset} */ (ruleset.eval(new contexts.Eval(context, /** @type {Node[]} */ ([this, frame]).concat(mixinFrames))));
-        if (important) {
-            ruleset = /** @type {Ruleset} */ (ruleset.makeImportant());
-        }
-        return ruleset;
-    }
-
-    /**
-     * @param {MixinArg[] | null} args
-     * @param {EvalContext} context
-     * @returns {boolean}
-     */
-    matchCondition(args, context) {
-        if (this.condition && !this.condition.eval(
-            new contexts.Eval(context,
-                /** @type {Node[]} */ ([this.evalParams(context, /* the parameter variables */
-                    new contexts.Eval(context, this.frames ? /** @type {Node[]} */ (this.frames).concat(/** @type {Node[]} */ (context.frames)) : context.frames), args, [])])
-                    .concat(/** @type {Node[]} */ (this.frames || [])) // the parent namespace/mixin frames
-                    .concat(/** @type {Node[]} */ (context.frames))))) { // the current environment frames
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * @param {MixinArg[] | null} args
-     * @param {EvalContext} [context]
-     * @returns {boolean}
-     */
-    matchArgs(args, context) {
-        const allArgsCnt = (args && args.length) || 0;
-        const evaldArguments = new Array(this.params.length);
-        const positionalArgs = [];
-        let positionalIndex = 0;
-
-        for (let i = 0; i < allArgsCnt; i++) {
-            const arg = /** @type {MixinArg[]} */ (args)[i];
-            if (!arg.name) {
-                positionalArgs.push(arg);
-                continue;
-            }
-
-            const paramIndex = this.params.findIndex((param, index) => param.name === arg.name && !evaldArguments[index]);
-            if (paramIndex < 0) {
-                return false;
-            }
-            evaldArguments[paramIndex] = arg;
-        }
-
-        for (let i = 0; i < this.params.length; i++) {
-            if (evaldArguments[i]) {
-                continue;
-            }
-            if (this.params[i].variadic) {
-                positionalIndex = positionalArgs.length;
-                continue;
-            }
-            if (positionalIndex < positionalArgs.length) {
-                evaldArguments[i] = positionalArgs[positionalIndex++];
-            } else if (!this.params[i].name || !this.params[i].value) {
-                return false;
-            }
-        }
-
-        if (positionalIndex < positionalArgs.length) {
-            return false;
-        }
-
-        // check patterns
-        for (let i = 0; i < this.arity; i++) {
-            if (!this.params[i].name && !this.params[i].variadic) {
-                if (evaldArguments[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-}
-
-export default Definition;

package/lib/less/tree/namespace-value.js

@@ -1,95 +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 Selector from './selector.js';
-
-class NamespaceValue extends Node {
-    get type() { return 'NamespaceValue'; }
-
-    /**
-     * @param {Node} ruleCall
-     * @param {string[]} lookups
-     * @param {number} index
-     * @param {FileInfo} fileInfo
-     */
-    constructor(ruleCall, lookups, index, fileInfo) {
-        super();
-        this.value = ruleCall;
-        this.lookups = lookups;
-        this._index = index;
-        this._fileInfo = fileInfo;
-    }
-
-    /**
-     * @param {EvalContext} context
-     * @returns {Node}
-     */
-    eval(context) {
-        let i, name;
-        /** @type {Ruleset | Node | Node[]} */
-        let rules = this.value.eval(context);
-
-        for (i = 0; i < this.lookups.length; i++) {
-            name = this.lookups[i];
-
-            if (Array.isArray(rules)) {
-                rules = new Ruleset([new Selector()], rules);
-            }
-
-            const rs = /** @type {Ruleset} */ (rules);
-
-            if (name === '') {
-                rules = rs.lastDeclaration();
-            }
-            else if (name.charAt(0) === '@') {
-                if (name.charAt(1) === '@') {
-                    name = `@${new Variable(name.slice(1)).eval(context).value}`;
-                }
-                if (rs.variables) {
-                    rules = rs.variable(name);
-                }
-
-                if (!rules) {
-                    throw { type: 'Name',
-                        message: `variable ${name} not found`,
-                        filename: this.fileInfo().filename,
-                        index: this.getIndex() };
-                }
-            }
-            else {
-                if (name.substring(0, 2) === '$@') {
-                    name = `$${new Variable(name.slice(1)).eval(context).value}`;
-                }
-                else {
-                    name = name.charAt(0) === '$' ? name : `$${name}`;
-                }
-                if (rs.properties) {
-                    rules = rs.property(name);
-                }
-
-                if (!rules) {
-                    throw { type: 'Name',
-                        message: `property "${name.slice(1)}" not found`,
-                        filename: this.fileInfo().filename,
-                        index: this.getIndex() };
-                }
-                const rulesArr = /** @type {Node[]} */ (rules);
-                rules = rulesArr[rulesArr.length - 1];
-            }
-
-            const current = /** @type {Node} */ (rules);
-            if (current.value) {
-                rules = /** @type {Node} */ (current.eval(context).value);
-            }
-            const currentNode = /** @type {Node & { ruleset?: Node }} */ (rules);
-            if (currentNode.ruleset) {
-                rules = currentNode.ruleset.eval(context);
-            }
-        }
-        return /** @type {Node} */ (rules);
-    }
-}
-
-export default NamespaceValue;