less 4.9.0 → 5.0.0-alpha.1

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;

package/lib/less/tree/negative.js

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

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

@@ -1,239 +0,0 @@
-// @ts-check
-/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
-import Ruleset from './ruleset.js';
-import Value from './value.js';
-import Selector from './selector.js';
-import Anonymous from './anonymous.js';
-import Expression from './expression.js';
-import * as utils from '../utils.js';
-import Node from './node.js';
-
-/**
- * @typedef {object} FunctionRegistry
- * @property {(name: string, func: Function) => void} add
- * @property {(functions: Object) => void} addMultiple
- * @property {(name: string) => Function} get
- * @property {() => Object} getLocalFunctions
- * @property {() => FunctionRegistry} inherit
- * @property {(base: FunctionRegistry) => FunctionRegistry} create
- */
-
-/**
- * @typedef {Node & {
- *   features: Value,
- *   rules: Ruleset[],
- *   type: string,
- *   functionRegistry?: FunctionRegistry,
- *   multiMedia?: boolean,
- *   debugInfo?: { lineNumber: number, fileName: string },
- *   allowRoot?: boolean,
- *   _evaluated?: boolean,
- *   evalFunction: () => void,
- *   evalTop: (context: EvalContext) => Node | Ruleset,
- *   evalNested: (context: EvalContext) => Node | Ruleset,
- *   permute: (arr: Node[][]) => Node[][],
- *   bubbleSelectors: (selectors: Selector[] | undefined) => void,
- *   outputRuleset: (context: EvalContext, output: CSSOutput, rules: Node[]) => void
- * }} NestableAtRuleThis
- */
-
-// A media query may only carry a media type at its front, before any
-// conditions (https://drafts.csswg.org/mediaqueries-5/#typedef-media-query-list).
-// Operators that join media-query parts, so a fragment leading with one is not
-// a media type. Any other bare identifier is treated as a type, since unknown
-// media types are valid non-matches in CSS, not syntax errors.
-const MEDIA_QUERY_OPERATORS = ['and', 'or'];
-
-/**
- * Whether a flattened media-query fragment leads with a media type, e.g.
- * `screen`, `only screen`, `print and (color)` or an unknown type like `foo`.
- * @param {Node & { value?: * }} fragment
- */
-function startsWithMediaType(fragment) {
-    let head;
-    if (fragment.type === 'Keyword' || fragment.type === 'Anonymous') {
-        head = fragment.value;
-    } else if (fragment.type === 'Expression' && Array.isArray(fragment.value)) {
-        const parts = fragment.value.filter(p => p && p.value !== undefined);
-        let idx = 0;
-        const first = parts[idx] && String(parts[idx].value).toLowerCase();
-        if (first === 'not' || first === 'only') { idx++; }
-        head = parts[idx] && parts[idx].value;
-    }
-    if (typeof head !== 'string' || head === '') {
-        return false;
-    }
-    // Inspect only the first token. A media type is a bare identifier; a feature
-    // condition begins with '(' - e.g. an escaped ~"(max-width: 1px)" is an
-    // Anonymous whose whole value is "(max-width: 1px)", which is not a media type.
-    const firstToken = head.trim().split(/[\s(]/)[0];
-    return firstToken !== ''
-        && MEDIA_QUERY_OPERATORS.indexOf(firstToken.toLowerCase()) < 0;
-}
-
-const NestableAtRulePrototype = {
-
-    isRulesetLike() {
-        return true;
-    },
-
-    /** @param {TreeVisitor} visitor */
-    accept(visitor) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (self.features) {
-            self.features = /** @type {Value} */ (visitor.visit(self.features));
-        }
-        if (self.rules) {
-            self.rules = /** @type {Ruleset[]} */ (visitor.visitArray(self.rules));
-        }
-    },
-
-    evalFunction: function () {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (!self.features || !Array.isArray(self.features.value) || self.features.value.length < 1) {
-            return;
-        }
-
-        const exprValues = /** @type {Node[]} */ (self.features.value);
-        /** @type {Node | undefined} */
-        let expr;
-        /** @type {Node | undefined} */
-        let paren;
-
-        for (let index = 0; index < exprValues.length; ++index) {
-            expr = exprValues[index];
-
-            if ((expr.type === 'Keyword' || expr.type === 'Variable')
-                && index + 1 < exprValues.length
-                && (/** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing || /** @type {Node & { noSpacing?: boolean }} */ (expr).noSpacing == null)) {
-                paren =  exprValues[index + 1];
-
-                if (paren.type ===  'Paren' && /** @type {Node & { noSpacing?: boolean }} */ (paren).noSpacing) {
-                    exprValues[index]= new Expression([expr, paren]);
-                    exprValues.splice(index + 1, 1);
-                    /** @type {Node & { noSpacing?: boolean }} */ (exprValues[index]).noSpacing = true;
-                }
-            }
-        }
-    },
-
-    /** @param {EvalContext} context */
-    evalTop(context) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        self.evalFunction();
-
-        /** @type {Node | Ruleset} */
-        let result = self;
-
-        // Render all dependent Media blocks.
-        if (context.mediaBlocks.length > 1) {
-            const selectors = (new Selector([], null, null, self.getIndex(), self.fileInfo())).createEmptySelectors();
-            result = new Ruleset(selectors, context.mediaBlocks);
-            /** @type {Ruleset & { multiMedia?: boolean }} */ (result).multiMedia = true;
-            result.copyVisibilityInfo(self.visibilityInfo());
-            self.setParent(result, self);
-        }
-
-        delete context.mediaBlocks;
-        delete context.mediaPath;
-
-        return result;
-    },
-
-    /** @param {EvalContext} context */
-    evalNested(context) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        self.evalFunction();
-
-        let i;
-        /** @type {Node | Node[]} */
-        let value;
-        const path = context.mediaPath.concat([self]);
-
-        // Extract the media-query conditions separated with `,` (OR).
-        for (i = 0; i < path.length; i++) {
-            if (path[i].type !== self.type) {
-                const blockIndex = context.mediaBlocks.indexOf(self);
-                if (blockIndex > -1) {
-                    context.mediaBlocks.splice(blockIndex, 1);
-                }
-                return self;
-            }
-
-            value = /** @type {NestableAtRuleThis} */ (path[i]).features instanceof Value ?
-                /** @type {Node[]} */ (/** @type {NestableAtRuleThis} */ (path[i]).features.value) : /** @type {NestableAtRuleThis} */ (path[i]).features;
-            path[i] = /** @type {Node} */ (/** @type {unknown} */ (Array.isArray(value) ? value : [value]));
-        }
-
-        // Trace all permutations to generate the resulting media-query.
-        //
-        // (a, b and c) with nested (d, e) ->
-        //    a and d
-        //    a and e
-        //    b and c and d
-        //    b and c and e
-        self.features = new Value(self.permute(/** @type {Node[][]} */ (/** @type {unknown} */ (path))).map(
-            /** @param {Node | Node[]} path */
-            path => {
-                path = /** @type {Node[]} */ (path).map(
-                /** @param {Node & { toCSS?: Function }} fragment */
-                    fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
-
-                // A media type nested inside conditions must move ahead of them
-                // so the flattened query stays valid (issue #3694, #3764).
-                const types = /** @type {Node[]} */ (path).filter(startsWithMediaType);
-                if (types.length && types.length < /** @type {Node[]} */ (path).length) {
-                    path = types.concat(/** @type {Node[]} */ (path).filter(f => !startsWithMediaType(f)));
-                }
-
-                for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
-                /** @type {Node[]} */ (path).splice(i, 0, new Anonymous('and'));
-                }
-
-                return new Expression(/** @type {Node[]} */ (path));
-            }));
-        self.setParent(self.features, self);
-
-        // Fake a tree-node that doesn't output anything.
-        return new Ruleset([], []);
-    },
-
-    /**
-     * @param {Node[][]} arr
-     * @returns {Node[][]}
-     */
-    permute(arr) {
-        if (arr.length === 0) {
-            return [];
-        } else if (arr.length === 1) {
-            return /** @type {Node[][]} */ (/** @type {unknown} */ (arr[0]));
-        } else {
-            /** @type {Node[][]} */
-            const result = [];
-            const rest = this.permute(arr.slice(1));
-            for (let i = 0; i < rest.length; i++) {
-                for (let j = 0; j < arr[0].length; j++) {
-                    result.push([arr[0][j]].concat(rest[i]));
-                }
-            }
-            return result;
-        }
-    },
-
-    /** @param {Selector[] | undefined} selectors */
-    bubbleSelectors(selectors) {
-        /** @type {NestableAtRuleThis} */
-        const self = /** @type {NestableAtRuleThis} */ (/** @type {unknown} */ (this));
-        if (!selectors) {
-            return;
-        }
-        self.rules = [new Ruleset(utils.copyArray(selectors), [self.rules[0]])];
-        self.setParent(self.rules, self);
-    }
-};
-
-export default NestableAtRulePrototype;