Fix.

node_modules/bs-logger/CHANGELOG.md

@@ -0,0 +1,60 @@
+<a name="0.2.6"></a>
+## [0.2.6](https://github.com/huafu/bs-logger/compare/v0.2.5...v0.2.6) (2018-11-10)
+
+
+
+<a name="0.2.5"></a>
+## [0.2.5](https://github.com/huafu/bs-logger/compare/v0.2.4...v0.2.5) (2018-09-04)
+
+
+
+<a name="0.2.4"></a>
+## [0.2.4](https://github.com/huafu/bs-logger/compare/v0.2.3...v0.2.4) (2018-09-04)
+
+
+
+<a name="0.2.3"></a>
+## [0.2.3](https://github.com/huafu/bs-logger/compare/v0.2.2...v0.2.3) (2018-08-31)
+
+
+### Bug Fixes
+
+* **formatter:** allow json formatter to serialize circular data ([103bac0](https://github.com/huafu/bs-logger/commit/103bac0))
+
+
+
+<a name="0.2.2"></a>
+## [0.2.2](https://github.com/huafu/bs-logger/compare/v0.2.1...v0.2.2) (2018-08-31)
+
+
+### Bug Fixes
+
+* **testing:** adds LoggerMock to exported symbols ([134dab8](https://github.com/huafu/bs-logger/commit/134dab8))
+
+
+
+<a name="0.2.1"></a>
+## [0.2.1](https://github.com/huafu/bs-logger/compare/v0.2.0...v0.2.1) (2018-08-31)
+
+
+
+<a name="0.2.0"></a>
+# [0.2.0](https://github.com/huafu/bs-logger/compare/v0.1.1...v0.2.0) (2018-08-31)
+
+
+### Features
+
+* **testing:** adds helpers for testing ([0e65a49](https://github.com/huafu/bs-logger/commit/0e65a49))
+
+
+
+<a name="0.1.1"></a>
+## [0.1.1](https://github.com/huafu/bs-logger/compare/02d6fc7...v0.1.1) (2018-08-30)
+
+
+### Features
+
+* adds custom formatters ([02d6fc7](https://github.com/huafu/bs-logger/commit/02d6fc7))
+
+
+

node_modules/bs-logger/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Huafu Gandon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/bs-logger/README.md

@@ -0,0 +1,319 @@
+<img align="right" src="icon.png"></img>
+
+# B.S. Logger [![Build Status](https://travis-ci.org/huafu/bs-logger.svg?branch=master)](https://travis-ci.org/huafu/bs-logger) [![Coverage Status](https://img.shields.io/coveralls/huafu/bs-logger/master.svg)](https://coveralls.io/github/huafu/bs-logger?branch=master) [![Beerpay](https://beerpay.io/huafu/bs-logger/badge.svg?style=beer-square)](https://beerpay.io/huafu/bs-logger)  [![Beerpay](https://beerpay.io/huafu/bs-logger/make-wish.svg?style=flat-square)](https://beerpay.io/huafu/bs-logger?focus=wish)
+
+**Opinionated bare simple logger for NodeJS (with TypeScript typings)**.
+
+BSLogger has been created after being disapointed not finding a matching logger on the internet. Not that others aren't good, they just did not fit what I was looking for.
+
+Here is what I was looking for (and tried to implemented in BSLogger):
+- light memory usage
+- easily extendable (see `child` method)
+- as few dependencies as possible
+- ability to define all targets in a string (so that `ENV` vars can be used)
+- when using file targets, not re-opening them
+- reasonable defautls:
+  - logs warnings and above to `stderr`
+  - logs JSON to files
+- no overhead if it's not going to log anywhere
+
+## TL,DR:
+
+Install:
+```sh
+npm install --save bs-logger
+# or
+yarn add bs-logger
+```
+Use:
+```js
+const { logger } = require('bs-logger');
+//    or
+// import logger from 'bs-logger';
+//    or
+// import { logger } from 'bs-logger';
+//    as default exports the logger
+
+logger('foo');
+logger.debug('bar');
+logger.warn({foo: 'bar'}, 'dummy', 'other'/*, ...*/);
+```
+
+More complex example:
+```js
+// env MY_LOG_TARGETS="debug.log:trace,stderr:warn%json"
+import { createLogger } from 'bs-logger';
+const logger = createLogger({
+  context: {namespace: 'http'},
+  targets: process.env.MY_LOG_TARGETS,
+  translate: (m) => {
+    if (process.env.NODE_ENV === 'production') {
+      m.context = { ...m.context, secret: null };
+    }
+    return m;
+  },
+});
+// [...]
+logger.debug({secret: 'xyz'}, 'trying to login')
+// will log into debug.log `trying to login` with secret in the context except in prod
+
+const login = logger.wrap(function login() {
+  // your login code
+})
+// [...]
+login();
+// will log `calling login` with the arguments in context
+```
+
+## Usage
+
+### Creating a logger
+
+#### Root logger
+
+BSLogger exports a global logger lazyly created on first use, but it is advised to create your own using the `createLogger()` helper:
+
+- If you are using it in a library wich is meant to be re-distributed:
+  ```js
+  import { createLogger, LogContexts } 'bs-logger';
+  const logger = createLogger({ [LogContexts.package]: 'my-pacakge' });
+  ```
+
+- If you are using it in an application of your own:
+  ```js
+  import { createLogger, LogContexts } 'bs-logger';
+  const logger = createLogger({ [LogContexts.application]: 'my-app' });
+  ```
+
+#### Child logger
+
+Child loggers extends the context, targets and message translators from their parent. You create a child logger using the `child` method:
+
+```js
+const childLogger = logger.child({ [LogContexts.namespace]: 'http' })
+// childLogger becomes a new logger
+```
+
+### Logging
+
+Any helper to log within BSLogger is a function which has the same signature as `console.log()`, and also accepts an **optional** first argument being the context. A context is any `object`, with some specific (but optional) properties which we'll see later.
+
+```ts
+logMethod(message: string, ...args: any[]): void
+  // or
+logMethod(context: LogContext, message: string, ...args: any[]): void
+```
+
+#### Directly
+
+You can log using any logger as a function directly (if the logger or its possible parent(s) has not been created with any log level in its context, no level will be attached):
+```js
+import { createLogger } from 'bs-logger'
+const logger = createLogger()
+// [...]
+logger('my message');
+```
+
+#### Using level helpers
+
+BSLogger is aware of 6 log levels (`trace`, `debug`, `info`, `warn`, `error` and `fatal`) but you can create your owns. A log level is basically a number. The higher it is, the more important will be the message. You can find log levels constants in `LogLevels` export:
+```js
+import { LogLevels } from 'bs-logger';
+
+const traceLevelValue = LogLevels.trace;
+const debugLevelValue = LogLevels.debug;
+// etc.
+```
+
+For each log level listed above, a logger will have a helper method to directly log using this level:
+```js
+import { createLogger } from 'bs-logger'
+const logger = createLogger()
+// [...]
+logger.trace('foo')
+logger.debug('bar')
+// etc.
+```
+
+Those helpers are the equivalent to
+```js
+logger({ [LogContexts.logLevel]: level }, 'foo')
+```
+...except that they'll be replaced with an empty function on the first call if their level will not be handled by any target.
+
+### Wrapping functions
+
+Each logger has a `wrap` method which you can use to wrap a function. If there is no matching log target, the `wrap` method will simply return your function, else it'll wrap it in another function of same signature. The wrapper will, before calling your function, log a message with received arguments in the context.
+
+```ts
+// With `F` being the type of your funciton:
+logger.wrap(func: F): F
+  // or
+logger.wrap(message: string, func: F): F
+  // or
+logger.wrap(context: LogContext, messages: string, func: F): F
+```
+
+### Defining target(s)
+
+Each root logger (created using `createLogger` helper) is attached to 0 or more "target". A target is responsible of writing a log entry somewhere. It is an object with the following properties:
+
+- **minLevel** `string`: The minimum log level this target's strem writer will be called for
+- **stream** `{ write: (str: string) => void }`: An object with a write function (like node's `stream.Writable`) which will be used to write log entries
+- **format** `(msg: LogMessage) => string`: A formatter which will be used to transform a log entry (message object) into a string
+
+#### Using targets
+
+When using the global logger, or if no `targets` specified when creating a logger, calling log methods will output to STDERR anything which has log level higher or equal to `warn`. This can be modified as follow by defineing the `LOG_TARGETS` environment variable or passing the `targets` option to `createLogger`. The `targets` can be an array of `LogTarget` (see above) or a `string` defining a list of one or more targets separated by comma (`,`). A `string` target is composed as follow:
+- The file path, absolute or relative to CWD. It can also be the specials `stdout` or `stderr` strings (case insensitive). When giving a path to a file, if it ends with the plus sign (`+`) the log data will be appended to the file instead of re-creating the file for each run.
+- An optional minimum log level after a colon (`:`). It should be a `number` or the log level name (ie `trace`, `error`, ...).
+- An optional formatter name after a percent sign (`%`). There are 2 included formatter: `json` (used for files by default) and `simple` (used for `stdout` and `stderr` by default). See below to define your own.
+
+Examples:
+- `debug.log%simple,stdout:fatal`
+  - Log everything to `debug.log` file in CWD dir (re-creates the file for each run). Uses the `simple` formatter.
+  - Log only messages with level >= `fatal` to the standard out.
+- `errors.log+:error,debug.log:15`
+  - Log only messages with level >= `error` to `errors.log` file (without re-creating the file at each run).
+  - Log only messages with level >= 15 to `debug.log` file (re-creates the file for each run).
+
+#### Custom formatters
+
+A custom formatter is a function that takes a `LogMessage` object and returns a `string`. It can be registered giving it a name using the `registerLogFormatter` helper:
+
+```js
+import { registerLogFormatter, createLogger } from 'bs-logger';
+registerLogFormatter('foo', m => `${m.sequence} ${new Date(m.tim).toLocaleString()} ${m.message}`);
+const logger = createLogger({
+  targets: 'stdout%foo', // specifying out formatter
+  });
+```
+
+### Testing
+
+The whole `testing` namespace has useful helpers for using BSLogger while unit testing your product.
+
+In your tests you would usually prefer not having any logging to happen, or you would like to check what has been logged but without actually logging it to any target.
+
+The `testing` namespace holds all testing utilities:
+```js
+import { testing } from 'bs-logger'
+```
+
+- If you use the root logger, here is how to disable its output:
+```js
+testing.setup()
+```
+and the `logger` (or `default`) export will become a `LoggerMock` instance (see below).
+
+- If you create logger(s) using `createLogger`, when testing use the `testing.createLoggerMock` instead. It accepts the same first argument, with an extra second argument, optional, being the `LogTargetMock` to be used (see below).
+
+#### LoggerMock
+
+Loggers created using the `testing` namespace will have one and only one log target being a `LogTargetMock`, and that target will be set on the `target` extra property of the logger.
+
+Here are the extra properties of `LogTargetMock` which you can then use for testing:
+
+- **messages** `LogMessage[]`: all log message objects which would have normally be logged
+  - **last** `LogMessage`: the last one being logged
+  - **trace** `LogMessage[]`: all log message objects with `trace` level
+    - **last** `LogMessage`: last one with `trace` level
+  - **debug** `LogMessage[]`: all log message objects with `debug` level
+    - **last** `LogMessage`: last one with `debug` level
+  - ...
+- **lines** `string[]`: all formatted log message lines which would have normally be logged
+  - **last** `string`: the last one being logged
+  - **trace** `string[]`: all formatted log message lines with `trace` level
+    - **last** `string`: last one with `trace` level
+  - **debug** `string[]`: all formatted log message lines with `debug` level
+    - **last** `string`: last one with `debug` level
+  - ...
+- **clear** `() => void`: method to clear all log message objects and formatted lines
+- **filteredMessages** `(level: number | null, untilLevel?: number) => LogMessage[]`: method to filter log message objects
+- **filteredLins** `(level: number | null, untilLevel?: number) => string[]`: method to filter formatted log message lines
+
+#### Example
+
+Let's say you have a `logger.js` file in which you create the logger for your app:
+```js
+// file: logger.js
+import { testing, createLogger, LogContexts } from 'bs-logger';
+
+const factory = process.env.TEST ? testing.createLoggerMock : createLogger;
+
+export default factory({ [LogContexts.application]: 'foo' });
+```
+
+In a test you could:
+```js
+import logger from './logger';
+// in `fetch(url)` you'd use the logger like `logger.debug({url}, 'GET')` when the request is actually made
+import fetch from './http';
+
+test('it should cache request', () => {
+  logger.target.clear();
+  fetch('http://foo.bar/dummy.json');
+  expect(logger.target.messages.length).toBe(1);
+  fetch('http://foo.bar/dummy.json');
+  expect(logger.target.messages.length).toBe(1);
+  // you can also expect on the message:
+  expect(logger.target.messages.last.message).toBe('GET')
+  expect(logger.target.messages.last.context.url).toBe('http://foo.bar/dummy.json')
+  // or (mock target formater prefix the message with `[level:xxx] ` when there is a level)
+  expect(logger.target.lines.last).toBe('[level:20] GET')
+  // or filtering with level:
+  expect(logger.target.lines.debug.last).toBe('[level:20] GET')
+});
+```
+
+## Installing
+
+Add to your project with `npm`:
+
+```bash
+npm install --save bs-logger
+```
+
+or with `yarn`:
+
+```bash
+yarn add bs-logger
+```
+
+## Running the tests
+
+You need to get a copy of the repository to run the tests:
+
+```bash
+git clone https://github.com/huafu/bs-logger.git
+cd bs-logger
+npm run test
+```
+
+## Built With
+
+* [TypeScript](https://www.typescriptlang.org/)
+* [ts-jest](https://github.com/kulshekhar/ts-jest)
+
+## Contributing
+
+Pull requests welcome!
+
+## Versioning
+
+We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/huafu/bs-logger/tags).
+
+## Authors
+
+* **Huafu Gandon** - *Initial work* - [huafu](https://github.com/huafu)
+
+See also the list of [contributors](https://github.com/huafu/bs-logger/contributors) who participated in this project.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
+
+## Support on Beerpay
+Hey dude! Help me out for a couple of :beers:!
+
+[![Beerpay](https://beerpay.io/huafu/bs-logger/badge.svg?style=beer-square)](https://beerpay.io/huafu/bs-logger)  [![Beerpay](https://beerpay.io/huafu/bs-logger/make-wish.svg?style=flat-square)](https://beerpay.io/huafu/bs-logger?focus=wish)

node_modules/bs-logger/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { LogMethod, Logger, createLogger, lastSequenceNumber, resetSequence } from './logger';
+import { LogContext, LogContexts } from './logger/context';
+import { LogLevelName, LogLevels, logLevelNameFor, parseLogLevel } from './logger/level';
+import { LogMessage, LogMessageFormatter, LogMessageTranslator, registerLogFormatter, resetLogFormatters } from './logger/message';
+import { rootLogger, setup } from './logger/root';
+import { DEFAULT_LOG_TARGET, LogTarget, parseLogTargets } from './logger/target';
+import * as testing from './testing';
+export { rootLogger as default, rootLogger as logger, setup, createLogger, DEFAULT_LOG_TARGET, lastSequenceNumber, LogContext, LogContexts, Logger, LogLevelName, logLevelNameFor, LogLevels, LogMessage, LogMessageFormatter, LogMessageTranslator, LogMethod, LogTarget, parseLogLevel, parseLogTargets, registerLogFormatter, resetLogFormatters, resetSequence, testing, };

node_modules/bs-logger/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger_1 = require("./logger");
+exports.createLogger = logger_1.createLogger;
+exports.lastSequenceNumber = logger_1.lastSequenceNumber;
+exports.resetSequence = logger_1.resetSequence;
+var context_1 = require("./logger/context");
+exports.LogContexts = context_1.LogContexts;
+var level_1 = require("./logger/level");
+exports.LogLevels = level_1.LogLevels;
+exports.logLevelNameFor = level_1.logLevelNameFor;
+exports.parseLogLevel = level_1.parseLogLevel;
+var message_1 = require("./logger/message");
+exports.registerLogFormatter = message_1.registerLogFormatter;
+exports.resetLogFormatters = message_1.resetLogFormatters;
+var root_1 = require("./logger/root");
+exports.default = root_1.rootLogger;
+exports.logger = root_1.rootLogger;
+exports.setup = root_1.setup;
+var target_1 = require("./logger/target");
+exports.DEFAULT_LOG_TARGET = target_1.DEFAULT_LOG_TARGET;
+exports.parseLogTargets = target_1.parseLogTargets;
+var testing = __importStar(require("./testing"));
+exports.testing = testing;

node_modules/bs-logger/dist/logger/context.d.ts

@@ -0,0 +1,16 @@
+declare enum LogContexts {
+    application = "application",
+    hostname = "hostname",
+    logLevel = "logLevel",
+    namespace = "namespace",
+    package = "package"
+}
+interface LogContext {
+    [key: string]: any;
+    [LogContexts.application]?: string;
+    [LogContexts.hostname]?: string;
+    [LogContexts.logLevel]?: number;
+    [LogContexts.namespace]?: string;
+    [LogContexts.package]?: string;
+}
+export { LogContext, LogContexts };

node_modules/bs-logger/dist/logger/context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LogContexts;
+(function (LogContexts) {
+    LogContexts["application"] = "application";
+    LogContexts["hostname"] = "hostname";
+    LogContexts["logLevel"] = "logLevel";
+    LogContexts["namespace"] = "namespace";
+    LogContexts["package"] = "package";
+})(LogContexts || (LogContexts = {}));
+exports.LogContexts = LogContexts;

node_modules/bs-logger/dist/logger/index.d.ts

@@ -0,0 +1,37 @@
+import { LogContext } from './context';
+import { LogMessageTranslator } from './message';
+import { LogTarget } from './target';
+interface LogMethod {
+    (message: string, ...args: any[]): void;
+    (context: LogContext, message: string, ...args: any[]): void;
+    isEmptyFunction?: boolean;
+}
+interface LogChildMethod {
+    (context: LogContext): Logger;
+    (translate: LogMessageTranslator): Logger;
+}
+interface LogWrapMethod {
+    <F extends (...args: any[]) => any>(func: F): F;
+    <F extends (...args: any[]) => any>(message: string, func: F): F;
+    <F extends (...args: any[]) => any>(context: LogContext, message: string, func: F): F;
+    <F extends (...args: any[]) => any>(level: number, message: string, func: F): F;
+}
+interface Logger extends LogMethod {
+    trace: LogMethod;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
+    child: LogChildMethod;
+    wrap: LogWrapMethod;
+}
+declare const resetSequence: (next?: number) => void;
+declare const lastSequenceNumber: () => number;
+interface CreateLoggerOptions {
+    context?: LogContext;
+    translate?: LogMessageTranslator;
+    targets?: string | LogTarget[];
+}
+declare const createLogger: ({ context: baseContext, targets: logTargets, translate: logTranslator, }?: CreateLoggerOptions) => Logger;
+export { createLogger, lastSequenceNumber, Logger, LogMethod, resetSequence, CreateLoggerOptions };

node_modules/bs-logger/dist/logger/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("util");
+var context_1 = require("./context");
+var level_1 = require("./level");
+var target_1 = require("./target");
+var lastSeqNumber = 0;
+var resetSequence = function (next) {
+    if (next === void 0) { next = 1; }
+    lastSeqNumber = next - 1;
+};
+exports.resetSequence = resetSequence;
+var lastSequenceNumber = function () { return lastSeqNumber; };
+exports.lastSequenceNumber = lastSequenceNumber;
+var createEmptyFunction = function () {
+    return Object.defineProperty(function emptyFunction() { }, 'isEmptyFunction', { value: true });
+};
+var createEmptyLogger = function () {
+    var log = createEmptyFunction();
+    log.child = function () { return createEmptyLogger(); };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return args.pop();
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        log[name] = log;
+    });
+    return log;
+};
+var createLogger = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.context, baseContext = _c === void 0 ? {} : _c, _d = _b.targets, logTargets = _d === void 0 ? target_1.DEFAULT_LOG_TARGET : _d, logTranslator = _b.translate;
+    var targets = typeof logTargets === 'string' ? target_1.parseLogTargets(logTargets) : logTargets;
+    if (targets.length === 0) {
+        return createEmptyLogger();
+    }
+    var log = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var time = Date.now();
+        var sequence = ++lastSeqNumber;
+        var context;
+        if (typeof args[0] === 'string') {
+            context = __assign({}, baseContext);
+        }
+        else {
+            context = __assign({}, baseContext, args.shift());
+        }
+        var msg = args.shift();
+        var logLevel = context[context_1.LogContexts.logLevel];
+        var destTargets = logLevel == null ? targets : targets.filter(function (t) { return logLevel >= t.minLevel; });
+        if (destTargets.length === 0) {
+            return;
+        }
+        var message = util_1.format.apply(void 0, __spread([msg], args));
+        var logMessage = {
+            context: context,
+            time: time,
+            sequence: sequence,
+            message: message,
+        };
+        if (logTranslator) {
+            logMessage = logTranslator(logMessage);
+        }
+        destTargets.forEach(function (t) { return t.stream.write(t.format(logMessage) + "\n"); });
+    };
+    log.child = function (ctxOrTranslator) {
+        var isTranslator = typeof ctxOrTranslator === 'function';
+        var childContext = isTranslator ? __assign({}, baseContext) : __assign({}, baseContext, ctxOrTranslator);
+        var translate;
+        if (isTranslator) {
+            if (logTranslator) {
+                translate = function (msg) { return ctxOrTranslator(logTranslator(msg)); };
+            }
+            else {
+                translate = ctxOrTranslator;
+            }
+        }
+        else {
+            translate = logTranslator;
+        }
+        return createLogger({ context: childContext, targets: targets, translate: translate });
+    };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _a;
+        var _b = __read(Array(3 - args.length).concat(args), 3), ctx = _b[0], msg = _b[1], func = _b[2];
+        var context = typeof ctx === 'number' ? __assign({}, baseContext, (_a = {}, _a[context_1.LogContexts.logLevel] = ctx, _a)) : __assign({}, baseContext, ctx);
+        var logLevel = context[context_1.LogContexts.logLevel];
+        if (typeof logLevel === 'number' && targets.every(function (t) { return t.minLevel > logLevel; })) {
+            return func;
+        }
+        var message = msg == null ? "calling " + (func.name || '[anonymous]') + "()" : msg;
+        return function wrapped() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            log(__assign({ call: { args: args } }, context), message);
+            return func.apply(this, args);
+        };
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        var _a;
+        var level = level_1.LogLevels[name];
+        var extraContext = (_a = {}, _a[context_1.LogContexts.logLevel] = level, _a);
+        log[name] = function (ctxOrMsg) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            if (targets.length === 0 || targets.every(function (t) { return t.minLevel > level; })) {
+                log[name] = createEmptyFunction();
+                return;
+            }
+            if (typeof ctxOrMsg === 'string') {
+                log.apply(void 0, __spread([extraContext, ctxOrMsg], args));
+            }
+            else {
+                log.apply(void 0, __spread([__assign({}, ctxOrMsg, extraContext)], args));
+            }
+        };
+    });
+    return log;
+};
+exports.createLogger = createLogger;

node_modules/bs-logger/dist/logger/level.d.ts

@@ -0,0 +1,25 @@
+declare const LogLevels: {
+    trace: number;
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+    fatal: number;
+    readonly lower: number;
+    readonly higher: number;
+};
+declare type LogLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+declare const LogLevelNames: LogLevelName[];
+declare const LogLevelValues: number[];
+interface LogLevelsScaleEntry {
+    range: {
+        from: number;
+        next: number;
+    };
+    name: string;
+    test(level: number): boolean;
+}
+declare const LogLevelsScale: ReadonlyArray<LogLevelsScaleEntry>;
+declare const logLevelNameFor: (level?: number | undefined) => string;
+declare const parseLogLevel: (level: string | number) => number | undefined;
+export { logLevelNameFor, LogLevels, LogLevelNames, LogLevelValues, LogLevelsScale, parseLogLevel, LogLevelName };

node_modules/bs-logger/dist/logger/level.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var cache_getters_1 = require("../utils/cache-getters");
+var LogLevels = cache_getters_1.cacheGetters({
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    get lower() {
+        return LogLevels.trace;
+    },
+    get higher() {
+        return LogLevels.fatal;
+    },
+}, 'lower', 'higher');
+exports.LogLevels = LogLevels;
+var LogLevelNames = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+exports.LogLevelNames = LogLevelNames;
+var LogLevelValues = LogLevelNames.map(function (name) { return LogLevels[name]; });
+exports.LogLevelValues = LogLevelValues;
+var LogLevelsScale = LogLevelNames.map(function (name, index, _a) {
+    var length = _a.length;
+    var first = index === 0;
+    var last = index === length - 1;
+    var from = first ? -Infinity : LogLevelValues[index];
+    var next = last ? +Infinity : LogLevelValues[index + 1];
+    var test;
+    if (first) {
+        test = function (level) { return level < next; };
+    }
+    else if (last) {
+        test = function (level) { return level >= from; };
+    }
+    else {
+        test = function (level) { return level < next && level >= from; };
+    }
+    return { range: { from: from, next: next }, name: name, test: test };
+});
+exports.LogLevelsScale = LogLevelsScale;
+var logLevelNameFor = function (level) {
+    if (level == null || isNaN(level)) {
+        return LogLevelNames[0];
+    }
+    return LogLevelsScale.find(function (_a) {
+        var test = _a.test;
+        return test(level);
+    }).name;
+};
+exports.logLevelNameFor = logLevelNameFor;
+var parseLogLevel = function (level) {
+    if (typeof level === 'string') {
+        level = level.toLowerCase();
+        if (level in LogLevels) {
+            return LogLevels[level];
+        }
+        return /^\s*[0-9]+\s*$/.test(level) ? parseInt(level.trim(), 10) : undefined;
+    }
+    return typeof level === 'number' && !isNaN(level) ? +level : undefined;
+};
+exports.parseLogLevel = parseLogLevel;

node_modules/bs-logger/dist/logger/message.d.ts

@@ -0,0 +1,18 @@
+import { LogContext } from './context';
+interface LogMessage {
+    context: LogContext;
+    message: string;
+    sequence: number;
+    time: number;
+}
+declare type LogMessageFormatter = (msg: LogMessage) => string;
+declare type LogMessageTranslator = (msg: LogMessage) => LogMessage;
+interface LogFormattersMap {
+    json: LogMessageFormatter;
+    simple: LogMessageFormatter;
+    [key: string]: LogMessageFormatter;
+}
+declare let LogFormatters: LogFormattersMap;
+declare const resetLogFormatters: () => void;
+declare const registerLogFormatter: (name: string, format: LogMessageFormatter) => void;
+export { LogMessage, LogMessageTranslator, LogMessageFormatter, LogFormatters, resetLogFormatters, registerLogFormatter, };

node_modules/bs-logger/dist/logger/message.js

@@ -0,0 +1,37 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+var context_1 = require("./context");
+var level_1 = require("./level");
+var LogFormatters = defaultLogFormatters();
+exports.LogFormatters = LogFormatters;
+var resetLogFormatters = function () {
+    exports.LogFormatters = LogFormatters = defaultLogFormatters();
+};
+exports.resetLogFormatters = resetLogFormatters;
+var registerLogFormatter = function (name, format) {
+    LogFormatters[name] = format;
+};
+exports.registerLogFormatter = registerLogFormatter;
+function defaultLogFormatters() {
+    return {
+        json: function (msg) { return fast_json_stable_stringify_1.default(__assign({}, msg, { time: new Date(msg.time) }), { cycles: true }); },
+        simple: function (msg) {
+            return (msg.context[context_1.LogContexts.package] || msg.context[context_1.LogContexts.application] || 'main') + "[" + (msg.context[context_1.LogContexts.namespace] || 'root') + "] (" + level_1.logLevelNameFor(msg.context[context_1.LogContexts.logLevel]).toUpperCase() + ") " + msg.message;
+        },
+    };
+}

node_modules/bs-logger/dist/logger/root.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '.';
+declare const setup: (factory?: () => Logger) => void;
+declare const rootLogger: Logger;
+export { rootLogger, setup };

node_modules/bs-logger/dist/logger/root.js

@@ -0,0 +1,79 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var e_1, _a;
+var cache_getters_1 = require("../utils/cache-getters");
+var _1 = require(".");
+var level_1 = require("./level");
+var cache;
+var setup = function (factory) {
+    if (factory === void 0) { factory = function () { return _1.createLogger({ targets: process.env.LOG_TARGETS || process.env.LOG_TARGET }); }; }
+    cache = cache_getters_1.cacheGetters({
+        get root() {
+            return factory();
+        },
+    }, 'root');
+};
+exports.setup = setup;
+var rootLogger = (function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return cache.root.apply(cache, __spread(args));
+});
+exports.rootLogger = rootLogger;
+var props = __spread(level_1.LogLevelNames, ['child', 'wrap']);
+var _loop_1 = function (prop) {
+    Object.defineProperty(rootLogger, prop, {
+        enumerable: true,
+        configurable: true,
+        get: function () {
+            return cache.root[prop];
+        },
+    });
+};
+try {
+    for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+        var prop = props_1_1.value;
+        _loop_1(prop);
+    }
+}
+catch (e_1_1) { e_1 = { error: e_1_1 }; }
+finally {
+    try {
+        if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
+    }
+    finally { if (e_1) throw e_1.error; }
+}
+cache_getters_1.cacheGetters.apply(void 0, __spread([rootLogger], props));
+setup();

node_modules/bs-logger/dist/logger/target.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { LogMessageFormatter } from './message';
+interface LogTarget {
+    stream: Writable;
+    minLevel: number;
+    format: LogMessageFormatter;
+}
+declare const parseLogTargets: (targetString?: string | undefined) => LogTarget[];
+declare const DEFAULT_LOG_TARGET: string;
+export { LogTarget, DEFAULT_LOG_TARGET, parseLogTargets };

node_modules/bs-logger/dist/logger/target.js

@@ -0,0 +1,90 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path_1 = require("path");
+var cache_getters_1 = require("../utils/cache-getters");
+var level_1 = require("./level");
+var message_1 = require("./message");
+var logTargetWithLevelRegex = new RegExp("^\\s*(.+):([0-9]+|" + level_1.LogLevelNames.join('|') + ")\\s*$", 'i');
+var parseLogTargets = function (targetString) {
+    var items = (targetString || '').split(/([^\\]),/g).reduce(function (list, item, index) {
+        if (index % 2 === 1) {
+            list[list.length - 1] += item;
+        }
+        else {
+            list.push(item);
+        }
+        return list;
+    }, []);
+    return items.reduce(function (targets, str) {
+        var format;
+        str = str.replace(/^(.+)%([a-z_][a-z0-9_]*)$/, function (_, before, key) {
+            format = message_1.LogFormatters[key];
+            return before;
+        });
+        var pieces = str.match(logTargetWithLevelRegex);
+        var file;
+        var level;
+        if (pieces) {
+            file = pieces[1].trim();
+            level = pieces[2].trim();
+        }
+        else {
+            file = str.trim();
+        }
+        var append = file.endsWith('+');
+        if (append) {
+            file = file.slice(0, -1).trim();
+        }
+        file = file.replace(/\\,/g, ',');
+        if (!file) {
+            return targets;
+        }
+        var isStandardFd = /^(stdout|stderr)$/i.test(file);
+        if (format == null) {
+            format = isStandardFd ? message_1.LogFormatters.simple : message_1.LogFormatters.json;
+        }
+        var target = cache_getters_1.cacheGetters({
+            format: format,
+            get minLevel() {
+                return level_1.parseLogLevel(level) || -Infinity;
+            },
+            get stream() {
+                if (isStandardFd) {
+                    return process[file.toLowerCase()];
+                }
+                else {
+                    return fs_1.createWriteStream(path_1.resolve(process.cwd(), file), {
+                        flags: append ? 'a' : 'w',
+                        autoClose: true,
+                        encoding: 'utf8',
+                    });
+                }
+            },
+        }, 'minLevel', 'stream');
+        return __spread(targets, [target]);
+    }, []);
+};
+exports.parseLogTargets = parseLogTargets;
+var DEFAULT_LOG_TARGET = "stderr:" + level_1.LogLevels.warn;
+exports.DEFAULT_LOG_TARGET = DEFAULT_LOG_TARGET;

node_modules/bs-logger/dist/testing/index.d.ts

@@ -0,0 +1,8 @@
+import { CreateLoggerOptions, Logger } from '../logger';
+import { ExtendedArray, LogTargetMock, extendArray } from './target-mock';
+declare const setupForTesting: (target?: LogTargetMock) => void;
+interface LoggerMock extends Logger {
+    readonly target: LogTargetMock;
+}
+declare const createLoggerMock: (options?: CreateLoggerOptions | undefined, target?: LogTargetMock) => LoggerMock;
+export { LogTargetMock, ExtendedArray, extendArray, setupForTesting as setup, createLoggerMock, LoggerMock };

node_modules/bs-logger/dist/testing/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger_1 = require("../logger");
+var root_1 = require("../logger/root");
+var target_mock_1 = require("./target-mock");
+exports.LogTargetMock = target_mock_1.LogTargetMock;
+exports.extendArray = target_mock_1.extendArray;
+var setupForTesting = function (target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    root_1.setup(function () { return createLoggerMock(undefined, target); });
+};
+exports.setup = setupForTesting;
+var createLoggerMock = function (options, target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    var opt = __assign({}, options, { targets: [target] });
+    return Object.assign(logger_1.createLogger(opt), { target: target });
+};
+exports.createLoggerMock = createLoggerMock;

node_modules/bs-logger/dist/testing/target-mock.d.ts

@@ -0,0 +1,28 @@
+import { LogMessage } from '../logger/message';
+import { LogTarget } from '../logger/target';
+interface ExtendedArray<T> extends Array<T> {
+    readonly last: T | undefined;
+}
+interface LogLevelMap<T> {
+    trace: T;
+    debug: T;
+    info: T;
+    warn: T;
+    error: T;
+    fatal: T;
+}
+declare const extendArray: <T>(array: T[]) => ExtendedArray<T>;
+declare class LogTargetMock implements LogTarget {
+    minLevel: number;
+    readonly messages: ExtendedArray<LogMessage> & LogLevelMap<ExtendedArray<LogMessage>>;
+    readonly lines: ExtendedArray<string> & LogLevelMap<ExtendedArray<string>>;
+    readonly stream: LogTarget['stream'];
+    constructor(minLevel?: number);
+    format(msg: LogMessage): string;
+    clear(): void;
+    filteredMessages(level: number, untilLevel?: number): ExtendedArray<LogMessage>;
+    filteredMessages(level: null): ExtendedArray<LogMessage>;
+    filteredLines(level: number, untilLevel?: number): ExtendedArray<string>;
+    filteredLines(level: null): ExtendedArray<string>;
+}
+export { LogTargetMock, extendArray, ExtendedArray };

node_modules/bs-logger/dist/testing/target-mock.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var context_1 = require("../logger/context");
+var level_1 = require("../logger/level");
+var extendArray = function (array) {
+    return Object.defineProperty(array, 'last', {
+        configurable: true,
+        get: function () {
+            return this[this.length - 1];
+        },
+    });
+};
+exports.extendArray = extendArray;
+var LogTargetMock = (function () {
+    function LogTargetMock(minLevel) {
+        if (minLevel === void 0) { minLevel = -Infinity; }
+        var _this = this;
+        this.minLevel = minLevel;
+        this.messages = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredMessages(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredMessages(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredMessages(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredMessages(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredMessages(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredMessages(level_1.LogLevels.fatal); } },
+        });
+        this.lines = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredLines(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredLines(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredLines(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredLines(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredLines(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredLines(level_1.LogLevels.fatal); } },
+        });
+        this.stream = {
+            write: function (msg) { return !!_this.lines.push(msg); },
+        };
+    }
+    LogTargetMock.prototype.format = function (msg) {
+        this.messages.push(msg);
+        var lvl = msg.context[context_1.LogContexts.logLevel];
+        if (lvl != null) {
+            return "[level:" + lvl + "] " + msg.message;
+        }
+        return msg.message;
+    };
+    LogTargetMock.prototype.clear = function () {
+        this.messages.splice(0, this.messages.length);
+        this.lines.splice(0, this.lines.length);
+    };
+    LogTargetMock.prototype.filteredMessages = function (level, untilLevel) {
+        var filter;
+        if (level == null) {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] == null; };
+        }
+        else if (untilLevel != null) {
+            filter = function (m) {
+                var lvl = m.context[context_1.LogContexts.logLevel];
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] === level; };
+        }
+        return extendArray(this.messages.filter(filter));
+    };
+    LogTargetMock.prototype.filteredLines = function (level, untilLevel) {
+        var extractLevel = function (line) {
+            var level = (line.match(/^\[level:([0-9]+)\] /) || [])[1];
+            return level == null ? undefined : parseInt(level, 10);
+        };
+        var filter;
+        if (level == null) {
+            filter = function (line) { return extractLevel(line) === undefined; };
+        }
+        else if (untilLevel != null) {
+            filter = function (line) {
+                var lvl = extractLevel(line);
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (line) { return extractLevel(line) === level; };
+        }
+        return extendArray(this.lines.filter(filter));
+    };
+    return LogTargetMock;
+}());
+exports.LogTargetMock = LogTargetMock;

node_modules/bs-logger/dist/utils/cache-getters.d.ts

@@ -0,0 +1,2 @@
+declare const cacheGetters: <T>(target: T, ...props: (keyof T)[]) => T;
+export { cacheGetters };

node_modules/bs-logger/dist/utils/cache-getters.js

@@ -0,0 +1,40 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cacheGetters = function (target) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    props.forEach(function (prop) {
+        var desc = Object.getOwnPropertyDescriptor(target, prop);
+        var set = desc.set, previousGet = desc.get, partial = __rest(desc, ["set", "get"]);
+        desc.get = function get() {
+            var value = previousGet.call(this);
+            Object.defineProperty(this, prop, __assign({}, partial, { value: value }));
+            return value;
+        };
+        Object.defineProperty(target, prop, desc);
+    });
+    return target;
+};
+exports.cacheGetters = cacheGetters;

node_modules/bs-logger/package.json

@@ -0,0 +1,108 @@
+{
+  "_from": "bs-logger@0.x",
+  "_id": "bs-logger@0.2.6",
+  "_inBundle": false,
+  "_integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==",
+  "_location": "/bs-logger",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "bs-logger@0.x",
+    "name": "bs-logger",
+    "escapedName": "bs-logger",
+    "rawSpec": "0.x",
+    "saveSpec": null,
+    "fetchSpec": "0.x"
+  },
+  "_requiredBy": [
+    "/ts-jest"
+  ],
+  "_resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz",
+  "_shasum": "eb7d365307a72cf974cc6cda76b68354ad336bd8",
+  "_spec": "bs-logger@0.x",
+  "_where": "E:\\github\\setup-java\\node_modules\\ts-jest",
+  "author": {
+    "name": "Huafu Gandon",
+    "email": "huafu.gandon@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/huafu/bs-logger/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "fast-json-stable-stringify": "2.x"
+  },
+  "deprecated": false,
+  "description": "Bare simple logger for NodeJS",
+  "devDependencies": {
+    "@commitlint/cli": "7.x",
+    "@commitlint/config-conventional": "7.x",
+    "@types/jest": "23.x",
+    "@types/node": "10.x",
+    "conventional-changelog-cli": "2.x",
+    "husky": "0.x",
+    "jest": "23.x",
+    "lint-staged": "7.x",
+    "prettier": "1.x",
+    "rimraf": "2.x",
+    "ts-jest": "23.x",
+    "tslint": "5.x",
+    "tslint-config-prettier": "1.x",
+    "tslint-plugin-prettier": "2.x",
+    "typescript": "3.x"
+  },
+  "engines": {
+    "node": ">= 6"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/huafu/bs-logger#readme",
+  "keywords": [
+    "bare simple logger",
+    "simple logger",
+    "simple",
+    "logger",
+    "typescript",
+    "lib",
+    "library"
+  ],
+  "license": "MIT",
+  "lint-staged": {
+    "linters": {
+      "*.{ts,tsx}": [
+        "tslint --fix",
+        "git add"
+      ]
+    }
+  },
+  "main": "dist/index.js",
+  "name": "bs-logger",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/huafu/bs-logger.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "clean": "rimraf dist coverage",
+    "commitmsg": "commitlint -E GIT_PARAMS",
+    "lint": "tslint --project tsconfig.json --format stylish",
+    "lint:fix": "tslint --fix --project tsconfig.json",
+    "postcommit": "git reset",
+    "posttest": "npm run typecheck && npm run lint",
+    "postversion": "git push && git push --tags",
+    "prebuild": "npm run clean",
+    "precommit": "lint-staged",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run test",
+    "preversion": "npm test",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "typecheck": "tsc -p . --noEmit",
+    "version": "npm run changelog && git add CHANGELOG.md"
+  },
+  "types": "dist/index.d.ts",
+  "version": "0.2.6"
+}