@logtape/logtape 0.11.0 → 0.12.0-dev.182

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+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 __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 ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/config.cjs

@@ -0,0 +1,247 @@
+const require_filter = require('./filter.cjs');
+const require_logger = require('./logger.cjs');
+const require_sink = require('./sink.cjs');
+
+//#region config.ts
+/**
+* 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 the 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.
+*
+* @example
+* ```typescript
+* await configure({
+*   sinks: {
+*     console: getConsoleSink(),
+*   },
+*   filters: {
+*     slow: (log) =>
+*       "duration" in log.properties &&
+*       log.properties.duration as number > 1000,
+*   },
+*   loggers: [
+*     {
+*       category: "my-app",
+*       sinks: ["console"],
+*       level: "info",
+*     },
+*     {
+*       category: ["my-app", "sql"],
+*       filters: ["slow"],
+*       level: "debug",
+*     },
+*     {
+*       category: "logtape",
+*       sinks: ["console"],
+*       level: "error",
+*     },
+*   ],
+* });
+* ```
+*
+* @param config The configuration.
+*/
+async function configure(config) {
+	if (currentConfig != null && !config.reset) throw new ConfigError("Already configured; if you want to reset, turn on the reset flag.");
+	await reset();
+	try {
+		configureInternal(config, true);
+	} catch (e) {
+		if (e instanceof ConfigError) await reset();
+		throw e;
+	}
+}
+/**
+* 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"],
+*       level: "info",
+*     },
+*     {
+*       category: "logtape",
+*       sinks: ["console"],
+*       level: "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;
+	let levelUsed = 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 = require_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;
+		if (cfg.level !== void 0) {
+			levelUsed = true;
+			logger.filters.push(require_filter.toFilter(cfg.level));
+		}
+		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(require_filter.toFilter(filter));
+		}
+		strongRefs.add(logger);
+	}
+	require_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 ("process" in globalThis && !("Deno" in globalThis)) process.on("exit", allowAsync ? dispose : disposeSync);
+	else addEventListener("unload", allowAsync ? dispose : disposeSync);
+	const meta = require_logger.LoggerImpl.getLogger(["logtape", "meta"]);
+	if (!metaConfigured) meta.sinks.push(require_sink.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"
+	});
+	if (levelUsed) meta.warn("The level option is deprecated in favor of lowestLevel option.  Please update your configuration.  See also <https://logtape.org/manual/levels#configuring-severity-levels>.");
+}
+/**
+* Get the current configuration, if any.  Otherwise, `null`.
+* @returns The current configuration, if any.  Otherwise, `null`.
+*/
+function getConfig() {
+	return currentConfig;
+}
+/**
+* Reset the configuration.  Mostly for testing purposes.
+*/
+async function reset() {
+	await dispose();
+	resetInternal();
+}
+/**
+* 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 = require_logger.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
+exports.ConfigError = ConfigError;
+exports.configure = configure;
+exports.configureSync = configureSync;
+exports.dispose = dispose;
+exports.disposeSync = disposeSync;
+exports.getConfig = getConfig;
+exports.reset = reset;
+exports.resetSync = resetSync;

package/dist/config.d.cts

@@ -0,0 +1,189 @@
+import { ContextLocalStorage } from "./context.cjs";
+import { LogLevel } from "./level.cjs";
+import { FilterLike } from "./filter.cjs";
+import { Sink } from "./sink.cjs";
+
+//#region config.d.ts
+
+/**
+ * A configuration for the loggers.
+ */
+interface Config<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The sinks to use.  The keys are the sink identifiers, and the values are
+   * {@link Sink}s.
+   */
+  sinks: Record<TSinkId, Sink>;
+  /**
+   * The filters to use.  The keys are the filter identifiers, and the values
+   * are either {@link Filter}s or {@link LogLevel}s.
+   */
+  filters?: Record<TFilterId, FilterLike>;
+  /**
+   * The loggers to configure.
+   */
+  loggers: LoggerConfig<TSinkId, TFilterId>[];
+  /**
+   * The context-local storage to use for implicit contexts.
+   * @since 0.7.0
+   */
+  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;
+  /**
+   * Whether to reset the configuration before applying this one.
+   */
+  reset?: boolean;
+}
+/**
+ * A logger configuration.
+ */
+interface LoggerConfig<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The category of the logger.  If a string, it is equivalent to an array
+   * with one element.
+   */
+  category: string | string[];
+  /**
+   * The sink identifiers to use.
+   */
+  sinks?: TSinkId[];
+  /**
+   * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks
+   * are used along with the specified sinks.  If `override`, the parent's
+   * sinks are not used, and only the specified sinks are used.
+   *
+   * The default is `inherit`.
+   * @default `"inherit"
+   * @since 0.6.0
+   */
+  parentSinks?: "inherit" | "override";
+  /**
+   * The filter identifiers to use.
+   */
+  filters?: TFilterId[];
+  /**
+   * The log level to filter by.  If `null`, the logger will reject all
+   * records.
+   * @deprecated Use `filters` instead for backward compatibility, or use
+   *             `lowestLevel` for less-misleading behavior.
+   */
+  level?: LogLevel | null;
+  /**
+   * The lowest log level to accept.  If `null`, the logger will reject all
+   * records.
+   * @since 0.8.0
+   */
+  lowestLevel?: LogLevel | null;
+}
+/**
+ * Configure the 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.
+ *
+ * @example
+ * ```typescript
+ * await configure({
+ *   sinks: {
+ *     console: getConsoleSink(),
+ *   },
+ *   filters: {
+ *     slow: (log) =>
+ *       "duration" in log.properties &&
+ *       log.properties.duration as number > 1000,
+ *   },
+ *   loggers: [
+ *     {
+ *       category: "my-app",
+ *       sinks: ["console"],
+ *       level: "info",
+ *     },
+ *     {
+ *       category: ["my-app", "sql"],
+ *       filters: ["slow"],
+ *       level: "debug",
+ *     },
+ *     {
+ *       category: "logtape",
+ *       sinks: ["console"],
+ *       level: "error",
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @param config The configuration.
+ */
+declare function configure<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): Promise<void>;
+/**
+ * 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"],
+ *       level: "info",
+ *     },
+ *     {
+ *       category: "logtape",
+ *       sinks: ["console"],
+ *       level: "error",
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @param config The configuration.
+ * @since 0.9.0
+ */
+declare function configureSync<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): void;
+/**
+ * Get the current configuration, if any.  Otherwise, `null`.
+ * @returns The current configuration, if any.  Otherwise, `null`.
+ */
+declare function getConfig(): Config<string, string> | null;
+/**
+ * Reset the configuration.  Mostly for testing purposes.
+ */
+declare function reset(): Promise<void>;
+/**
+ * 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
+ */
+declare function resetSync(): void;
+/**
+ * Dispose of the disposables.
+ */
+declare function dispose(): Promise<void>;
+/**
+ * Dispose of the sync disposables. Async disposables will be untouched,
+ * use {@link dispose} if you have async sinks.
+ * @since 0.9.0
+ */
+declare function disposeSync(): void;
+/**
+ * A configuration error.
+ */
+declare class ConfigError extends Error {
+  /**
+   * Constructs a new configuration error.
+   * @param message The error message.
+   */
+  constructor(message: string);
+}
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+export { Config, ConfigError, LoggerConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync };
+//# sourceMappingURL=config.d.cts.map

