less 4.5.1 → 4.6.0

package/lib/less/import-manager.js

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var contexts_1 = tslib_1.__importDefault(require("./contexts"));
-var parser_1 = tslib_1.__importDefault(require("./parser/parser"));
-var less_error_1 = tslib_1.__importDefault(require("./less-error"));
-var utils = tslib_1.__importStar(require("./utils"));
-var logger_1 = tslib_1.__importDefault(require("./logger"));
-function default_1(environment) {
+import contexts from './contexts.js';
+import Parser from './parser/parser.js';
+import LessError from './less-error.js';
+import * as utils from './utils.js';
+import logger from './logger.js';
+
+export default function(environment) {
     // FileInfo = {
     //  'rewriteUrls' - option - whether to adjust URL's to be relative
     //  'filename' - full resolved filename of current file
@@ -15,20 +13,22 @@ function default_1(environment) {
     //  'rootFilename' - filename of the base file
     //  'entryPath' - absolute path to the entry file
     //  'reference' - whether the file should not be output and only output parts that are referenced
-    var ImportManager = /** @class */ (function () {
-        function ImportManager(less, context, rootFileInfo) {
+
+    class ImportManager {
+        constructor(less, context, rootFileInfo) {
             this.less = less;
             this.rootFilename = rootFileInfo.filename;
-            this.paths = context.paths || []; // Search paths, when importing
-            this.contents = {}; // map - filename to contents of all the files
+            this.paths = context.paths || [];  // Search paths, when importing
+            this.contents = {};             // map - filename to contents of all the files
             this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
             this.mime = context.mime;
             this.error = null;
             this.context = context;
             // Deprecated? Unused outside of here, could be useful.
-            this.queue = []; // Files which haven't been imported yet
-            this.files = {}; // Holds the imported parse trees.
+            this.queue = [];        // Files which haven't been imported yet
+            this.files = {};        // Holds the imported parse trees.
         }
+
         /**
          * Add an import to be imported
          * @param path - the raw path
@@ -37,44 +37,50 @@ function default_1(environment) {
          * @param importOptions - import options
          * @param callback - callback for when it is imported
          */
-        ImportManager.prototype.push = function (path, tryAppendExtension, currentFileInfo, importOptions, callback) {
-            var importManager = this, pluginLoader = this.context.pluginManager.Loader;
+        push(path, tryAppendExtension, currentFileInfo, importOptions, callback) {
+            const importManager = this, pluginLoader = this.context.pluginManager.Loader;
+
             this.queue.push(path);
-            var fileParsedFunc = function (e, root, fullPath) {
+
+            const fileParsedFunc = function (e, root, fullPath) {
                 importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
-                var importedEqualsRoot = fullPath === importManager.rootFilename;
+
+                const importedEqualsRoot = fullPath === importManager.rootFilename;
                 if (importOptions.optional && e) {
-                    callback(null, { rules: [] }, false, null);
-                    logger_1.default.info("The file ".concat(fullPath, " was skipped because it was not found and the import was marked optional."));
+                    callback(null, {rules:[]}, false, null);
+                    logger.info(`The file ${fullPath} was skipped because it was not found and the import was marked optional.`);
                 }
                 else {
                     // Inline imports aren't cached here.
                     // If we start to cache them, please make sure they won't conflict with non-inline imports of the
                     // same name as they used to do before this comment and the condition below have been added.
                     if (!importManager.files[fullPath] && !importOptions.inline) {
-                        importManager.files[fullPath] = { root: root, options: importOptions };
-                    }
-                    if (e && !importManager.error) {
-                        importManager.error = e;
+                        importManager.files[fullPath] = { root, options: importOptions };
                     }
+                    if (e && !importManager.error) { importManager.error = e; }
                     callback(e, root, importedEqualsRoot, fullPath);
                 }
             };
-            var newFileInfo = {
+
+            const newFileInfo = {
                 rewriteUrls: this.context.rewriteUrls,
                 entryPath: currentFileInfo.entryPath,
                 rootpath: currentFileInfo.rootpath,
                 rootFilename: currentFileInfo.rootFilename
             };
-            var fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
+
+            const fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
+
             if (!fileManager) {
-                fileParsedFunc({ message: "Could not find a file-manager for ".concat(path) });
+                fileParsedFunc({ message: `Could not find a file-manager for ${path}` });
                 return;
             }
-            var loadFileCallback = function (loadedFile) {
-                var plugin;
-                var resolvedFilename = loadedFile.filename;
-                var contents = loadedFile.contents.replace(/^\uFEFF/, '');
+
+            const loadFileCallback = function(loadedFile) {
+                let plugin;
+                const resolvedFilename = loadedFile.filename;
+                const contents = loadedFile.contents.replace(/^\uFEFF/, '');
+
                 // Pass on an updated rootpath if path of imported file is relative and file
                 // is in a (sub|sup) directory
                 //
@@ -85,90 +91,93 @@ function default_1(environment) {
                 //   then rootpath should become 'less/../'
                 newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
                 if (newFileInfo.rewriteUrls) {
-                    newFileInfo.rootpath = fileManager.join((importManager.context.rootpath || ''), fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
+                    newFileInfo.rootpath = fileManager.join(
+                        (importManager.context.rootpath || ''),
+                        fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
+
                     if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
                         newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
                     }
                 }
                 newFileInfo.filename = resolvedFilename;
-                var newEnv = new contexts_1.default.Parse(importManager.context);
+
+                const newEnv = new contexts.Parse(importManager.context);
+
                 newEnv.processImports = false;
                 importManager.contents[resolvedFilename] = contents;
+
                 if (currentFileInfo.reference || importOptions.reference) {
                     newFileInfo.reference = true;
                 }
+
                 if (importOptions.isPlugin) {
                     plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
-                    if (plugin instanceof less_error_1.default) {
+                    if (plugin instanceof LessError) {
                         fileParsedFunc(plugin, null, resolvedFilename);
                     }
                     else {
                         fileParsedFunc(null, plugin, resolvedFilename);
                     }
-                }
-                else if (importOptions.inline) {
+                } else if (importOptions.inline) {
                     fileParsedFunc(null, contents, resolvedFilename);
-                }
-                else {
+                } else {
                     // import (multiple) parse trees apparently get altered and can't be cached.
                     // TODO: investigate why this is
                     if (importManager.files[resolvedFilename]
                         && !importManager.files[resolvedFilename].options.multiple
                         && !importOptions.multiple) {
+
                         fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
                     }
                     else {
-                        new parser_1.default(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
+                        new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
                             fileParsedFunc(e, root, resolvedFilename);
                         });
                     }
                 }
             };
-            var loadedFile;
-            var promise;
-            var context = utils.clone(this.context);
+            let loadedFile;
+            let promise;
+            const context = utils.clone(this.context);
+
             if (tryAppendExtension) {
                 context.ext = importOptions.isPlugin ? '.js' : '.less';
             }
+
             if (importOptions.isPlugin) {
                 context.mime = 'application/javascript';
+
                 if (context.syncImport) {
                     loadedFile = pluginLoader.loadPluginSync(path, currentFileInfo.currentDirectory, context, environment, fileManager);
-                }
-                else {
+                } else {
                     promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
                 }
             }
             else {
                 if (context.syncImport) {
                     loadedFile = fileManager.loadFileSync(path, currentFileInfo.currentDirectory, context, environment);
-                }
-                else {
-                    promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment, function (err, loadedFile) {
-                        if (err) {
-                            fileParsedFunc(err);
-                        }
-                        else {
-                            loadFileCallback(loadedFile);
-                        }
-                    });
+                } else {
+                    promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment,
+                        (err, loadedFile) => {
+                            if (err) {
+                                fileParsedFunc(err);
+                            } else {
+                                loadFileCallback(loadedFile);
+                            }
+                        });
                 }
             }
             if (loadedFile) {
                 if (!loadedFile.filename) {
                     fileParsedFunc(loadedFile);
-                }
-                else {
+                } else {
                     loadFileCallback(loadedFile);
                 }
-            }
-            else if (promise) {
+            } else if (promise) {
                 promise.then(loadFileCallback, fileParsedFunc);
             }
-        };
-        return ImportManager;
-    }());
+        }
+    }
+
     return ImportManager;
 }
-exports.default = default_1;
-//# sourceMappingURL=import-manager.js.map

package/lib/less/index.js

@@ -1,73 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var environment_1 = tslib_1.__importDefault(require("./environment/environment"));
-var data_1 = tslib_1.__importDefault(require("./data"));
-var tree_1 = tslib_1.__importDefault(require("./tree"));
-var abstract_file_manager_1 = tslib_1.__importDefault(require("./environment/abstract-file-manager"));
-var abstract_plugin_loader_1 = tslib_1.__importDefault(require("./environment/abstract-plugin-loader"));
-var visitors_1 = tslib_1.__importDefault(require("./visitors"));
-var parser_1 = tslib_1.__importDefault(require("./parser/parser"));
-var functions_1 = tslib_1.__importDefault(require("./functions"));
-var contexts_1 = tslib_1.__importDefault(require("./contexts"));
-var less_error_1 = tslib_1.__importDefault(require("./less-error"));
-var transform_tree_1 = tslib_1.__importDefault(require("./transform-tree"));
-var utils = tslib_1.__importStar(require("./utils"));
-var plugin_manager_1 = tslib_1.__importDefault(require("./plugin-manager"));
-var logger_1 = tslib_1.__importDefault(require("./logger"));
-var source_map_output_1 = tslib_1.__importDefault(require("./source-map-output"));
-var source_map_builder_1 = tslib_1.__importDefault(require("./source-map-builder"));
-var parse_tree_1 = tslib_1.__importDefault(require("./parse-tree"));
-var import_manager_1 = tslib_1.__importDefault(require("./import-manager"));
-var parse_1 = tslib_1.__importDefault(require("./parse"));
-var render_1 = tslib_1.__importDefault(require("./render"));
-var package_json_1 = require("../../package.json");
-var parse_node_version_1 = tslib_1.__importDefault(require("parse-node-version"));
-function default_1(environment, fileManagers) {
-    var sourceMapOutput, sourceMapBuilder, parseTree, importManager;
-    environment = new environment_1.default(environment, fileManagers);
-    sourceMapOutput = (0, source_map_output_1.default)(environment);
-    sourceMapBuilder = (0, source_map_builder_1.default)(sourceMapOutput, environment);
-    parseTree = (0, parse_tree_1.default)(sourceMapBuilder);
-    importManager = (0, import_manager_1.default)(environment);
-    var render = (0, render_1.default)(environment, parseTree, importManager);
-    var parse = (0, parse_1.default)(environment, parseTree, importManager);
-    var v = (0, parse_node_version_1.default)("v".concat(package_json_1.version));
-    var initial = {
+import Environment from './environment/environment.js';
+import data from './data/index.js';
+import tree from './tree/index.js';
+import AbstractFileManager from './environment/abstract-file-manager.js';
+import AbstractPluginLoader from './environment/abstract-plugin-loader.js';
+import visitors from './visitors/index.js';
+import Parser from './parser/parser.js';
+import functions from './functions/index.js';
+import contexts from './contexts.js';
+import LessError from './less-error.js';
+import transformTree from './transform-tree.js';
+import * as utils from './utils.js';
+import PluginManager from './plugin-manager.js';
+import logger from './logger.js';
+import SourceMapOutput from './source-map-output.js';
+import SourceMapBuilder from './source-map-builder.js';
+import ParseTree from './parse-tree.js';
+import ImportManager from './import-manager.js';
+import Parse from './parse.js';
+import Render from './render.js';
+import parseVersion from 'parse-node-version';
+
+export default function(environment, fileManagers, version = '0.0.0') {
+    let sourceMapOutput, sourceMapBuilder, parseTree, importManager;
+
+    environment = new Environment(environment, fileManagers);
+    sourceMapOutput = SourceMapOutput(environment);
+    sourceMapBuilder = SourceMapBuilder(sourceMapOutput, environment);
+    parseTree = ParseTree(sourceMapBuilder);
+    importManager = ImportManager(environment);
+
+    const render = Render(environment, parseTree, importManager);
+    const parse = Parse(environment, parseTree, importManager);
+
+    const v = parseVersion(`v${version}`);
+    const initial = {
         version: [v.major, v.minor, v.patch],
-        data: data_1.default,
-        tree: tree_1.default,
-        Environment: environment_1.default,
-        AbstractFileManager: abstract_file_manager_1.default,
-        AbstractPluginLoader: abstract_plugin_loader_1.default,
-        environment: environment,
-        visitors: visitors_1.default,
-        Parser: parser_1.default,
-        functions: (0, functions_1.default)(environment),
-        contexts: contexts_1.default,
+        data,
+        tree,
+        Environment,
+        AbstractFileManager,
+        AbstractPluginLoader,
+        environment,
+        visitors,
+        Parser,
+        functions: functions(environment),
+        contexts,
         SourceMapOutput: sourceMapOutput,
         SourceMapBuilder: sourceMapBuilder,
         ParseTree: parseTree,
         ImportManager: importManager,
-        render: render,
-        parse: parse,
-        LessError: less_error_1.default,
-        transformTree: transform_tree_1.default,
-        utils: utils,
-        PluginManager: plugin_manager_1.default,
-        logger: logger_1.default
+        render,
+        parse,
+        LessError,
+        transformTree,
+        utils,
+        PluginManager,
+        logger
     };
+
     // Create a public API
-    var ctor = function (t) {
-        return function () {
-            var obj = Object.create(t.prototype);
-            t.apply(obj, Array.prototype.slice.call(arguments, 0));
-            return obj;
+
+    const ctor = function(t) {
+        return function(...args) {
+            return new t(...args);
         };
     };
-    var t;
-    var api = Object.create(initial);
-    for (var n in initial.tree) {
+    let t;
+    const api = Object.create(initial);
+    for (const n in initial.tree) {
         /* eslint guard-for-in: 0 */
         t = initial.tree[n];
         if (typeof t === 'function') {
@@ -75,21 +75,21 @@ function default_1(environment, fileManagers) {
         }
         else {
             api[n] = Object.create(null);
-            for (var o in t) {
+            for (const o in t) {
                 /* eslint guard-for-in: 0 */
                 api[n][o.toLowerCase()] = ctor(t[o]);
             }
         }
     }
+
     /**
      * Some of the functions assume a `this` context of the API object,
      * which causes it to fail when wrapped for ES6 imports.
-     *
+     * 
      * An assumed `this` should be removed in the future.
      */
     initial.parse = initial.parse.bind(api);
     initial.render = initial.render.bind(api);
+
     return api;
 }
-exports.default = default_1;
-//# sourceMappingURL=index.js.map

package/lib/less/less-error.js

@@ -1,8 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var utils = tslib_1.__importStar(require("./utils"));
-var anonymousFunc = /(<anonymous>|Function):(\d+):(\d+)/;
+import * as utils from './utils.js';
+
+const anonymousFunc = /(<anonymous>|Function):(\d+):(\d+)/;
+
 /**
  * This is a centralized class of any error that could be thrown internally (mostly by the parser).
  * Besides standard .message it keeps some additional data like a path to the file where the error
@@ -25,26 +24,33 @@ var anonymousFunc = /(<anonymous>|Function):(\d+):(\d+)/;
  * @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
  * @param {string} [currentFilename]
  */
-var LessError = function (e, fileContentMap, currentFilename) {
+const LessError = function(e, fileContentMap, currentFilename) {
     Error.call(this);
-    var filename = e.filename || currentFilename;
+
+    const filename = e.filename || currentFilename;
+
     this.message = e.message;
     this.stack = e.stack;
+    
     // Set type early so it's always available, even if fileContentMap is missing
     this.type = e.type || 'Syntax';
+
     if (fileContentMap && filename) {
-        var input = fileContentMap.contents[filename];
-        var loc = utils.getLocation(e.index, input);
+        const input = fileContentMap.contents[filename];
+        const loc = utils.getLocation(e.index, input);
         var line = loc.line;
-        var col = loc.column;
-        var callLine = e.call && utils.getLocation(e.call, input).line;
-        var lines = input ? input.split('\n') : '';
+        const col  = loc.column;
+        const callLine = e.call && utils.getLocation(e.call, input).line;
+        const lines = input ? input.split('\n') : '';
+
         this.filename = filename;
         this.index = e.index;
         this.line = typeof line === 'number' ? line + 1 : null;
         this.column = col;
+
         if (!this.line && this.stack) {
-            var found = this.stack.match(anonymousFunc);
+            const found = this.stack.match(anonymousFunc);
+
             /**
              * We have to figure out how this environment stringifies anonymous functions
              * so we can correctly map plugin errors.
@@ -52,15 +58,15 @@ var LessError = function (e, fileContentMap, currentFilename) {
              * Note, in Node 8, the output of anonymous funcs varied based on parameters
              * being present or not, so we inject dummy params.
              */
-            var func = new Function('a', 'throw new Error()');
-            var lineAdjust = 0;
+            const func = new Function('a', 'throw new Error()');
+            let lineAdjust = 0;
             try {
                 func();
-            }
-            catch (e) {
-                var match = e.stack.match(anonymousFunc);
+            } catch (e) {
+                const match = e.stack.match(anonymousFunc);
                 lineAdjust = 1 - parseInt(match[2]);
             }
+
             if (found) {
                 if (found[2]) {
                     this.line = parseInt(found[2]) + lineAdjust;
@@ -70,24 +76,29 @@ var LessError = function (e, fileContentMap, currentFilename) {
                 }
             }
         }
+
         this.callLine = callLine + 1;
         this.callExtract = lines[callLine];
+
         this.extract = [
             lines[this.line - 2],
             lines[this.line - 1],
             lines[this.line]
         ];
     }
+
 };
+
 if (typeof Object.create === 'undefined') {
-    var F = function () { };
+    const F = function () {};
     F.prototype = Error.prototype;
     LessError.prototype = new F();
-}
-else {
+} else {
     LessError.prototype = Object.create(Error.prototype);
 }
+
 LessError.prototype.constructor = LessError;
+
 /**
  * An overridden version of the default Object.prototype.toString
  * which uses additional information to create a helpful message.
@@ -95,54 +106,61 @@ LessError.prototype.constructor = LessError;
  * @param {Object} options
  * @returns {string}
  */
-LessError.prototype.toString = function (options) {
-    var _a;
+LessError.prototype.toString = function(options) {
     options = options || {};
-    var isWarning = ((_a = this.type) !== null && _a !== void 0 ? _a : '').toLowerCase().includes('warning');
-    var type = isWarning ? this.type : "".concat(this.type, "Error");
-    var color = isWarning ? 'yellow' : 'red';
-    var message = '';
-    var extract = this.extract || [];
-    var error = [];
-    var stylize = function (str) { return str; };
+    const isWarning = (this.type ?? '').toLowerCase().includes('warning');
+    const type = isWarning ? this.type : `${this.type}Error`;
+    const color = isWarning ? 'yellow' : 'red';
+
+    let message = '';
+    const extract = this.extract || [];
+    let error = [];
+    let stylize = function (str) { return str; };
     if (options.stylize) {
-        var type_1 = typeof options.stylize;
-        if (type_1 !== 'function') {
-            throw Error("options.stylize should be a function, got a ".concat(type_1, "!"));
+        const type = typeof options.stylize;
+        if (type !== 'function') {
+            throw Error(`options.stylize should be a function, got a ${type}!`);
         }
         stylize = options.stylize;
     }
+
     if (this.line !== null) {
         if (!isWarning && typeof extract[0] === 'string') {
-            error.push(stylize("".concat(this.line - 1, " ").concat(extract[0]), 'grey'));
+            error.push(stylize(`${this.line - 1} ${extract[0]}`, 'grey'));
         }
+
         if (typeof extract[1] === 'string') {
-            var errorTxt = "".concat(this.line, " ");
+            let errorTxt = `${this.line} `;
             if (extract[1]) {
                 errorTxt += extract[1].slice(0, this.column) +
-                    stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') +
+                    stylize(stylize(stylize(extract[1].slice(this.column, this.column + 1), 'bold') +
                         extract[1].slice(this.column + 1), 'red'), 'inverse');
             }
             error.push(errorTxt);
         }
+
         if (!isWarning && typeof extract[2] === 'string') {
-            error.push(stylize("".concat(this.line + 1, " ").concat(extract[2]), 'grey'));
+            error.push(stylize(`${this.line + 1} ${extract[2]}`, 'grey'));
         }
-        error = "".concat(error.join('\n') + stylize('', 'reset'), "\n");
+        error = `${error.join('\n') + stylize('', 'reset')}\n`;
     }
-    message += stylize("".concat(type, ": ").concat(this.message), color);
+
+    message += stylize(`${type}: ${this.message}`, color);
     if (this.filename) {
         message += stylize(' in ', color) + this.filename;
     }
     if (this.line) {
-        message += stylize(" on line ".concat(this.line, ", column ").concat(this.column + 1, ":"), 'grey');
+        message += stylize(` on line ${this.line}, column ${this.column + 1}:`, 'grey');
     }
-    message += "\n".concat(error);
+
+    message += `\n${error}`;
+
     if (this.callLine) {
-        message += "".concat(stylize('from ', color) + (this.filename || ''), "/n");
-        message += "".concat(stylize(this.callLine, 'grey'), " ").concat(this.callExtract, "/n");
+        message += `${stylize('from ', color) + (this.filename || '')}/n`;
+        message += `${stylize(this.callLine, 'grey')} ${this.callExtract}/n`;
     }
+
     return message;
 };
-exports.default = LessError;
-//# sourceMappingURL=less-error.js.map
+
+export default LessError;

package/lib/less/logger.js

@@ -1,32 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    error: function (msg) {
+export default {
+    error: function(msg) {
         this._fireEvent('error', msg);
     },
-    warn: function (msg) {
+    warn: function(msg) {
         this._fireEvent('warn', msg);
     },
-    info: function (msg) {
+    info: function(msg) {
         this._fireEvent('info', msg);
     },
-    debug: function (msg) {
+    debug: function(msg) {
         this._fireEvent('debug', msg);
     },
-    addListener: function (listener) {
+    addListener: function(listener) {
         this._listeners.push(listener);
     },
-    removeListener: function (listener) {
-        for (var i = 0; i < this._listeners.length; i++) {
+    removeListener: function(listener) {
+        for (let i = 0; i < this._listeners.length; i++) {
             if (this._listeners[i] === listener) {
                 this._listeners.splice(i, 1);
                 return;
             }
         }
     },
-    _fireEvent: function (type, msg) {
-        for (var i = 0; i < this._listeners.length; i++) {
-            var logFunction = this._listeners[i][type];
+    _fireEvent: function(type, msg) {
+        for (let i = 0; i < this._listeners.length; i++) {
+            const logFunction = this._listeners[i][type];
             if (logFunction) {
                 logFunction(msg);
             }
@@ -34,4 +32,3 @@ exports.default = {
     },
     _listeners: []
 };
-//# sourceMappingURL=logger.js.map