@logtape/logtape 0.1.0-dev.10

package/types/filter.d.ts

@@ -0,0 +1,30 @@
+import type { LogLevel, LogRecord } from "./record.js";
+/**
+ * A filter is a function that accepts a log record and returns `true` if the
+ * record should be passed to the sink.
+ *
+ * @param record The log record to filter.
+ * @returns `true` if the record should be passed to the sink.
+ */
+export type Filter = (record: LogRecord) => boolean;
+/**
+ * A filter-like value is either a {@link Filter} or a {@link LogLevel}.
+ * `null` is also allowed to represent a filter that rejects all records.
+ */
+export type FilterLike = Filter | LogLevel | null;
+/**
+ * Converts a {@link FilterLike} value to an actual {@link Filter}.
+ *
+ * @param filter The filter-like value to convert.
+ * @returns The actual filter.
+ */
+export declare function toFilter(filter: FilterLike): Filter;
+/**
+ * Returns a filter that accepts log records with the specified level.
+ *
+ * @param level The level to filter by.  If `null`, the filter will reject all
+ *              records.
+ * @returns The filter.
+ */
+export declare function getLevelFilter(level: LogLevel | null): Filter;
+//# sourceMappingURL=filter.d.ts.map

package/types/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAGnD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAoB7D"}

package/types/filter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.test.d.ts","sourceRoot":"","sources":["../src/filter.test.ts"],"names":[],"mappings":""}

package/types/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../src/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,IAAI,EAAE,SAMlB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,SAGnB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,SAGrB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,SAGnB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,SAGnB,CAAC"}

package/types/formatter.d.ts

