standard-log 12.1.2 → 13.0.1

package/dist/standard-log.iife.js

@@ -0,0 +1,952 @@
+var StandardLog = (function(exports) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	//#region ../../node_modules/.pnpm/unpartial@1.0.5/node_modules/unpartial/esm/index.js
+	function required(source1, source2, source3) {
+		return merge([
+			source1,
+			source2,
+			source3
+		], (p, e) => {
+			return {
+				...p,
+				...e
+			};
+		});
+	}
+	function merge(entries, reducer) {
+		if (entries[0] === void 0 || entries[0] === null) return entries[0];
+		return entries.filter((x) => !!x).reduce(reducer, {});
+	}
+	function unpartial(s1, s2, s3) {
+		if (s1 === void 0 || s1 === null) return s1;
+		return [
+			s1,
+			s2,
+			s3
+		].filter(notNil).reduce((p, s) => ({
+			...p,
+			...trimNilProps(s)
+		}), {});
+	}
+	function trimNilProps(value) {
+		return Object.keys(value).reduce((p, k) => {
+			if (notNil(value[k])) p[k] = value[k];
+			return p;
+		}, {});
+	}
+	function notNil(value) {
+		return value !== null && value !== void 0;
+	}
+	//#endregion
+	//#region ../../node_modules/.pnpm/type-plus@7.6.2/node_modules/type-plus/esm/object/mapKey.js
+	function mapKey(subject, predicate, thisArg) {
+		return Object.keys(subject).map(function(k, i, a) {
+			return predicate.apply(this, [
+				k,
+				i,
+				a,
+				subject
+			]);
+		}, thisArg);
+	}
+	//#endregion
+	//#region ../../node_modules/.pnpm/type-plus@7.6.2/node_modules/type-plus/esm/object/reduceKey.js
+	function reduceByKey(subject, callbackfn, initialValue) {
+		return Object.keys(subject).reduce((p, k, i, a) => callbackfn(p, k, i, a, subject), initialValue);
+	}
+	/**
+	* @deprecated renamed to reduceByKey
+	*/
+	const reduceKey = reduceByKey;
+	//#endregion
+	//#region ../../node_modules/.pnpm/type-plus@7.6.2/node_modules/type-plus/esm/object/record.js
+	function record(value) {
+		const r = Object.create(null);
+		return value ? Object.assign(r, value) : r;
+	}
+	//#endregion
+	//#region ts/log_levels.ts
+	var import_ms = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+		/**
+		* Helpers.
+		*/
+		var s = 1e3;
+		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]);
+			switch ((match[2] || "ms").toLowerCase()) {
+				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;
+			}
+		}
+		/**
+		* 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" : "");
+		}
+	})))(), 1);
+	const logLevels = {
+		/**
+		* none: 0
+		*/
+		none: 0,
+		/**
+		* emergency: 100
+		*
+		* emergency -> alert
+		*/
+		emergency: 100,
+		/**
+		* alert: 200
+		*
+		* emergency -> alert -> critical
+		*/
+		alert: 200,
+		/**
+		* critical: 300
+		*
+		* alert -> critical -> error
+		*/
+		critical: 300,
+		/**
+		* error: 400
+		*
+		* critical -> error -> warn
+		*/
+		error: 400,
+		/**
+		* warn: 500
+		*
+		* error -> warn -> notice
+		*/
+		warn: 500,
+		/**
+		* notice: 600
+		*
+		* warn -> notice -> info
+		*/
+		notice: 600,
+		/**
+		* info: 700
+		*
+		* notice -> info -> debug
+		*/
+		info: 700,
+		/**
+		* debug: 800
+		*
+		* info -> debug -> trace
+		*/
+		debug: 800,
+		/**
+		* trace: 900
+		*
+		* debug -> trace -> planck
+		*/
+		trace: 900,
+		/**
+		* planck: Infinity
+		* `planck unit` is a very small unit <https://en.wikipedia.org/wiki/Planck_units>.
+		*
+		* trace -> planck
+		*/
+		planck: Number.POSITIVE_INFINITY,
+		/**
+		* all: Infinity
+		*/
+		all: Number.POSITIVE_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()];
+	}
+	const DEFAULT_LOG_METHOD_NAMES = [
+		"emergency",
+		"alert",
+		"critical",
+		"error",
+		"warn",
+		"notice",
+		"info",
+		"debug",
+		"trace",
+		"planck"
+	];
+	//#endregion
+	//#region ts/formatter.ts
+	function createTimestampFormatter(format) {
+		switch (format) {
+			case "none": return (_timestamp) => void 0;
+			case "iso": return (timestamp) => timestamp.toISOString();
+			case "elapsed": {
+				let lastTick;
+				return (timestamp) => {
+					const newTick = timestamp.getTime();
+					const result = (0, import_ms.default)(lastTick === void 0 ? 0 : newTick - lastTick);
+					lastTick = newTick;
+					return result;
+				};
+			}
+		}
+	}
+	function formatLogLevel(level) {
+		return `(${toLogLevelName(level).toUpperCase()})`;
+	}
+	/**
+	* Formats log entry as plain text with the following format:
+	* `timestamp id level ...args`
+	*
+	* This is typically useful for writing logs to file
+	*/
+	function plainLogFormatter({ id, level, args, timestamp }) {
+		return [
+			timestamp.toISOString(),
+			id,
+			formatLogLevel(level),
+			...args
+		];
+	}
+	/**
+	* Formats log entry like default console log.
+	*/
+	function consoleFormatter({ args }) {
+		return args;
+	}
+	//#endregion
+	//#region ts/platform.browser.ts
+	const toInspectLogEntry = (e) => e;
+	const polyfill = record();
+	//#endregion
+	//#region ts/console.ts
+	function toConsoleMethod(level) {
+		switch (true) {
+			case level <= 0: return "debug";
+			case level <= logLevels.error: return "error";
+			case level <= logLevels.warn: return "warn";
+			case level <= logLevels.info: return "info";
+			default: return "debug";
+		}
+	}
+	// istanbul ignore next
+	function buildPolyfillConsole() {
+		if (!!console.log.bind) return {
+			debug: (typeof console.info === "function" ? console.debug : console.log).bind(console),
+			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)
+		};
+		return {
+			debug: buildFn(typeof console.debug === "function" ? "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 (...args) => {
+			console[name](...args);
+		};
+	}
+	function createConsoleLogReporter(options) {
+		const { id, formatter, filter } = unpartial({
+			id: "console",
+			formatter: consoleFormatter
+		}, options);
+		if (!polyfill.console) polyfill.console = buildPolyfillConsole();
+		return Object.freeze({
+			id,
+			isConsoleReporter: true,
+			get formatter() {
+				return formatter;
+			},
+			get filter() {
+				return filter;
+			},
+			console: polyfill.console,
+			write(entry) {
+				if (filter && !filter(entry)) return;
+				const values = formatter(entry);
+				const method = toConsoleMethod(entry.level);
+				this.console[method](...values);
+			}
+		});
+	}
+	//#endregion
+	//#region ../../node_modules/.pnpm/iso-error@6.0.3/node_modules/iso-error/esm/index.js
+	var __classPrivateFieldGet = function(receiver, state, kind, f) {
+		if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+		if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+		return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var _a;
+	var _IsoError_hasCause;
+	var _IsoError_toIsoError;
+	// istanbul ignore next
+	if (!Error.captureStackTrace) Error.captureStackTrace = function(error) {
+		const container = /* @__PURE__ */ new Error();
+		Object.defineProperty(error, "stack", {
+			configurable: true,
+			get: function() {
+				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
+		});
+	}
+	var SerializableConverter = class {
+		constructor() {
+			Object.defineProperty(this, "plugins", {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: []
+			});
+		}
+		addPlugin(plugin) {
+			this.plugins.unshift(plugin);
+		}
+		/**
+		* Deserialize an `Error` from `Serializable`
+		*/
+		fromSerializable(json, options) {
+			const err = this.deserializeError(json);
+			Error.captureStackTrace(err, options?.ssf);
+			return err;
+		}
+		fromSerializableImpl(json) {
+			if (json["name"] === "AggregateError") {
+				const { message, errors, ...rest } = json;
+				// istanbul ignore next
+				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 ? this.deserializeError(cause) : void 0;
+			if (json["name"] === "Error") return Object.assign(new Error(message), causeError ? {
+				...rest,
+				cause: causeError
+			} : rest);
+			return Object.assign(new IsoError(message, causeError ? { cause: causeError } : void 0), rest);
+		}
+		deserializeError(json) {
+			let err = void 0;
+			for (const { fromSerializable } of this.plugins) {
+				err = fromSerializable(json);
+				if (err) break;
+			}
+			return err || this.fromSerializableImpl(json);
+		}
+		/**
+		* Serialize `Error` to `Serializable`
+		*/
+		toSerializable(err) {
+			return this.plugins.reduce((p, s) => p || s.toSerializable(err), void 0) || this.toSerializableImpl(err);
+		}
+		toSerializableImpl(err) {
+			if (isAggregateError(err)) return {
+				...err,
+				name: err.constructor.name,
+				message: err.message,
+				errors: err.errors.map(this.toSerializableImpl)
+			};
+			if (err instanceof Error) {
+				const { message, cause } = err;
+				return cause ? {
+					...err,
+					name: err.constructor.name,
+					message,
+					cause: this.toSerializableImpl(cause)
+				} : {
+					...err,
+					name: err.constructor.name,
+					message
+				};
+			}
+			return err;
+		}
+	};
+	const getCircularReplacer = () => {
+		const seen = /* @__PURE__ */ new WeakSet();
+		return (_, value) => {
+			if (typeof value === "object" && value !== null) {
+				if (seen.has(value)) return;
+				seen.add(value);
+			}
+			return value;
+		};
+	};
+	/**
+	* Isomorphic Error that works across physical boundary.
+	*/
+	var IsoError = class IsoError extends Error {
+		/**
+		* 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), getCircularReplacer());
+		}
+		static toSerializable(err) {
+			return this.converter.toSerializable(err);
+		}
+		/**
+		* @type P Additional properties of the IsoError
+		* @param text Json representation of a IsoError
+		*/
+		static parse(text) {
+			const json = JSON.parse(text);
+			return this.converter.fromSerializable(json, { ssf: IsoError.parse });
+		}
+		/**
+		* @type P Additional properties of the IsoError
+		* @param text Json representation of a IsoError
+		*/
+		static deserialize(text) {
+			const json = JSON.parse(text);
+			return this.converter.fromSerializable(json, { ssf: IsoError.deserialize });
+		}
+		static fromSerializable(json) {
+			return this.converter.fromSerializable(json, { ssf: IsoError.fromSerializable });
+		}
+		/**
+		* returns the error message including the error causes.
+		*/
+		static 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(...this.trace(e).split("\n").map((s) => "  " + s)));
+			if (err instanceof Error) {
+				if (__classPrivateFieldGet(this, _a, "m", _IsoError_hasCause).call(this, err)) messages.push(...this.trace(err.cause).split("\n").map((s) => "  " + s));
+			} else messages.push(typeof err === "string" ? err : JSON.stringify(err));
+			return messages.join("\n");
+		}
+		static addPlugin(plugin) {
+			this.converter.addPlugin(plugin);
+		}
+		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
+			});
+			const actualProto = new.target.prototype;
+			this.name = actualProto.constructor.name;
+			// istanbul ignore next
+			if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
+			else this.__proto__ = actualProto;
+			if (options?.cause) this.cause = __classPrivateFieldGet(IsoError, _a, "m", _IsoError_toIsoError).call(IsoError, options.cause);
+			if (options?.ssf) Error.captureStackTrace(this, options.ssf);
+		}
+		toString() {
+			return IsoError.serialize(this);
+		}
+		trace() {
+			return IsoError.trace(this);
+		}
+	};
+	_a = IsoError, _IsoError_hasCause = function _IsoError_hasCause(x) {
+		return !!x.cause;
+	}, _IsoError_toIsoError = function _IsoError_toIsoError(err) {
+		return Object.assign(err, { name: err.name ?? err.constructor.name });
+	};
+	Object.defineProperty(IsoError, "converter", {
+		enumerable: true,
+		configurable: true,
+		writable: true,
+		value: new SerializableConverter()
+	});
+	/**
+	* An IsoError with a module property.
+	*/
+	var ModuleError = class 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);
+	}
+	//#endregion
+	//#region ts/errors.ts
+	/**
+	* @deprecated No longer used since 11.2.0
+	*/
+	var StandardLogError = class extends ModuleError {
+		constructor(description, options) {
+			super("standard-log", description, options);
+		}
+	};
+	/**
+	* @deprecated no longer used since 11.2.0
+	*/
+	var InvalidId = class extends StandardLogError {
+		id;
+		constructor(id, options) {
+			super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options);
+			this.id = id;
+		}
+	};
+	//#endregion
+	//#region ts/memory.ts
+	function toMessageWithLevel(logs) {
+		return logs.map(toInspectLogEntry).map((log) => `${formatLogLevel(log.level)} ${log.args.join(" ")}`).join("\n").replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, "");
+	}
+	function createMemoryLogReporter(options) {
+		return Object.freeze(buildMemoryReporter(unpartial({ id: "memory" }, options)));
+	}
+	function buildMemoryReporter(options) {
+		const { id, formatter, filter } = required({
+			id: "memory",
+			formatter: (e) => e
+		}, options);
+		const logs = [];
+		return {
+			id,
+			get formatter() {
+				return formatter;
+			},
+			get filter() {
+				return filter;
+			},
+			logs,
+			write(entry) {
+				if (filter && !filter(entry)) return;
+				logs.push(formatter(entry));
+			},
+			getLogMessage() {
+				return this.getLogMessages().join("\n");
+			},
+			getLogMessages() {
+				return logs.map(toInspectLogEntry).map((log) => log.args.join(" "));
+			},
+			getLogMessagesWithLevel() {
+				return logs.map(toInspectLogEntry).map((log) => `${formatLogLevel(log.level)} ${log.args.join(" ")}`);
+			},
+			getLogMessagesWithIdAndLevel() {
+				return logs.map(toInspectLogEntry).map((log) => `${log.id} ${formatLogLevel(log.level)} ${log.args.join(" ")}`);
+			},
+			getLogMessageWithLevel() {
+				return toMessageWithLevel(logs);
+			},
+			/**
+			* emit the saved log to console for easy debugging
+			*/
+			emit() {
+				const reporter = createConsoleLogReporter();
+				logs.forEach((l) => reporter.write(l));
+			}
+		};
+	}
+	function createMemoryWithConsoleLogReporter(options) {
+		return Object.freeze(Object.assign(buildMemoryReporter(unpartial({ id: "memory-with-console" }, options)), { isConsoleReporter: true }));
+	}
+	//#endregion
+	//#region ts/log_store.ts
+	function createLogStore(options) {
+		return {
+			loggers: record(),
+			nonConsoleLoggers: record(),
+			reporters: options.reporters || [createConsoleLogReporter()],
+			logLevel: options.logLevel,
+			logLevelStore: logLevelStore(options)
+		};
+	}
+	function logLevelStore(options) {
+		const customLevels = options.customLevels || record();
+		const store = {
+			customLevels,
+			customLevelsReverse: reduceByKey(customLevels, (p, k) => {
+				p[customLevels[k]] = k;
+				return p;
+			}, {})
+		};
+		return {
+			getName(level) {
+				return store.customLevelsReverse[level] ?? toLogLevelName(level);
+			},
+			getLevel(name) {
+				return store.customLevels[name] ?? toLogLevel(name);
+			},
+			getAllLevels() {
+				return reduceKey(logLevels, (result, name) => {
+					if (name !== "none" && name !== "all") result.push({
+						name,
+						level: logLevels[name]
+					});
+					return result;
+				}, mapKey(store.customLevels, (name) => ({
+					name,
+					level: store.customLevels[name]
+				})));
+			}
+		};
+	}
+	//#endregion
+	//#region ts/logger.ts
+	function createLogger(store, id, options) {
+		id = sanitizeId(id);
+		const writeTo = options?.writeTo ?? (() => true);
+		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: options?.level,
+			write
+		};
+		Object.defineProperties(logger, {
+			id: {
+				value: id,
+				writable: false
+			},
+			count: {
+				writable: false,
+				value: ((counter) => (...args) => {
+					if (shouldLog(store, logLevels.debug, logger.level)) write({
+						id,
+						level: logLevels.debug,
+						args: [++counter, ...args],
+						timestamp: /* @__PURE__ */ 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, logger.level ?? store.logLevel);
+						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: /* @__PURE__ */ new Date()
+					});
+				}
+			});
+		});
+		return logger;
+	}
+	function sanitizeId(id) {
+		return id.replace(/[`~!#$%^&*()=+[\]{},|<>?]/g, "-");
+	}
+	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 !== void 0 ? loggerLevel : store.logLevel);
+	}
+	//#endregion
+	//#region ts/standard_log.ctx.ts
+	const ctx = record();
+	//#endregion
+	//#region ts/standard_log.ts
+	function createStandardLog(options) {
+		const closure = createStandardLogClosure(options);
+		if (options?.reporters?.some((r) => !r.id)) closure.standardLog.getLogger("standard-log").critical(`Detected reporter with empty id. This is not allowed as it will create problems with feature like 'getNonConsoleLogger()'. Please add an id to your reporter.`);
+		if (!ctx.gsl) ctx.gsl = closure;
+		return closure.standardLog;
+	}
+	function noop() {}
+	function createStandardLogClosure(options) {
+		const store = createLogStore(required({ logLevel: logLevels.info }, options));
+		const nonConsoleReporters = options?.reporters?.filter((r) => !r.isConsoleReporter).map((r) => r.id) ?? [];
+		const logMethods = DEFAULT_LOG_METHOD_NAMES.concat(Object.keys(options?.customLevels ?? {})).concat([
+			"on",
+			"count",
+			"write"
+		]);
+		return {
+			store,
+			standardLog: {
+				get logLevel() {
+					return store.logLevel;
+				},
+				toLogLevelName(level) {
+					return store.logLevelStore.getName(level);
+				},
+				toLogLevel(name) {
+					return store.logLevelStore.getLevel(name);
+				},
+				getLogger(id, options) {
+					if (store.loggers[id]) return store.loggers[id];
+					return store.loggers[id] = createLogger(store, id, {
+						ssf: this.getLogger,
+						...options
+					});
+				},
+				getNonConsoleLogger(id, options) {
+					if (store.nonConsoleLoggers[id]) return store.nonConsoleLoggers[id];
+					if (store.loggers[id]) {
+						this.getLogger("standard-log").warn(`attempt to create a non-console logger with existing id ('${id}'), ignoring`);
+						return store.nonConsoleLoggers[id] = createDummyLogger(logMethods);
+					}
+					return store.nonConsoleLoggers[id] = nonConsoleReporters.length === 0 ? createDummyLogger(logMethods) : createLogger(store, id, {
+						ssf: this.getNonConsoleLogger,
+						...options,
+						writeTo(reporterId) {
+							return nonConsoleReporters.indexOf(reporterId) >= 0;
+						}
+					});
+				}
+			}
+		};
+	}
+	function createDummyLogger(logMethods) {
+		return logMethods.reduce((p, m) => {
+			p[m] = noop;
+			return p;
+		}, record());
+	}
+	function suppressLogs(block, ...logs) {
+		const origLevels = logs.map((l) => l.level);
+		logs.forEach((l) => l.level = logLevels.none);
+		const result = block();
+		logs.forEach((l, i) => l.level = origLevels[i]);
+		return result;
+	}
+	function getLogger(id, options) {
+		return getGlobalSL().getLogger(id, options);
+	}
+	function getGlobalSL() {
+		if (!ctx.gsl) ctx.gsl = createStandardLogClosure();
+		return ctx.gsl.standardLog;
+	}
+	function configGlobal(options) {
+		if (ctx.configured) ctx.gsl.standardLog.getLogger("standard-log").warn("configGlobal() is being called more than once. Please make sure this is expected. Application should use `createStandardLog()` most of the time.");
+		if (ctx.gsl) {
+			if (options.logLevel) ctx.gsl.store.logLevel = options.logLevel;
+			if (options.reporters) {
+				const reporters = ctx.gsl.store.reporters;
+				reporters.length = 0;
+				reporters.push(...options.reporters);
+			}
+		} else ctx.gsl = createStandardLogClosure(options);
+		ctx.configured = true;
+	}
+	//#endregion
+	exports.DEFAULT_LOG_METHOD_NAMES = DEFAULT_LOG_METHOD_NAMES;
+	exports.InvalidId = InvalidId;
+	exports.StandardLogError = StandardLogError;
+	exports.configGlobal = configGlobal;
+	exports.consoleFormatter = consoleFormatter;
+	exports.createConsoleLogReporter = createConsoleLogReporter;
+	exports.createMemoryLogReporter = createMemoryLogReporter;
+	exports.createMemoryWithConsoleLogReporter = createMemoryWithConsoleLogReporter;
+	exports.createStandardLog = createStandardLog;
+	exports.createTimestampFormatter = createTimestampFormatter;
+	exports.formatLogLevel = formatLogLevel;
+	exports.getLogger = getLogger;
+	exports.logLevels = logLevels;
+	exports.plainLogFormatter = plainLogFormatter;
+	exports.suppressLogs = suppressLogs;
+	exports.toConsoleMethod = toConsoleMethod;
+	exports.toLogLevel = toLogLevel;
+	exports.toLogLevelName = toLogLevelName;
+	exports.toMessageWithLevel = toMessageWithLevel;
+	return exports;
+})({});
+
+//# sourceMappingURL=standard-log.iife.js.map