standard-log 7.1.0 → 9.0.0

package/dist/standard-log.es5.js

@@ -0,0 +1,1971 @@
+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, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createConsoleLogReporter = exports.toConsoleMethod = void 0;
+var type_plus_1 = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/cjs/index.js");
+var logLevels_js_1 = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+var platform_js_1 = __webpack_require__(/*! ./platform.js */ "./ts/platform.ts");
+var formatter_js_1 = __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_1.logLevels.error): return 'error';
+        case (level <= logLevels_js_1.logLevels.warn): return 'warn';
+        case (level <= logLevels_js_1.logLevels.info): return 'info';
+        default: return 'debug';
+    }
+}
+exports.toConsoleMethod = toConsoleMethod;
+// istanbul ignore next
+/* eslint-disable no-console */
+function buildPolyfillConsole() {
+    // old phantomjs does not have bind function
+    var 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_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_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 () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console[name].apply(console, args);
+    };
+}
+function createConsoleLogReporter(options) {
+    var _a = (0, type_plus_1.required)({ id: 'console', formatter: formatter_js_1.plainLogFormatter }, options), id = _a.id, formatter = _a.formatter, filter = _a.filter;
+    if (!platform_js_1.polyfill.console)
+        platform_js_1.polyfill.console = buildPolyfillConsole();
+    return Object.freeze({
+        id: id,
+        isConsoleReporter: true,
+        get formatter() { return formatter; },
+        get filter() { return filter; },
+        console: platform_js_1.polyfill.console,
+        write: function (entry) {
+            var _a;
+            if (filter && !filter(entry))
+                return;
+            var values = formatter(entry);
+            var method = toConsoleMethod(entry.level);
+            (_a = this.console)[method].apply(_a, values);
+        }
+    });
+}
+exports.createConsoleLogReporter = createConsoleLogReporter;
+
+
+/***/ }),
+
+/***/ "./ts/errors.ts":
+/*!**********************!*\
+  !*** ./ts/errors.ts ***!
+  \**********************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.InvalidId = exports.StandardLogError = void 0;
+var iso_error_1 = __webpack_require__(/*! iso-error */ "../../node_modules/iso-error/cjs/index.js");
+var StandardLogError = /** @class */ (function (_super) {
+    __extends(StandardLogError, _super);
+    function StandardLogError(description, options) {
+        return _super.call(this, 'standard-log', description, options) || this;
+    }
+    return StandardLogError;
+}(iso_error_1.ModuleError));
+exports.StandardLogError = StandardLogError;
+var InvalidId = /** @class */ (function (_super) {
+    __extends(InvalidId, _super);
+    function InvalidId(id, options) {
+        var _this = _super.call(this, "logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ".concat(id), options) || this;
+        Object.defineProperty(_this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: id
+        });
+        return _this;
+    }
+    return InvalidId;
+}(StandardLogError));
+exports.InvalidId = InvalidId;
+
+
+/***/ }),
+
+/***/ "./ts/formatter.ts":
+/*!*************************!*\
+  !*** ./ts/formatter.ts ***!
+  \*************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.plainLogFormatter = exports.formatLogLevel = exports.createTimestampFormatter = void 0;
+var ms_1 = __importDefault(__webpack_require__(/*! ms */ "../../node_modules/ms/index.js"));
+var upper_case_1 = __webpack_require__(/*! upper-case */ "../../node_modules/upper-case/dist/index.js");
+var logLevels_js_1 = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+function createTimestampFormatter(format) {
+    switch (format) {
+        case 'none':
+            return function (_timestamp) { return undefined; };
+        case 'iso':
+            return function (timestamp) { return timestamp.toISOString(); };
+        case 'elapsed': {
+            var lastTick_1;
+            return function (timestamp) {
+                var newTick = timestamp.getTime();
+                var result = (0, ms_1.default)(lastTick_1 === undefined ? 0 : newTick - lastTick_1);
+                lastTick_1 = newTick;
+                return result;
+            };
+        }
+    }
+}
+exports.createTimestampFormatter = createTimestampFormatter;
+function formatLogLevel(level) {
+    return "(".concat((0, upper_case_1.upperCase)((0, logLevels_js_1.toLogLevelName)(level)), ")");
+}
+exports.formatLogLevel = formatLogLevel;
+function plainLogFormatter(_a) {
+    var id = _a.id, level = _a.level, args = _a.args, timestamp = _a.timestamp;
+    return __spreadArray([timestamp.toISOString(), id, formatLogLevel(level)], args, true);
+}
+exports.plainLogFormatter = plainLogFormatter;
+
+
+/***/ }),
+
+/***/ "./ts/index.ts":
+/*!*********************!*\
+  !*** ./ts/index.ts ***!
+  \*********************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(/*! ./console.js */ "./ts/console.ts"), exports);
+__exportStar(__webpack_require__(/*! ./errors.js */ "./ts/errors.ts"), exports);
+__exportStar(__webpack_require__(/*! ./formatter.js */ "./ts/formatter.ts"), exports);
+__exportStar(__webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts"), exports);
+__exportStar(__webpack_require__(/*! ./memory.js */ "./ts/memory.ts"), exports);
+__exportStar(__webpack_require__(/*! ./standardLog.js */ "./ts/standardLog.ts"), exports);
+__exportStar(__webpack_require__(/*! ./types.js */ "./ts/types.ts"), exports);
+
+
+/***/ }),
+
+/***/ "./ts/logLevels.ts":
+/*!*************************!*\
+  !*** ./ts/logLevels.ts ***!
+  \*************************/
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.toLogLevel = exports.toLogLevelName = exports.logLevels = void 0;
+exports.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';
+}
+exports.toLogLevelName = toLogLevelName;
+/**
+ * Convert default log level name to log level value.
+ */
+function toLogLevel(name) {
+    return exports.logLevels[name.toLocaleLowerCase()];
+}
+exports.toLogLevel = toLogLevel;
+
+
+/***/ }),
+
+/***/ "./ts/logStore.ts":
+/*!************************!*\
+  !*** ./ts/logStore.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.logLevelStore = exports.createLogStore = void 0;
+var type_plus_1 = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/cjs/index.js");
+var console_js_1 = __webpack_require__(/*! ./console.js */ "./ts/console.ts");
+var logLevels_js_1 = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+function createLogStore(options) {
+    return {
+        loggers: {},
+        reporters: options.reporters || [(0, console_js_1.createConsoleLogReporter)()],
+        logLevel: options.logLevel,
+        logLevelStore: logLevelStore(options)
+    };
+}
+exports.createLogStore = createLogStore;
+function logLevelStore(options) {
+    var customLevels = options.customLevels || {};
+    var store = {
+        customLevels: customLevels,
+        customLevelsReverse: (0, type_plus_1.reduceByKey)(customLevels, function (p, k) {
+            p[customLevels[k]] = k;
+            return p;
+        }, {})
+    };
+    return {
+        getName: function (level) {
+            var _a;
+            return (_a = store.customLevelsReverse[level]) !== null && _a !== void 0 ? _a : (0, logLevels_js_1.toLogLevelName)(level);
+        },
+        getLevel: function (name) {
+            var _a;
+            return (_a = store.customLevels[name]) !== null && _a !== void 0 ? _a : (0, logLevels_js_1.toLogLevel)(name);
+        },
+        getAllLevels: function () {
+            return (0, type_plus_1.reduceKey)(logLevels_js_1.logLevels, function (result, name) {
+                if (name !== 'none' && name !== 'all')
+                    result.push({ name: name, level: logLevels_js_1.logLevels[name] });
+                return result;
+            }, (0, type_plus_1.mapKey)(store.customLevels, function (name) { return ({ name: name, level: store.customLevels[name] }); }));
+        }
+    };
+}
+exports.logLevelStore = logLevelStore;
+
+
+/***/ }),
+
+/***/ "./ts/logger.ts":
+/*!**********************!*\
+  !*** ./ts/logger.ts ***!
+  \**********************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createLogger = void 0;
+var errors_js_1 = __webpack_require__(/*! ./errors.js */ "./ts/errors.ts");
+var logLevels_js_1 = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+function createLogger(_a, meta) {
+    var store = _a[0], id = _a[1], _b = _a[2], level = _b.level, _c = _b.writeTo, writeTo = _c === void 0 ? function () { return true; } : _c;
+    validateId(id, meta);
+    var _d = typeof writeTo === 'string'
+        ? [function (id) { return id === writeTo; }, store.reporters]
+        : writeTo instanceof RegExp
+            ? [function (id) { return writeTo.test(id); }, store.reporters]
+            : typeof writeTo === 'function'
+                ? [writeTo, store.reporters]
+                : [function () { return true; }, [writeTo]], filter = _d[0], reporters = _d[1];
+    function write(entry) {
+        writeToReporters(reporters, entry, filter);
+    }
+    var logger = {
+        level: level,
+        write: write
+    };
+    Object.defineProperties(logger, {
+        id: { value: id, writable: false },
+        count: {
+            writable: false,
+            value: (function (counter) { return function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var level = logLevels_js_1.logLevels.debug;
+                if (shouldLog(store, level, logger.level))
+                    write({
+                        id: id,
+                        level: level,
+                        args: __spreadArray([++counter], args, true),
+                        timestamp: new Date()
+                    });
+            }; })(0)
+        },
+        on: {
+            writable: false,
+            value: function (level, logFn) {
+                var logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level) : level;
+                if (shouldLog(store, logLevel, logger.level)) {
+                    var methodName = store.logLevelStore.getName(logLevel);
+                    var bindedMethod = logger[methodName].bind(logger);
+                    var result = logFn(bindedMethod);
+                    if (result)
+                        bindedMethod(result);
+                }
+            }
+        }
+    });
+    store.logLevelStore.getAllLevels().forEach(function addMethod(_a) {
+        var name = _a.name, level = _a.level;
+        Object.defineProperty(logger, name, {
+            writable: false,
+            value: function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (shouldLog(store, level, logger.level))
+                    write({ id: id, level: level, args: args, timestamp: new Date() });
+            }
+        });
+    });
+    return logger;
+}
+exports.createLogger = createLogger;
+function validateId(id, meta) {
+    if (/[`~!#$%^&*()=+[\]{},|<>?]/.test(id))
+        throw new errors_js_1.InvalidId(id, meta);
+}
+function writeToReporters(reporters, logEntry, filter) {
+    reporters.filter(function (r) { return filter(r.id); }).forEach(function (r) { return 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, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createMemoryLogReporter = exports.toMessageWithLevel = void 0;
+var type_plus_1 = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/cjs/index.js");
+var platform_js_1 = __webpack_require__(/*! ./platform.js */ "./ts/platform.ts");
+var formatter_js_1 = __webpack_require__(/*! ./formatter.js */ "./ts/formatter.ts");
+function toMessageWithLevel(logs) {
+    return logs.map(platform_js_1.toInspectLogEntry)
+        .map(function (log) { return "".concat((0, formatter_js_1.formatLogLevel)(log.level), " ").concat(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/, '');
+}
+exports.toMessageWithLevel = toMessageWithLevel;
+function createMemoryLogReporter(options) {
+    var _a = (0, type_plus_1.required)({ id: 'memory', formatter: function (e) { return e; } }, options), id = _a.id, formatter = _a.formatter, filter = _a.filter;
+    var logs = [];
+    return Object.freeze({
+        id: id,
+        get formatter() { return formatter; },
+        get filter() { return filter; },
+        logs: logs,
+        write: function (entry) {
+            if (filter && !filter(entry))
+                return;
+            logs.push(formatter(entry));
+        },
+        getLogMessage: function () {
+            return logs.map(platform_js_1.toInspectLogEntry)
+                .map(function (log) { return log.args.join(' '); })
+                .join('\n');
+        },
+        getLogMessageWithLevel: function () { return toMessageWithLevel(logs); }
+    });
+}
+exports.createMemoryLogReporter = createMemoryLogReporter;
+
+
+/***/ }),
+
+/***/ "./ts/platform.ts":
+/*!************************!*\
+  !*** ./ts/platform.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.polyfill = exports.toInspectLogEntry = exports.isConsoleDebugAvailable = exports.semverGt = void 0;
+var util_1 = __webpack_require__(/*! util */ "../../node_modules/util/util.js");
+function semverGt(versionString, version) {
+    var actual = versionString.split('.').reverse().reduce(function (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]);
+}
+exports.semverGt = semverGt;
+// istanbul ignore next
+function isConsoleDebugAvailable() {
+    // without this, systemJs will complain `process is not defined`
+    if (!__webpack_require__.g.process)
+        return true;
+    var versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version;
+    return semverGt(versionString, [9, 3, 0]);
+}
+exports.isConsoleDebugAvailable = isConsoleDebugAvailable;
+var toInspectLogEntry = function (e) { return (e.args = e.args.map(function (value) { return typeof value === 'object' && value !== null ? (0, util_1.inspect)(value) : value; }),
+    e); };
+exports.toInspectLogEntry = toInspectLogEntry;
+exports.polyfill = {};
+
+
+/***/ }),
+
+/***/ "./ts/standardLog.ts":
+/*!***************************!*\
+  !*** ./ts/standardLog.ts ***!
+  \***************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"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 }));
+exports.suppressLogs = exports.createStandardLogForTest = exports.createStandardLog = void 0;
+var type_plus_1 = __webpack_require__(/*! type-plus */ "../../node_modules/type-plus/cjs/index.js");
+var logger_js_1 = __webpack_require__(/*! ./logger.js */ "./ts/logger.ts");
+var logLevels_js_1 = __webpack_require__(/*! ./logLevels.js */ "./ts/logLevels.ts");
+var logStore_js_1 = __webpack_require__(/*! ./logStore.js */ "./ts/logStore.ts");
+var memory_js_1 = __webpack_require__(/*! ./memory.js */ "./ts/memory.ts");
+function createStandardLog(options, _meta) {
+    var store = (0, logStore_js_1.createLogStore)((0, type_plus_1.required)({ logLevel: logLevels_js_1.logLevels.info }, options));
+    return Object.freeze({
+        get logLevel() { return store.logLevel; },
+        toLogLevelName: function (level) {
+            return store.logLevelStore.getName(level);
+        },
+        toLogLevel: function (name) {
+            return store.logLevelStore.getLevel(name);
+        },
+        getLogger: function (_a, meta) {
+            var id = _a[0], options = _a[1];
+            if (store.loggers[id])
+                return store.loggers[id];
+            var opt = (0, type_plus_1.required)({ level: store.logLevel }, options);
+            return store.loggers[id] = (0, logger_js_1.createLogger)([store, id, opt], __assign({ ssf: this.getLogger }, meta));
+        }
+    });
+}
+exports.createStandardLog = createStandardLog;
+function createStandardLogForTest(logLevel) {
+    if (logLevel === void 0) { logLevel = logLevels_js_1.logLevels.debug; }
+    var reporter = (0, memory_js_1.createMemoryLogReporter)();
+    var standardLog = createStandardLog({ reporters: [reporter], logLevel: logLevel });
+    return __assign(__assign({}, standardLog), { reporter: reporter });
+}
+exports.createStandardLogForTest = createStandardLogForTest;
+function suppressLogs(block) {
+    var logs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        logs[_i - 1] = arguments[_i];
+    }
+    var origLevels = logs.map(function (l) { return l.level; });
+    logs.forEach(function (l) { return l.level = logLevels_js_1.logLevels.none; });
+    var result = block();
+    logs.forEach(function (l, i) { return l.level = origLevels[i]; });
+    return result;
+}
+exports.suppressLogs = suppressLogs;
+
+
+/***/ }),
+
+/***/ "./ts/types.ts":
+/*!*********************!*\
+  !*** ./ts/types.ts ***!
+  \*********************/
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ "../../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/cjs/index.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/iso-error/cjs/index.js ***!
+  \*************************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+/* eslint-disable @typescript-eslint/unbound-method */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isAggregateError = exports.ModuleError = exports.IsoError = void 0;
+//#region captureStackTrace polyfill
+// istanbul ignore next
+if (!Error.captureStackTrace) {
+    Error.captureStackTrace = function (error) {
+        var 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: value,
+        writable: true,
+    });
+}
+var serializers = [];
+var deserializers = [];
+/**
+ * Isomorphic Error that works across physical boundary.
+ */
+var IsoError = /** @class */ (function (_super) {
+    __extends(IsoError, _super);
+    function IsoError(message, options) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        /**
+         * 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
+        var actualProto = _newTarget.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 === null || options === void 0 ? void 0 : options.cause)
+            _this.cause = toIsoError(options.cause);
+        if (options === null || options === void 0 ? void 0 : options.ssf)
+            Error.captureStackTrace(_this, options.ssf);
+        return _this;
+    }
+    /**
+     * Create an IsoError with additional properties without the need to create a new class.
+     * @param props properties of the IsoError
+     */
+    Object.defineProperty(IsoError, "create", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (props) {
+            var message = props.message, cause = props.cause, rest = __rest(props, ["message", "cause"]);
+            var err = new IsoError(message, { cause: cause, ssf: IsoError.create });
+            return Object.assign(err, rest);
+        }
+    });
+    Object.defineProperty(IsoError, "stringify", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (err) {
+            return this.serialize(err);
+        }
+    });
+    Object.defineProperty(IsoError, "serialize", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (err) {
+            return JSON.stringify(this.toSerializable(err));
+        }
+    });
+    /**
+     * @type P Additional properties of the IsoError
+     * @param text Json representation of a IsoError
+     */
+    Object.defineProperty(IsoError, "parse", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (text) {
+            return deserialize(IsoError.parse, text);
+        }
+    });
+    /**
+     * @type P Additional properties of the IsoError
+     * @param text Json representation of a IsoError
+     */
+    Object.defineProperty(IsoError, "deserialize", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (text) {
+            return deserialize(IsoError.deserialize, text);
+        }
+    });
+    Object.defineProperty(IsoError, "toSerializable", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (err) {
+            return serializers.reduce(function (p, s) { return p || s(err); }, undefined)
+                || toSerializableError(err);
+        }
+    });
+    Object.defineProperty(IsoError, "fromSerializable", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (json) {
+            var err = deserializeError(json);
+            Error.captureStackTrace(err, IsoError.fromSerializable);
+            return err;
+        }
+    });
+    /**
+     * returns the error message including the error causes.
+     */
+    Object.defineProperty(IsoError, "trace", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (err) {
+            return trace(err);
+        }
+    });
+    Object.defineProperty(IsoError, "addPlugin", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a) {
+            var toSerializable = _a.toSerializable, fromSerializable = _a.fromSerializable;
+            serializers.unshift(toSerializable);
+            deserializers.unshift(fromSerializable);
+        }
+    });
+    Object.defineProperty(IsoError.prototype, "toString", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () { return IsoError.serialize(this); }
+    });
+    Object.defineProperty(IsoError.prototype, "trace", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () { return IsoError.trace(this); }
+    });
+    return IsoError;
+}(Error));
+exports.IsoError = IsoError;
+function deserialize(fn, text) {
+    var json = JSON.parse(text);
+    var err = deserializeError(json);
+    Error.captureStackTrace(err, fn);
+    return err;
+}
+function deserializeError(json) {
+    var err = undefined;
+    for (var _i = 0, deserializers_1 = deserializers; _i < deserializers_1.length; _i++) {
+        var d = deserializers_1[_i];
+        err = d(json);
+        if (err)
+            break;
+    }
+    return err || defaultDeserializeError(json);
+}
+function defaultDeserializeError(json) {
+    if (json.name === 'AggregateError') {
+        var _a = json, message_1 = _a.message, errors = _a.errors, rest_1 = __rest(_a, ["message", "errors"]);
+        // @ts-ignore
+        if (__webpack_require__.g.AggregateError) {
+            return Object.assign(new AggregateError(errors, message_1), rest_1);
+        }
+        else {
+            return Object.assign(new Error(message_1), __assign(__assign({}, rest_1), { errors: errors }));
+        }
+    }
+    var _b = json, message = _b.message, cause = _b.cause, rest = __rest(_b, ["message", "cause"]);
+    var causeError = cause ? deserializeError(cause) : undefined;
+    if (json.name === 'Error') {
+        return Object.assign(new Error(message), causeError ? __assign(__assign({}, rest), { cause: causeError }) : rest);
+    }
+    // @ts-ignore
+    return Object.assign(new IsoError(message, causeError ? { cause: causeError } : undefined), rest);
+}
+function toSerializableError(err) {
+    if (isAggregateError(err)) {
+        return __assign(__assign({}, err), { name: err.constructor.name, message: err.message, errors: err.errors.map(toSerializableError) });
+    }
+    if (err instanceof Error) {
+        var message = err.message, cause = err.cause;
+        return cause
+            ? __assign(__assign({}, err), { name: err.constructor.name, message: message, cause: toSerializableError(cause) }) : __assign(__assign({}, err), { name: err.constructor.name, message: 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) {
+    var messages = [];
+    if (err instanceof ModuleError) {
+        messages.push("".concat(err.name, "(").concat(err.module, "): ").concat(err.message));
+    }
+    else if (err instanceof Error) {
+        messages.push("".concat(err.name, ": ").concat(err.message));
+    }
+    if (isAggregateError(err)) {
+        err.errors.forEach(function (e) { return messages.push.apply(messages, trace(e).split('\n').map(function (s) { return '  ' + s; })); });
+    }
+    if (err instanceof Error) {
+        if (hasCause(err))
+            messages.push.apply(messages, trace(err.cause).split('\n').map(function (s) { return '  ' + 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.
+ */
+var ModuleError = /** @class */ (function (_super) {
+    __extends(ModuleError, _super);
+    /**
+     * @param module The module that defines this error.
+     */
+    function ModuleError(module, message, options) {
+        var _this = _super.call(this, message, options) || this;
+        Object.defineProperty(_this, "module", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: module
+        });
+        return _this;
+    }
+    return ModuleError;
+}(IsoError));
+exports.ModuleError = ModuleError;
+function isAggregateError(error) {
+    return error instanceof Error && Array.isArray(error.errors);
+}
+exports.isAggregateError = isAggregateError;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../node_modules/type-plus/cjs/index.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/type-plus/cjs/index.js ***!
+  \*************************************************/
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+
+var __createBinding = (undefined && undefined.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (undefined && undefined.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredDeep = exports.required = void 0;
+var unpartial_1 = require("unpartial");
+Object.defineProperty(exports, "required", { enumerable: true, get: function () { return unpartial_1.required; } });
+Object.defineProperty(exports, "requiredDeep", { enumerable: true, get: function () { return unpartial_1.requiredDeep; } });
+__exportStar(require("./array/index.js"), exports);
+__exportStar(require("./assertion/index.js"), exports);
+__exportStar(require("./class/index.js"), exports);
+__exportStar(require("./function/index.js"), exports);
+__exportStar(require("./functional/index.js"), exports);
+__exportStar(require("./JSONTypes.js"), exports);
+__exportStar(require("./math/index.js"), exports);
+__exportStar(require("./nodejs/index.js"), exports);
+__exportStar(require("./nominal-types/index.js"), exports);
+__exportStar(require("./object/index.js"), exports);
+__exportStar(require("./predicates/index.js"), exports);
+__exportStar(require("./promise/index.js"), exports);
+__exportStar(require("./testing/index.js"), exports);
+__exportStar(require("./utils/index.js"), exports);
+//# sourceMappingURL=index.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].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* 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/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 });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./ts/index.ts");
+/******/ 	StandardLog = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+//# sourceMappingURL=standard-log.es5.js.map