standard-log 7.1.0 → 9.0.0

package/dist/standard-log.esm.js

@@ -0,0 +1,1887 @@
+var StandardLog;
+/******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../../node_modules/ms/index.js":
+/*!**************************************!*\
+  !*** ../../node_modules/ms/index.js ***!
+  \**************************************/
+/***/ (function(module) {
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function (val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
+
+
+/***/ }),
+
+/***/ "./ts/console.ts":
+/*!***********************!*\
+  !*** ./ts/console.ts ***!
+  \***********************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createConsoleLogReporter": function() { return /* binding */ createConsoleLogReporter; },
+/* harmony export */   "toConsoleMethod": function() { return /* binding */ toConsoleMethod; }
+/* harmony export */ });
+/* harmony import */ var type_plus__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! type-plus */ "../../node_modules/unpartial/esm/required.js");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./platform.js */ "./ts/platform.ts");
+/* harmony import */ var _formatter_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./formatter.js */ "./ts/formatter.ts");
+
+
+
+
+function toConsoleMethod(level) {
+    switch (true) {
+        // edge case in case none is somehow written
+        case (level <= 0): return 'debug';
+        case (level <= _logLevels_js__WEBPACK_IMPORTED_MODULE_0__.logLevels.error): return 'error';
+        case (level <= _logLevels_js__WEBPACK_IMPORTED_MODULE_0__.logLevels.warn): return 'warn';
+        case (level <= _logLevels_js__WEBPACK_IMPORTED_MODULE_0__.logLevels.info): return 'info';
+        default: return 'debug';
+    }
+}
+// istanbul ignore next
+/* eslint-disable no-console */
+function buildPolyfillConsole() {
+    // old phantomjs does not have bind function
+    const hasBind = !!console.log.bind;
+    if (hasBind) {
+        return {
+            // Node@9.3 or below has `console.debug = undefined` or it doesn't log
+            // Should use `console.log()` in those case.
+            debug: ((0,_platform_js__WEBPACK_IMPORTED_MODULE_1__.isConsoleDebugAvailable)() ? console.debug : console.log).bind(console),
+            // the `typeof` guards against IE where `console.log.apply()`
+            // results in error `Object doesn't support property or method 'apply'`
+            info: (typeof console.info === 'function' ? console.info : console.log).bind(console),
+            warn: (typeof console.warn === 'function' ? console.warn : console.log).bind(console),
+            error: (typeof console.error === 'function' ? console.error : console.log).bind(console)
+        };
+    }
+    else {
+        return {
+            debug: buildFn((0,_platform_js__WEBPACK_IMPORTED_MODULE_1__.isConsoleDebugAvailable)() ? 'debug' : 'log'),
+            info: buildFn(typeof console.info === 'function' ? 'info' : 'log'),
+            warn: buildFn(typeof console.warn === 'function' ? 'warn' : 'log'),
+            error: buildFn(typeof console.error === 'function' ? 'error' : 'log'),
+        };
+    }
+}
+// istanbul ignore next
+function buildFn(name) {
+    return function (...args) { console[name](...args); };
+}
+function createConsoleLogReporter(options) {
+    const { id, formatter, filter } = (0,type_plus__WEBPACK_IMPORTED_MODULE_2__.required)({ id: 'console', formatter: _formatter_js__WEBPACK_IMPORTED_MODULE_3__.plainLogFormatter }, options);
+    if (!_platform_js__WEBPACK_IMPORTED_MODULE_1__.polyfill.console)
+        _platform_js__WEBPACK_IMPORTED_MODULE_1__.polyfill.console = buildPolyfillConsole();
+    return Object.freeze({
+        id,
+        isConsoleReporter: true,
+        get formatter() { return formatter; },
+        get filter() { return filter; },
+        console: _platform_js__WEBPACK_IMPORTED_MODULE_1__.polyfill.console,
+        write(entry) {
+            if (filter && !filter(entry))
+                return;
+            const values = formatter(entry);
+            const method = toConsoleMethod(entry.level);
+            this.console[method](...values);
+        }
+    });
+}
+
+
+/***/ }),
+
+/***/ "./ts/errors.ts":
+/*!**********************!*\
+  !*** ./ts/errors.ts ***!
+  \**********************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "InvalidId": function() { return /* binding */ InvalidId; },
+/* harmony export */   "StandardLogError": function() { return /* binding */ StandardLogError; }
+/* harmony export */ });
+/* harmony import */ var iso_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! iso-error */ "../../node_modules/iso-error/esm/index.js");
+
+class StandardLogError extends iso_error__WEBPACK_IMPORTED_MODULE_0__.ModuleError {
+    constructor(description, options) {
+        super('standard-log', description, options);
+    }
+}
+class InvalidId extends StandardLogError {
+    constructor(id, options) {
+        super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: id
+        });
+    }
+}
+
+
+/***/ }),
+
+/***/ "./ts/formatter.ts":
+/*!*************************!*\
+  !*** ./ts/formatter.ts ***!
+  \*************************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createTimestampFormatter": function() { return /* binding */ createTimestampFormatter; },
+/* harmony export */   "formatLogLevel": function() { return /* binding */ formatLogLevel; },
+/* harmony export */   "plainLogFormatter": function() { return /* binding */ plainLogFormatter; }
+/* harmony export */ });
+/* harmony import */ var ms__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ms */ "../../node_modules/ms/index.js");
+/* harmony import */ var ms__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(ms__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var upper_case__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! upper-case */ "../../node_modules/upper-case/dist/index.js");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+
+
+
+function createTimestampFormatter(format) {
+    switch (format) {
+        case 'none':
+            return (_timestamp) => undefined;
+        case 'iso':
+            return (timestamp) => timestamp.toISOString();
+        case 'elapsed': {
+            let lastTick;
+            return (timestamp) => {
+                const newTick = timestamp.getTime();
+                const result = ms__WEBPACK_IMPORTED_MODULE_0___default()(lastTick === undefined ? 0 : newTick - lastTick);
+                lastTick = newTick;
+                return result;
+            };
+        }
+    }
+}
+function formatLogLevel(level) {
+    return `(${(0,upper_case__WEBPACK_IMPORTED_MODULE_1__.upperCase)((0,_logLevels_js__WEBPACK_IMPORTED_MODULE_2__.toLogLevelName)(level))})`;
+}
+function plainLogFormatter({ id, level, args, timestamp }) {
+    return [timestamp.toISOString(), id, formatLogLevel(level), ...args];
+}
+
+
+/***/ }),
+
+/***/ "./ts/logLevels.ts":
+/*!*************************!*\
+  !*** ./ts/logLevels.ts ***!
+  \*************************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "logLevels": function() { return /* binding */ logLevels; },
+/* harmony export */   "toLogLevel": function() { return /* binding */ toLogLevel; },
+/* harmony export */   "toLogLevelName": function() { return /* binding */ toLogLevelName; }
+/* harmony export */ });
+const logLevels = {
+    /**
+     * none: 0
+     */
+    none: 0,
+    /**
+     * emergency: 100
+     */
+    emergency: 100,
+    /**
+     * alert: 200
+     */
+    alert: 200,
+    /**
+     * critical: 300
+     */
+    critical: 300,
+    /**
+     * error: 400
+     */
+    error: 400,
+    /**
+     * warn: 500
+     */
+    warn: 500,
+    /**
+     * notice: 600
+     */
+    notice: 600,
+    /**
+     * info: 700
+     */
+    info: 700,
+    /**
+     * debug: 800
+     */
+    debug: 800,
+    /**
+     * trace: 900
+     */
+    trace: 900,
+    /**
+     * planck: Infinity
+     * `planck unit` is a very small unit <https://en.wikipedia.org/wiki/Planck_units>.
+     */
+    planck: Infinity,
+    /**
+     * all: Infinity
+     */
+    all: Infinity
+};
+/**
+ * Convert default log level value to log level name.
+ */
+function toLogLevelName(level) {
+    if (level <= 100)
+        return 'emergency';
+    if (level <= 200)
+        return 'alert';
+    if (level <= 300)
+        return 'critical';
+    if (level <= 400)
+        return 'error';
+    if (level <= 500)
+        return 'warn';
+    if (level <= 600)
+        return 'notice';
+    if (level <= 700)
+        return 'info';
+    if (level <= 800)
+        return 'debug';
+    if (level <= 900)
+        return 'trace';
+    return 'planck';
+}
+/**
+ * Convert default log level name to log level value.
+ */
+function toLogLevel(name) {
+    return logLevels[name.toLocaleLowerCase()];
+}
+
+
+/***/ }),
+
+/***/ "./ts/logStore.ts":
+/*!************************!*\
+  !*** ./ts/logStore.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createLogStore": function() { return /* binding */ createLogStore; },
+/* harmony export */   "logLevelStore": function() { return /* binding */ logLevelStore; }
+/* harmony export */ });
+/* harmony import */ var type_plus__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/esm/object/reduceKey.js");
+/* harmony import */ var type_plus__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/esm/object/mapKey.js");
+/* harmony import */ var _console_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./console.js */ "./ts/console.ts");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+
+
+
+function createLogStore(options) {
+    return {
+        loggers: {},
+        reporters: options.reporters || [(0,_console_js__WEBPACK_IMPORTED_MODULE_0__.createConsoleLogReporter)()],
+        logLevel: options.logLevel,
+        logLevelStore: logLevelStore(options)
+    };
+}
+function logLevelStore(options) {
+    const customLevels = options.customLevels || {};
+    const store = {
+        customLevels,
+        customLevelsReverse: (0,type_plus__WEBPACK_IMPORTED_MODULE_1__.reduceByKey)(customLevels, (p, k) => {
+            p[customLevels[k]] = k;
+            return p;
+        }, {})
+    };
+    return {
+        getName(level) {
+            return store.customLevelsReverse[level] ?? (0,_logLevels_js__WEBPACK_IMPORTED_MODULE_2__.toLogLevelName)(level);
+        },
+        getLevel(name) {
+            return store.customLevels[name] ?? (0,_logLevels_js__WEBPACK_IMPORTED_MODULE_2__.toLogLevel)(name);
+        },
+        getAllLevels() {
+            return (0,type_plus__WEBPACK_IMPORTED_MODULE_1__.reduceKey)(_logLevels_js__WEBPACK_IMPORTED_MODULE_2__.logLevels, (result, name) => {
+                if (name !== 'none' && name !== 'all')
+                    result.push({ name, level: _logLevels_js__WEBPACK_IMPORTED_MODULE_2__.logLevels[name] });
+                return result;
+            }, (0,type_plus__WEBPACK_IMPORTED_MODULE_3__.mapKey)(store.customLevels, name => ({ name, level: store.customLevels[name] })));
+        }
+    };
+}
+
+
+/***/ }),
+
+/***/ "./ts/logger.ts":
+/*!**********************!*\
+  !*** ./ts/logger.ts ***!
+  \**********************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createLogger": function() { return /* binding */ createLogger; }
+/* harmony export */ });
+/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./errors.js */ "./ts/errors.ts");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+
+
+function createLogger([store, id, { level, writeTo = () => true }], meta) {
+    validateId(id, meta);
+    const [filter, reporters] = typeof writeTo === 'string'
+        ? [id => id === writeTo, store.reporters]
+        : writeTo instanceof RegExp
+            ? [id => writeTo.test(id), store.reporters]
+            : typeof writeTo === 'function'
+                ? [writeTo, store.reporters]
+                : [() => true, [writeTo]];
+    function write(entry) {
+        writeToReporters(reporters, entry, filter);
+    }
+    const logger = {
+        level,
+        write
+    };
+    Object.defineProperties(logger, {
+        id: { value: id, writable: false },
+        count: {
+            writable: false,
+            value: ((counter) => (...args) => {
+                const level = _logLevels_js__WEBPACK_IMPORTED_MODULE_0__.logLevels.debug;
+                if (shouldLog(store, level, logger.level))
+                    write({
+                        id,
+                        level,
+                        args: [++counter, ...args],
+                        timestamp: new Date()
+                    });
+            })(0)
+        },
+        on: {
+            writable: false,
+            value: (level, logFn) => {
+                const logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level) : level;
+                if (shouldLog(store, logLevel, logger.level)) {
+                    const methodName = store.logLevelStore.getName(logLevel);
+                    const bindedMethod = logger[methodName].bind(logger);
+                    const result = logFn(bindedMethod);
+                    if (result)
+                        bindedMethod(result);
+                }
+            }
+        }
+    });
+    store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
+        Object.defineProperty(logger, name, {
+            writable: false,
+            value: (...args) => {
+                if (shouldLog(store, level, logger.level))
+                    write({ id, level, args, timestamp: new Date() });
+            }
+        });
+    });
+    return logger;
+}
+function validateId(id, meta) {
+    if (/[`~!#$%^&*()=+[\]{},|<>?]/.test(id))
+        throw new _errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidId(id, meta);
+}
+function writeToReporters(reporters, logEntry, filter) {
+    reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry));
+}
+/**
+ * Determines should you log.
+ * @param loggerLevel Log level of the logger.
+ * It can be undefined which the global log level will be used.
+ */
+function shouldLog(store, targetLevel, loggerLevel) {
+    return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel);
+}
+
+
+/***/ }),
+
+/***/ "./ts/memory.ts":
+/*!**********************!*\
+  !*** ./ts/memory.ts ***!
+  \**********************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createMemoryLogReporter": function() { return /* binding */ createMemoryLogReporter; },
+/* harmony export */   "toMessageWithLevel": function() { return /* binding */ toMessageWithLevel; }
+/* harmony export */ });
+/* harmony import */ var type_plus__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! type-plus */ "../../node_modules/unpartial/esm/required.js");
+/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./platform.js */ "./ts/platform.ts");
+/* harmony import */ var _formatter_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./formatter.js */ "./ts/formatter.ts");
+
+
+
+function toMessageWithLevel(logs) {
+    return logs.map(_platform_js__WEBPACK_IMPORTED_MODULE_0__.toInspectLogEntry)
+        .map(log => `${(0,_formatter_js__WEBPACK_IMPORTED_MODULE_1__.formatLogLevel)(log.level)} ${log.args.join(' ')}`)
+        .join('\n')
+        // if it has more than this log,
+        // we assume it is running under tests,
+        // and remove this log to simplify testing.
+        .replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '');
+}
+function createMemoryLogReporter(options) {
+    const { id, formatter, filter } = (0,type_plus__WEBPACK_IMPORTED_MODULE_2__.required)({ id: 'memory', formatter: (e) => e }, options);
+    const logs = [];
+    return Object.freeze({
+        id,
+        get formatter() { return formatter; },
+        get filter() { return filter; },
+        logs,
+        write(entry) {
+            if (filter && !filter(entry))
+                return;
+            logs.push(formatter(entry));
+        },
+        getLogMessage() {
+            return logs.map(_platform_js__WEBPACK_IMPORTED_MODULE_0__.toInspectLogEntry)
+                .map(log => log.args.join(' '))
+                .join('\n');
+        },
+        getLogMessageWithLevel() { return toMessageWithLevel(logs); }
+    });
+}
+
+
+/***/ }),
+
+/***/ "./ts/platform.ts":
+/*!************************!*\
+  !*** ./ts/platform.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "isConsoleDebugAvailable": function() { return /* binding */ isConsoleDebugAvailable; },
+/* harmony export */   "polyfill": function() { return /* binding */ polyfill; },
+/* harmony export */   "semverGt": function() { return /* binding */ semverGt; },
+/* harmony export */   "toInspectLogEntry": function() { return /* binding */ toInspectLogEntry; }
+/* harmony export */ });
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! util */ "../../node_modules/util/util.js");
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_0__);
+
+function semverGt(versionString, version) {
+    const actual = versionString.split('.').reverse().reduce((p, v, i) => {
+        p += Number.parseInt(v, 10) * Math.pow(100, i);
+        return p;
+    }, 0);
+    return actual > (version[0] * 10000 + version[1] * 100 + version[2]);
+}
+// istanbul ignore next
+function isConsoleDebugAvailable() {
+    // without this, systemJs will complain `process is not defined`
+    if (!__webpack_require__.g.process)
+        return true;
+    const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version;
+    return semverGt(versionString, [9, 3, 0]);
+}
+const toInspectLogEntry = (e) => (e.args = e.args.map(value => typeof value === 'object' && value !== null ? (0,util__WEBPACK_IMPORTED_MODULE_0__.inspect)(value) : value),
+    e);
+const polyfill = {};
+
+
+/***/ }),
+
+/***/ "./ts/standardLog.ts":
+/*!***************************!*\
+  !*** ./ts/standardLog.ts ***!
+  \***************************/
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "createStandardLog": function() { return /* binding */ createStandardLog; },
+/* harmony export */   "createStandardLogForTest": function() { return /* binding */ createStandardLogForTest; },
+/* harmony export */   "suppressLogs": function() { return /* binding */ suppressLogs; }
+/* harmony export */ });
+/* harmony import */ var type_plus__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! type-plus */ "../../node_modules/unpartial/esm/required.js");
+/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./logger.js */ "./ts/logger.ts");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+/* harmony import */ var _logStore_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logStore.js */ "./ts/logStore.ts");
+/* harmony import */ var _memory_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./memory.js */ "./ts/memory.ts");
+
+
+
+
+
+function createStandardLog(options, _meta) {
+    const store = (0,_logStore_js__WEBPACK_IMPORTED_MODULE_0__.createLogStore)((0,type_plus__WEBPACK_IMPORTED_MODULE_1__.required)({ logLevel: _logLevels_js__WEBPACK_IMPORTED_MODULE_2__.logLevels.info }, options));
+    return Object.freeze({
+        get logLevel() { return store.logLevel; },
+        toLogLevelName(level) {
+            return store.logLevelStore.getName(level);
+        },
+        toLogLevel(name) {
+            return store.logLevelStore.getLevel(name);
+        },
+        getLogger([id, options], meta) {
+            if (store.loggers[id])
+                return store.loggers[id];
+            const opt = (0,type_plus__WEBPACK_IMPORTED_MODULE_1__.required)({ level: store.logLevel }, options);
+            return store.loggers[id] = (0,_logger_js__WEBPACK_IMPORTED_MODULE_3__.createLogger)([store, id, opt], { ssf: this.getLogger, ...meta });
+        }
+    });
+}
+function createStandardLogForTest(logLevel = _logLevels_js__WEBPACK_IMPORTED_MODULE_2__.logLevels.debug) {
+    const reporter = (0,_memory_js__WEBPACK_IMPORTED_MODULE_4__.createMemoryLogReporter)();
+    const standardLog = createStandardLog({ reporters: [reporter], logLevel });
+    return { ...standardLog, reporter };
+}
+function suppressLogs(block, ...logs) {
+    const origLevels = logs.map(l => l.level);
+    logs.forEach(l => l.level = _logLevels_js__WEBPACK_IMPORTED_MODULE_2__.logLevels.none);
+    const result = block();
+    logs.forEach((l, i) => l.level = origLevels[i]);
+    return result;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/upper-case/dist/index.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/upper-case/dist/index.js ***!
+  \***************************************************/
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.upperCase = exports.localeUpperCase = void 0;
+/**
+ * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
+ */
+var SUPPORTED_LOCALE = {
+    tr: {
+        regexp: /[\u0069]/g,
+        map: {
+            i: "\u0130",
+        },
+    },
+    az: {
+        regexp: /[\u0069]/g,
+        map: {
+            i: "\u0130",
+        },
+    },
+    lt: {
+        regexp: /[\u0069\u006A\u012F]\u0307|\u0069\u0307[\u0300\u0301\u0303]/g,
+        map: {
+            i̇: "\u0049",
+            j̇: "\u004A",
+            į̇: "\u012E",
+            i̇̀: "\u00CC",
+            i̇́: "\u00CD",
+            i̇̃: "\u0128",
+        },
+    },
+};
+/**
+ * Localized upper case.
+ */
+function localeUpperCase(str, locale) {
+    var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
+    if (lang)
+        return upperCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
+    return upperCase(str);
+}
+exports.localeUpperCase = localeUpperCase;
+/**
+ * Upper case as a function.
+ */
+function upperCase(str) {
+    return str.toUpperCase();
+}
+exports.upperCase = upperCase;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../node_modules/util/node_modules/inherits/inherits_browser.js":
+/*!*************************************************************************!*\
+  !*** ../../node_modules/util/node_modules/inherits/inherits_browser.js ***!
+  \*************************************************************************/
+/***/ (function(module) {
+
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/util/support/isBufferBrowser.js":
+/*!**********************************************************!*\
+  !*** ../../node_modules/util/support/isBufferBrowser.js ***!
+  \**********************************************************/
+/***/ (function(module) {
+
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+
+/***/ }),
+
+/***/ "../../node_modules/util/util.js":
+/*!***************************************!*\
+  !*** ../../node_modules/util/util.js ***!
+  \***************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(__webpack_require__.g.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = __webpack_require__(/*! ./support/isBuffer */ "../../node_modules/util/support/isBufferBrowser.js");
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = __webpack_require__(/*! inherits */ "../../node_modules/util/node_modules/inherits/inherits_browser.js");
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/iso-error/esm/index.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/iso-error/esm/index.js ***!
+  \*************************************************/
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "IsoError": function() { return /* binding */ IsoError; },
+/* harmony export */   "ModuleError": function() { return /* binding */ ModuleError; },
+/* harmony export */   "isAggregateError": function() { return /* binding */ isAggregateError; }
+/* harmony export */ });
+/* eslint-disable @typescript-eslint/unbound-method */
+//#region captureStackTrace polyfill
+// istanbul ignore next
+if (!Error.captureStackTrace) {
+    Error.captureStackTrace = function (error) {
+        const container = new Error();
+        Object.defineProperty(error, 'stack', {
+            configurable: true,
+            get: function () {
+                // Replace property with value for faster future accesses.
+                defineStack(this, container.stack);
+                return container.stack;
+            },
+            set: function (stack) { defineStack(error, stack); },
+        });
+    };
+}
+// istanbul ignore next
+function defineStack(target, value) {
+    Object.defineProperty(target, 'stack', {
+        configurable: true,
+        value,
+        writable: true,
+    });
+}
+const serializers = [];
+const deserializers = [];
+/**
+ * Isomorphic Error that works across physical boundary.
+ */
+class IsoError extends Error {
+    constructor(message, options) {
+        super(message);
+        /**
+         * Name of the error
+         */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Error cause
+         */
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        //restore prototype chain
+        const actualProto = new.target.prototype;
+        this.name = actualProto.constructor.name;
+        // istanbul ignore next
+        if (Object.setPrototypeOf)
+            Object.setPrototypeOf(this, actualProto);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        else
+            this.__proto__ = actualProto;
+        if (options?.cause)
+            this.cause = toIsoError(options.cause);
+        if (options?.ssf)
+            Error.captureStackTrace(this, options.ssf);
+    }
+    /**
+     * Create an IsoError with additional properties without the need to create a new class.
+     * @param props properties of the IsoError
+     */
+    static create(props) {
+        const { message, cause, ...rest } = props;
+        const err = new IsoError(message, { cause, ssf: IsoError.create });
+        return Object.assign(err, rest);
+    }
+    static stringify(err) {
+        return this.serialize(err);
+    }
+    static serialize(err) {
+        return JSON.stringify(this.toSerializable(err));
+    }
+    /**
+     * @type P Additional properties of the IsoError
+     * @param text Json representation of a IsoError
+     */
+    static parse(text) {
+        return deserialize(IsoError.parse, text);
+    }
+    /**
+     * @type P Additional properties of the IsoError
+     * @param text Json representation of a IsoError
+     */
+    static deserialize(text) {
+        return deserialize(IsoError.deserialize, text);
+    }
+    static toSerializable(err) {
+        return serializers.reduce((p, s) => p || s(err), undefined)
+            || toSerializableError(err);
+    }
+    static fromSerializable(json) {
+        const err = deserializeError(json);
+        Error.captureStackTrace(err, IsoError.fromSerializable);
+        return err;
+    }
+    /**
+     * returns the error message including the error causes.
+     */
+    static trace(err) {
+        return trace(err);
+    }
+    static addPlugin({ toSerializable, fromSerializable }) {
+        serializers.unshift(toSerializable);
+        deserializers.unshift(fromSerializable);
+    }
+    toString() { return IsoError.serialize(this); }
+    trace() { return IsoError.trace(this); }
+}
+function deserialize(fn, text) {
+    const json = JSON.parse(text);
+    const err = deserializeError(json);
+    Error.captureStackTrace(err, fn);
+    return err;
+}
+function deserializeError(json) {
+    let err = undefined;
+    for (const d of deserializers) {
+        err = d(json);
+        if (err)
+            break;
+    }
+    return err || defaultDeserializeError(json);
+}
+function defaultDeserializeError(json) {
+    if (json.name === 'AggregateError') {
+        const { message, errors, ...rest } = json;
+        // @ts-ignore
+        if (global.AggregateError) {
+            return Object.assign(new AggregateError(errors, message), rest);
+        }
+        else {
+            return Object.assign(new Error(message), {
+                ...rest,
+                errors
+            });
+        }
+    }
+    const { message, cause, ...rest } = json;
+    const causeError = cause ? deserializeError(cause) : undefined;
+    if (json.name === 'Error') {
+        return Object.assign(new Error(message), causeError ? { ...rest, cause: causeError } : rest);
+    }
+    // @ts-ignore
+    return Object.assign(new IsoError(message, causeError ? { cause: causeError } : undefined), rest);
+}
+function toSerializableError(err) {
+    if (isAggregateError(err)) {
+        return {
+            ...err, name: err.constructor.name, message: err.message,
+            errors: err.errors.map(toSerializableError)
+        };
+    }
+    if (err instanceof Error) {
+        const { message, cause } = err;
+        return cause
+            ? { ...err, name: err.constructor.name, message, cause: toSerializableError(cause) }
+            : { ...err, name: err.constructor.name, message };
+    }
+    return err;
+}
+// NOTE: In this function I have to to Object.assign to keep the err instance and its stack trace.
+function toIsoError(err) {
+    if (err instanceof IsoError)
+        return err;
+    // When the error is an internal error from deserialzation,
+    // the err.constructor.name is object
+    return Object.assign(err, { name: err.constructor.name !== 'Object' ? err.constructor.name : err.name });
+}
+function trace(err) {
+    const messages = [];
+    if (err instanceof ModuleError) {
+        messages.push(`${err.name}(${err.module}): ${err.message}`);
+    }
+    else if (err instanceof Error) {
+        messages.push(`${err.name}: ${err.message}`);
+    }
+    if (isAggregateError(err)) {
+        err.errors.forEach(e => messages.push(...trace(e).split('\n').map(s => '  ' + s)));
+    }
+    if (err instanceof Error) {
+        if (hasCause(err))
+            messages.push(...trace(err.cause).split('\n').map(s => '  ' + s));
+    }
+    else {
+        messages.push(typeof err === 'string' ? err : JSON.stringify(err));
+    }
+    return messages.join('\n');
+}
+function hasCause(x) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return !!x.cause;
+}
+/**
+ * An IsoError with a module property.
+ */
+class ModuleError extends IsoError {
+    /**
+     * @param module The module that defines this error.
+     */
+    constructor(module, message, options) {
+        super(message, options);
+        Object.defineProperty(this, "module", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: module
+        });
+    }
+}
+function isAggregateError(error) {
+    return error instanceof Error && Array.isArray(error.errors);
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../node_modules/type-plus/esm/object/mapKey.js":
+/*!*********************************************************!*\
+  !*** ../../node_modules/type-plus/esm/object/mapKey.js ***!
+  \*********************************************************/
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "mapKey": function() { return /* binding */ mapKey; }
+/* harmony export */ });
+function mapKey(subject, predicate, thisArg) {
+    return Object.keys(subject).map(predicate, thisArg);
+}
+//# sourceMappingURL=mapKey.js.map
+
+/***/ }),
+
+/***/ "../../node_modules/type-plus/esm/object/reduceKey.js":
+/*!************************************************************!*\
+  !*** ../../node_modules/type-plus/esm/object/reduceKey.js ***!
+  \************************************************************/
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "reduceByKey": function() { return /* binding */ reduceByKey; },
+/* harmony export */   "reduceKey": function() { return /* binding */ reduceKey; }
+/* harmony export */ });
+function reduceByKey(subject, callbackfn, initialValue) {
+    return Object.keys(subject).reduce(callbackfn, initialValue);
+}
+const reduceKey = reduceByKey;
+//# sourceMappingURL=reduceKey.js.map
+
+/***/ }),
+
+/***/ "../../node_modules/unpartial/esm/required.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/unpartial/esm/required.js ***!
+  \****************************************************/
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "required": function() { return /* binding */ required; },
+/* harmony export */   "requiredDeep": function() { return /* binding */ requiredDeep; }
+/* harmony export */ });
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+function required(source1, source2, source3) {
+    return merge([source1, source2, source3], (p, e) => ({ ...p, ...e }));
+}
+function requiredDeep(source1, source2, source3) {
+    return merge([source1, source2, source3], (p, e) => deepmerge(p, e));
+}
+function merge(entries, reducer) {
+    if (entries[0] === undefined || entries[0] === null)
+        return entries[0];
+    return entries.filter(x => !!x).reduce(reducer, {});
+}
+function deepmerge(source1, source2) {
+    if (typeof source1 !== 'object' || source1 === null)
+        return source2 !== undefined ? source2 : source1;
+    if (Array.isArray(source1)) {
+        if (Array.isArray(source2))
+            return source2;
+        if (source2 === undefined)
+            return [...source1];
+        return [...source1, source2];
+    }
+    return getAllKeys(source1).concat(getAllKeys(source2)).reduce((p, k) => {
+        // @ts-ignore
+        p[k] = deepmerge(source1[k], source2 && source2[k]);
+        return p;
+    }, {});
+}
+function getAllKeys(subject, internal = false) {
+    if (typeof subject !== 'object')
+        return [];
+    const propertyNames = Object.getOwnPropertyNames(subject);
+    const keys = internal ? propertyNames.filter(n => n !== 'constructor') : propertyNames;
+    const proto = Object.getPrototypeOf(subject);
+    return proto !== Object.prototype ? keys.concat(getAllKeys(proto, true)) : keys;
+}
+//# sourceMappingURL=required.js.map
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	!function() {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+!function() {
+"use strict";
+/*!*********************!*\
+  !*** ./ts/index.ts ***!
+  \*********************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "InvalidId": function() { return /* reexport safe */ _errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidId; },
+/* harmony export */   "StandardLogError": function() { return /* reexport safe */ _errors_js__WEBPACK_IMPORTED_MODULE_1__.StandardLogError; },
+/* harmony export */   "createConsoleLogReporter": function() { return /* reexport safe */ _console_js__WEBPACK_IMPORTED_MODULE_0__.createConsoleLogReporter; },
+/* harmony export */   "createMemoryLogReporter": function() { return /* reexport safe */ _memory_js__WEBPACK_IMPORTED_MODULE_4__.createMemoryLogReporter; },
+/* harmony export */   "createStandardLog": function() { return /* reexport safe */ _standardLog_js__WEBPACK_IMPORTED_MODULE_5__.createStandardLog; },
+/* harmony export */   "createStandardLogForTest": function() { return /* reexport safe */ _standardLog_js__WEBPACK_IMPORTED_MODULE_5__.createStandardLogForTest; },
+/* harmony export */   "createTimestampFormatter": function() { return /* reexport safe */ _formatter_js__WEBPACK_IMPORTED_MODULE_2__.createTimestampFormatter; },
+/* harmony export */   "formatLogLevel": function() { return /* reexport safe */ _formatter_js__WEBPACK_IMPORTED_MODULE_2__.formatLogLevel; },
+/* harmony export */   "logLevels": function() { return /* reexport safe */ _logLevels_js__WEBPACK_IMPORTED_MODULE_3__.logLevels; },
+/* harmony export */   "plainLogFormatter": function() { return /* reexport safe */ _formatter_js__WEBPACK_IMPORTED_MODULE_2__.plainLogFormatter; },
+/* harmony export */   "suppressLogs": function() { return /* reexport safe */ _standardLog_js__WEBPACK_IMPORTED_MODULE_5__.suppressLogs; },
+/* harmony export */   "toConsoleMethod": function() { return /* reexport safe */ _console_js__WEBPACK_IMPORTED_MODULE_0__.toConsoleMethod; },
+/* harmony export */   "toLogLevel": function() { return /* reexport safe */ _logLevels_js__WEBPACK_IMPORTED_MODULE_3__.toLogLevel; },
+/* harmony export */   "toLogLevelName": function() { return /* reexport safe */ _logLevels_js__WEBPACK_IMPORTED_MODULE_3__.toLogLevelName; },
+/* harmony export */   "toMessageWithLevel": function() { return /* reexport safe */ _memory_js__WEBPACK_IMPORTED_MODULE_4__.toMessageWithLevel; }
+/* harmony export */ });
+/* harmony import */ var _console_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./console.js */ "./ts/console.ts");
+/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./errors.js */ "./ts/errors.ts");
+/* harmony import */ var _formatter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./formatter.js */ "./ts/formatter.ts");
+/* harmony import */ var _logLevels_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+/* harmony import */ var _memory_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./memory.js */ "./ts/memory.ts");
+/* harmony import */ var _standardLog_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./standardLog.js */ "./ts/standardLog.ts");
+
+
+
+
+
+
+
+
+}();
+StandardLog = __webpack_exports__;
+/******/ })()
+;
+//# sourceMappingURL=standard-log.esm.js.map