package/dist/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;;EA4CL,mBAAA,CAAA,EAvDA,mBAuDA,CAvDoB,MAuDpB,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EA6EF;;;EAGE,KAAE,CAAA,EAAA,OAAA;;;AAAoB;AAgD9C;AAA6B,UA5KZ,YA4KY,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;AACb;EA6IA,QAAA,EAAA,MAAS,GAAA,MAAI,EAAA;EAOP;AAUtB;AAgBA;EAegB,KAAA,CAAA,EA7VN,OA6ViB,EAAA;EAQd;;;;;;;;;;;;;YArVD;;;;;;;UAQF;;;;;;gBAOM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6EM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBA6IV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}

package/dist/config.d.ts

@@ -0,0 +1,189 @@
+import { ContextLocalStorage } from "./context.js";
+import { LogLevel } from "./level.js";
+import { FilterLike } from "./filter.js";
+import { Sink } from "./sink.js";
+
+//#region config.d.ts
+
+/**
+ * A configuration for the loggers.
+ */
+interface Config<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The sinks to use.  The keys are the sink identifiers, and the values are
+   * {@link Sink}s.
+   */
+  sinks: Record<TSinkId, Sink>;
+  /**
+   * The filters to use.  The keys are the filter identifiers, and the values
+   * are either {@link Filter}s or {@link LogLevel}s.
+   */
+  filters?: Record<TFilterId, FilterLike>;
+  /**
+   * The loggers to configure.
+   */
+  loggers: LoggerConfig<TSinkId, TFilterId>[];
+  /**
+   * The context-local storage to use for implicit contexts.
+   * @since 0.7.0
+   */
+  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;
+  /**
+   * Whether to reset the configuration before applying this one.
+   */
+  reset?: boolean;
+}
+/**
+ * A logger configuration.
+ */
+interface LoggerConfig<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The category of the logger.  If a string, it is equivalent to an array
+   * with one element.
+   */
+  category: string | string[];
+  /**
+   * The sink identifiers to use.
+   */
+  sinks?: TSinkId[];
+  /**
+   * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks
+   * are used along with the specified sinks.  If `override`, the parent's
+   * sinks are not used, and only the specified sinks are used.
+   *
+   * The default is `inherit`.
+   * @default `"inherit"
+   * @since 0.6.0
+   */
+  parentSinks?: "inherit" | "override";
+  /**
+   * The filter identifiers to use.
+   */
+  filters?: TFilterId[];
+  /**
+   * The log level to filter by.  If `null`, the logger will reject all
+   * records.
+   * @deprecated Use `filters` instead for backward compatibility, or use
+   *             `lowestLevel` for less-misleading behavior.
+   */
+  level?: LogLevel | null;
+  /**
+   * The lowest log level to accept.  If `null`, the logger will reject all
+   * records.
+   * @since 0.8.0
+   */
+  lowestLevel?: LogLevel | null;
+}
+/**
+ * Configure the 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.
+ *
+ * @example
+ * ```typescript
+ * await configure({
+ *   sinks: {
+ *     console: getConsoleSink(),
+ *   },
+ *   filters: {
+ *     slow: (log) =>
+ *       "duration" in log.properties &&
+ *       log.properties.duration as number > 1000,
+ *   },
+ *   loggers: [
+ *     {
+ *       category: "my-app",
+ *       sinks: ["console"],
+ *       level: "info",
+ *     },
+ *     {
+ *       category: ["my-app", "sql"],
+ *       filters: ["slow"],
+ *       level: "debug",
+ *     },
+ *     {
+ *       category: "logtape",
+ *       sinks: ["console"],
+ *       level: "error",
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @param config The configuration.
+ */
+declare function configure<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): Promise<void>;
+/**
+ * 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"],
+ *       level: "info",
+ *     },
+ *     {
+ *       category: "logtape",
+ *       sinks: ["console"],
+ *       level: "error",
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @param config The configuration.
+ * @since 0.9.0
+ */
+declare function configureSync<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): void;
+/**
+ * Get the current configuration, if any.  Otherwise, `null`.
+ * @returns The current configuration, if any.  Otherwise, `null`.
+ */
+declare function getConfig(): Config<string, string> | null;
+/**
+ * Reset the configuration.  Mostly for testing purposes.
+ */
+declare function reset(): Promise<void>;
+/**
+ * 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
+ */
+declare function resetSync(): void;
+/**
+ * Dispose of the disposables.
+ */
+declare function dispose(): Promise<void>;
+/**
+ * Dispose of the sync disposables. Async disposables will be untouched,
+ * use {@link dispose} if you have async sinks.
+ * @since 0.9.0
+ */
+declare function disposeSync(): void;
+/**
+ * A configuration error.
+ */
+declare class ConfigError extends Error {
+  /**
+   * Constructs a new configuration error.
+   * @param message The error message.
+   */
+  constructor(message: string);
+}
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+export { Config, ConfigError, LoggerConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync };
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;;EA4CL,mBAAA,CAAA,EAvDA,mBAuDA,CAvDoB,MAuDpB,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EA6EF;;;EAGE,KAAE,CAAA,EAAA,OAAA;;;AAAoB;AAgD9C;AAA6B,UA5KZ,YA4KY,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;AACb;EA6IA,QAAA,EAAA,MAAS,GAAA,MAAI,EAAA;EAOP;AAUtB;AAgBA;EAegB,KAAA,CAAA,EA7VN,OA6ViB,EAAA;EAQd;;;;;;;;;;;;;YArVD;;;;;;;UAQF;;;;;;gBAOM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6EM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBA6IV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}