less 4.5.1 → 4.6.0

package/lib/less/visitors/import-sequencer.js

@@ -1,34 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var ImportSequencer = /** @class */ (function () {
-    function ImportSequencer(onSequencerEmpty) {
+class ImportSequencer {
+    constructor(onSequencerEmpty) {
         this.imports = [];
         this.variableImports = [];
         this._onSequencerEmpty = onSequencerEmpty;
         this._currentDepth = 0;
     }
-    ImportSequencer.prototype.addImport = function (callback) {
-        var importSequencer = this, importItem = {
-            callback: callback,
-            args: null,
-            isReady: false
-        };
+
+    addImport(callback) {
+        const importSequencer = this,
+            importItem = {
+                callback,
+                args: null,
+                isReady: false
+            };
         this.imports.push(importItem);
-        return function () {
+        return function() {
             importItem.args = Array.prototype.slice.call(arguments, 0);
             importItem.isReady = true;
             importSequencer.tryRun();
         };
-    };
-    ImportSequencer.prototype.addVariableImport = function (callback) {
+    }
+
+    addVariableImport(callback) {
         this.variableImports.push(callback);
-    };
-    ImportSequencer.prototype.tryRun = function () {
+    }
+
+    tryRun() {
         this._currentDepth++;
         try {
             while (true) {
                 while (this.imports.length > 0) {
-                    var importItem = this.imports[0];
+                    const importItem = this.imports[0];
                     if (!importItem.isReady) {
                         return;
                     }
@@ -38,19 +40,17 @@ var ImportSequencer = /** @class */ (function () {
                 if (this.variableImports.length === 0) {
                     break;
                 }
-                var variableImport = this.variableImports[0];
+                const variableImport = this.variableImports[0];
                 this.variableImports = this.variableImports.slice(1);
                 variableImport();
             }
-        }
-        finally {
+        } finally {
             this._currentDepth--;
         }
         if (this._currentDepth === 0 && this._onSequencerEmpty) {
             this._onSequencerEmpty();
         }
-    };
-    return ImportSequencer;
-}());
-exports.default = ImportSequencer;
-//# sourceMappingURL=import-sequencer.js.map
+    }
+}
+
+export default ImportSequencer;

package/lib/less/visitors/import-visitor.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
 /* eslint-disable no-unused-vars */
 /**
  * @todo - Remove unused when JSDoc types are added for visitor methods
  */
-var contexts_1 = tslib_1.__importDefault(require("../contexts"));
-var visitor_1 = tslib_1.__importDefault(require("./visitor"));
-var import_sequencer_1 = tslib_1.__importDefault(require("./import-sequencer"));
-var utils = tslib_1.__importStar(require("../utils"));
-var ImportVisitor = function (importer, finish) {
-    this._visitor = new visitor_1.default(this);
+import contexts from '../contexts.js';
+import Visitor from './visitor.js';
+import ImportSequencer from './import-sequencer.js';
+import * as utils from '../utils.js';
+
+const ImportVisitor = function(importer, finish) {
+
+    this._visitor = new Visitor(this);
     this._importer = importer;
     this._finish = finish;
-    this.context = new contexts_1.default.Eval();
+    this.context = new contexts.Eval();
     this.importCount = 0;
     this.onceFileDetectionMap = {};
     this.recursionDetector = {};
-    this._sequencer = new import_sequencer_1.default(this._onSequencerEmpty.bind(this));
+    this._sequencer = new ImportSequencer(this._onSequencerEmpty.bind(this));
 };
+
 ImportVisitor.prototype = {
     isReplacing: false,
     run: function (root) {
@@ -29,62 +29,68 @@ ImportVisitor.prototype = {
         catch (e) {
             this.error = e;
         }
+
         this.isFinished = true;
         this._sequencer.tryRun();
     },
-    _onSequencerEmpty: function () {
+    _onSequencerEmpty: function() {
         if (!this.isFinished) {
             return;
         }
         this._finish(this.error);
     },
     visitImport: function (importNode, visitArgs) {
-        var inlineCSS = importNode.options.inline;
+        const inlineCSS = importNode.options.inline;
+
         if (!importNode.css || inlineCSS) {
-            var context = new contexts_1.default.Eval(this.context, utils.copyArray(this.context.frames));
-            var importParent = context.frames[0];
+
+            const context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));
+            const importParent = context.frames[0];
+
             this.importCount++;
             if (importNode.isVariableImport()) {
                 this._sequencer.addVariableImport(this.processImportNode.bind(this, importNode, context, importParent));
-            }
-            else {
+            } else {
                 this.processImportNode(importNode, context, importParent);
             }
         }
         visitArgs.visitDeeper = false;
     },
-    processImportNode: function (importNode, context, importParent) {
-        var evaldImportNode;
-        var inlineCSS = importNode.options.inline;
+    processImportNode: function(importNode, context, importParent) {
+        let evaldImportNode;
+        const inlineCSS = importNode.options.inline;
+
         try {
             evaldImportNode = importNode.evalForImport(context);
-        }
-        catch (e) {
-            if (!e.filename) {
-                e.index = importNode.getIndex();
-                e.filename = importNode.fileInfo().filename;
-            }
+        } catch (e) {
+            if (!e.filename) { e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename; }
             // attempt to eval properly and treat as css
             importNode.css = true;
             // if that fails, this error will be thrown
             importNode.error = e;
         }
+
         if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
+
             if (evaldImportNode.options.multiple) {
                 context.importMultiple = true;
             }
+
             // try appending if we haven't determined if it is css or not
-            var tryAppendLessExtension = evaldImportNode.css === undefined;
-            for (var i = 0; i < importParent.rules.length; i++) {
+            const tryAppendLessExtension = evaldImportNode.css === undefined;
+
+            for (let i = 0; i < importParent.rules.length; i++) {
                 if (importParent.rules[i] === importNode) {
                     importParent.rules[i] = evaldImportNode;
                     break;
                 }
             }
-            var onImported = this.onImported.bind(this, evaldImportNode, context), sequencedOnImported = this._sequencer.addImport(onImported);
-            this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(), evaldImportNode.options, sequencedOnImported);
-        }
-        else {
+
+            const onImported = this.onImported.bind(this, evaldImportNode, context), sequencedOnImported = this._sequencer.addImport(onImported);
+
+            this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(),
+                evaldImportNode.options, sequencedOnImported);
+        } else {
             this.importCount--;
             if (this.isFinished) {
                 this._sequencer.tryRun();
@@ -94,18 +100,22 @@ ImportVisitor.prototype = {
     onImported: function (importNode, context, e, root, importedAtRoot, fullPath) {
         if (e) {
             if (!e.filename) {
-                e.index = importNode.getIndex();
-                e.filename = importNode.fileInfo().filename;
+                e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename;
             }
             this.error = e;
         }
-        var importVisitor = this, inlineCSS = importNode.options.inline, isPlugin = importNode.options.isPlugin, isOptional = importNode.options.optional, duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+
+        const importVisitor = this,
+            inlineCSS = importNode.options.inline,
+            isPlugin = importNode.options.isPlugin,
+            isOptional = importNode.options.optional,
+            duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+
         if (!context.importMultiple) {
             if (duplicateImport) {
                 importNode.skip = true;
-            }
-            else {
-                importNode.skip = function () {
+            } else {
+                importNode.skip = function() {
                     if (fullPath in importVisitor.onceFileDetectionMap) {
                         return true;
                     }
@@ -114,26 +124,31 @@ ImportVisitor.prototype = {
                 };
             }
         }
+
         if (!fullPath && isOptional) {
             importNode.skip = true;
         }
+
         if (root) {
             importNode.root = root;
             importNode.importedFilename = fullPath;
+
             if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
                 importVisitor.recursionDetector[fullPath] = true;
-                var oldContext = this.context;
+
+                const oldContext = this.context;
                 this.context = context;
                 try {
                     this._visitor.visit(root);
-                }
-                catch (e) {
+                } catch (e) {
                     this.error = e;
                 }
                 this.context = oldContext;
             }
         }
+
         importVisitor.importCount--;
+
         if (importVisitor.isFinished) {
             importVisitor._sequencer.tryRun();
         }
@@ -141,12 +156,11 @@ ImportVisitor.prototype = {
     visitDeclaration: function (declNode, visitArgs) {
         if (declNode.value.type === 'DetachedRuleset') {
             this.context.frames.unshift(declNode);
-        }
-        else {
+        } else {
             visitArgs.visitDeeper = false;
         }
     },
-    visitDeclarationOut: function (declNode) {
+    visitDeclarationOut: function(declNode) {
         if (declNode.value.type === 'DetachedRuleset') {
             this.context.frames.shift();
         }
@@ -154,16 +168,13 @@ ImportVisitor.prototype = {
     visitAtRule: function (atRuleNode, visitArgs) {
         if (atRuleNode.value) {
             this.context.frames.unshift(atRuleNode);
-        }
-        else if (atRuleNode.declarations && atRuleNode.declarations.length) {
+        } else if (atRuleNode.declarations && atRuleNode.declarations.length) {
             if (atRuleNode.isRooted) {
                 this.context.frames.unshift(atRuleNode);
-            }
-            else {
+            } else {
                 this.context.frames.unshift(atRuleNode.declarations[0]);
             }
-        }
-        else if (atRuleNode.rules && atRuleNode.rules.length) {
+        } else if (atRuleNode.rules && atRuleNode.rules.length) {
             this.context.frames.unshift(atRuleNode);
         }
     },
@@ -189,5 +200,4 @@ ImportVisitor.prototype = {
         this.context.frames.shift();
     }
 };
-exports.default = ImportVisitor;
-//# sourceMappingURL=import-visitor.js.map
+export default ImportVisitor;

package/lib/less/visitors/index.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var visitor_1 = tslib_1.__importDefault(require("./visitor"));
-var import_visitor_1 = tslib_1.__importDefault(require("./import-visitor"));
-var set_tree_visibility_visitor_1 = tslib_1.__importDefault(require("./set-tree-visibility-visitor"));
-var extend_visitor_1 = tslib_1.__importDefault(require("./extend-visitor"));
-var join_selector_visitor_1 = tslib_1.__importDefault(require("./join-selector-visitor"));
-var to_css_visitor_1 = tslib_1.__importDefault(require("./to-css-visitor"));
-exports.default = {
-    Visitor: visitor_1.default,
-    ImportVisitor: import_visitor_1.default,
-    MarkVisibleSelectorsVisitor: set_tree_visibility_visitor_1.default,
-    ExtendVisitor: extend_visitor_1.default,
-    JoinSelectorVisitor: join_selector_visitor_1.default,
-    ToCSSVisitor: to_css_visitor_1.default
+import Visitor from './visitor.js';
+import ImportVisitor from './import-visitor.js';
+import MarkVisibleSelectorsVisitor from './set-tree-visibility-visitor.js';
+import ExtendVisitor from './extend-visitor.js';
+import JoinSelectorVisitor from './join-selector-visitor.js';
+import ToCSSVisitor from './to-css-visitor.js';
+
+export default {
+    Visitor,
+    ImportVisitor,
+    MarkVisibleSelectorsVisitor,
+    ExtendVisitor,
+    JoinSelectorVisitor,
+    ToCSSVisitor
 };
-//# sourceMappingURL=index.js.map

package/lib/less/visitors/join-selector-visitor.js

@@ -1,62 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
 /* eslint-disable no-unused-vars */
 /**
  * @todo - Remove unused when JSDoc types are added for visitor methods
  */
-var visitor_1 = tslib_1.__importDefault(require("./visitor"));
-var JoinSelectorVisitor = /** @class */ (function () {
-    function JoinSelectorVisitor() {
+import Visitor from './visitor.js';
+
+class JoinSelectorVisitor {
+    constructor() {
         this.contexts = [[]];
-        this._visitor = new visitor_1.default(this);
+        this._visitor = new Visitor(this);
     }
-    JoinSelectorVisitor.prototype.run = function (root) {
+
+    run(root) {
         return this._visitor.visit(root);
-    };
-    JoinSelectorVisitor.prototype.visitDeclaration = function (declNode, visitArgs) {
+    }
+
+    visitDeclaration(declNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    JoinSelectorVisitor.prototype.visitMixinDefinition = function (mixinDefinitionNode, visitArgs) {
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
         visitArgs.visitDeeper = false;
-    };
-    JoinSelectorVisitor.prototype.visitRuleset = function (rulesetNode, visitArgs) {
-        var context = this.contexts[this.contexts.length - 1];
-        var paths = [];
-        var selectors;
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+        const paths = [];
+        let selectors;
+
         this.contexts.push(paths);
+
         if (!rulesetNode.root) {
             selectors = rulesetNode.selectors;
             if (selectors) {
-                selectors = selectors.filter(function (selector) { return selector.getIsOutput(); });
+                selectors = selectors.filter(function(selector) { return selector.getIsOutput(); });
                 rulesetNode.selectors = selectors.length ? selectors : (selectors = null);
-                if (selectors) {
-                    rulesetNode.joinSelectors(paths, context, selectors);
-                }
-            }
-            if (!selectors) {
-                rulesetNode.rules = null;
+                if (selectors) { rulesetNode.joinSelectors(paths, context, selectors); }
             }
+            if (!selectors) { rulesetNode.rules = null; }
             rulesetNode.paths = paths;
         }
-    };
-    JoinSelectorVisitor.prototype.visitRulesetOut = function (rulesetNode) {
+    }
+
+    visitRulesetOut(rulesetNode) {
         this.contexts.length = this.contexts.length - 1;
-    };
-    JoinSelectorVisitor.prototype.visitMedia = function (mediaNode, visitArgs) {
-        var context = this.contexts[this.contexts.length - 1];
+    }
+
+    visitMedia(mediaNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
         mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
-    };
-    JoinSelectorVisitor.prototype.visitAtRule = function (atRuleNode, visitArgs) {
-        var context = this.contexts[this.contexts.length - 1];
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+
         if (atRuleNode.declarations && atRuleNode.declarations.length) {
             atRuleNode.declarations[0].root = (context.length === 0 || context[0].multiMedia);
         }
         else if (atRuleNode.rules && atRuleNode.rules.length) {
             atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);
         }
-    };
-    return JoinSelectorVisitor;
-}());
-exports.default = JoinSelectorVisitor;
-//# sourceMappingURL=join-selector-visitor.js.map
+    }
+}
+
+export default JoinSelectorVisitor;

package/lib/less/visitors/set-tree-visibility-visitor.js

@@ -1,43 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var SetTreeVisibilityVisitor = /** @class */ (function () {
-    function SetTreeVisibilityVisitor(visible) {
+import Node from '../tree/node.js';
+
+class SetTreeVisibilityVisitor {
+    /** @param {boolean} visible */
+    constructor(visible) {
         this.visible = visible;
     }
-    SetTreeVisibilityVisitor.prototype.run = function (root) {
+
+    /** @param {Node} root */
+    run(root) {
         this.visit(root);
-    };
-    SetTreeVisibilityVisitor.prototype.visitArray = function (nodes) {
+    }
+
+    /**
+     * @param {Node[]} nodes
+     * @returns {Node[]}
+     */
+    visitArray(nodes) {
         if (!nodes) {
             return nodes;
         }
-        var cnt = nodes.length;
-        var i;
+
+        const cnt = nodes.length;
+        let i;
         for (i = 0; i < cnt; i++) {
             this.visit(nodes[i]);
         }
         return nodes;
-    };
-    SetTreeVisibilityVisitor.prototype.visit = function (node) {
+    }
+
+    /**
+     * @param {*} node
+     * @returns {*}
+     */
+    visit(node) {
         if (!node) {
             return node;
         }
         if (node.constructor === Array) {
             return this.visitArray(node);
         }
+
         if (!node.blocksVisibility || node.blocksVisibility()) {
             return node;
         }
         if (this.visible) {
             node.ensureVisibility();
-        }
-        else {
+        } else {
             node.ensureInvisibility();
         }
+
         node.accept(this);
         return node;
-    };
-    return SetTreeVisibilityVisitor;
-}());
-exports.default = SetTreeVisibilityVisitor;
-//# sourceMappingURL=set-tree-visibility-visitor.js.map
+    }
+}
+
+export default SetTreeVisibilityVisitor;