@@ -0,0 +1,38 @@
+import type { LogRecord } from "./record.js";
+/**
+ * A text formatter is a function that accepts a log record and returns
+ * a string.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ */
+export type TextFormatter = (record: LogRecord) => string;
+/**
+ * The default text formatter.  This formatter formats log records as follows:
+ *
+ * ```
+ * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+ * ```
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ */
+export declare function defaultTextFormatter(record: LogRecord): string;
+/**
+ * A console formatter is a function that accepts a log record and returns
+ * an array of arguments to pass to {@link console.log}.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+export type ConsoleFormatter = (record: LogRecord) => readonly unknown[];
+/**
+ * The default console formatter.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+export declare function defaultConsoleFormatter(record: LogRecord): readonly unknown[];
+//# sourceMappingURL=formatter.d.ts.map

package/types/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,CAAC;AA+B1D;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAW9D;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,SAAS,OAAO,EAAE,CAAC;AAazE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,OAAO,EAAE,CAoB7E"}

package/types/formatter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.test.d.ts","sourceRoot":"","sources":["../src/formatter.test.ts"],"names":[],"mappings":""}

package/types/logger.d.ts

@@ -0,0 +1,363 @@
+import type { Filter } from "./filter.js";
+import type { LogLevel, LogRecord } from "./record.js";
+import type { Sink } from "./sink.js";
+/**
+ * A logger interface.  It provides methods to log messages at different
+ * severity levels.
+ *
+ * ```typescript
+ * const logger = getLogger("category");
+ * logger.debug `A debug message with ${value}.`;
+ * logger.info `An info message with ${value}.`;
+ * logger.warn `A warning message with ${value}.`;
+ * logger.error `An error message with ${value}.`;
+ * logger.fatal `A fatal error message with ${value}.`;
+ * ```
+ */
+export interface Logger {
+    /**
+     * The category of the logger.  It is an array of strings.
+     */
+    readonly category: readonly string[];
+    /**
+     * The logger with the supercategory of the current logger.  If the current
+     * logger is the root logger, this is `null`.
+     */
+    readonly parent: Logger | null;
+    /**
+     * Get a child logger with the given subcategory.
+     *
+     * ```typescript
+     * const logger = getLogger("category");
+     * const subLogger = logger.getChild("sub-category");
+     * ```
+     *
+     * The above code is equivalent to:
+     *
+     * ```typescript
+     * const logger = getLogger("category");
+     * const subLogger = getLogger(["category", "sub-category"]);
+     * ```
+     *
+     * @param subcategory The subcategory.
+     * @returns The child logger.
+     */
+    getChild(subcategory: string | readonly [string] | readonly [string, ...string[]]): Logger;
+    /**
+     * Log a debug message.  Use this as a template string prefix.
+     *
+     * ```typescript
+     * logger.debug `A debug message with ${value}.`;
+     * ```
+     *
+     * @param message The message template strings array.
+     * @param values The message template values.
+     */
+    debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+    /**
+     * Log a debug message with properties.
+     *
+     * ```typescript
+     * logger.debug('A debug message with {value}.', { value });
+     * ```
+     *
+     * If the properties are expensive to compute, you can pass a callback that
+     * returns the properties:
+     *
+     * ```typescript
+     * logger.debug(
+     *   'A debug 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.
+     */
+    debug(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+    /**
+     * Lazily log a debug message.  Use this when the message values are expensive
+     * to compute and should only be computed if the message is actually logged.
+     *
+     * ```typescript
+     * logger.debug(l => l`A debug message with ${expensiveValue()}.`);
+     * ```
+     *
+     * @param callback A callback that returns the message template prefix.
+     */
+    debug(callback: LogCallback): void;
+    /**
+     * Log an informational message.  Use this as a template string prefix.
+     *
+     * ```typescript
+     * logger.info `An info message with ${value}.`;
+     * ```
+     *
+     * @param message The message template strings array.
+     * @param values The message template values.
+     */
+    info(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+    /**
+     * Log an informational message with properties.
+     *
+     * ```typescript
+     * logger.info('An info message with {value}.', { value });
+     * ```
+     *
+     * If the properties are expensive to compute, you can pass a callback that
+     * returns the properties:
+     *
+     * ```typescript
+     * logger.info(
+     *   'An info 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.
+     */
+    info(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+    /**
+     * Lazily log an informational message.  Use this when the message values are
+     * expensive to compute and should only be computed if the message is actually
+     * logged.
+     *
+     * ```typescript
+     * logger.info(l => l`An info message with ${expensiveValue()}.`);
+     * ```
+     *
+     * @param callback A callback that returns the message template prefix.
+     */
+    info(callback: LogCallback): void;
+    /**
+     * Log a warning message.  Use this as a template string prefix.
+     *
+     * ```typescript
+     * logger.warn `A warning message with ${value}.`;
+     * ```
+     *
+     * @param message The message template strings array.
+     * @param values The message template values.
+     */
+    warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+    /**
+     * Log a warning message with properties.
+     *
+     * ```typescript
+     * logger.warn('A warning message with {value}.', { value });
+     * ```
+     *
+     * If the properties are expensive to compute, you can pass a callback that
+     * returns the properties:
+     *
+     * ```typescript
+     * logger.warn(
+     *   '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.
+     */
+    warn(message: string, properties?: Record<string, unknown> | (() => 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.warn(l => l`A warning message with ${expensiveValue()}.`);
+     * ```
+     *
+     * @param callback A callback that returns the message template prefix.
+     */
+    warn(callback: LogCallback): void;
+    /**
+     * Log an error message.  Use this as a template string prefix.
+     *
+     * ```typescript
+     * logger.error `An error message with ${value}.`;
+     * ```
+     *
+     * @param message The message template strings array.
+     * @param values The message template values.
+     */
+    error(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+    /**
+     * Log an error message with properties.
+     *
+     * ```typescript
+     * logger.warn('An error message with {value}.', { value });
+     * ```
+     *
+     * If the properties are expensive to compute, you can pass a callback that
+     * returns the properties:
+     *
+     * ```typescript
+     * logger.error(
+     *   'An error 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.
+     */
+    error(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+    /**
+     * Lazily log an error message.  Use this when the message values are
+     * expensive to compute and should only be computed if the message is actually
+     * logged.
+     *
+     * ```typescript
+     * logger.error(l => l`An error message with ${expensiveValue()}.`);
+     * ```
+     *
+     * @param callback A callback that returns the message template prefix.
+     */
+    error(callback: LogCallback): void;
+    /**
+     * Log a fatal error message.  Use this as a template string prefix.
+     *
+     * ```typescript
+     * logger.fatal `A fatal error message with ${value}.`;
+     * ```
+     *
+     * @param message The message template strings array.
+     * @param values The message template values.
+     */
+    fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+    /**
+     * Log a fatal error message with properties.
+     *
+     * ```typescript
+     * logger.warn('A fatal error message with {value}.', { value });
+     * ```
+     *
+     * If the properties are expensive to compute, you can pass a callback that
+     * returns the properties:
+     *
+     * ```typescript
+     * logger.fatal(
+     *   'A fatal error 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.
+     */
+    fatal(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+    /**
+     * Lazily log a fatal error message.  Use this when the message values are
+     * expensive to compute and should only be computed if the message is actually
+     * logged.
+     *
+     * ```typescript
+     * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);
+     * ```
+     *
+     * @param callback A callback that returns the message template prefix.
+     */
+    fatal(callback: LogCallback): void;
+}
+/**
+ * A logging callback function.  It is used to defer the computation of a
+ * message template until it is actually logged.
+ * @param prefix The message template prefix.
+ * @returns The rendered message array.
+ */
+export type LogCallback = (prefix: LogTemplatePrefix) => unknown[];
+/**
+ * A logging template prefix function.  It is used to log a message in
+ * a {@link LogCallback} function.
+ * @param message The message template strings array.
+ * @param values The message template values.
+ * @returns The rendered message array.
+ */
+export type LogTemplatePrefix = (message: TemplateStringsArray, ...values: unknown[]) => unknown[];
+/**
+ * Get a logger with the given category.
+ *
+ * ```typescript
+ * const logger = getLogger(["my-app"]);
+ * ```
+ *
+ * @param category The category of the logger.  It can be a string or an array
+ *                 of strings.  If it is a string, it is equivalent to an array
+ *                 with a single element.
+ * @returns The logger.
+ */
+export declare function getLogger(category?: string | readonly string[]): Logger;
+/**
+ * A logger implementation.  Do not use this directly; use {@link getLogger}
+ * instead.  This class is exported for testing purposes.
+ */
+export declare class LoggerImpl implements Logger {
+    readonly parent: LoggerImpl | null;
+    readonly children: Record<string, WeakRef<LoggerImpl>>;
+    readonly category: readonly string[];
+    readonly sinks: Sink[];
+    readonly filters: Filter[];
+    static getLogger(category?: string | readonly string[]): LoggerImpl;
+    private constructor();
+    getChild(subcategory: string | readonly [string] | readonly [string, ...readonly string[]]): LoggerImpl;
+    /**
+     * Reset the logger.  This removes all sinks and filters from the logger.
+     */
+    reset(): void;
+    /**
+     * Reset the logger and all its descendants.  This removes all sinks and
+     * filters from the logger and all its descendants.
+     */
+    resetDescendants(): void;
+    filter(record: LogRecord): boolean;
+    getSinks(): Iterable<Sink>;
+    emit(record: LogRecord, bypassSinks?: Set<Sink>): void;
+    log(level: LogLevel, message: string, properties: Record<string, unknown> | (() => Record<string, unknown>), bypassSinks?: Set<Sink>): void;
+    logLazily(level: LogLevel, callback: LogCallback): void;
+    logTemplate(level: LogLevel, messageTemplate: TemplateStringsArray, values: unknown[]): void;
+    debug(message: TemplateStringsArray | string | LogCallback, ...values: unknown[]): void;
+    info(message: TemplateStringsArray | string | LogCallback, ...values: unknown[]): void;
+    warn(message: TemplateStringsArray | string | LogCallback, ...values: unknown[]): void;
+    error(message: TemplateStringsArray | string | LogCallback, ...values: unknown[]): void;
+    fatal(message: TemplateStringsArray | string | LogCallback, ...values: unknown[]): void;
+}
+/**
+ * Parse a message template into a message template array and a values array.
+ * @param template The message template.
+ * @param properties The values to replace placeholders with.
+ * @returns The message template array and the values array.
+ */
+export declare function parseMessageTemplate(template: string, properties: Record<string, unknown>): readonly unknown[];
+/**
+ * Render a message template with values.
+ * @param template The message template.
+ * @param values The message template values.
+ * @returns The message template values interleaved between the substitution
+ *          values.
+ */
+export declare function renderMessage(template: TemplateStringsArray, values: readonly unknown[]): unknown[];
+//# sourceMappingURL=logger.d.ts.map

package/types/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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"}

package/types/logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../src/logger.test.ts"],"names":[],"mappings":""}

package/types/mod.d.ts

@@ -0,0 +1,7 @@
+export { type Config, ConfigError, configure, type LoggerConfig, } from "./config.js";
+export { type Filter, type FilterLike, getLevelFilter, toFilter, } from "./filter.js";
+export { type ConsoleFormatter, defaultConsoleFormatter, type TextFormatter, } from "./formatter.js";
+export { getLogger, type Logger } from "./logger.js";
+export type { LogLevel, LogRecord } from "./record.js";
+export { getConsoleSink, type Sink } from "./sink.js";
+//# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,WAAW,EACX,SAAS,EACT,KAAK,YAAY,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,cAAc,EACd,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,gBAAgB,EACrB,uBAAuB,EACvB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AACrD,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/types/record.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The severity level of a {@link LogRecord}.
+ */
+export type LogLevel = "debug" | "info" | "warning" | "error" | "fatal";
+/**
+ * A log record.
+ */
+export interface LogRecord {
+    /**
+     * The category of the logger that produced the log record.
+     */
+    readonly category: readonly string[];
+    /**
+     * The log level.
+     */
+    readonly level: LogLevel;
+    /**
+     * The log message.  This is the result of substituting the message template
+     * with the values.  The number of elements in this array is always odd,
+     * with the message template values interleaved between the substitution
+     * values.
+     */
+    readonly message: readonly unknown[];
+    /**
+     * The timestamp of the log record in milliseconds since the Unix epoch.
+     */
+    readonly timestamp: number;
+    /**
+     * The extra properties of the log record.
+     */
+    readonly properties: Record<string, unknown>;
+}
+//# sourceMappingURL=record.d.ts.map

package/types/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAEzB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9C"}

package/types/sink.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as dntShim from "./_dnt.shims.js";
+import { type ConsoleFormatter, type TextFormatter } from "./formatter.js";
+import type { LogRecord } from "./record.js";
+/**
+ * A sink is a function that accepts a log record and prints it somewhere.
+ * Thrown exceptions will be suppressed and then logged to the meta logger,
+ * a {@link Logger} with the category `["logtape", "meta"]`.  (In that case,
+ * the meta log record will not be passed to the sink to avoid infinite
+ * recursion.)
+ *
+ * @param record The log record to sink.
+ */
+export type Sink = (record: LogRecord) => void;
+/**
+ * A factory that returns a sink that writes to a {@link WritableStream}.
+ *
+ * Note that the `stream` is of Web Streams API, which is different from
+ * Node.js streams.  You can convert a Node.js stream to a Web Streams API
+ * stream using [`stream.Writable.toWeb()`] method.
+ *
+ * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable
+ *
+ * @example Sink to the standard error in Deno
+ * ```typescript
+ * const stderrSink = getStreamSink(Deno.stderr.writable);
+ * ```
+ *
+ * @example Sink to the standard error in Node.js
+ * ```typescript
+ * import stream from "node:stream";
+ * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));
+ * ```
+ *
+ * @param stream The stream to write to.
+ * @param formatter The text formatter to use.  Defaults to
+ *                  {@link defaultTextFormatter}.
+ * @param encoder The text encoder to use.  Defaults to an instance of
+ *                {@link TextEncoder}.
+ * @returns A sink that writes to the stream.
+ */
+export declare function getStreamSink(stream: dntShim.WritableStream, formatter?: TextFormatter, encoder?: {
+    encode(text: string): Uint8Array;
+}): Sink;
+/**
+ * A console sink factory that returns a sink that logs to the console.
+ *
+ * @param formatter A console formatter.  Defaults to
+ *                  {@link defaultConsoleFormatter}.
+ * @param console The console to log to.  Defaults to {@link console}.
+ * @returns A sink that logs to the console.
+ */
+export declare function getConsoleSink(formatter?: ConsoleFormatter, console?: Console): Sink;
+//# sourceMappingURL=sink.d.ts.map

package/types/sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../src/sink.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EACL,KAAK,gBAAgB,EAGrB,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,CAAC,cAAc,EAC9B,SAAS,GAAE,aAAoC,EAC/C,OAAO,GAAE;IAAE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;CAAsB,GAChE,IAAI,CAMN;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,SAAS,GAAE,gBAA0C,EACrD,OAAO,GAAE,OAA4B,GACpC,IAAI,CAUN"}

package/types/sink.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink.test.d.ts","sourceRoot":"","sources":["../src/sink.test.ts"],"names":[],"mappings":""}