likec4 1.47.0 → 1.48.0

package/dist/_chunks/libs/@logtape/logtape.mjs

@@ -0,0 +1,1354 @@
+import { r as __exportAll } from "../../rolldown-runtime.mjs";
+import util from "node:util";
+
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/filter.js
+/**
+* Converts a {@link FilterLike} value to an actual {@link Filter}.
+*
+* @param filter The filter-like value to convert.
+* @returns The actual filter.
+*/
+function toFilter(filter) {
+	if (typeof filter === "function") return filter;
+	return getLevelFilter(filter);
+}
+/**
+* Returns a filter that accepts log records with the specified level.
+*
+* @param level The level to filter by.  If `null`, the filter will reject all
+*              records.
+* @returns The filter.
+*/
+function getLevelFilter(level) {
+	if (level == null) return () => false;
+	if (level === "fatal") return (record) => record.level === "fatal";
+	else if (level === "error") return (record) => record.level === "fatal" || record.level === "error";
+	else if (level === "warning") return (record) => record.level === "fatal" || record.level === "error" || record.level === "warning";
+	else if (level === "info") return (record) => record.level === "fatal" || record.level === "error" || record.level === "warning" || record.level === "info";
+	else if (level === "debug") return (record) => record.level === "fatal" || record.level === "error" || record.level === "warning" || record.level === "info" || record.level === "debug";
+	else if (level === "trace") return () => true;
+	throw new TypeError(`Invalid log level: ${level}.`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/level.js
+const logLevels = [
+	"trace",
+	"debug",
+	"info",
+	"warning",
+	"error",
+	"fatal"
+];
+/**
+* Compares two log levels.
+* @param a The first log level.
+* @param b The second log level.
+* @returns A negative number if `a` is less than `b`, a positive number if `a`
+*          is greater than `b`, or zero if they are equal.
+* @since 0.8.0
+*/
+function compareLogLevel(a, b) {
+	const aIndex = logLevels.indexOf(a);
+	if (aIndex < 0) throw new TypeError(`Invalid log level: ${JSON.stringify(a)}.`);
+	const bIndex = logLevels.indexOf(b);
+	if (bIndex < 0) throw new TypeError(`Invalid log level: ${JSON.stringify(b)}.`);
+	return aIndex - bIndex;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/logger.js
+/**
+* Get a logger with the given category.
+*
+* ```typescript
+* const logger = getLogger(["my-app"]);
+* ```
+*
+* @param category The category of the logger.  It can be a string or an array
+*                 of strings.  If it is a string, it is equivalent to an array
+*                 with a single element.
+* @returns The logger.
+*/
+function getLogger(category = []) {
+	return LoggerImpl.getLogger(category);
+}
+/**
+* The symbol for the global root logger.
+*/
+const globalRootLoggerSymbol = Symbol.for("logtape.rootLogger");
+/**
+* A logger implementation.  Do not use this directly; use {@link getLogger}
+* instead.  This class is exported for testing purposes.
+*/
+var LoggerImpl = class LoggerImpl {
+	parent;
+	children;
+	category;
+	sinks;
+	parentSinks = "inherit";
+	filters;
+	lowestLevel = "trace";
+	contextLocalStorage;
+	static getLogger(category = []) {
+		let rootLogger = globalRootLoggerSymbol in globalThis ? globalThis[globalRootLoggerSymbol] ?? null : null;
+		if (rootLogger == null) {
+			rootLogger = new LoggerImpl(null, []);
+			globalThis[globalRootLoggerSymbol] = rootLogger;
+		}
+		if (typeof category === "string") return rootLogger.getChild(category);
+		if (category.length === 0) return rootLogger;
+		return rootLogger.getChild(category);
+	}
+	constructor(parent, category) {
+		this.parent = parent;
+		this.children = {};
+		this.category = category;
+		this.sinks = [];
+		this.filters = [];
+	}
+	getChild(subcategory) {
+		const name = typeof subcategory === "string" ? subcategory : subcategory[0];
+		const childRef = this.children[name];
+		let child = childRef instanceof LoggerImpl ? childRef : childRef?.deref();
+		if (child == null) {
+			child = new LoggerImpl(this, [...this.category, name]);
+			this.children[name] = "WeakRef" in globalThis ? new WeakRef(child) : child;
+		}
+		if (typeof subcategory === "string" || subcategory.length === 1) return child;
+		return child.getChild(subcategory.slice(1));
+	}
+	/**
+	* Reset the logger.  This removes all sinks and filters from the logger.
+	*/
+	reset() {
+		while (this.sinks.length > 0) this.sinks.shift();
+		this.parentSinks = "inherit";
+		while (this.filters.length > 0) this.filters.shift();
+		this.lowestLevel = "trace";
+	}
+	/**
+	* Reset the logger and all its descendants.  This removes all sinks and
+	* filters from the logger and all its descendants.
+	*/
+	resetDescendants() {
+		for (const child of Object.values(this.children)) {
+			const logger = child instanceof LoggerImpl ? child : child.deref();
+			if (logger != null) logger.resetDescendants();
+		}
+		this.reset();
+	}
+	with(properties) {
+		return new LoggerCtx(this, { ...properties });
+	}
+	filter(record) {
+		for (const filter of this.filters) if (!filter(record)) return false;
+		if (this.filters.length < 1) return this.parent?.filter(record) ?? true;
+		return true;
+	}
+	*getSinks(level) {
+		if (this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0) return;
+		if (this.parent != null && this.parentSinks === "inherit") for (const sink of this.parent.getSinks(level)) yield sink;
+		for (const sink of this.sinks) yield sink;
+	}
+	emit(record, bypassSinks) {
+		const categoryPrefix = getCategoryPrefix();
+		const baseCategory = "category" in record ? record.category : this.category;
+		const fullCategory = categoryPrefix.length > 0 ? [...categoryPrefix, ...baseCategory] : baseCategory;
+		const descriptors = Object.getOwnPropertyDescriptors(record);
+		descriptors.category = {
+			value: fullCategory,
+			enumerable: true,
+			configurable: true
+		};
+		const fullRecord = Object.defineProperties({}, descriptors);
+		if (this.lowestLevel === null || compareLogLevel(fullRecord.level, this.lowestLevel) < 0 || !this.filter(fullRecord)) return;
+		for (const sink of this.getSinks(fullRecord.level)) {
+			if (bypassSinks?.has(sink)) continue;
+			try {
+				sink(fullRecord);
+			} catch (error) {
+				const bypassSinks2 = new Set(bypassSinks);
+				bypassSinks2.add(sink);
+				metaLogger.log("fatal", "Failed to emit a log record to sink {sink}: {error}", {
+					sink,
+					error,
+					record: fullRecord
+				}, bypassSinks2);
+			}
+		}
+	}
+	log(level, rawMessage, properties, bypassSinks) {
+		const implicitContext = getImplicitContext();
+		let cachedProps = void 0;
+		const record = typeof properties === "function" ? {
+			category: this.category,
+			level,
+			timestamp: Date.now(),
+			get message() {
+				return parseMessageTemplate(rawMessage, this.properties);
+			},
+			rawMessage,
+			get properties() {
+				if (cachedProps == null) cachedProps = {
+					...implicitContext,
+					...properties()
+				};
+				return cachedProps;
+			}
+		} : {
+			category: this.category,
+			level,
+			timestamp: Date.now(),
+			message: parseMessageTemplate(rawMessage, {
+				...implicitContext,
+				...properties
+			}),
+			rawMessage,
+			properties: {
+				...implicitContext,
+				...properties
+			}
+		};
+		this.emit(record, bypassSinks);
+	}
+	logLazily(level, callback, properties = {}) {
+		const implicitContext = getImplicitContext();
+		let rawMessage = void 0;
+		let msg = void 0;
+		function realizeMessage() {
+			if (msg == null || rawMessage == null) {
+				msg = callback((tpl, ...values) => {
+					rawMessage = tpl;
+					return renderMessage(tpl, values);
+				});
+				if (rawMessage == null) throw new TypeError("No log record was made.");
+			}
+			return [msg, rawMessage];
+		}
+		this.emit({
+			category: this.category,
+			level,
+			get message() {
+				return realizeMessage()[0];
+			},
+			get rawMessage() {
+				return realizeMessage()[1];
+			},
+			timestamp: Date.now(),
+			properties: {
+				...implicitContext,
+				...properties
+			}
+		});
+	}
+	logTemplate(level, messageTemplate, values, properties = {}) {
+		const implicitContext = getImplicitContext();
+		this.emit({
+			category: this.category,
+			level,
+			message: renderMessage(messageTemplate, values),
+			rawMessage: messageTemplate,
+			timestamp: Date.now(),
+			properties: {
+				...implicitContext,
+				...properties
+			}
+		});
+	}
+	trace(message, ...values) {
+		if (typeof message === "string") this.log("trace", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("trace", message);
+		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
+		else this.logTemplate("trace", message, values);
+	}
+	debug(message, ...values) {
+		if (typeof message === "string") this.log("debug", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("debug", message);
+		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
+		else this.logTemplate("debug", message, values);
+	}
+	info(message, ...values) {
+		if (typeof message === "string") this.log("info", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("info", message);
+		else if (!Array.isArray(message)) this.log("info", "{*}", message);
+		else this.logTemplate("info", message, values);
+	}
+	warn(message, ...values) {
+		if (typeof message === "string") this.log("warning", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
+		else this.logTemplate("warning", message, values);
+	}
+	warning(message, ...values) {
+		this.warn(message, ...values);
+	}
+	error(message, ...values) {
+		if (typeof message === "string") this.log("error", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("error", message);
+		else if (!Array.isArray(message)) this.log("error", "{*}", message);
+		else this.logTemplate("error", message, values);
+	}
+	fatal(message, ...values) {
+		if (typeof message === "string") this.log("fatal", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
+		else this.logTemplate("fatal", message, values);
+	}
+};
+/**
+* A logger implementation with contextual properties.  Do not use this
+* directly; use {@link Logger.with} instead.  This class is exported
+* for testing purposes.
+*/
+var LoggerCtx = class LoggerCtx {
+	logger;
+	properties;
+	constructor(logger, properties) {
+		this.logger = logger;
+		this.properties = properties;
+	}
+	get category() {
+		return this.logger.category;
+	}
+	get parent() {
+		return this.logger.parent;
+	}
+	getChild(subcategory) {
+		return this.logger.getChild(subcategory).with(this.properties);
+	}
+	with(properties) {
+		return new LoggerCtx(this.logger, {
+			...this.properties,
+			...properties
+		});
+	}
+	log(level, message, properties, bypassSinks) {
+		this.logger.log(level, message, typeof properties === "function" ? () => ({
+			...this.properties,
+			...properties()
+		}) : {
+			...this.properties,
+			...properties
+		}, bypassSinks);
+	}
+	logLazily(level, callback) {
+		this.logger.logLazily(level, callback, this.properties);
+	}
+	logTemplate(level, messageTemplate, values) {
+		this.logger.logTemplate(level, messageTemplate, values, this.properties);
+	}
+	emit(record) {
+		const recordWithContext = {
+			...record,
+			properties: {
+				...this.properties,
+				...record.properties
+			}
+		};
+		this.logger.emit(recordWithContext);
+	}
+	trace(message, ...values) {
+		if (typeof message === "string") this.log("trace", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("trace", message);
+		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
+		else this.logTemplate("trace", message, values);
+	}
+	debug(message, ...values) {
+		if (typeof message === "string") this.log("debug", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("debug", message);
+		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
+		else this.logTemplate("debug", message, values);
+	}
+	info(message, ...values) {
+		if (typeof message === "string") this.log("info", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("info", message);
+		else if (!Array.isArray(message)) this.log("info", "{*}", message);
+		else this.logTemplate("info", message, values);
+	}
+	warn(message, ...values) {
+		if (typeof message === "string") this.log("warning", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("warning", message);
+		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
+		else this.logTemplate("warning", message, values);
+	}
+	warning(message, ...values) {
+		this.warn(message, ...values);
+	}
+	error(message, ...values) {
+		if (typeof message === "string") this.log("error", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("error", message);
+		else if (!Array.isArray(message)) this.log("error", "{*}", message);
+		else this.logTemplate("error", message, values);
+	}
+	fatal(message, ...values) {
+		if (typeof message === "string") this.log("fatal", message, values[0] ?? {});
+		else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
+		else this.logTemplate("fatal", message, values);
+	}
+};
+/**
+* The meta logger.  It is a logger with the category `["logtape", "meta"]`.
+*/
+const metaLogger = LoggerImpl.getLogger(["logtape", "meta"]);
+/**
+* Check if a property access key contains nested access patterns.
+* @param key The property key to check.
+* @returns True if the key contains nested access patterns.
+*/
+function isNestedAccess(key) {
+	return key.includes(".") || key.includes("[") || key.includes("?.");
+}
+/**
+* Safely access an own property from an object, blocking prototype pollution.
+*
+* @param obj The object to access the property from.
+* @param key The property key to access.
+* @returns The property value or undefined if not accessible.
+*/
+function getOwnProperty(obj, key) {
+	if (key === "__proto__" || key === "prototype" || key === "constructor") return void 0;
+	if ((typeof obj === "object" || typeof obj === "function") && obj !== null) return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+}
+/**
+* Parse the next segment from a property path string.
+*
+* @param path The full property path string.
+* @param fromIndex The index to start parsing from.
+* @returns The parsed segment and next index, or null if parsing fails.
+*/
+function parseNextSegment(path, fromIndex) {
+	const len = path.length;
+	let i = fromIndex;
+	if (i >= len) return null;
+	let segment;
+	if (path[i] === "[") {
+		i++;
+		if (i >= len) return null;
+		if (path[i] === "\"" || path[i] === "'") {
+			const quote = path[i];
+			i++;
+			let segmentStr = "";
+			while (i < len && path[i] !== quote) if (path[i] === "\\") {
+				i++;
+				if (i < len) {
+					const escapeChar = path[i];
+					switch (escapeChar) {
+						case "n":
+							segmentStr += "\n";
+							break;
+						case "t":
+							segmentStr += "	";
+							break;
+						case "r":
+							segmentStr += "\r";
+							break;
+						case "b":
+							segmentStr += "\b";
+							break;
+						case "f":
+							segmentStr += "\f";
+							break;
+						case "v":
+							segmentStr += "\v";
+							break;
+						case "0":
+							segmentStr += "\0";
+							break;
+						case "\\":
+							segmentStr += "\\";
+							break;
+						case "\"":
+							segmentStr += "\"";
+							break;
+						case "'":
+							segmentStr += "'";
+							break;
+						case "u":
+							if (i + 4 < len) {
+								const hex = path.slice(i + 1, i + 5);
+								const codePoint = Number.parseInt(hex, 16);
+								if (!Number.isNaN(codePoint)) {
+									segmentStr += String.fromCharCode(codePoint);
+									i += 4;
+								} else segmentStr += escapeChar;
+							} else segmentStr += escapeChar;
+							break;
+						default: segmentStr += escapeChar;
+					}
+					i++;
+				}
+			} else {
+				segmentStr += path[i];
+				i++;
+			}
+			if (i >= len) return null;
+			segment = segmentStr;
+			i++;
+		} else {
+			const startIndex = i;
+			while (i < len && path[i] !== "]" && path[i] !== "'" && path[i] !== "\"") i++;
+			if (i >= len) return null;
+			const indexStr = path.slice(startIndex, i);
+			if (indexStr.length === 0) return null;
+			const indexNum = Number(indexStr);
+			segment = Number.isNaN(indexNum) ? indexStr : indexNum;
+		}
+		while (i < len && path[i] !== "]") i++;
+		if (i < len) i++;
+	} else {
+		const startIndex = i;
+		while (i < len && path[i] !== "." && path[i] !== "[" && path[i] !== "?" && path[i] !== "]") i++;
+		segment = path.slice(startIndex, i);
+		if (segment.length === 0) return null;
+	}
+	if (i < len && path[i] === ".") i++;
+	return {
+		segment,
+		nextIndex: i
+	};
+}
+/**
+* Access a property or index on an object or array.
+*
+* @param obj The object or array to access.
+* @param segment The property key or array index.
+* @returns The accessed value or undefined if not accessible.
+*/
+function accessProperty(obj, segment) {
+	if (typeof segment === "string") return getOwnProperty(obj, segment);
+	if (Array.isArray(obj) && segment >= 0 && segment < obj.length) return obj[segment];
+}
+/**
+* Resolve a nested property path from an object.
+*
+* There are two types of property access patterns:
+* 1. Array/index access: [0] or ["prop"]
+* 2. Property access: prop or prop?.next
+*
+* @param obj The object to traverse.
+* @param path The property path (e.g., "user.name", "users[0].email", "user['full-name']").
+* @returns The resolved value or undefined if path doesn't exist.
+*/
+function resolvePropertyPath(obj, path) {
+	if (obj == null) return void 0;
+	if (path.length === 0 || path.endsWith(".")) return void 0;
+	let current = obj;
+	let i = 0;
+	const len = path.length;
+	while (i < len) {
+		if (path.slice(i, i + 2) === "?.") {
+			i += 2;
+			if (current == null) return void 0;
+		} else if (current == null) return void 0;
+		const result = parseNextSegment(path, i);
+		if (result === null) return void 0;
+		const { segment, nextIndex } = result;
+		i = nextIndex;
+		current = accessProperty(current, segment);
+		if (current === void 0) return void 0;
+	}
+	return current;
+}
+/**
+* Parse a message template into a message template array and a values array.
+*
+* Placeholders to be replaced with `values` are indicated by keys in curly braces
+* (e.g., `{value}`). The system supports both simple property access and nested
+* property access patterns:
+*
+* **Simple property access:**
+* ```ts
+* parseMessageTemplate("Hello, {user}!", { user: "foo" })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Nested property access (dot notation):**
+* ```ts
+* parseMessageTemplate("Hello, {user.name}!", {
+*   user: { name: "foo", email: "foo@example.com" }
+* })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Array indexing:**
+* ```ts
+* parseMessageTemplate("First: {users[0]}", {
+*   users: ["foo", "bar", "baz"]
+* })
+* // Returns: ["First: ", "foo", ""]
+* ```
+*
+* **Bracket notation for special property names:**
+* ```ts
+* parseMessageTemplate("Name: {user[\"full-name\"]}", {
+*   user: { "full-name": "foo bar" }
+* })
+* // Returns: ["Name: ", "foo bar", ""]
+* ```
+*
+* **Optional chaining for safe navigation:**
+* ```ts
+* parseMessageTemplate("Email: {user?.profile?.email}", {
+*   user: { name: "foo" }
+* })
+* // Returns: ["Email: ", undefined, ""]
+* ```
+*
+* **Wildcard patterns:**
+* - `{*}` - Replaced with the entire properties object
+* - `{ key-with-whitespace }` - Whitespace is trimmed when looking up keys
+*
+* **Escaping:**
+* - `{{` and `}}` are escaped literal braces
+*
+* **Error handling:**
+* - Non-existent paths return `undefined`
+* - Malformed expressions resolve to `undefined` without throwing errors
+* - Out of bounds array access returns `undefined`
+*
+* @param template The message template string containing placeholders.
+* @param properties The values to replace placeholders with.
+* @returns The message template array with values interleaved between text segments.
+*/
+function parseMessageTemplate(template, properties) {
+	const length = template.length;
+	if (length === 0) return [""];
+	if (!template.includes("{")) return [template];
+	const message = [];
+	let startIndex = 0;
+	for (let i = 0; i < length; i++) {
+		const char = template[i];
+		if (char === "{") {
+			if ((i + 1 < length ? template[i + 1] : "") === "{") {
+				i++;
+				continue;
+			}
+			const closeIndex = template.indexOf("}", i + 1);
+			if (closeIndex === -1) continue;
+			const beforeText = template.slice(startIndex, i);
+			message.push(beforeText.replace(/{{/g, "{").replace(/}}/g, "}"));
+			const key = template.slice(i + 1, closeIndex);
+			let prop;
+			const trimmedKey = key.trim();
+			if (trimmedKey === "*") prop = key in properties ? properties[key] : "*" in properties ? properties["*"] : properties;
+			else {
+				if (key !== trimmedKey) prop = key in properties ? properties[key] : properties[trimmedKey];
+				else prop = properties[key];
+				if (prop === void 0 && isNestedAccess(trimmedKey)) prop = resolvePropertyPath(properties, trimmedKey);
+			}
+			message.push(prop);
+			i = closeIndex;
+			startIndex = i + 1;
+		} else if (char === "}" && i + 1 < length && template[i + 1] === "}") i++;
+	}
+	const remainingText = template.slice(startIndex);
+	message.push(remainingText.replace(/{{/g, "{").replace(/}}/g, "}"));
+	return message;
+}
+/**
+* Render a message template with values.
+* @param template The message template.
+* @param values The message template values.
+* @returns The message template values interleaved between the substitution
+*          values.
+*/
+function renderMessage(template, values) {
+	const args = [];
+	for (let i = 0; i < template.length; i++) {
+		args.push(template[i]);
+		if (i < values.length) args.push(values[i]);
+	}
+	return args;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/context.js
+/**
+* Internal symbol for storing category prefix in context.
+*/
+const categoryPrefixSymbol = Symbol.for("logtape.categoryPrefix");
+/**
+* Gets the current category prefix from context local storage.
+* @returns The current category prefix, or an empty array if not set.
+* @since 1.3.0
+*/
+function getCategoryPrefix() {
+	const store = LoggerImpl.getLogger().contextLocalStorage?.getStore();
+	if (store == null) return [];
+	const prefix = store[categoryPrefixSymbol];
+	return Array.isArray(prefix) ? prefix : [];
+}
+/**
+* Gets the current implicit context from context local storage, excluding
+* internal symbol keys (like category prefix).
+* @returns The current implicit context without internal symbol keys.
+* @since 1.3.0
+*/
+function getImplicitContext() {
+	const store = LoggerImpl.getLogger().contextLocalStorage?.getStore();
+	if (store == null) return {};
+	const result = {};
+	for (const key of Object.keys(store)) result[key] = store[key];
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/util.node.js
+var util_node_exports = /* @__PURE__ */ __exportAll({ inspect: () => inspect$1 });
+function inspect$1(obj, options) {
+	return util.inspect(obj, options);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/formatter.js
+/**
+* The severity level abbreviations.
+*/
+const levelAbbreviations = {
+	"trace": "TRC",
+	"debug": "DBG",
+	"info": "INF",
+	"warning": "WRN",
+	"error": "ERR",
+	"fatal": "FTL"
+};
+/**
+* A platform-specific inspect function.  In Deno, this is {@link Deno.inspect},
+* and in Node.js/Bun it is `util.inspect()`.  If neither is available, it
+* falls back to {@link JSON.stringify}.
+*
+* @param value The value to inspect.
+* @param options The options for inspecting the value.
+*                If `colors` is `true`, the output will be ANSI-colored.
+* @returns The string representation of the value.
+*/
+const inspect = typeof document !== "undefined" || typeof navigator !== "undefined" && navigator.product === "ReactNative" ? (v) => JSON.stringify(v) : "Deno" in globalThis && "inspect" in globalThis.Deno && typeof globalThis.Deno.inspect === "function" ? (v, opts) => globalThis.Deno.inspect(v, {
+	strAbbreviateSize: Infinity,
+	iterableLimit: Infinity,
+	...opts
+}) : util_node_exports != null && "inspect" in util_node_exports && typeof inspect$1 === "function" ? (v, opts) => inspect$1(v, {
+	maxArrayLength: Infinity,
+	maxStringLength: Infinity,
+	...opts
+}) : (v) => JSON.stringify(v);
+function padZero(num) {
+	return num < 10 ? `0${num}` : `${num}`;
+}
+function padThree(num) {
+	return num < 10 ? `00${num}` : num < 100 ? `0${num}` : `${num}`;
+}
+const timestampFormatters = {
+	"date-time-timezone": (ts) => {
+		const d = new Date(ts);
+		return `${d.getUTCFullYear()}-${padZero(d.getUTCMonth() + 1)}-${padZero(d.getUTCDate())} ${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())} +00:00`;
+	},
+	"date-time-tz": (ts) => {
+		const d = new Date(ts);
+		return `${d.getUTCFullYear()}-${padZero(d.getUTCMonth() + 1)}-${padZero(d.getUTCDate())} ${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())} +00`;
+	},
+	"date-time": (ts) => {
+		const d = new Date(ts);
+		return `${d.getUTCFullYear()}-${padZero(d.getUTCMonth() + 1)}-${padZero(d.getUTCDate())} ${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())}`;
+	},
+	"time-timezone": (ts) => {
+		const d = new Date(ts);
+		return `${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())} +00:00`;
+	},
+	"time-tz": (ts) => {
+		const d = new Date(ts);
+		return `${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())} +00`;
+	},
+	"time": (ts) => {
+		const d = new Date(ts);
+		return `${padZero(d.getUTCHours())}:${padZero(d.getUTCMinutes())}:${padZero(d.getUTCSeconds())}.${padThree(d.getUTCMilliseconds())}`;
+	},
+	"date": (ts) => {
+		const d = new Date(ts);
+		return `${d.getUTCFullYear()}-${padZero(d.getUTCMonth() + 1)}-${padZero(d.getUTCDate())}`;
+	},
+	"rfc3339": (ts) => new Date(ts).toISOString(),
+	"none": () => null
+};
+const levelRenderersCache = {
+	ABBR: levelAbbreviations,
+	abbr: {
+		trace: "trc",
+		debug: "dbg",
+		info: "inf",
+		warning: "wrn",
+		error: "err",
+		fatal: "ftl"
+	},
+	FULL: {
+		trace: "TRACE",
+		debug: "DEBUG",
+		info: "INFO",
+		warning: "WARNING",
+		error: "ERROR",
+		fatal: "FATAL"
+	},
+	full: {
+		trace: "trace",
+		debug: "debug",
+		info: "info",
+		warning: "warning",
+		error: "error",
+		fatal: "fatal"
+	},
+	L: {
+		trace: "T",
+		debug: "D",
+		info: "I",
+		warning: "W",
+		error: "E",
+		fatal: "F"
+	},
+	l: {
+		trace: "t",
+		debug: "d",
+		info: "i",
+		warning: "w",
+		error: "e",
+		fatal: "f"
+	}
+};
+/**
+* Get a text formatter with the specified options.  Although it's flexible
+* enough to create a custom formatter, if you want more control, you can
+* create a custom formatter that satisfies the {@link TextFormatter} type
+* instead.
+*
+* For more information on the options, see {@link TextFormatterOptions}.
+*
+* By default, the formatter formats log records as follows:
+*
+* ```
+* 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+* ```
+* @param options The options for the text formatter.
+* @returns The text formatter.
+* @since 0.6.0
+*/
+function getTextFormatter(options = {}) {
+	const timestampRenderer = (() => {
+		const tsOption = options.timestamp;
+		if (tsOption == null) return timestampFormatters["date-time-timezone"];
+		else if (tsOption === "disabled") return timestampFormatters["none"];
+		else if (typeof tsOption === "string" && tsOption in timestampFormatters) return timestampFormatters[tsOption];
+		else return tsOption;
+	})();
+	const categorySeparator = options.category ?? "·";
+	const valueRenderer = options.value ? (v) => options.value(v, inspect) : inspect;
+	const levelRenderer = (() => {
+		const levelOption = options.level;
+		if (levelOption == null || levelOption === "ABBR") return (level) => levelRenderersCache.ABBR[level];
+		else if (levelOption === "abbr") return (level) => levelRenderersCache.abbr[level];
+		else if (levelOption === "FULL") return (level) => levelRenderersCache.FULL[level];
+		else if (levelOption === "full") return (level) => levelRenderersCache.full[level];
+		else if (levelOption === "L") return (level) => levelRenderersCache.L[level];
+		else if (levelOption === "l") return (level) => levelRenderersCache.l[level];
+		else return levelOption;
+	})();
+	const formatter = options.format ?? (({ timestamp, level, category, message }) => `${timestamp ? `${timestamp} ` : ""}[${level}] ${category}: ${message}`);
+	return (record) => {
+		const msgParts = record.message;
+		const msgLen = msgParts.length;
+		let message;
+		if (msgLen === 1) message = msgParts[0];
+		else if (msgLen <= 6) {
+			message = "";
+			for (let i = 0; i < msgLen; i++) message += i % 2 === 0 ? msgParts[i] : valueRenderer(msgParts[i]);
+		} else {
+			const parts = new Array(msgLen);
+			for (let i = 0; i < msgLen; i++) parts[i] = i % 2 === 0 ? msgParts[i] : valueRenderer(msgParts[i]);
+			message = parts.join("");
+		}
+		return `${formatter({
+			timestamp: timestampRenderer(record.timestamp),
+			level: levelRenderer(record.level),
+			category: typeof categorySeparator === "function" ? categorySeparator(record.category) : record.category.join(categorySeparator),
+			message,
+			record
+		})}\n`;
+	};
+}
+/**
+* The default text formatter.  This formatter formats log records as follows:
+*
+* ```
+* 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+* ```
+*
+* @param record The log record to format.
+* @returns The formatted log record.
+*/
+const defaultTextFormatter = getTextFormatter();
+const RESET = "\x1B[0m";
+const ansiColors = {
+	black: "\x1B[30m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	white: "\x1B[37m"
+};
+const ansiStyles = {
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	italic: "\x1B[3m",
+	underline: "\x1B[4m",
+	strikethrough: "\x1B[9m"
+};
+const defaultLevelColors = {
+	trace: null,
+	debug: "blue",
+	info: "green",
+	warning: "yellow",
+	error: "red",
+	fatal: "magenta"
+};
+/**
+* Get an ANSI color formatter with the specified options.
+*
+* ![A preview of an ANSI color formatter.](https://i.imgur.com/I8LlBUf.png)
+* @param option The options for the ANSI color formatter.
+* @returns The ANSI color formatter.
+* @since 0.6.0
+*/
+function getAnsiColorFormatter(options = {}) {
+	const format = options.format;
+	const timestampStyle = typeof options.timestampStyle === "undefined" ? "dim" : options.timestampStyle;
+	const timestampColor = options.timestampColor ?? null;
+	const timestampPrefix = `${timestampStyle == null ? "" : ansiStyles[timestampStyle]}${timestampColor == null ? "" : ansiColors[timestampColor]}`;
+	const timestampSuffix = timestampStyle == null && timestampColor == null ? "" : RESET;
+	const levelStyle = typeof options.levelStyle === "undefined" ? "bold" : options.levelStyle;
+	const levelColors = options.levelColors ?? defaultLevelColors;
+	const categoryStyle = typeof options.categoryStyle === "undefined" ? "dim" : options.categoryStyle;
+	const categoryColor = options.categoryColor ?? null;
+	const categoryPrefix = `${categoryStyle == null ? "" : ansiStyles[categoryStyle]}${categoryColor == null ? "" : ansiColors[categoryColor]}`;
+	const categorySuffix = categoryStyle == null && categoryColor == null ? "" : RESET;
+	return getTextFormatter({
+		timestamp: "date-time-tz",
+		value(value, fallbackInspect) {
+			return fallbackInspect(value, { colors: true });
+		},
+		...options,
+		format({ timestamp, level, category, message, record }) {
+			const levelColor = levelColors[record.level];
+			timestamp = `${timestampPrefix}${timestamp}${timestampSuffix}`;
+			level = `${levelStyle == null ? "" : ansiStyles[levelStyle]}${levelColor == null ? "" : ansiColors[levelColor]}${level}${levelStyle == null && levelColor == null ? "" : RESET}`;
+			return format == null ? `${timestamp} ${level} ${categoryPrefix}${category}:${categorySuffix} ${message}` : format({
+				timestamp,
+				level,
+				category: `${categoryPrefix}${category}${categorySuffix}`,
+				message,
+				record
+			});
+		}
+	});
+}
+/**
+* A text formatter that uses ANSI colors to format log records.
+*
+* ![A preview of ansiColorFormatter.](https://i.imgur.com/I8LlBUf.png)
+*
+* @param record The log record to format.
+* @returns The formatted log record.
+* @since 0.5.0
+*/
+const ansiColorFormatter = getAnsiColorFormatter();
+/**
+* Get a [JSON Lines] formatter with the specified options.  The log records
+* will be rendered as JSON objects, one per line, which is a common format
+* for log files.  This format is also known as Newline-Delimited JSON (NDJSON).
+* It looks like this:
+*
+* ```json
+* {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+* ```
+*
+* [JSON Lines]: https://jsonlines.org/
+* @param options The options for the JSON Lines formatter.
+* @returns The JSON Lines formatter.
+* @since 0.11.0
+*/
+function getJsonLinesFormatter(options = {}) {
+	if (!options.categorySeparator && !options.message && !options.properties) return (record) => {
+		if (record.message.length === 3) return JSON.stringify({
+			"@timestamp": new Date(record.timestamp).toISOString(),
+			level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+			message: record.message[0] + JSON.stringify(record.message[1]) + record.message[2],
+			logger: record.category.join("."),
+			properties: record.properties
+		}) + "\n";
+		if (record.message.length === 1) return JSON.stringify({
+			"@timestamp": new Date(record.timestamp).toISOString(),
+			level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+			message: record.message[0],
+			logger: record.category.join("."),
+			properties: record.properties
+		}) + "\n";
+		let msg = record.message[0];
+		for (let i = 1; i < record.message.length; i++) msg += i & 1 ? JSON.stringify(record.message[i]) : record.message[i];
+		return JSON.stringify({
+			"@timestamp": new Date(record.timestamp).toISOString(),
+			level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+			message: msg,
+			logger: record.category.join("."),
+			properties: record.properties
+		}) + "\n";
+	};
+	const isTemplateMessage = options.message === "template";
+	const propertiesOption = options.properties ?? "nest:properties";
+	let joinCategory;
+	if (typeof options.categorySeparator === "function") joinCategory = options.categorySeparator;
+	else {
+		const separator = options.categorySeparator ?? ".";
+		joinCategory = (category) => category.join(separator);
+	}
+	let getProperties;
+	if (propertiesOption === "flatten") getProperties = (properties) => properties;
+	else if (propertiesOption.startsWith("prepend:")) {
+		const prefix = propertiesOption.substring(8);
+		if (prefix === "") throw new TypeError(`Invalid properties option: ${JSON.stringify(propertiesOption)}. It must be of the form "prepend:<prefix>" where <prefix> is a non-empty string.`);
+		getProperties = (properties) => {
+			const result = {};
+			for (const key in properties) result[`${prefix}${key}`] = properties[key];
+			return result;
+		};
+	} else if (propertiesOption.startsWith("nest:")) {
+		const key = propertiesOption.substring(5);
+		getProperties = (properties) => ({ [key]: properties });
+	} else throw new TypeError(`Invalid properties option: ${JSON.stringify(propertiesOption)}. It must be "flatten", "prepend:<prefix>", or "nest:<key>".`);
+	let getMessage;
+	if (isTemplateMessage) getMessage = (record) => {
+		if (typeof record.rawMessage === "string") return record.rawMessage;
+		let msg = "";
+		for (let i = 0; i < record.rawMessage.length; i++) msg += i % 2 < 1 ? record.rawMessage[i] : "{}";
+		return msg;
+	};
+	else getMessage = (record) => {
+		const msgLen = record.message.length;
+		if (msgLen === 1) return record.message[0];
+		let msg = "";
+		for (let i = 0; i < msgLen; i++) msg += i % 2 < 1 ? record.message[i] : JSON.stringify(record.message[i]);
+		return msg;
+	};
+	return (record) => {
+		return JSON.stringify({
+			"@timestamp": new Date(record.timestamp).toISOString(),
+			level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+			message: getMessage(record),
+			logger: joinCategory(record.category),
+			...getProperties(record.properties)
+		}) + "\n";
+	};
+}
+/**
+* The default [JSON Lines] formatter.  This formatter formats log records
+* as JSON objects, one per line, which is a common format for log files.
+* It looks like this:
+*
+* ```json
+* {"@timestamp":"2023-11-14T22:13:20.000Z","level":"INFO","message":"Hello, world!","logger":"my.logger","properties":{"key":"value"}}
+* ```
+*
+* You can customize the output by passing options to
+* {@link getJsonLinesFormatter}.  For example, you can change the category
+* separator, the message format, and how the properties are formatted.
+*
+* [JSON Lines]: https://jsonlines.org/
+* @since 0.11.0
+*/
+const jsonLinesFormatter = getJsonLinesFormatter();
+/**
+* The styles for the log level in the console.
+*/
+const logLevelStyles = {
+	"trace": "background-color: gray; color: white;",
+	"debug": "background-color: gray; color: white;",
+	"info": "background-color: white; color: black;",
+	"warning": "background-color: orange; color: black;",
+	"error": "background-color: red; color: white;",
+	"fatal": "background-color: maroon; color: white;"
+};
+/**
+* The default console formatter.
+*
+* @param record The log record to format.
+* @returns The formatted log record, as an array of arguments for
+*          {@link console.log}.
+*/
+function defaultConsoleFormatter(record) {
+	let msg = "";
+	const values = [];
+	for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) msg += record.message[i];
+	else {
+		msg += "%o";
+		values.push(record.message[i]);
+	}
+	const date = new Date(record.timestamp);
+	return [
+		`%c${`${date.getUTCHours().toString().padStart(2, "0")}:${date.getUTCMinutes().toString().padStart(2, "0")}:${date.getUTCSeconds().toString().padStart(2, "0")}.${date.getUTCMilliseconds().toString().padStart(3, "0")}`} %c${levelAbbreviations[record.level]}%c %c${record.category.join("·")} %c${msg}`,
+		"color: gray;",
+		logLevelStyles[record.level],
+		"background-color: default;",
+		"color: gray;",
+		"color: default;",
+		...values
+	];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/sink.js
+/**
+* A console sink factory that returns a sink that logs to the console.
+*
+* @param options The options for the sink.
+* @returns A sink that logs to the console. If `nonBlocking` is enabled,
+*          returns a sink that also implements {@link Disposable}.
+*/
+function getConsoleSink(options = {}) {
+	const formatter = options.formatter ?? defaultConsoleFormatter;
+	const levelMap = {
+		trace: "debug",
+		debug: "debug",
+		info: "info",
+		warning: "warn",
+		error: "error",
+		fatal: "error",
+		...options.levelMap ?? {}
+	};
+	const console = options.console ?? globalThis.console;
+	const baseSink = (record) => {
+		const args = formatter(record);
+		const method = levelMap[record.level];
+		if (method === void 0) throw new TypeError(`Invalid log level: ${record.level}.`);
+		if (typeof args === "string") {
+			const msg = args.replace(/\r?\n$/, "");
+			console[method](msg);
+		} else console[method](...args);
+	};
+	if (!options.nonBlocking) return baseSink;
+	const nonBlockingConfig = options.nonBlocking === true ? {} : options.nonBlocking;
+	const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+	const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+	const buffer = [];
+	let flushTimer = null;
+	let disposed = false;
+	let flushScheduled = false;
+	const maxBufferSize = bufferSize * 2;
+	function flush() {
+		if (buffer.length === 0) return;
+		const records = buffer.splice(0);
+		for (const record of records) try {
+			baseSink(record);
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (flushScheduled) return;
+		flushScheduled = true;
+		setTimeout(() => {
+			flushScheduled = false;
+			flush();
+		}, 0);
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			flush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (buffer.length >= maxBufferSize) buffer.shift();
+		buffer.push(record);
+		if (buffer.length >= bufferSize) scheduleFlush();
+		else if (flushTimer === null) startFlushTimer();
+	};
+	nonBlockingSink[Symbol.dispose] = () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		flush();
+	};
+	return nonBlockingSink;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.5/node_modules/@logtape/logtape/dist/config.js
+/**
+* The current configuration, if any.  Otherwise, `null`.
+*/
+let currentConfig = null;
+/**
+* Strong references to the loggers.
+* This is to prevent the loggers from being garbage collected so that their
+* sinks and filters are not removed.
+*/
+const strongRefs = /* @__PURE__ */ new Set();
+/**
+* Disposables to dispose when resetting the configuration.
+*/
+const disposables = /* @__PURE__ */ new Set();
+/**
+* Async disposables to dispose when resetting the configuration.
+*/
+const asyncDisposables = /* @__PURE__ */ new Set();
+/**
+* Check if a config is for the meta logger.
+*/
+function isLoggerConfigMeta(cfg) {
+	return cfg.category.length === 0 || cfg.category.length === 1 && cfg.category[0] === "logtape" || cfg.category.length === 2 && cfg.category[0] === "logtape" && cfg.category[1] === "meta";
+}
+/**
+* Configure sync loggers with the specified configuration.
+*
+* Note that if the given sinks or filters are disposable, they will be
+* disposed when the configuration is reset, or when the process exits.
+*
+* Also note that passing async sinks or filters will throw. If
+* necessary use {@link resetSync} or {@link disposeSync}.
+*
+* @example
+* ```typescript
+* configureSync({
+*   sinks: {
+*     console: getConsoleSink(),
+*   },
+*   loggers: [
+*     {
+*       category: "my-app",
+*       sinks: ["console"],
+*       lowestLevel: "info",
+*     },
+*     {
+*       category: "logtape",
+*       sinks: ["console"],
+*       lowestLevel: "error",
+*     },
+*   ],
+* });
+* ```
+*
+* @param config The configuration.
+* @since 0.9.0
+*/
+function configureSync(config) {
+	if (currentConfig != null && !config.reset) throw new ConfigError("Already configured; if you want to reset, turn on the reset flag.");
+	if (asyncDisposables.size > 0) throw new ConfigError("Previously configured async disposables are still active. Use configure() instead or explicitly dispose them using dispose().");
+	resetSync();
+	try {
+		configureInternal(config, false);
+	} catch (e) {
+		if (e instanceof ConfigError) resetSync();
+		throw e;
+	}
+}
+function configureInternal(config, allowAsync) {
+	currentConfig = config;
+	let metaConfigured = false;
+	const configuredCategories = /* @__PURE__ */ new Set();
+	for (const cfg of config.loggers) {
+		if (isLoggerConfigMeta(cfg)) metaConfigured = true;
+		const categoryKey = Array.isArray(cfg.category) ? JSON.stringify(cfg.category) : JSON.stringify([cfg.category]);
+		if (configuredCategories.has(categoryKey)) throw new ConfigError(`Duplicate logger configuration for category: ${categoryKey}. Each category can only be configured once.`);
+		configuredCategories.add(categoryKey);
+		const logger = LoggerImpl.getLogger(cfg.category);
+		for (const sinkId of cfg.sinks ?? []) {
+			const sink = config.sinks[sinkId];
+			if (!sink) throw new ConfigError(`Sink not found: ${sinkId}.`);
+			logger.sinks.push(sink);
+		}
+		logger.parentSinks = cfg.parentSinks ?? "inherit";
+		if (cfg.lowestLevel !== void 0) logger.lowestLevel = cfg.lowestLevel;
+		for (const filterId of cfg.filters ?? []) {
+			const filter = config.filters?.[filterId];
+			if (filter === void 0) throw new ConfigError(`Filter not found: ${filterId}.`);
+			logger.filters.push(toFilter(filter));
+		}
+		strongRefs.add(logger);
+	}
+	LoggerImpl.getLogger().contextLocalStorage = config.contextLocalStorage;
+	for (const sink of Object.values(config.sinks)) {
+		if (Symbol.asyncDispose in sink) if (allowAsync) asyncDisposables.add(sink);
+		else throw new ConfigError("Async disposables cannot be used with configureSync().");
+		if (Symbol.dispose in sink) disposables.add(sink);
+	}
+	for (const filter of Object.values(config.filters ?? {})) {
+		if (filter == null || typeof filter === "string") continue;
+		if (Symbol.asyncDispose in filter) if (allowAsync) asyncDisposables.add(filter);
+		else throw new ConfigError("Async disposables cannot be used with configureSync().");
+		if (Symbol.dispose in filter) disposables.add(filter);
+	}
+	if (typeof globalThis.EdgeRuntime !== "string" && "process" in globalThis && !("Deno" in globalThis)) {
+		const proc = globalThis.process;
+		const onMethod = proc?.["on"];
+		if (typeof onMethod === "function") onMethod.call(proc, "exit", allowAsync ? dispose : disposeSync);
+	} else addEventListener("unload", allowAsync ? dispose : disposeSync);
+	const meta = LoggerImpl.getLogger(["logtape", "meta"]);
+	if (!metaConfigured) meta.sinks.push(getConsoleSink());
+	meta.info("LogTape loggers are configured.  Note that LogTape itself uses the meta logger, which has category {metaLoggerCategory}.  The meta logger purposes to log internal errors such as sink exceptions.  If you are seeing this message, the meta logger is automatically configured.  It's recommended to configure the meta logger with a separate sink so that you can easily notice if logging itself fails or is misconfigured.  To turn off this message, configure the meta logger with higher log levels than {dismissLevel}.  See also <https://logtape.org/manual/categories#meta-logger>.", {
+		metaLoggerCategory: ["logtape", "meta"],
+		dismissLevel: "info"
+	});
+}
+/**
+* Reset the configuration.  Mostly for testing purposes. Will not clear async
+* sinks, only use with sync sinks. Use {@link reset} if you have async sinks.
+* @since 0.9.0
+*/
+function resetSync() {
+	disposeSync();
+	resetInternal();
+}
+function resetInternal() {
+	const rootLogger = LoggerImpl.getLogger([]);
+	rootLogger.resetDescendants();
+	delete rootLogger.contextLocalStorage;
+	strongRefs.clear();
+	currentConfig = null;
+}
+/**
+* Dispose of the disposables.
+*/
+async function dispose() {
+	disposeSync();
+	const promises = [];
+	for (const disposable of asyncDisposables) {
+		promises.push(disposable[Symbol.asyncDispose]());
+		asyncDisposables.delete(disposable);
+	}
+	await Promise.all(promises);
+}
+/**
+* Dispose of the sync disposables. Async disposables will be untouched,
+* use {@link dispose} if you have async sinks.
+* @since 0.9.0
+*/
+function disposeSync() {
+	for (const disposable of disposables) disposable[Symbol.dispose]();
+	disposables.clear();
+}
+/**
+* A configuration error.
+*/
+var ConfigError = class extends Error {
+	/**
+	* Constructs a new configuration error.
+	* @param message The error message.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "ConfigureError";
+	}
+};
+
+//#endregion
+export { getLogger as i, getConsoleSink as n, getAnsiColorFormatter as r, configureSync as t };