less 4.5.1 → 4.6.0

package/lib/less/tree/ruleset.js

@@ -1,63 +1,129 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var declaration_1 = tslib_1.__importDefault(require("./declaration"));
-var keyword_1 = tslib_1.__importDefault(require("./keyword"));
-var comment_1 = tslib_1.__importDefault(require("./comment"));
-var paren_1 = tslib_1.__importDefault(require("./paren"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var element_1 = tslib_1.__importDefault(require("./element"));
-var anonymous_1 = tslib_1.__importDefault(require("./anonymous"));
-var contexts_1 = tslib_1.__importDefault(require("../contexts"));
-var function_registry_1 = tslib_1.__importDefault(require("../functions/function-registry"));
-var default_1 = tslib_1.__importDefault(require("../functions/default"));
-var debug_info_1 = tslib_1.__importDefault(require("./debug-info"));
-var utils = tslib_1.__importStar(require("../utils"));
-var parser_1 = tslib_1.__importDefault(require("../parser/parser"));
-var Ruleset = function (selectors, rules, strictImports, visibilityInfo) {
-    this.selectors = selectors;
-    this.rules = rules;
-    this._lookups = {};
-    this._variables = null;
-    this._properties = null;
-    this.strictImports = strictImports;
-    this.copyVisibilityInfo(visibilityInfo);
-    this.allowRoot = true;
-    this.setParent(this.selectors, this);
-    this.setParent(this.rules, this);
-};
-Ruleset.prototype = Object.assign(new node_1.default(), {
-    type: 'Ruleset',
-    isRuleset: true,
-    isRulesetLike: function () { return true; },
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, CSSOutput, TreeVisitor, FileInfo, VisibilityInfo } from './node.js' */
+/** @import { FunctionRegistry } from './nested-at-rule.js' */
+import Node from './node.js';
+import Declaration from './declaration.js';
+import Keyword from './keyword.js';
+import Comment from './comment.js';
+import Paren from './paren.js';
+import Selector from './selector.js';
+import Element from './element.js';
+import Anonymous from './anonymous.js';
+import contexts from '../contexts.js';
+import globalFunctionRegistry from '../functions/function-registry.js';
+import defaultFunc from '../functions/default.js';
+import getDebugInfo from './debug-info.js';
+import * as utils from '../utils.js';
+import Parser from '../parser/parser.js';
+
+/**
+ * @typedef {Node & {
+ *   rules?: Node[],
+ *   selectors?: Selector[],
+ *   root?: boolean,
+ *   firstRoot?: boolean,
+ *   allowImports?: boolean,
+ *   functionRegistry?: FunctionRegistry,
+ *   originalRuleset?: Node,
+ *   debugInfo?: { lineNumber: number, fileName: string },
+ *   evalFirst?: boolean,
+ *   isRuleset?: boolean,
+ *   isCharset?: () => boolean,
+ *   merge?: boolean | string,
+ *   multiMedia?: boolean,
+ *   parse?: { context: EvalContext, importManager: object },
+ *   bubbleSelectors?: (selectors: Selector[]) => void
+ * }} RuleNode
+ */
+
+class Ruleset extends Node {
+    get type() { return 'Ruleset'; }
+
+    /**
+     * @param {Selector[] | null} selectors
+     * @param {Node[] | null} rules
+     * @param {boolean} [strictImports]
+     * @param {VisibilityInfo} [visibilityInfo]
+     */
+    constructor(selectors, rules, strictImports, visibilityInfo) {
+        super();
+        /** @type {Selector[] | null} */
+        this.selectors = selectors;
+        /** @type {Node[] | null} */
+        this.rules = rules;
+        /** @type {Object<string, { rule: Node, path: Node[] }[]>} */
+        this._lookups = {};
+        /** @type {Object<string, Declaration> | null} */
+        this._variables = null;
+        /** @type {Object<string, Declaration[]> | null} */
+        this._properties = null;
+        /** @type {boolean | undefined} */
+        this.strictImports = strictImports;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+        /** @type {boolean} */
+        this.isRuleset = true;
+
+        /** @type {boolean | undefined} */
+        this.root = undefined;
+        /** @type {boolean | undefined} */
+        this.firstRoot = undefined;
+        /** @type {boolean | undefined} */
+        this.allowImports = undefined;
+        /** @type {FunctionRegistry | undefined} */
+        this.functionRegistry = undefined;
+        /** @type {Node | undefined} */
+        this.originalRuleset = undefined;
+        /** @type {{ lineNumber: number, fileName: string } | undefined} */
+        this.debugInfo = undefined;
+        /** @type {Selector[][] | undefined} */
+        this.paths = undefined;
+        /** @type {Ruleset[] | null | undefined} */
+        this._rulesets = undefined;
+        /** @type {boolean | undefined} */
+        this.evalFirst = undefined;
+        this.setParent(this.selectors, this);
+        this.setParent(this.rules, this);
+    }
+
+    isRulesetLike() { return true; }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.paths) {
-            this.paths = visitor.visitArray(this.paths, true);
-        }
-        else if (this.selectors) {
-            this.selectors = visitor.visitArray(this.selectors);
+            this.paths = /** @type {Selector[][]} */ (/** @type {unknown} */ (visitor.visitArray(/** @type {Node[]} */ (/** @type {unknown} */ (this.paths)), true)));
+        } else if (this.selectors) {
+            this.selectors = /** @type {Selector[]} */ (visitor.visitArray(this.selectors));
         }
         if (this.rules && this.rules.length) {
             this.rules = visitor.visitArray(this.rules);
         }
-    },
-    eval: function (context) {
-        var selectors;
-        var selCnt;
-        var selector;
-        var i;
-        var hasVariable;
-        var hasOnePassingSelector = false;
+    }
+
+    /** @param {EvalContext} context */
+    eval(context) {
+        /** @type {Selector[] | undefined} */
+        let selectors;
+        /** @type {number} */
+        let selCnt;
+        /** @type {Selector} */
+        let selector;
+        /** @type {number} */
+        let i;
+        /** @type {boolean | undefined} */
+        let hasVariable;
+        let hasOnePassingSelector = false;
+
         if (this.selectors && (selCnt = this.selectors.length)) {
             selectors = new Array(selCnt);
-            default_1.default.error({
+            defaultFunc.error({
                 type: 'Syntax',
                 message: 'it is currently only allowed in parametric mixin guards,'
             });
+
             for (i = 0; i < selCnt; i++) {
-                selector = this.selectors[i].eval(context);
-                for (var j = 0; j < selector.elements.length; j++) {
+                selector = /** @type {Selector} */ (this.selectors[i].eval(context));
+                for (let j = 0; j < selector.elements.length; j++) {
                     if (selector.elements[j].isVariable) {
                         hasVariable = true;
                         break;
@@ -68,112 +134,126 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                     hasOnePassingSelector = true;
                 }
             }
+
             if (hasVariable) {
-                var toParseSelectors = new Array(selCnt);
+                const toParseSelectors = new Array(selCnt);
                 for (i = 0; i < selCnt; i++) {
                     selector = selectors[i];
                     toParseSelectors[i] = selector.toCSS(context);
                 }
-                var startingIndex = selectors[0].getIndex();
-                var selectorFileInfo = selectors[0].fileInfo();
-                new parser_1.default(context, this.parse.importManager, selectorFileInfo, startingIndex).parseNode(toParseSelectors.join(','), ['selectors'], function (err, result) {
-                    if (result) {
-                        selectors = utils.flattenArray(result);
-                    }
-                });
+                const startingIndex = selectors[0].getIndex();
+                const selectorFileInfo = selectors[0].fileInfo();
+                new (/** @type {new (...args: [EvalContext, object, FileInfo, number]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(context, /** @type {{ context: EvalContext, importManager: object }} */ (this.parse).importManager, selectorFileInfo, startingIndex).parseNode(
+                    toParseSelectors.join(','),
+                    ['selectors'],
+                    function(/** @type {Error | null} */ err, /** @type {Node[]} */ result) {
+                        if (result) {
+                            selectors = /** @type {Selector[]} */ (utils.flattenArray(result));
+                        }
+                    });
             }
-            default_1.default.reset();
-        }
-        else {
+
+            defaultFunc.reset();
+        } else {
             hasOnePassingSelector = true;
         }
-        var rules = this.rules ? utils.copyArray(this.rules) : null;
-        var ruleset = new Ruleset(selectors, rules, this.strictImports, this.visibilityInfo());
-        var rule;
-        var subRule;
+
+        let rules = this.rules ? utils.copyArray(this.rules) : null;
+        const ruleset = new Ruleset(selectors, rules, this.strictImports, this.visibilityInfo());
+        /** @type {Node} */
+        let rule;
+        /** @type {Node} */
+        let subRule;
+
         ruleset.originalRuleset = this;
         ruleset.root = this.root;
         ruleset.firstRoot = this.firstRoot;
         ruleset.allowImports = this.allowImports;
+
         if (this.debugInfo) {
             ruleset.debugInfo = this.debugInfo;
         }
+
         if (!hasOnePassingSelector) {
-            rules.length = 0;
+            /** @type {Node[]} */ (rules).length = 0;
         }
+
+        // push the current ruleset to the frames stack
+        const ctxFrames = context.frames;
+
         // inherit a function registry from the frames stack when possible;
         // otherwise from the global registry
-        ruleset.functionRegistry = (function (frames) {
-            var i = 0;
-            var n = frames.length;
-            var found;
-            for (; i !== n; ++i) {
-                found = frames[i].functionRegistry;
-                if (found) {
-                    return found;
-                }
-            }
-            return function_registry_1.default;
-        }(context.frames)).inherit();
-        // push the current ruleset to the frames stack
-        var ctxFrames = context.frames;
+        /** @type {FunctionRegistry | undefined} */
+        let foundRegistry;
+        for (let fi = 0, fn = ctxFrames.length; fi !== fn; ++fi) {
+            foundRegistry = /** @type {RuleNode} */ (ctxFrames[fi]).functionRegistry;
+            if (foundRegistry) { break; }
+        }
+        ruleset.functionRegistry = (foundRegistry || globalFunctionRegistry).inherit();
         ctxFrames.unshift(ruleset);
+
         // currrent selectors
-        var ctxSelectors = context.selectors;
+        /** @type {Selector[][] | undefined} */
+        let ctxSelectors = /** @type {EvalContext & { selectors?: Selector[][] }} */ (context).selectors;
         if (!ctxSelectors) {
-            context.selectors = ctxSelectors = [];
+            /** @type {EvalContext & { selectors?: Selector[][] }} */ (context).selectors = ctxSelectors = [];
         }
         ctxSelectors.unshift(this.selectors);
+
         // Evaluate imports
         if (ruleset.root || ruleset.allowImports || !ruleset.strictImports) {
             ruleset.evalImports(context);
         }
+
         // Store the frames around mixin definitions,
         // so they can be evaluated like closures when the time comes.
-        var rsRules = ruleset.rules;
+        const rsRules = /** @type {Node[]} */ (ruleset.rules);
         for (i = 0; (rule = rsRules[i]); i++) {
-            if (rule.evalFirst) {
+            if (/** @type {RuleNode} */ (rule).evalFirst) {
                 rsRules[i] = rule.eval(context);
             }
         }
-        var mediaBlockCount = (context.mediaBlocks && context.mediaBlocks.length) || 0;
+
+        const mediaBlockCount = (context.mediaBlocks && context.mediaBlocks.length) || 0;
+
         // Evaluate mixin calls.
         for (i = 0; (rule = rsRules[i]); i++) {
             if (rule.type === 'MixinCall') {
                 /* jshint loopfunc:true */
-                rules = rule.eval(context).filter(function (r) {
-                    if ((r instanceof declaration_1.default) && r.variable) {
+                rules = /** @type {Node[]} */ (/** @type {unknown} */ (rule.eval(context))).filter(function(/** @type {Node & { variable?: boolean }} */ r) {
+                    if ((r instanceof Declaration) && r.variable) {
                         // do not pollute the scope if the variable is
                         // already there. consider returning false here
                         // but we need a way to "return" variable from mixins
-                        return !(ruleset.variable(r.name));
+                        return !(ruleset.variable(/** @type {string} */ (r.name)));
                     }
                     return true;
                 });
-                rsRules.splice.apply(rsRules, [i, 1].concat(rules));
+                rsRules.splice.apply(rsRules, /** @type {[number, number, ...Node[]]} */ ([i, 1].concat(rules)));
                 i += rules.length - 1;
                 ruleset.resetCache();
-            }
-            else if (rule.type === 'VariableCall') {
+            } else if (rule.type ===  'VariableCall') {
                 /* jshint loopfunc:true */
-                rules = rule.eval(context).rules.filter(function (r) {
-                    if ((r instanceof declaration_1.default) && r.variable) {
+                rules = /** @type {Node[]} */ (/** @type {RuleNode} */ (rule.eval(context)).rules).filter(function(/** @type {Node & { variable?: boolean }} */ r) {
+                    if ((r instanceof Declaration) && r.variable) {
                         // do not pollute the scope at all
                         return false;
                     }
                     return true;
                 });
-                rsRules.splice.apply(rsRules, [i, 1].concat(rules));
+                rsRules.splice.apply(rsRules, /** @type {[number, number, ...Node[]]} */ ([i, 1].concat(rules)));
                 i += rules.length - 1;
                 ruleset.resetCache();
             }
         }
+
         // Evaluate everything else
         for (i = 0; (rule = rsRules[i]); i++) {
-            if (!rule.evalFirst) {
+            if (!/** @type {RuleNode} */ (rule).evalFirst) {
                 rsRules[i] = rule = rule.eval ? rule.eval(context) : rule;
             }
         }
+
         // Evaluate everything else
         for (i = 0; (rule = rsRules[i]); i++) {
             // for rulesets, check if it is a css guard and can be removed
@@ -181,10 +261,11 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                 // check if it can be folded in (e.g. & where)
                 if (rule.selectors[0] && rule.selectors[0].isJustParentSelector()) {
                     rsRules.splice(i--, 1);
-                    for (var j = 0; (subRule = rule.rules[j]); j++) {
-                        if (subRule instanceof node_1.default) {
+
+                    for (let j = 0; (subRule = rule.rules[j]); j++) {
+                        if (subRule instanceof Node) {
                             subRule.copyVisibilityInfo(rule.visibilityInfo());
-                            if (!(subRule instanceof declaration_1.default) || !subRule.variable) {
+                            if (!(subRule instanceof Declaration) || !subRule.variable) {
                                 rsRules.splice(++i, 0, subRule);
                             }
                         }
@@ -192,84 +273,100 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                 }
             }
         }
+
         // Pop the stack
         ctxFrames.shift();
         ctxSelectors.shift();
+
         if (context.mediaBlocks) {
             for (i = mediaBlockCount; i < context.mediaBlocks.length; i++) {
-                context.mediaBlocks[i].bubbleSelectors(selectors);
+                /** @type {RuleNode} */ (context.mediaBlocks[i]).bubbleSelectors(selectors);
             }
         }
+
         return ruleset;
-    },
-    evalImports: function (context) {
-        var rules = this.rules;
-        var i;
-        var importRules;
-        if (!rules) {
-            return;
-        }
+    }
+
+    /** @param {EvalContext} context */
+    evalImports(context) {
+        const rules = this.rules;
+        /** @type {number} */
+        let i;
+        /** @type {Node | Node[]} */
+        let importRules;
+        if (!rules) { return; }
+
         for (i = 0; i < rules.length; i++) {
             if (rules[i].type === 'Import') {
                 importRules = rules[i].eval(context);
-                if (importRules && (importRules.length || importRules.length === 0)) {
-                    rules.splice.apply(rules, [i, 1].concat(importRules));
-                    i += importRules.length - 1;
-                }
-                else {
+                if (importRules && (/** @type {Node[]} */ (/** @type {unknown} */ (importRules)).length || /** @type {Node[]} */ (/** @type {unknown} */ (importRules)).length === 0)) {
+                    const importArr = /** @type {Node[]} */ (/** @type {unknown} */ (importRules));
+                    rules.splice(i, 1, ...importArr);
+                    i += importArr.length - 1;
+                } else {
                     rules.splice(i, 1, importRules);
                 }
                 this.resetCache();
             }
         }
-    },
-    makeImportant: function () {
-        var result = new Ruleset(this.selectors, this.rules.map(function (r) {
+    }
+
+    makeImportant() {
+        const result = new Ruleset(this.selectors, /** @type {Node[]} */ (this.rules).map(function (/** @type {Node & { makeImportant?: () => Node }} */ r) {
             if (r.makeImportant) {
                 return r.makeImportant();
-            }
-            else {
+            } else {
                 return r;
             }
         }), this.strictImports, this.visibilityInfo());
+
         return result;
-    },
-    matchArgs: function (args) {
+    }
+
+    /** @param {Node[] | object[] | null} [args] */
+    matchArgs(args) {
         return !args || args.length === 0;
-    },
-    // lets you call a css selector with a guard
-    matchCondition: function (args, context) {
-        var lastSelector = this.selectors[this.selectors.length - 1];
+    }
+
+    /**
+     * @param {Node[] | object[] | null} args
+     * @param {EvalContext} context
+     */
+    matchCondition(args, context) {
+        const lastSelector = /** @type {Selector[]} */ (this.selectors)[/** @type {Selector[]} */ (this.selectors).length - 1];
         if (!lastSelector.evaldCondition) {
             return false;
         }
         if (lastSelector.condition &&
-            !lastSelector.condition.eval(new contexts_1.default.Eval(context, context.frames))) {
+            !lastSelector.condition.eval(
+                new contexts.Eval(context,
+                    context.frames))) {
             return false;
         }
         return true;
-    },
-    resetCache: function () {
+    }
+
+    resetCache() {
         this._rulesets = null;
         this._variables = null;
         this._properties = null;
         this._lookups = {};
-    },
-    variables: function () {
+    }
+
+    variables() {
         if (!this._variables) {
-            this._variables = !this.rules ? {} : this.rules.reduce(function (hash, r) {
-                if (r instanceof declaration_1.default && r.variable === true) {
-                    hash[r.name] = r;
+            this._variables = !this.rules ? {} : this.rules.reduce(function (/** @type {Object<string, Declaration>} */ hash, /** @type {Node} */ r) {
+                if (r instanceof Declaration && r.variable === true) {
+                    hash[/** @type {string} */ (r.name)] = r;
                 }
                 // when evaluating variables in an import statement, imports have not been eval'd
                 // so we need to go inside import statements.
                 // guard against root being a string (in the case of inlined less)
-                if (r.type === 'Import' && r.root && r.root.variables) {
-                    var vars = r.root.variables();
-                    for (var name_1 in vars) {
-                        // eslint-disable-next-line no-prototype-builtins
-                        if (vars.hasOwnProperty(name_1)) {
-                            hash[name_1] = r.root.variable(name_1);
+                if (r.type === 'Import' && /** @type {RuleNode} */ (r).root && /** @type {RuleNode & { root: Ruleset }} */ (r).root.variables) {
+                    const vars = /** @type {RuleNode & { root: Ruleset }} */ (r).root.variables();
+                    for (const name in vars) {
+                        if (Object.prototype.hasOwnProperty.call(vars, name)) {
+                            hash[name] = /** @type {Declaration} */ (/** @type {RuleNode & { root: Ruleset }} */ (r).root.variable(name));
                         }
                     }
                 }
@@ -277,65 +374,77 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
             }, {});
         }
         return this._variables;
-    },
-    properties: function () {
+    }
+
+    properties() {
         if (!this._properties) {
-            this._properties = !this.rules ? {} : this.rules.reduce(function (hash, r) {
-                if (r instanceof declaration_1.default && r.variable !== true) {
-                    var name_2 = (r.name.length === 1) && (r.name[0] instanceof keyword_1.default) ?
-                        r.name[0].value : r.name;
+            this._properties = !this.rules ? {} : this.rules.reduce(function (/** @type {Object<string, Declaration[]>} */ hash, /** @type {Node} */ r) {
+                if (r instanceof Declaration && r.variable !== true) {
+                    const name = (/** @type {Node[]} */ (r.name).length === 1) && (/** @type {Node[]} */ (r.name)[0] instanceof Keyword) ?
+                        /** @type {string} */ (/** @type {Node[]} */ (r.name)[0].value) : /** @type {string} */ (r.name);
                     // Properties don't overwrite as they can merge
-                    if (!hash["$".concat(name_2)]) {
-                        hash["$".concat(name_2)] = [r];
+                    if (!hash[`$${name}`]) {
+                        hash[`$${name}`] = [ r ];
                     }
                     else {
-                        hash["$".concat(name_2)].push(r);
+                        hash[`$${name}`].push(r);
                     }
                 }
                 return hash;
             }, {});
         }
         return this._properties;
-    },
-    variable: function (name) {
-        var decl = this.variables()[name];
+    }
+
+    /** @param {string} name */
+    variable(name) {
+        const decl = this.variables()[name];
         if (decl) {
             return this.parseValue(decl);
         }
-    },
-    property: function (name) {
-        var decl = this.properties()[name];
+    }
+
+    /** @param {string} name */
+    property(name) {
+        const decl = this.properties()[name];
         if (decl) {
             return this.parseValue(decl);
         }
-    },
-    lastDeclaration: function () {
-        for (var i = this.rules.length; i > 0; i--) {
-            var decl = this.rules[i - 1];
-            if (decl instanceof declaration_1.default) {
+    }
+
+    lastDeclaration() {
+        for (let i = /** @type {Node[]} */ (this.rules).length; i > 0; i--) {
+            const decl = /** @type {Node[]} */ (this.rules)[i - 1];
+            if (decl instanceof Declaration) {
                 return this.parseValue(decl);
             }
         }
-    },
-    parseValue: function (toParse) {
-        var self = this;
+    }
+
+    /** @param {Declaration | Declaration[]} toParse */
+    parseValue(toParse) {
+        const self = this;
+        /** @param {Declaration} decl */
         function transformDeclaration(decl) {
-            if (decl.value instanceof anonymous_1.default && !decl.parsed) {
+            if (decl.value instanceof Anonymous && !/** @type {Declaration & { parsed?: boolean }} */ (decl).parsed) {
                 if (typeof decl.value.value === 'string') {
-                    new parser_1.default(this.parse.context, this.parse.importManager, decl.fileInfo(), decl.value.getIndex()).parseNode(decl.value.value, ['value', 'important'], function (err, result) {
-                        if (err) {
-                            decl.parsed = true;
-                        }
-                        if (result) {
-                            decl.value = result[0];
-                            decl.important = result[1] || '';
-                            decl.parsed = true;
-                        }
-                    });
-                }
-                else {
-                    decl.parsed = true;
+                    new (/** @type {new (...args: [EvalContext, object, FileInfo, number]) => { parseNode: Function }} */ (/** @type {unknown} */ (Parser)))(/** @type {{ context: EvalContext, importManager: object }} */ (/** @type {Ruleset} */ (this).parse).context, /** @type {{ context: EvalContext, importManager: object }} */ (/** @type {Ruleset} */ (this).parse).importManager, decl.fileInfo(), decl.value.getIndex()).parseNode(
+                        decl.value.value,
+                        ['value', 'important'],
+                        function(/** @type {Error | null} */ err, /** @type {Node[]} */ result) {
+                            if (err) {
+                                decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
+                            }
+                            if (result) {
+                                decl.value = result[0];
+                                /** @type {Declaration & { important?: string }} */ (decl).important = /** @type {string} */ (/** @type {unknown} */ (result[1])) || '';
+                                decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
+                            }
+                        });
+                } else {
+                    decl.parsed = /** @type {Node} */ (/** @type {unknown} */ (true));
                 }
+
                 return decl;
             }
             else {
@@ -346,63 +455,79 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
             return transformDeclaration.call(self, toParse);
         }
         else {
-            var nodes_1 = [];
-            toParse.forEach(function (n) {
-                nodes_1.push(transformDeclaration.call(self, n));
-            });
-            return nodes_1;
-        }
-    },
-    rulesets: function () {
-        if (!this.rules) {
-            return [];
+            /** @type {Declaration[]} */
+            const nodes = [];
+            for (let ti = 0; ti < toParse.length; ti++) {
+                nodes.push(transformDeclaration.call(self, toParse[ti]));
+            }
+            return nodes;
         }
-        var filtRules = [];
-        var rules = this.rules;
-        var i;
-        var rule;
+    }
+
+    rulesets() {
+        if (!this.rules) { return []; }
+
+        /** @type {Node[]} */
+        const filtRules = [];
+        const rules = this.rules;
+        /** @type {number} */
+        let i;
+        /** @type {Node} */
+        let rule;
+
         for (i = 0; (rule = rules[i]); i++) {
-            if (rule.isRuleset) {
+            if (/** @type {RuleNode} */ (rule).isRuleset) {
                 filtRules.push(rule);
             }
         }
+
         return filtRules;
-    },
-    prependRule: function (rule) {
-        var rules = this.rules;
+    }
+
+    /** @param {Node} rule */
+    prependRule(rule) {
+        const rules = this.rules;
         if (rules) {
             rules.unshift(rule);
-        }
-        else {
-            this.rules = [rule];
+        } else {
+            this.rules = [ rule ];
         }
         this.setParent(rule, this);
-    },
-    find: function (selector, self, filter) {
+    }
+
+    /**
+     * @param {Selector} selector
+     * @param {Ruleset | null} [self]
+     * @param {((rule: Node) => boolean)} [filter]
+     * @returns {{ rule: Node, path: Node[] }[]}
+     */
+    find(selector, self, filter) {
         self = self || this;
-        var rules = [];
-        var match;
-        var foundMixins;
-        var key = selector.toCSS();
-        if (key in this._lookups) {
-            return this._lookups[key];
-        }
+        /** @type {{ rule: Node, path: Node[] }[]} */
+        const rules = [];
+        /** @type {number | undefined} */
+        let match;
+        /** @type {{ rule: Node, path: Node[] }[]} */
+        let foundMixins;
+        const key = selector.toCSS(/** @type {EvalContext} */ ({}));
+
+        if (key in this._lookups) { return /** @type {{ rule: Node, path: Node[] }[]} */ (this._lookups[key]); }
+
         this.rulesets().forEach(function (rule) {
             if (rule !== self) {
-                for (var j = 0; j < rule.selectors.length; j++) {
-                    match = selector.match(rule.selectors[j]);
+                for (let j = 0; j < /** @type {RuleNode} */ (rule).selectors.length; j++) {
+                    match = selector.match(/** @type {RuleNode} */ (rule).selectors[j]);
                     if (match) {
                         if (selector.elements.length > match) {
                             if (!filter || filter(rule)) {
-                                foundMixins = rule.find(new selector_1.default(selector.elements.slice(match)), self, filter);
-                                for (var i = 0; i < foundMixins.length; ++i) {
+                                foundMixins = /** @type {Ruleset} */ (/** @type {unknown} */ (rule)).find(new Selector(selector.elements.slice(match)), self, filter);
+                                for (let i = 0; i < foundMixins.length; ++i) {
                                     foundMixins[i].path.push(rule);
                                 }
                                 Array.prototype.push.apply(rules, foundMixins);
                             }
-                        }
-                        else {
-                            rules.push({ rule: rule, path: [] });
+                        } else {
+                            rules.push({ rule, path: []});
                         }
                         break;
                     }
@@ -411,139 +536,211 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
         });
         this._lookups[key] = rules;
         return rules;
-    },
-    genCSS: function (context, output) {
-        var i;
-        var j;
-        var charsetRuleNodes = [];
-        var ruleNodes = [];
-        var // Line number debugging
-        debugInfo;
-        var rule;
-        var path;
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @param {CSSOutput} output
+     */
+    genCSS(context, output) {
+        /** @type {number} */
+        let i;
+        /** @type {number} */
+        let j;
+        /** @type {Node[]} */
+        const charsetRuleNodes = [];
+        /** @type {Node[]} */
+        let ruleNodes = [];
+
+        let // Line number debugging
+            debugInfo;
+
+        /** @type {Node} */
+        let rule;
+        /** @type {Selector[]} */
+        let path;
+
         context.tabLevel = (context.tabLevel || 0);
+
         if (!this.root) {
             context.tabLevel++;
         }
-        var tabRuleStr = context.compress ? '' : Array(context.tabLevel + 1).join('  ');
-        var tabSetStr = context.compress ? '' : Array(context.tabLevel).join('  ');
-        var sep;
-        var charsetNodeIndex = 0;
-        var importNodeIndex = 0;
-        for (i = 0; (rule = this.rules[i]); i++) {
-            if (rule instanceof comment_1.default) {
+
+        const tabRuleStr = context.compress ? '' : Array(context.tabLevel + 1).join('  ');
+        const tabSetStr = context.compress ? '' : Array(context.tabLevel).join('  ');
+        /** @type {string} */
+        let sep;
+
+        let charsetNodeIndex = 0;
+        let importNodeIndex = 0;
+        for (i = 0; (rule = /** @type {Node[]} */ (this.rules)[i]); i++) {
+            if (rule instanceof Comment) {
                 if (importNodeIndex === i) {
                     importNodeIndex++;
                 }
                 ruleNodes.push(rule);
-            }
-            else if (rule.isCharset && rule.isCharset()) {
+            } else if (/** @type {RuleNode} */ (rule).isCharset && /** @type {RuleNode} */ (rule).isCharset()) {
                 ruleNodes.splice(charsetNodeIndex, 0, rule);
                 charsetNodeIndex++;
                 importNodeIndex++;
-            }
-            else if (rule.type === 'Import') {
+            } else if (rule.type === 'Import') {
                 ruleNodes.splice(importNodeIndex, 0, rule);
                 importNodeIndex++;
-            }
-            else {
+            } else {
                 ruleNodes.push(rule);
             }
         }
         ruleNodes = charsetRuleNodes.concat(ruleNodes);
+
         // If this is the root node, we don't render
         // a selector, or {}.
         if (!this.root) {
-            debugInfo = (0, debug_info_1.default)(context, this, tabSetStr);
+            debugInfo = getDebugInfo(context, /** @type {{ debugInfo: { lineNumber: number, fileName: string } }} */ (/** @type {unknown} */ (this)), tabSetStr);
+
             if (debugInfo) {
                 output.add(debugInfo);
                 output.add(tabSetStr);
             }
-            var paths = this.paths;
-            var pathCnt = paths.length;
-            var pathSubCnt = void 0;
-            sep = context.compress ? ',' : (",\n".concat(tabSetStr));
+
+            const paths = /** @type {Selector[][]} */ (this.paths);
+            const pathCnt = paths.length;
+            /** @type {number} */
+            let pathSubCnt;
+
+            sep = context.compress ? ',' : (`,\n${tabSetStr}`);
+
             for (i = 0; i < pathCnt; i++) {
                 path = paths[i];
-                if (!(pathSubCnt = path.length)) {
-                    continue;
-                }
-                if (i > 0) {
-                    output.add(sep);
-                }
-                context.firstSelector = true;
+                if (!(pathSubCnt = path.length)) { continue; }
+                if (i > 0) { output.add(sep); }
+
+                /** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector = true;
                 path[0].genCSS(context, output);
-                context.firstSelector = false;
+
+                /** @type {EvalContext & { firstSelector?: boolean }} */ (context).firstSelector = false;
                 for (j = 1; j < pathSubCnt; j++) {
                     path[j].genCSS(context, output);
                 }
             }
+
             output.add((context.compress ? '{' : ' {\n') + tabRuleStr);
         }
+
         // Compile rules and rulesets
         for (i = 0; (rule = ruleNodes[i]); i++) {
+
             if (i + 1 === ruleNodes.length) {
                 context.lastRule = true;
             }
-            var currentLastRule = context.lastRule;
-            if (rule.isRulesetLike(rule)) {
+
+            const currentLastRule = context.lastRule;
+            if (rule.isRulesetLike()) {
                 context.lastRule = false;
             }
+
             if (rule.genCSS) {
                 rule.genCSS(context, output);
+            } else if (rule.value) {
+                output.add(/** @type {string} */ (rule.value).toString());
             }
-            else if (rule.value) {
-                output.add(rule.value.toString());
-            }
+
             context.lastRule = currentLastRule;
+
             if (!context.lastRule && rule.isVisible()) {
-                output.add(context.compress ? '' : ("\n".concat(tabRuleStr)));
-            }
-            else {
+                output.add(context.compress ? '' : (`\n${tabRuleStr}`));
+            } else {
                 context.lastRule = false;
             }
         }
+
         if (!this.root) {
-            output.add((context.compress ? '}' : "\n".concat(tabSetStr, "}")));
+            output.add((context.compress ? '}' : `\n${tabSetStr}}`));
             context.tabLevel--;
         }
+
         if (!output.isEmpty() && !context.compress && this.firstRoot) {
             output.add('\n');
         }
-    },
-    joinSelectors: function (paths, context, selectors) {
-        for (var s = 0; s < selectors.length; s++) {
+    }
+
+    /**
+     * @param {Selector[][]} paths
+     * @param {Selector[][]} context
+     * @param {Selector[]} selectors
+     */
+    joinSelectors(paths, context, selectors) {
+        for (let s = 0; s < selectors.length; s++) {
             this.joinSelector(paths, context, selectors[s]);
         }
-    },
-    joinSelector: function (paths, context, selector) {
+    }
+
+    /**
+     * @param {Selector[][]} paths
+     * @param {Selector[][]} context
+     * @param {Selector} selector
+     */
+    joinSelector(paths, context, selector) {
+
+        /**
+         * @param {Selector[]} elementsToPak
+         * @param {Element} originalElement
+         * @returns {Paren}
+         */
         function createParenthesis(elementsToPak, originalElement) {
-            var replacementParen, j;
+            /** @type {Paren} */
+            let replacementParen;
+            /** @type {number} */
+            let j;
             if (elementsToPak.length === 0) {
-                replacementParen = new paren_1.default(elementsToPak[0]);
-            }
-            else {
-                var insideParent = new Array(elementsToPak.length);
+                replacementParen = new Paren(elementsToPak[0]);
+            } else {
+                const insideParent = new Array(elementsToPak.length);
                 for (j = 0; j < elementsToPak.length; j++) {
-                    insideParent[j] = new element_1.default(null, elementsToPak[j], originalElement.isVariable, originalElement._index, originalElement._fileInfo);
+                    insideParent[j] = new Element(
+                        null,
+                        elementsToPak[j],
+                        originalElement.isVariable,
+                        originalElement._index,
+                        originalElement._fileInfo
+                    );
                 }
-                replacementParen = new paren_1.default(new selector_1.default(insideParent));
+                replacementParen = new Paren(new Selector(insideParent));
             }
             return replacementParen;
         }
+
+        /**
+         * @param {Paren | Selector} containedElement
+         * @param {Element} originalElement
+         * @returns {Selector}
+         */
         function createSelector(containedElement, originalElement) {
-            var element, selector;
-            element = new element_1.default(null, containedElement, originalElement.isVariable, originalElement._index, originalElement._fileInfo);
-            selector = new selector_1.default([element]);
+            /** @type {Element} */
+            let element;
+            /** @type {Selector} */
+            let selector;
+            element = new Element(null, containedElement, originalElement.isVariable, originalElement._index, originalElement._fileInfo);
+            selector = new Selector([element]);
             return selector;
         }
-        // joins selector path from `beginningPath` with selector path in `addPath`
-        // `replacedElement` contains element that is being replaced by `addPath`
-        // returns concatenated path
+
+        /**
+         * @param {Selector[]} beginningPath
+         * @param {Selector[]} addPath
+         * @param {Element} replacedElement
+         * @param {Selector} originalSelector
+         * @returns {Selector[]}
+         */
         function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {
-            var newSelectorPath, lastSelector, newJoinedSelector;
+            /** @type {Selector[]} */
+            let newSelectorPath;
+            /** @type {Selector} */
+            let lastSelector;
+            /** @type {Selector} */
+            let newJoinedSelector;
             // our new selector path
             newSelectorPath = [];
+
             // construct the joined selector - if & is the first thing this will be empty,
             // if not newJoinedSelector will be the last set of elements in the selector
             if (beginningPath.length > 0) {
@@ -554,68 +751,99 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
             else {
                 newJoinedSelector = originalSelector.createDerived([]);
             }
+
             if (addPath.length > 0) {
                 // /deep/ is a CSS4 selector - (removed, so should deprecate)
                 // that is valid without anything in front of it
                 // so if the & does not have a combinator that is "" or " " then
                 // and there is a combinator on the parent, then grab that.
                 // this also allows + a { & .b { .a & { ... though not sure why you would want to do that
-                var combinator = replacedElement.combinator;
-                var parentEl = addPath[0].elements[0];
+                let combinator = replacedElement.combinator;
+
+                const parentEl = addPath[0].elements[0];
                 if (combinator.emptyOrWhitespace && !parentEl.combinator.emptyOrWhitespace) {
                     combinator = parentEl.combinator;
                 }
                 // join the elements so far with the first part of the parent
-                newJoinedSelector.elements.push(new element_1.default(combinator, parentEl.value, replacedElement.isVariable, replacedElement._index, replacedElement._fileInfo));
+                newJoinedSelector.elements.push(new Element(
+                    combinator,
+                    parentEl.value,
+                    replacedElement.isVariable,
+                    replacedElement._index,
+                    replacedElement._fileInfo
+                ));
                 newJoinedSelector.elements = newJoinedSelector.elements.concat(addPath[0].elements.slice(1));
             }
+
             // now add the joined selector - but only if it is not empty
             if (newJoinedSelector.elements.length !== 0) {
                 newSelectorPath.push(newJoinedSelector);
             }
+
             // put together the parent selectors after the join (e.g. the rest of the parent)
             if (addPath.length > 1) {
-                var restOfPath = addPath.slice(1);
-                restOfPath = restOfPath.map(function (selector) {
+                let restOfPath = addPath.slice(1);
+                restOfPath = restOfPath.map(function (/** @type {Selector} */ selector) {
                     return selector.createDerived(selector.elements, []);
                 });
                 newSelectorPath = newSelectorPath.concat(restOfPath);
             }
             return newSelectorPath;
         }
-        // joins selector path from `beginningPath` with every selector path in `addPaths` array
-        // `replacedElement` contains element that is being replaced by `addPath`
-        // returns array with all concatenated paths
-        function addAllReplacementsIntoPath(beginningPath, addPaths, replacedElement, originalSelector, result) {
-            var j;
+
+        /**
+         * @param {Selector[][]} beginningPath
+         * @param {Selector[]} addPaths
+         * @param {Element} replacedElement
+         * @param {Selector} originalSelector
+         * @param {Selector[][]} result
+         * @returns {Selector[][]}
+         */
+        function addAllReplacementsIntoPath( beginningPath, addPaths, replacedElement, originalSelector, result) {
+            /** @type {number} */
+            let j;
             for (j = 0; j < beginningPath.length; j++) {
-                var newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
+                const newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
                 result.push(newSelectorPath);
             }
             return result;
         }
+
+        /**
+         * @param {Element[]} elements
+         * @param {Selector[][]} selectors
+         */
         function mergeElementsOnToSelectors(elements, selectors) {
-            var i, sel;
+            /** @type {number} */
+            let i;
+            /** @type {Selector[]} */
+            let sel;
+
             if (elements.length === 0) {
-                return;
+                return ;
             }
             if (selectors.length === 0) {
-                selectors.push([new selector_1.default(elements)]);
+                selectors.push([ new Selector(elements) ]);
                 return;
             }
+
             for (i = 0; (sel = selectors[i]); i++) {
                 // if the previous thing in sel is a parent this needs to join on to it
                 if (sel.length > 0) {
                     sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));
                 }
                 else {
-                    sel.push(new selector_1.default(elements));
+                    sel.push(new Selector(elements));
                 }
             }
         }
-        // replace all parent selectors inside `inSelector` by content of `context` array
-        // resulting selectors are returned inside `paths` array
-        // returns true if `inSelector` contained at least one parent selector
+
+        /**
+         * @param {Selector[][]} paths
+         * @param {Selector[][]} context
+         * @param {Selector} inSelector
+         * @returns {boolean}
+         */
         function replaceParentSelector(paths, context, inSelector) {
             // The paths are [[Selector]]
             // The first list is a list of comma separated selectors
@@ -627,18 +855,47 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
             // }
             // == [[.a] [.c]] [[.b] [.c]]
             //
-            var i, j, k, currentElements, newSelectors, selectorsMultiplied, sel, el, hadParentSelector = false, length, lastSelector;
+            /** @type {number} */
+            let i;
+            /** @type {number} */
+            let j;
+            /** @type {number} */
+            let k;
+            /** @type {Element[]} */
+            let currentElements;
+            /** @type {Selector[][]} */
+            let newSelectors;
+            /** @type {Selector[][]} */
+            let selectorsMultiplied;
+            /** @type {Selector[]} */
+            let sel;
+            /** @type {Element} */
+            let el;
+            let hadParentSelector = false;
+            /** @type {number} */
+            let length;
+            /** @type {Selector} */
+            let lastSelector;
+
+            /**
+             * @param {Element} element
+             * @returns {Selector | null}
+             */
             function findNestedSelector(element) {
-                var maybeSelector;
-                if (!(element.value instanceof paren_1.default)) {
+                /** @type {Node} */
+                let maybeSelector;
+                if (!(element.value instanceof Paren)) {
                     return null;
                 }
-                maybeSelector = element.value.value;
-                if (!(maybeSelector instanceof selector_1.default)) {
+
+                maybeSelector = /** @type {Node} */ (element.value.value);
+                if (!(maybeSelector instanceof Selector)) {
                     return null;
                 }
+
                 return maybeSelector;
             }
+
             // the elements from the current selector so far
             currentElements = [];
             // the current list of new selectors to add to the path.
@@ -647,38 +904,74 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
             newSelectors = [
                 []
             ];
+
             for (i = 0; (el = inSelector.elements[i]); i++) {
                 // non parent reference elements just get added
                 if (el.value !== '&') {
-                    var nestedSelector = findNestedSelector(el);
+                    const nestedSelector = findNestedSelector(el);
                     if (nestedSelector !== null) {
                         // merge the current list of non parent selector elements
                         // on to the current list of selectors to add
                         mergeElementsOnToSelectors(currentElements, newSelectors);
-                        var nestedPaths = [];
-                        var replaced = void 0;
-                        var replacedNewSelectors = [];
-                        replaced = replaceParentSelector(nestedPaths, context, nestedSelector);
-                        hadParentSelector = hadParentSelector || replaced;
-                        // the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors
-                        for (k = 0; k < nestedPaths.length; k++) {
-                            var replacementSelector = createSelector(createParenthesis(nestedPaths[k], el), el);
+
+                        /** @type {Selector[][]} */
+                        const nestedPaths = [];
+                        /** @type {boolean | undefined} */
+                        let replaced;
+                        /** @type {Selector[][]} */
+                        const replacedNewSelectors = [];
+
+                        // Check if this is a comma-separated selector list inside the paren
+                        // e.g. :not(&.a, &.b) produces Selector([Selector, Anonymous(','), Selector])
+                        const hasSubSelectors = nestedSelector.elements.some(e => e instanceof Selector);
+
+                        if (hasSubSelectors) {
+                            // Process each sub-selector individually
+                            /** @type {(Element | Selector)[]} */
+                            const resolvedElements = [];
+                            for (const subEl of nestedSelector.elements) {
+                                if (subEl instanceof Selector) {
+                                    /** @type {Selector[][]} */
+                                    const subPaths = [];
+                                    const subReplaced = replaceParentSelector(subPaths, context, subEl);
+                                    replaced = replaced || subReplaced;
+                                    if (subPaths.length > 0 && subPaths[0].length > 0) {
+                                        resolvedElements.push(subPaths[0][0]);
+                                    } else {
+                                        resolvedElements.push(subEl);
+                                    }
+                                } else {
+                                    resolvedElements.push(subEl);
+                                }
+                            }
+                            hadParentSelector = hadParentSelector || /** @type {boolean} */ (replaced);
+                            const resolvedNestedSelector = new Selector(resolvedElements);
+                            const replacementSelector = createSelector(createParenthesis([resolvedNestedSelector], el), el);
                             addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);
+                        } else {
+                            replaced = replaceParentSelector(nestedPaths, context, nestedSelector);
+                            hadParentSelector = hadParentSelector || replaced;
+                            // the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors
+                            for (k = 0; k < nestedPaths.length; k++) {
+                                const replacementSelector = createSelector(createParenthesis(nestedPaths[k], el), el);
+                                addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);
+                            }
                         }
                         newSelectors = replacedNewSelectors;
                         currentElements = [];
-                    }
-                    else {
+                    } else {
                         currentElements.push(el);
                     }
-                }
-                else {
+
+                } else {
                     hadParentSelector = true;
                     // the new list of selectors to add
                     selectorsMultiplied = [];
+
                     // merge the current list of non parent selector elements
                     // on to the current list of selectors to add
                     mergeElementsOnToSelectors(currentElements, newSelectors);
+
                     // loop through our current selectors
                     for (j = 0; j < newSelectors.length; j++) {
                         sel = newSelectors[j];
@@ -688,7 +981,7 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                             // the combinator used on el should now be applied to the next element instead so that
                             // it is not lost
                             if (sel.length > 0) {
-                                sel[0].elements.push(new element_1.default(el.combinator, '', el.isVariable, el._index, el._fileInfo));
+                                sel[0].elements.push(new Element(el.combinator, '', el.isVariable, el._index, el._fileInfo));
                             }
                             selectorsMultiplied.push(sel);
                         }
@@ -697,20 +990,23 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                             for (k = 0; k < context.length; k++) {
                                 // We need to put the current selectors
                                 // then join the last selector's elements on to the parents selectors
-                                var newSelectorPath = addReplacementIntoPath(sel, context[k], el, inSelector);
+                                const newSelectorPath = addReplacementIntoPath(sel, context[k], el, inSelector);
                                 // add that to our new set of selectors
                                 selectorsMultiplied.push(newSelectorPath);
                             }
                         }
                     }
+
                     // our new selectors has been multiplied, so reset the state
                     newSelectors = selectorsMultiplied;
                     currentElements = [];
                 }
             }
+
             // if we have any elements left over (e.g. .a& .b == .b)
             // add them on to all the current selectors
             mergeElementsOnToSelectors(currentElements, newSelectors);
+
             for (i = 0; i < newSelectors.length; i++) {
                 length = newSelectors[i].length;
                 if (length > 0) {
@@ -719,22 +1015,38 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                     newSelectors[i][length - 1] = lastSelector.createDerived(lastSelector.elements, inSelector.extendList);
                 }
             }
+
             return hadParentSelector;
         }
+
+        /**
+         * @param {VisibilityInfo} visibilityInfo
+         * @param {Selector} deriveFrom
+         */
         function deriveSelector(visibilityInfo, deriveFrom) {
-            var newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);
+            const newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);
             newSelector.copyVisibilityInfo(visibilityInfo);
             return newSelector;
         }
+
         // joinSelector code follows
-        var i, newPaths, hadParentSelector;
+        /** @type {number} */
+        let i;
+        /** @type {Selector[][]} */
+        let newPaths;
+        /** @type {boolean} */
+        let hadParentSelector;
+
         newPaths = [];
         hadParentSelector = replaceParentSelector(newPaths, context, selector);
+
         if (!hadParentSelector) {
             if (context.length > 0) {
                 newPaths = [];
                 for (i = 0; i < context.length; i++) {
-                    var concatenated = context[i].map(deriveSelector.bind(this, selector.visibilityInfo()));
+
+                    const concatenated = context[i].map(deriveSelector.bind(this, selector.visibilityInfo()));
+
                     concatenated.push(selector);
                     newPaths.push(concatenated);
                 }
@@ -743,10 +1055,12 @@ Ruleset.prototype = Object.assign(new node_1.default(), {
                 newPaths = [[selector]];
             }
         }
+
         for (i = 0; i < newPaths.length; i++) {
             paths.push(newPaths[i]);
         }
+
     }
-});
-exports.default = Ruleset;
-//# sourceMappingURL=ruleset.js.map
+}
+
+export default Ruleset;