@logtape/logtape 0.12.0-dev.183 → 0.12.0-dev.185

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "0.12.0-dev.183+dc6777f0",
+  "version": "0.12.0-dev.185+3924dfe1",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/logger.cjs

@@ -207,6 +207,9 @@ var LoggerImpl = class LoggerImpl {
 		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);
@@ -280,6 +283,9 @@ var LoggerCtx = class LoggerCtx {
 		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);

package/dist/logger.d.cts

@@ -305,6 +305,85 @@ interface Logger {
    * @throws {TypeError} If no log record was made inside the callback.
    */
   warn(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  warning(callback: LogCallback): void;
   /**
    * Log an error message.  Use this as a template string prefix.
    *

package/dist/logger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.cts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYX,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYZ,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;AA0ER;AAS7B;AASA;AAiBA;;;;;;;;;;;sFA5eK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;iBAYA;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYT,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYd,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;;;;;;AAgKR;AAS7B;AASA;AAiBA;;;;;;sFAlkBK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;mBAYE;;;;;;;;;;;;;;;;;;;;;;;;;wCA4BF,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgC5B;;;;;;;;;;;;;oBAcF;;;;;;;;;;;iBAYH;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}

package/dist/logger.d.ts

@@ -305,6 +305,85 @@ interface Logger {
    * @throws {TypeError} If no log record was made inside the callback.
    */
   warn(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  warning(callback: LogCallback): void;
   /**
    * Log an error message.  Use this as a template string prefix.
    *

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYX,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYZ,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;AA0ER;AAS7B;AASA;AAiBA;;;;;;;;;;;sFA5eK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;iBAYA;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYT,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYd,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;;;;;;AAgKR;AAS7B;AASA;AAiBA;;;;;;sFAlkBK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;mBAYE;;;;;;;;;;;;;;;;;;;;;;;;;wCA4BF,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgC5B;;;;;;;;;;;;;oBAcF;;;;;;;;;;;iBAYH;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}

package/dist/logger.js

@@ -207,6 +207,9 @@ var LoggerImpl = class LoggerImpl {
 		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);
@@ -280,6 +283,9 @@ var LoggerCtx = class LoggerCtx {
 		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);

package/dist/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","names":["category: string | readonly string[]","rootLogger: LoggerImpl | null","parent: LoggerImpl | null","category: readonly string[]","subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])]","child: LoggerImpl | undefined","properties: Record<string, unknown>","record: LogRecord","level: LogLevel","bypassSinks?: Set<Sink>","rawMessage: string","properties: Record<string, unknown> | (() => Record<string, unknown>)","cachedProps: Record<string, unknown> | undefined","callback: LogCallback","rawMessage: TemplateStringsArray | undefined","msg: unknown[] | undefined","messageTemplate: TemplateStringsArray","values: unknown[]","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>","logger: LoggerImpl","subcategory: string | readonly [string] | readonly [string, ...string[]]","message: string","template: string","message: unknown[]","prop: unknown","template: TemplateStringsArray","values: readonly unknown[]"],"sources":["../logger.ts"],"sourcesContent":["import type { ContextLocalStorage } from \"./context.ts\";\nimport type { Filter } from \"./filter.ts\";\nimport { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\nimport type { Sink } from \"./sink.ts\";\n\n/**\n * A logger interface.  It provides methods to log messages at different\n * severity levels.\n *\n * ```typescript\n * const logger = getLogger(\"category\");\n * logger.debug `A debug message with ${value}.`;\n * logger.info `An info message with ${value}.`;\n * logger.warn `A warning message with ${value}.`;\n * logger.error `An error message with ${value}.`;\n * logger.fatal `A fatal error message with ${value}.`;\n * ```\n */\nexport interface Logger {\n  /**\n   * The category of the logger.  It is an array of strings.\n   */\n  readonly category: readonly string[];\n\n  /**\n   * The logger with the supercategory of the current logger.  If the current\n   * logger is the root logger, this is `null`.\n   */\n  readonly parent: Logger | null;\n\n  /**\n   * Get a child logger with the given subcategory.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = logger.getChild(\"sub-category\");\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = getLogger([\"category\", \"sub-category\"]);\n   * ```\n   *\n   * @param subcategory The subcategory.\n   * @returns The child logger.\n   */\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger;\n\n  /**\n   * Get a logger with contextual properties.  This is useful for\n   * log multiple messages with the shared set of properties.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const ctx = logger.with({ foo: 123, bar: \"abc\" });\n   * ctx.info(\"A message with {foo} and {bar}.\");\n   * ctx.warn(\"Another message with {foo}, {bar}, and {baz}.\", { baz: true });\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * logger.info(\"A message with {foo} and {bar}.\", { foo: 123, bar: \"abc\" });\n   * logger.warn(\n   *   \"Another message with {foo}, {bar}, and {baz}.\",\n   *   { foo: 123, bar: \"abc\", baz: true },\n   * );\n   * ```\n   *\n   * @param properties\n   * @returns\n   * @since 0.5.0\n   */\n  with(properties: Record<string, unknown>): Logger;\n\n  /**\n   * Log a debug message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.debug `A debug message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a debug message with properties.\n   *\n   * ```typescript\n   * logger.debug('A debug message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.debug(\n   *   'A debug message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a debug values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.debug({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.debug('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  debug(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a debug message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  debug(callback: LogCallback): void;\n\n  /**\n   * Log an informational message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.info `An info message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an informational message with properties.\n   *\n   * ```typescript\n   * logger.info('An info message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.info(\n   *   'An info message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an informational values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.info({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.info('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  info(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an informational message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.info(l => l`An info message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  info(callback: LogCallback): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warn `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warn('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warn(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warn({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warn('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  warn(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  warn(callback: LogCallback): void;\n\n  /**\n   * Log an error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.error `An error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an error message with properties.\n   *\n   * ```typescript\n   * logger.warn('An error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   'An error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.error({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.error('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  error(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.error(l => l`An error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  error(callback: LogCallback): void;\n\n  /**\n   * Log a fatal error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.fatal `A fatal error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a fatal error message with properties.\n   *\n   * ```typescript\n   * logger.warn('A fatal error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.fatal('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  fatal(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a fatal error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  fatal(callback: LogCallback): void;\n}\n\n/**\n * A logging callback function.  It is used to defer the computation of a\n * message template until it is actually logged.\n * @param prefix The message template prefix.\n * @returns The rendered message array.\n */\nexport type LogCallback = (prefix: LogTemplatePrefix) => unknown[];\n\n/**\n * A logging template prefix function.  It is used to log a message in\n * a {@link LogCallback} function.\n * @param message The message template strings array.\n * @param values The message template values.\n * @returns The rendered message array.\n */\nexport type LogTemplatePrefix = (\n  message: TemplateStringsArray,\n  ...values: unknown[]\n) => unknown[];\n\n/**\n * Get a logger with the given category.\n *\n * ```typescript\n * const logger = getLogger([\"my-app\"]);\n * ```\n *\n * @param category The category of the logger.  It can be a string or an array\n *                 of strings.  If it is a string, it is equivalent to an array\n *                 with a single element.\n * @returns The logger.\n */\nexport function getLogger(category: string | readonly string[] = []): Logger {\n  return LoggerImpl.getLogger(category);\n}\n\n/**\n * The symbol for the global root logger.\n */\nconst globalRootLoggerSymbol = Symbol.for(\"logtape.rootLogger\");\n\n/**\n * The global root logger registry.\n */\ninterface GlobalRootLoggerRegistry {\n  [globalRootLoggerSymbol]?: LoggerImpl;\n}\n\n/**\n * A logger implementation.  Do not use this directly; use {@link getLogger}\n * instead.  This class is exported for testing purposes.\n */\nexport class LoggerImpl implements Logger {\n  readonly parent: LoggerImpl | null;\n  readonly children: Record<string, LoggerImpl | WeakRef<LoggerImpl>>;\n  readonly category: readonly string[];\n  readonly sinks: Sink[];\n  parentSinks: \"inherit\" | \"override\" = \"inherit\";\n  readonly filters: Filter[];\n  lowestLevel: LogLevel | null = \"debug\";\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  static getLogger(category: string | readonly string[] = []): LoggerImpl {\n    let rootLogger: LoggerImpl | null = globalRootLoggerSymbol in globalThis\n      ? ((globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] ??\n        null)\n      : null;\n    if (rootLogger == null) {\n      rootLogger = new LoggerImpl(null, []);\n      (globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] =\n        rootLogger;\n    }\n    if (typeof category === \"string\") return rootLogger.getChild(category);\n    if (category.length === 0) return rootLogger;\n    return rootLogger.getChild(category as readonly [string, ...string[]]);\n  }\n\n  private constructor(parent: LoggerImpl | null, category: readonly string[]) {\n    this.parent = parent;\n    this.children = {};\n    this.category = category;\n    this.sinks = [];\n    this.filters = [];\n  }\n\n  getChild(\n    subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])],\n  ): LoggerImpl {\n    const name = typeof subcategory === \"string\" ? subcategory : subcategory[0];\n    const childRef = this.children[name];\n    let child: LoggerImpl | undefined = childRef instanceof LoggerImpl\n      ? childRef\n      : childRef?.deref();\n    if (child == null) {\n      child = new LoggerImpl(this, [...this.category, name]);\n      this.children[name] = \"WeakRef\" in globalThis\n        ? new WeakRef(child)\n        : child;\n    }\n    if (typeof subcategory === \"string\" || subcategory.length === 1) {\n      return child;\n    }\n    return child.getChild(\n      subcategory.slice(1) as [string, ...(readonly string[])],\n    );\n  }\n\n  /**\n   * Reset the logger.  This removes all sinks and filters from the logger.\n   */\n  reset(): void {\n    while (this.sinks.length > 0) this.sinks.shift();\n    this.parentSinks = \"inherit\";\n    while (this.filters.length > 0) this.filters.shift();\n    this.lowestLevel = \"debug\";\n  }\n\n  /**\n   * Reset the logger and all its descendants.  This removes all sinks and\n   * filters from the logger and all its descendants.\n   */\n  resetDescendants(): void {\n    for (const child of Object.values(this.children)) {\n      const logger = child instanceof LoggerImpl ? child : child.deref();\n      if (logger != null) logger.resetDescendants();\n    }\n    this.reset();\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this, { ...properties });\n  }\n\n  filter(record: LogRecord): boolean {\n    for (const filter of this.filters) {\n      if (!filter(record)) return false;\n    }\n    if (this.filters.length < 1) return this.parent?.filter(record) ?? true;\n    return true;\n  }\n\n  *getSinks(level: LogLevel): Iterable<Sink> {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return;\n    }\n    if (this.parent != null && this.parentSinks === \"inherit\") {\n      for (const sink of this.parent.getSinks(level)) yield sink;\n    }\n    for (const sink of this.sinks) yield sink;\n  }\n\n  emit(record: LogRecord, bypassSinks?: Set<Sink>): void {\n    if (\n      this.lowestLevel === null ||\n      compareLogLevel(record.level, this.lowestLevel) < 0 ||\n      !this.filter(record)\n    ) {\n      return;\n    }\n    for (const sink of this.getSinks(record.level)) {\n      if (bypassSinks?.has(sink)) continue;\n      try {\n        sink(record);\n      } catch (error) {\n        const bypassSinks2 = new Set(bypassSinks);\n        bypassSinks2.add(sink);\n        metaLogger.log(\n          \"fatal\",\n          \"Failed to emit a log record to sink {sink}: {error}\",\n          { sink, error, record },\n          bypassSinks2,\n        );\n      }\n    }\n  }\n\n  log(\n    level: LogLevel,\n    rawMessage: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    let cachedProps: Record<string, unknown> | undefined = undefined;\n    const record: LogRecord = typeof properties === \"function\"\n      ? {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        get message() {\n          return parseMessageTemplate(rawMessage, this.properties);\n        },\n        rawMessage,\n        get properties() {\n          if (cachedProps == null) {\n            cachedProps = {\n              ...implicitContext,\n              ...properties(),\n            };\n          }\n          return cachedProps;\n        },\n      }\n      : {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        message: parseMessageTemplate(rawMessage, {\n          ...implicitContext,\n          ...properties,\n        }),\n        rawMessage,\n        properties: { ...implicitContext, ...properties },\n      };\n    this.emit(record, bypassSinks);\n  }\n\n  logLazily(\n    level: LogLevel,\n    callback: LogCallback,\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    let rawMessage: TemplateStringsArray | undefined = undefined;\n    let msg: unknown[] | undefined = undefined;\n    function realizeMessage(): [unknown[], TemplateStringsArray] {\n      if (msg == null || rawMessage == null) {\n        msg = callback((tpl, ...values) => {\n          rawMessage = tpl;\n          return renderMessage(tpl, values);\n        });\n        if (rawMessage == null) throw new TypeError(\"No log record was made.\");\n      }\n      return [msg, rawMessage];\n    }\n    this.emit({\n      category: this.category,\n      level,\n      get message() {\n        return realizeMessage()[0];\n      },\n      get rawMessage() {\n        return realizeMessage()[1];\n      },\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    this.emit({\n      category: this.category,\n      level,\n      message: renderMessage(messageTemplate, values),\n      rawMessage: messageTemplate,\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"debug\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"info\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\n        \"warning\",\n        message,\n        (values[0] ?? {}) as Record<string, unknown>,\n      );\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"error\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"fatal\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * A logger implementation with contextual properties.  Do not use this\n * directly; use {@link Logger.with} instead.  This class is exported\n * for testing purposes.\n */\nexport class LoggerCtx implements Logger {\n  logger: LoggerImpl;\n  properties: Record<string, unknown>;\n\n  constructor(logger: LoggerImpl, properties: Record<string, unknown>) {\n    this.logger = logger;\n    this.properties = properties;\n  }\n\n  get category(): readonly string[] {\n    return this.logger.category;\n  }\n\n  get parent(): Logger | null {\n    return this.logger.parent;\n  }\n\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger {\n    return this.logger.getChild(subcategory).with(this.properties);\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this.logger, { ...this.properties, ...properties });\n  }\n\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    this.logger.log(\n      level,\n      message,\n      typeof properties === \"function\"\n        ? () => ({\n          ...this.properties,\n          ...properties(),\n        })\n        : { ...this.properties, ...properties },\n      bypassSinks,\n    );\n  }\n\n  logLazily(level: LogLevel, callback: LogCallback): void {\n    this.logger.logLazily(level, callback, this.properties);\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n  ): void {\n    this.logger.logTemplate(level, messageTemplate, values, this.properties);\n  }\n\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"debug\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"info\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\n        \"warning\",\n        message,\n        (values[0] ?? {}) as Record<string, unknown>,\n      );\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"error\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"fatal\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * The meta logger.  It is a logger with the category `[\"logtape\", \"meta\"]`.\n */\nconst metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n\n/**\n * Parse a message template into a message template array and a values array.\n * @param template The message template.\n * @param properties The values to replace placeholders with.\n * @returns The message template array and the values array.\n */\nexport function parseMessageTemplate(\n  template: string,\n  properties: Record<string, unknown>,\n): readonly unknown[] {\n  const message: unknown[] = [];\n  let part = \"\";\n  for (let i = 0; i < template.length; i++) {\n    const char = template.charAt(i);\n    const nextChar = template.charAt(i + 1);\n\n    if (char === \"{\" && nextChar === \"{\") {\n      // Escaped { character\n      part = part + char;\n      i++;\n    } else if (char === \"}\" && nextChar === \"}\") {\n      // Escaped } character\n      part = part + char;\n      i++;\n    } else if (char === \"{\") {\n      // Start of a placeholder\n      message.push(part);\n      part = \"\";\n    } else if (char === \"}\") {\n      // End of a placeholder\n      let prop: unknown;\n      if (part.match(/^\\s*\\*\\s*$/)) {\n        prop = part in properties\n          ? properties[part]\n          : \"*\" in properties\n          ? properties[\"*\"]\n          : properties;\n      } else if (part.match(/^\\s|\\s$/)) {\n        prop = part in properties ? properties[part] : properties[part.trim()];\n      } else {\n        prop = properties[part];\n      }\n      message.push(prop);\n      part = \"\";\n    } else {\n      // Default case\n      part = part + char;\n    }\n  }\n  message.push(part);\n  return message;\n}\n\n/**\n * Render a message template with values.\n * @param template The message template.\n * @param values The message template values.\n * @returns The message template values interleaved between the substitution\n *          values.\n */\nexport function renderMessage(\n  template: TemplateStringsArray,\n  values: readonly unknown[],\n): unknown[] {\n  const args = [];\n  for (let i = 0; i < template.length; i++) {\n    args.push(template[i]);\n    if (i < values.length) args.push(values[i]);\n  }\n  return args;\n}\n"],"mappings":"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"}
+{"version":3,"file":"logger.js","names":["category: string | readonly string[]","rootLogger: LoggerImpl | null","parent: LoggerImpl | null","category: readonly string[]","subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])]","child: LoggerImpl | undefined","properties: Record<string, unknown>","record: LogRecord","level: LogLevel","bypassSinks?: Set<Sink>","rawMessage: string","properties: Record<string, unknown> | (() => Record<string, unknown>)","cachedProps: Record<string, unknown> | undefined","callback: LogCallback","rawMessage: TemplateStringsArray | undefined","msg: unknown[] | undefined","messageTemplate: TemplateStringsArray","values: unknown[]","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>","logger: LoggerImpl","subcategory: string | readonly [string] | readonly [string, ...string[]]","message: string","template: string","message: unknown[]","prop: unknown","template: TemplateStringsArray","values: readonly unknown[]"],"sources":["../logger.ts"],"sourcesContent":["import type { ContextLocalStorage } from \"./context.ts\";\nimport type { Filter } from \"./filter.ts\";\nimport { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\nimport type { Sink } from \"./sink.ts\";\n\n/**\n * A logger interface.  It provides methods to log messages at different\n * severity levels.\n *\n * ```typescript\n * const logger = getLogger(\"category\");\n * logger.debug `A debug message with ${value}.`;\n * logger.info `An info message with ${value}.`;\n * logger.warn `A warning message with ${value}.`;\n * logger.error `An error message with ${value}.`;\n * logger.fatal `A fatal error message with ${value}.`;\n * ```\n */\nexport interface Logger {\n  /**\n   * The category of the logger.  It is an array of strings.\n   */\n  readonly category: readonly string[];\n\n  /**\n   * The logger with the supercategory of the current logger.  If the current\n   * logger is the root logger, this is `null`.\n   */\n  readonly parent: Logger | null;\n\n  /**\n   * Get a child logger with the given subcategory.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = logger.getChild(\"sub-category\");\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = getLogger([\"category\", \"sub-category\"]);\n   * ```\n   *\n   * @param subcategory The subcategory.\n   * @returns The child logger.\n   */\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger;\n\n  /**\n   * Get a logger with contextual properties.  This is useful for\n   * log multiple messages with the shared set of properties.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const ctx = logger.with({ foo: 123, bar: \"abc\" });\n   * ctx.info(\"A message with {foo} and {bar}.\");\n   * ctx.warn(\"Another message with {foo}, {bar}, and {baz}.\", { baz: true });\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * logger.info(\"A message with {foo} and {bar}.\", { foo: 123, bar: \"abc\" });\n   * logger.warn(\n   *   \"Another message with {foo}, {bar}, and {baz}.\",\n   *   { foo: 123, bar: \"abc\", baz: true },\n   * );\n   * ```\n   *\n   * @param properties\n   * @returns\n   * @since 0.5.0\n   */\n  with(properties: Record<string, unknown>): Logger;\n\n  /**\n   * Log a debug message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.debug `A debug message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a debug message with properties.\n   *\n   * ```typescript\n   * logger.debug('A debug message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.debug(\n   *   'A debug message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a debug values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.debug({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.debug('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  debug(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a debug message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  debug(callback: LogCallback): void;\n\n  /**\n   * Log an informational message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.info `An info message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an informational message with properties.\n   *\n   * ```typescript\n   * logger.info('An info message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.info(\n   *   'An info message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an informational values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.info({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.info('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  info(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an informational message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.info(l => l`An info message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  info(callback: LogCallback): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warn `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warn('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warn(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warn({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warn('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  warn(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  warn(callback: LogCallback): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warning `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warning('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warning(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warning({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warning('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  warning(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  warning(callback: LogCallback): void;\n\n  /**\n   * Log an error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.error `An error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an error message with properties.\n   *\n   * ```typescript\n   * logger.warn('An error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   'An error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.error({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.error('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  error(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.error(l => l`An error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  error(callback: LogCallback): void;\n\n  /**\n   * Log a fatal error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.fatal `A fatal error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a fatal error message with properties.\n   *\n   * ```typescript\n   * logger.warn('A fatal error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.fatal('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  fatal(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a fatal error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  fatal(callback: LogCallback): void;\n}\n\n/**\n * A logging callback function.  It is used to defer the computation of a\n * message template until it is actually logged.\n * @param prefix The message template prefix.\n * @returns The rendered message array.\n */\nexport type LogCallback = (prefix: LogTemplatePrefix) => unknown[];\n\n/**\n * A logging template prefix function.  It is used to log a message in\n * a {@link LogCallback} function.\n * @param message The message template strings array.\n * @param values The message template values.\n * @returns The rendered message array.\n */\nexport type LogTemplatePrefix = (\n  message: TemplateStringsArray,\n  ...values: unknown[]\n) => unknown[];\n\n/**\n * Get a logger with the given category.\n *\n * ```typescript\n * const logger = getLogger([\"my-app\"]);\n * ```\n *\n * @param category The category of the logger.  It can be a string or an array\n *                 of strings.  If it is a string, it is equivalent to an array\n *                 with a single element.\n * @returns The logger.\n */\nexport function getLogger(category: string | readonly string[] = []): Logger {\n  return LoggerImpl.getLogger(category);\n}\n\n/**\n * The symbol for the global root logger.\n */\nconst globalRootLoggerSymbol = Symbol.for(\"logtape.rootLogger\");\n\n/**\n * The global root logger registry.\n */\ninterface GlobalRootLoggerRegistry {\n  [globalRootLoggerSymbol]?: LoggerImpl;\n}\n\n/**\n * A logger implementation.  Do not use this directly; use {@link getLogger}\n * instead.  This class is exported for testing purposes.\n */\nexport class LoggerImpl implements Logger {\n  readonly parent: LoggerImpl | null;\n  readonly children: Record<string, LoggerImpl | WeakRef<LoggerImpl>>;\n  readonly category: readonly string[];\n  readonly sinks: Sink[];\n  parentSinks: \"inherit\" | \"override\" = \"inherit\";\n  readonly filters: Filter[];\n  lowestLevel: LogLevel | null = \"debug\";\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  static getLogger(category: string | readonly string[] = []): LoggerImpl {\n    let rootLogger: LoggerImpl | null = globalRootLoggerSymbol in globalThis\n      ? ((globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] ??\n        null)\n      : null;\n    if (rootLogger == null) {\n      rootLogger = new LoggerImpl(null, []);\n      (globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] =\n        rootLogger;\n    }\n    if (typeof category === \"string\") return rootLogger.getChild(category);\n    if (category.length === 0) return rootLogger;\n    return rootLogger.getChild(category as readonly [string, ...string[]]);\n  }\n\n  private constructor(parent: LoggerImpl | null, category: readonly string[]) {\n    this.parent = parent;\n    this.children = {};\n    this.category = category;\n    this.sinks = [];\n    this.filters = [];\n  }\n\n  getChild(\n    subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])],\n  ): LoggerImpl {\n    const name = typeof subcategory === \"string\" ? subcategory : subcategory[0];\n    const childRef = this.children[name];\n    let child: LoggerImpl | undefined = childRef instanceof LoggerImpl\n      ? childRef\n      : childRef?.deref();\n    if (child == null) {\n      child = new LoggerImpl(this, [...this.category, name]);\n      this.children[name] = \"WeakRef\" in globalThis\n        ? new WeakRef(child)\n        : child;\n    }\n    if (typeof subcategory === \"string\" || subcategory.length === 1) {\n      return child;\n    }\n    return child.getChild(\n      subcategory.slice(1) as [string, ...(readonly string[])],\n    );\n  }\n\n  /**\n   * Reset the logger.  This removes all sinks and filters from the logger.\n   */\n  reset(): void {\n    while (this.sinks.length > 0) this.sinks.shift();\n    this.parentSinks = \"inherit\";\n    while (this.filters.length > 0) this.filters.shift();\n    this.lowestLevel = \"debug\";\n  }\n\n  /**\n   * Reset the logger and all its descendants.  This removes all sinks and\n   * filters from the logger and all its descendants.\n   */\n  resetDescendants(): void {\n    for (const child of Object.values(this.children)) {\n      const logger = child instanceof LoggerImpl ? child : child.deref();\n      if (logger != null) logger.resetDescendants();\n    }\n    this.reset();\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this, { ...properties });\n  }\n\n  filter(record: LogRecord): boolean {\n    for (const filter of this.filters) {\n      if (!filter(record)) return false;\n    }\n    if (this.filters.length < 1) return this.parent?.filter(record) ?? true;\n    return true;\n  }\n\n  *getSinks(level: LogLevel): Iterable<Sink> {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return;\n    }\n    if (this.parent != null && this.parentSinks === \"inherit\") {\n      for (const sink of this.parent.getSinks(level)) yield sink;\n    }\n    for (const sink of this.sinks) yield sink;\n  }\n\n  emit(record: LogRecord, bypassSinks?: Set<Sink>): void {\n    if (\n      this.lowestLevel === null ||\n      compareLogLevel(record.level, this.lowestLevel) < 0 ||\n      !this.filter(record)\n    ) {\n      return;\n    }\n    for (const sink of this.getSinks(record.level)) {\n      if (bypassSinks?.has(sink)) continue;\n      try {\n        sink(record);\n      } catch (error) {\n        const bypassSinks2 = new Set(bypassSinks);\n        bypassSinks2.add(sink);\n        metaLogger.log(\n          \"fatal\",\n          \"Failed to emit a log record to sink {sink}: {error}\",\n          { sink, error, record },\n          bypassSinks2,\n        );\n      }\n    }\n  }\n\n  log(\n    level: LogLevel,\n    rawMessage: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    let cachedProps: Record<string, unknown> | undefined = undefined;\n    const record: LogRecord = typeof properties === \"function\"\n      ? {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        get message() {\n          return parseMessageTemplate(rawMessage, this.properties);\n        },\n        rawMessage,\n        get properties() {\n          if (cachedProps == null) {\n            cachedProps = {\n              ...implicitContext,\n              ...properties(),\n            };\n          }\n          return cachedProps;\n        },\n      }\n      : {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        message: parseMessageTemplate(rawMessage, {\n          ...implicitContext,\n          ...properties,\n        }),\n        rawMessage,\n        properties: { ...implicitContext, ...properties },\n      };\n    this.emit(record, bypassSinks);\n  }\n\n  logLazily(\n    level: LogLevel,\n    callback: LogCallback,\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    let rawMessage: TemplateStringsArray | undefined = undefined;\n    let msg: unknown[] | undefined = undefined;\n    function realizeMessage(): [unknown[], TemplateStringsArray] {\n      if (msg == null || rawMessage == null) {\n        msg = callback((tpl, ...values) => {\n          rawMessage = tpl;\n          return renderMessage(tpl, values);\n        });\n        if (rawMessage == null) throw new TypeError(\"No log record was made.\");\n      }\n      return [msg, rawMessage];\n    }\n    this.emit({\n      category: this.category,\n      level,\n      get message() {\n        return realizeMessage()[0];\n      },\n      get rawMessage() {\n        return realizeMessage()[1];\n      },\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext =\n      LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};\n    this.emit({\n      category: this.category,\n      level,\n      message: renderMessage(messageTemplate, values),\n      rawMessage: messageTemplate,\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"debug\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"info\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\n        \"warning\",\n        message,\n        (values[0] ?? {}) as Record<string, unknown>,\n      );\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    this.warn(message, ...values);\n  }\n\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"error\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"fatal\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * A logger implementation with contextual properties.  Do not use this\n * directly; use {@link Logger.with} instead.  This class is exported\n * for testing purposes.\n */\nexport class LoggerCtx implements Logger {\n  logger: LoggerImpl;\n  properties: Record<string, unknown>;\n\n  constructor(logger: LoggerImpl, properties: Record<string, unknown>) {\n    this.logger = logger;\n    this.properties = properties;\n  }\n\n  get category(): readonly string[] {\n    return this.logger.category;\n  }\n\n  get parent(): Logger | null {\n    return this.logger.parent;\n  }\n\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger {\n    return this.logger.getChild(subcategory).with(this.properties);\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this.logger, { ...this.properties, ...properties });\n  }\n\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    this.logger.log(\n      level,\n      message,\n      typeof properties === \"function\"\n        ? () => ({\n          ...this.properties,\n          ...properties(),\n        })\n        : { ...this.properties, ...properties },\n      bypassSinks,\n    );\n  }\n\n  logLazily(level: LogLevel, callback: LogCallback): void {\n    this.logger.logLazily(level, callback, this.properties);\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n  ): void {\n    this.logger.logTemplate(level, messageTemplate, values, this.properties);\n  }\n\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"debug\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"info\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\n        \"warning\",\n        message,\n        (values[0] ?? {}) as Record<string, unknown>,\n      );\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    this.warn(message, ...values);\n  }\n\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"error\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void {\n    if (typeof message === \"string\") {\n      this.log(\"fatal\", message, (values[0] ?? {}) as Record<string, unknown>);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * The meta logger.  It is a logger with the category `[\"logtape\", \"meta\"]`.\n */\nconst metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n\n/**\n * Parse a message template into a message template array and a values array.\n * @param template The message template.\n * @param properties The values to replace placeholders with.\n * @returns The message template array and the values array.\n */\nexport function parseMessageTemplate(\n  template: string,\n  properties: Record<string, unknown>,\n): readonly unknown[] {\n  const message: unknown[] = [];\n  let part = \"\";\n  for (let i = 0; i < template.length; i++) {\n    const char = template.charAt(i);\n    const nextChar = template.charAt(i + 1);\n\n    if (char === \"{\" && nextChar === \"{\") {\n      // Escaped { character\n      part = part + char;\n      i++;\n    } else if (char === \"}\" && nextChar === \"}\") {\n      // Escaped } character\n      part = part + char;\n      i++;\n    } else if (char === \"{\") {\n      // Start of a placeholder\n      message.push(part);\n      part = \"\";\n    } else if (char === \"}\") {\n      // End of a placeholder\n      let prop: unknown;\n      if (part.match(/^\\s*\\*\\s*$/)) {\n        prop = part in properties\n          ? properties[part]\n          : \"*\" in properties\n          ? properties[\"*\"]\n          : properties;\n      } else if (part.match(/^\\s|\\s$/)) {\n        prop = part in properties ? properties[part] : properties[part.trim()];\n      } else {\n        prop = properties[part];\n      }\n      message.push(prop);\n      part = \"\";\n    } else {\n      // Default case\n      part = part + char;\n    }\n  }\n  message.push(part);\n  return message;\n}\n\n/**\n * Render a message template with values.\n * @param template The message template.\n * @param values The message template values.\n * @returns The message template values interleaved between the substitution\n *          values.\n */\nexport function renderMessage(\n  template: TemplateStringsArray,\n  values: readonly unknown[],\n): unknown[] {\n  const args = [];\n  for (let i = 0; i < template.length; i++) {\n    args.push(template[i]);\n    if (i < values.length) args.push(values[i]);\n  }\n  return args;\n}\n"],"mappings":"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"}

package/logger.test.ts

@@ -496,7 +496,7 @@ test("LoggerCtx.logTemplate()", () => {
   }
 });
 
-const methods = ["debug", "info", "warn", "error", "fatal"] as const;
+const methods = ["debug", "info", "warn", "warning", "error", "fatal"] as const;
 for (const method of methods) {
   test(`Logger.${method}() [template]`, () => {
     const logger = LoggerImpl.getLogger("foo");

package/logger.ts

@@ -336,6 +336,92 @@ export interface Logger {
    */
   warn(callback: LogCallback): void;
 
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  warning(
+    message: string,
+    properties?: Record<string, unknown> | (() => Record<string, unknown>),
+  ): void;
+
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  warning(properties: Record<string, unknown>): void;
+
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  warning(callback: LogCallback): void;
+
   /**
    * Log an error message.  Use this as a template string prefix.
    *
@@ -844,6 +930,17 @@ export class LoggerImpl implements Logger {
     }
   }
 
+  warning(
+    message:
+      | TemplateStringsArray
+      | string
+      | LogCallback
+      | Record<string, unknown>,
+    ...values: unknown[]
+  ): void {
+    this.warn(message, ...values);
+  }
+
   error(
     message:
       | TemplateStringsArray
@@ -1007,6 +1104,17 @@ export class LoggerCtx implements Logger {
     }
   }
 
+  warning(
+    message:
+      | TemplateStringsArray
+      | string
+      | LogCallback
+      | Record<string, unknown>,
+    ...values: unknown[]
+  ): void {
+    this.warn(message, ...values);
+  }
+
   error(
     message:
       | TemplateStringsArray

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "0.12.0-dev.183+dc6777f0",
+  "version": "0.12.0-dev.185+3924dfe1",
   "description": "Simple logging library with zero dependencies for Deno/Node.js/Bun/browsers",
   "keywords": [
     "logging",
@@ -42,9 +42,10 @@
       "node": "./dist/util.node.cjs",
       "bun": "./dist/util.node.js",
       "deno": "./dist/util.deno.js",
-      "import": "./dist/util.mjs",
-      "require": "./dist/util.js",
-      "types": "./dist/util.d.mts"
+      "import": "./dist/util.js",
+      "require": "./dist/util.cjs",
+      "default": "./dist/util.js",
+      "types": "./dist/util.d.ts"
     }
   },
   "devDependencies": {