@vidavidorra/bunyan-pretty-stream 3.0.17 → 4.0.0-beta.2

package/LICENSE.md

@@ -217,23 +217,23 @@ produce it from the Program, in the form of source code under the
 terms of section 4, provided that you also meet all of these
 conditions:
 
--   a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
--   b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under
-    section 7. This requirement modifies the requirement in section 4
-    to "keep intact all notices".
--   c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy. This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged. This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
--   d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
+- a) The work must carry prominent notices stating that you modified
+  it, and giving a relevant date.
+- b) The work must carry prominent notices stating that it is
+  released under this License and any conditions added under
+  section 7. This requirement modifies the requirement in section 4
+  to "keep intact all notices".
+- c) You must license the entire work, as a whole, under this
+  License to anyone who comes into possession of a copy. This
+  License will therefore apply, along with any applicable section 7
+  additional terms, to the whole of the work, and all its parts,
+  regardless of how they are packaged. This License gives no
+  permission to license the work in any other way, but it does not
+  invalidate such permission if you have separately received it.
+- d) If the work has interactive user interfaces, each must display
+  Appropriate Legal Notices; however, if the Program has interactive
+  interfaces that do not display Appropriate Legal Notices, your
+  work need not make them do so.
 
 A compilation of a covered work with other separate and independent
 works, which are not by their nature extensions of the covered work,
@@ -252,42 +252,42 @@ sections 4 and 5, provided that you also convey the machine-readable
 Corresponding Source under the terms of this License, in one of these
 ways:
 
--   a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
--   b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the Corresponding
-    Source from a network server at no charge.
--   c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source. This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
--   d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge. You need not require recipients to copy the
-    Corresponding Source along with the object code. If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source. Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
--   e) Convey the object code using peer-to-peer transmission,
-    provided you inform other peers where the object code and
-    Corresponding Source of the work are being offered to the general
-    public at no charge under subsection 6d.
+- a) Convey the object code in, or embodied in, a physical product
+  (including a physical distribution medium), accompanied by the
+  Corresponding Source fixed on a durable physical medium
+  customarily used for software interchange.
+- b) Convey the object code in, or embodied in, a physical product
+  (including a physical distribution medium), accompanied by a
+  written offer, valid for at least three years and valid for as
+  long as you offer spare parts or customer support for that product
+  model, to give anyone who possesses the object code either (1) a
+  copy of the Corresponding Source for all the software in the
+  product that is covered by this License, on a durable physical
+  medium customarily used for software interchange, for a price no
+  more than your reasonable cost of physically performing this
+  conveying of source, or (2) access to copy the Corresponding
+  Source from a network server at no charge.
+- c) Convey individual copies of the object code with a copy of the
+  written offer to provide the Corresponding Source. This
+  alternative is allowed only occasionally and noncommercially, and
+  only if you received the object code with such an offer, in accord
+  with subsection 6b.
+- d) Convey the object code by offering access from a designated
+  place (gratis or for a charge), and offer equivalent access to the
+  Corresponding Source in the same way through the same place at no
+  further charge. You need not require recipients to copy the
+  Corresponding Source along with the object code. If the place to
+  copy the object code is a network server, the Corresponding Source
+  may be on a different server (operated by you or a third party)
+  that supports equivalent copying facilities, provided you maintain
+  clear directions next to the object code saying where to find the
+  Corresponding Source. Regardless of what server hosts the
+  Corresponding Source, you remain obligated to ensure that it is
+  available for as long as needed to satisfy these requirements.
+- e) Convey the object code using peer-to-peer transmission,
+  provided you inform other peers where the object code and
+  Corresponding Source of the work are being offered to the general
+  public at no charge under subsection 6d.
 
 A separable portion of the object code, whose source code is excluded
 from the Corresponding Source as a System Library, need not be
@@ -363,23 +363,23 @@ Notwithstanding any other provision of this License, for material you
 add to a covered work, you may (if authorized by the copyright holders
 of that material) supplement the terms of this License with terms:
 
--   a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
--   b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
--   c) Prohibiting misrepresentation of the origin of that material,
-    or requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
--   d) Limiting the use for publicity purposes of names of licensors
-    or authors of the material; or
--   e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
--   f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions
-    of it) with contractual assumptions of liability to the recipient,
-    for any liability that these contractual assumptions directly
-    impose on those licensors and authors.
+- a) Disclaiming warranty or limiting liability differently from the
+  terms of sections 15 and 16 of this License; or
+- b) Requiring preservation of specified reasonable legal notices or
+  author attributions in that material or in the Appropriate Legal
+  Notices displayed by works containing it; or
+- c) Prohibiting misrepresentation of the origin of that material,
+  or requiring that modified versions of such material be marked in
+  reasonable ways as different from the original version; or
+- d) Limiting the use for publicity purposes of names of licensors
+  or authors of the material; or
+- e) Declining to grant rights under trademark law for use of some
+  trade names, trademarks, or service marks; or
+- f) Requiring indemnification of licensors and authors of that
+  material by anyone who conveys the material (or modified versions
+  of it) with contractual assumptions of liability to the recipient,
+  for any liability that these contractual assumptions directly
+  impose on those licensors and authors.
 
 All other non-permissive additional terms are considered "further
 restrictions" within the meaning of section 10. If the Program as you

package/dist/bunyan/core-fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bunyan core fields as defined by the [Core fields](
+ * https://github.com/trentm/node-bunyan/tree/1.8.15#core-fields) documentation.
+ */
+declare const coreFields: readonly string[];
+export default coreFields;

package/dist/bunyan/core-fields.js

@@ -0,0 +1,16 @@
+/**
+ * Bunyan core fields as defined by the [Core fields](
+ * https://github.com/trentm/node-bunyan/tree/1.8.15#core-fields) documentation.
+ */
+const coreFields = [
+    'v',
+    'level',
+    'name',
+    'hostname',
+    'pid',
+    'time',
+    'msg',
+    'src',
+];
+export default coreFields;
+//# sourceMappingURL=core-fields.js.map

package/dist/bunyan/from-json-string.d.ts

@@ -0,0 +1,3 @@
+import type BunyanRecord from './record.js';
+declare function fromJsonString(json: string): BunyanRecord;
+export default fromJsonString;

package/dist/bunyan/from-json-string.js

@@ -0,0 +1,17 @@
+import isBunyanRecord from './is-record.js';
+function fromJsonString(json) {
+    const record = JSON.parse(json, (key, value) => {
+        if (key === 'time' &&
+            typeof value === 'string' &&
+            /^((\+-)\d{2})?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(value)) {
+            return new Date(value);
+        }
+        return value;
+    });
+    if (!isBunyanRecord(record)) {
+        throw new Error('string MUST be parsable to a valid Bunyan record');
+    }
+    return record;
+}
+export default fromJsonString;
+//# sourceMappingURL=from-json-string.js.map

package/dist/bunyan/index.d.ts

@@ -0,0 +1,4 @@
+export { default as isBunyanRecord } from './is-record.js';
+export { type default as BunyanRecord } from './record.js';
+export { default as coreFields } from './core-fields.js';
+export { default as fromJsonString } from './from-json-string.js';

package/dist/bunyan/index.js

@@ -0,0 +1,4 @@
+export { default as isBunyanRecord } from './is-record.js';
+export { default as coreFields } from './core-fields.js';
+export { default as fromJsonString } from './from-json-string.js';
+//# sourceMappingURL=index.js.map

package/dist/bunyan/is-record.d.ts

@@ -0,0 +1,3 @@
+import type BunyanRecord from './record.js';
+declare function isBunyanRecord(value: unknown): value is BunyanRecord;
+export default isBunyanRecord;

package/dist/bunyan/is-record.js

@@ -0,0 +1,17 @@
+import is from '@sindresorhus/is';
+function isBunyanRecord(value) {
+    return (is.plainObject(value) &&
+        is.number(value.v) &&
+        is.number(value.level) &&
+        is.string(value.name) &&
+        is.string(value.hostname) &&
+        is.number(value.pid) &&
+        is.date(value.time) &&
+        is.string(value.msg) &&
+        (is.undefined(value.src) ||
+            (is.plainObject(value.src) &&
+                is.number(value.src.line) &&
+                (is.undefined(value.src.func) || is.string(value.src.func)))));
+}
+export default isBunyanRecord;
+//# sourceMappingURL=is-record.js.map

package/dist/bunyan/record.d.ts

@@ -0,0 +1,16 @@
+type BunyanRecord = {
+    [key: string]: unknown;
+    v: number;
+    level: number;
+    name: string;
+    hostname: string;
+    pid: number;
+    time: Date;
+    msg: string;
+    src?: {
+        file: string;
+        line: number;
+        func?: string;
+    };
+};
+export default BunyanRecord;

package/dist/bunyan/record.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=record.js.map

package/dist/bunyan-pretty-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
+import type { PublicOptions as Options } from './options.js';
+declare class PrettyStream extends Transform {
+    private readonly _formatter;
+    constructor(options?: Options);
+    _transform(chunk: any, _: BufferEncoding, done: TransformCallback): void;
+}
+export { PrettyStream };

package/dist/bunyan-pretty-stream.js

@@ -0,0 +1,25 @@
+import { Transform } from 'node:stream';
+import { fromJsonString, isBunyanRecord } from './bunyan/index.js';
+import { Formatter } from './formatter/index.js';
+class PrettyStream extends Transform {
+    _formatter;
+    constructor(options = {}) {
+        super({ objectMode: true });
+        this._formatter = new Formatter(options);
+    }
+    _transform(chunk, _, done) {
+        if (typeof chunk === 'string') {
+            this.push(this._formatter.format(fromJsonString(chunk)));
+            done();
+        }
+        else if (isBunyanRecord(chunk)) {
+            this.push(this._formatter.format(chunk));
+            done();
+        }
+        else {
+            done(new Error('data MUST be a valid bunyan record'));
+        }
+    }
+}
+export { PrettyStream };
+//# sourceMappingURL=bunyan-pretty-stream.js.map

package/dist/formatter/extra.d.ts

@@ -0,0 +1,11 @@
+declare class Extra {
+    private readonly _keyValueSeparator;
+    constructor(keyValueSeparator: string);
+    format(key: string, value: unknown): {
+        formatted: string;
+        key: string;
+        value: string;
+    } | null;
+    private stringify;
+}
+export default Extra;

package/dist/formatter/extra.js

@@ -0,0 +1,33 @@
+class Extra {
+    _keyValueSeparator;
+    constructor(keyValueSeparator) {
+        this._keyValueSeparator = keyValueSeparator;
+    }
+    format(key, value) {
+        const stringifiedKey = this.stringify(key);
+        const stringifiedValue = this.stringify(value);
+        if (stringifiedKey === undefined || stringifiedValue === undefined) {
+            return null;
+        }
+        return {
+            formatted: [
+                stringifiedKey,
+                this._keyValueSeparator,
+                stringifiedValue,
+            ].join(''),
+            key: stringifiedKey,
+            value: stringifiedValue,
+        };
+    }
+    stringify(value) {
+        if (typeof value === 'string' &&
+            value.length > 0 &&
+            !/\s|"/.test(value) &&
+            !value.includes(this._keyValueSeparator)) {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+}
+export default Extra;
+//# sourceMappingURL=extra.js.map

package/dist/formatter/extras.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from '../options.js';
+declare class Extras {
+    private readonly _formatCharacters;
+    constructor(formatCharacters: Options['extras']['formatCharacters']);
+    format(extras: string[]): string;
+}
+export default Extras;

package/dist/formatter/extras.js

@@ -0,0 +1,18 @@
+class Extras {
+    _formatCharacters;
+    constructor(formatCharacters) {
+        this._formatCharacters = formatCharacters;
+    }
+    format(extras) {
+        if (extras.length === 0) {
+            return '';
+        }
+        return [
+            this._formatCharacters.start,
+            extras.join(this._formatCharacters.separator),
+            this._formatCharacters.end,
+        ].join('');
+    }
+}
+export default Extras;
+//# sourceMappingURL=extras.js.map

package/dist/formatter/formatter.d.ts

@@ -0,0 +1,25 @@
+import type { ChalkInstance as Chalk } from 'chalk';
+import type BunyanRecord from '../bunyan/record.js';
+import type { PublicOptions } from '../options.js';
+import type { ParsedRecord } from '../parser/parser.js';
+declare class Formatter {
+    private readonly _options;
+    private readonly _parser;
+    private readonly _extras;
+    private readonly _time;
+    private readonly _newLineRegex;
+    private readonly _levels;
+    constructor(options: PublicOptions);
+    format(record: BunyanRecord): string;
+    formatTime(time: ParsedRecord['time']): string;
+    formatLevel(level: ParsedRecord['level']): string;
+    formatName(name: ParsedRecord['name']): string;
+    formatPid(pid: ParsedRecord['pid']): string;
+    formatHostname(hostname: ParsedRecord['hostname']): string;
+    formatSource(source: ParsedRecord['source'], colour: Chalk): string;
+    formatMessage(message: ParsedRecord['message'], colour: Chalk): string;
+    formatExtras(extras: string[], colour: Chalk): string;
+    formatDetails(message: ParsedRecord['message'], details: ParsedRecord['details']): string;
+    private indent;
+}
+export { Formatter };

package/dist/formatter/formatter.js

@@ -0,0 +1,116 @@
+import { relative } from 'node:path';
+import bunyan from 'bunyan';
+import chalk from 'chalk';
+import stringify from 'json-stringify-pretty-compact';
+import { schema } from '../options.js';
+import Parser from '../parser/parser.js';
+import normalisePath from '../helpers/normalise-path.js';
+import Extras from './extras.js';
+import Time from './time.js';
+class Formatter {
+    _options;
+    _parser;
+    _extras;
+    _time;
+    _newLineRegex;
+    _levels;
+    constructor(options) {
+        this._options = schema.parse(options);
+        this._parser = new Parser({
+            show: this._options.show.extras,
+            extras: this._options.extras,
+        });
+        this._extras = new Extras(this._options.extras.formatCharacters);
+        this._time = new Time(this._options.time);
+        this._newLineRegex = /\r\n|\r|\n/;
+        this._levels = {
+            [bunyan.levelFromName.trace]: chalk.gray('TRACE'),
+            [bunyan.levelFromName.debug]: chalk.blue('DEBUG'),
+            [bunyan.levelFromName.info]: chalk.green(' INFO'),
+            [bunyan.levelFromName.warn]: chalk.magenta(' WARN'),
+            [bunyan.levelFromName.error]: chalk.red('ERROR'),
+            [bunyan.levelFromName.fatal]: chalk.bgRed('FATAL'),
+        };
+    }
+    format(record) {
+        const parsedRecord = this._parser.parse(structuredClone(record));
+        return [
+            this.formatTime(parsedRecord.time),
+            this.formatLevel(parsedRecord.level),
+            ':',
+            this.formatName(parsedRecord.name),
+            this.formatPid(parsedRecord.pid),
+            this.formatHostname(parsedRecord.hostname),
+            this.formatSource(parsedRecord.source, chalk.green),
+            this.formatMessage(parsedRecord.message, chalk.blue),
+            this.formatExtras(parsedRecord.extras, chalk.red),
+            this._options.newLineCharacter,
+            this.formatDetails(parsedRecord.message, parsedRecord.details),
+        ].join('');
+    }
+    formatTime(time) {
+        return this._options.show.time ? `[${this._time.format(time)}]` : '';
+    }
+    formatLevel(level) {
+        const prefix = this._options.show.time ? ' ' : '';
+        return `${prefix}${this._levels[level]}`;
+    }
+    formatName(name) {
+        return this._options.show.name ? ` ${name}` : '';
+    }
+    formatPid(pid) {
+        return this._options.show.pid
+            ? `${this._options.show.name ? '/' : ' '}${pid}`
+            : '';
+    }
+    formatHostname(hostname) {
+        if (!this._options.show.hostname) {
+            return '';
+        }
+        return [
+            ' ',
+            this._options.show.name || this._options.show.pid ? 'on ' : '',
+            hostname,
+        ].join('');
+    }
+    formatSource(source, colour) {
+        if (!this._options.show.source || source === undefined) {
+            return '';
+        }
+        const file = relative(this._options.basePath, normalisePath(source.file));
+        const formattedSource = [
+            ` (${file}:${source.line}`,
+            source.func === undefined ? '' : ` in ${source.func}`,
+            ')',
+        ].join('');
+        return colour(formattedSource);
+    }
+    formatMessage(message, colour) {
+        return this._newLineRegex.test(message) ? '' : colour(` ${message}`);
+    }
+    formatExtras(extras, colour) {
+        const formattedExtras = this._extras.format(extras);
+        return formattedExtras.length === 0 ? '' : colour(` ${formattedExtras}`);
+    }
+    formatDetails(message, details) {
+        const formatted = [];
+        if (this._newLineRegex.test(message)) {
+            formatted.push(chalk.blue(this.indent(message)));
+        }
+        formatted.push(...Object.entries(details).map(([key, value]) => chalk.cyan(this.indent(`${key}: ${stringify(value, {
+            indent: this._options.indent.json,
+            maxLength: 80,
+        })}`))));
+        const suffix = formatted.length > 0 ? this._options.newLineCharacter : '';
+        return `${formatted.join(this._options.newLineCharacter)}${suffix}`;
+    }
+    indent(input) {
+        const indentation = ' '.repeat(this._options.indent.details);
+        const formatted = input
+            .split(this._newLineRegex)
+            .join(`${this._options.newLineCharacter}${indentation}`);
+        return `${indentation}${formatted}`;
+    }
+}
+export { Formatter };
+//# sourceMappingURL=formatter.js.map

package/dist/formatter/index.d.ts

@@ -0,0 +1 @@
+export { Formatter } from './formatter.js';

package/dist/formatter/index.js

@@ -0,0 +1,2 @@
+export { Formatter } from './formatter.js';
+//# sourceMappingURL=index.js.map

package/dist/formatter/time.d.ts

@@ -0,0 +1,11 @@
+import type { Options } from '../options.js';
+declare class Formatter {
+    private readonly _options;
+    private readonly _iso8601Presets;
+    constructor(options: Options['time']);
+    format(date: Date): string;
+    private isIso8601;
+    private toIso8601;
+    private toLocaleString;
+}
+export default Formatter;

package/dist/formatter/time.js

@@ -0,0 +1,68 @@
+import { DateTime } from 'luxon';
+class Formatter {
+    _options;
+    _iso8601Presets = [
+        'TIME_ISO_8601',
+        'TIME_ISO_8601_OFFSET',
+        'DATETIME_ISO_8601_OFFSET',
+        'DATETIME_ISO_8601',
+    ];
+    constructor(options) {
+        this._options = options;
+    }
+    format(date) {
+        const dateTime = this._options.utc
+            ? DateTime.fromJSDate(date).toUTC()
+            : DateTime.fromJSDate(date);
+        if (this._options.format !== undefined) {
+            return dateTime.toFormat(this._options.format);
+        }
+        if (this.isIso8601(this._options.preset)) {
+            return this.toIso8601(dateTime, this._options.preset);
+        }
+        return this.toLocaleString(dateTime);
+    }
+    isIso8601(preset) {
+        return this._iso8601Presets.includes(preset);
+    }
+    toIso8601(dateTime, preset) {
+        const includeOffset = preset === 'TIME_ISO_8601_OFFSET' ||
+            preset === 'DATETIME_ISO_8601_OFFSET';
+        if (preset === 'TIME_ISO_8601_OFFSET' || preset === 'TIME_ISO_8601') {
+            return dateTime.toISOTime({ includeOffset });
+        }
+        return dateTime.toISO({ includeOffset });
+    }
+    toLocaleString(dateTime) {
+        const presetToFormatOptions = new Map([
+            ['DATE_SHORT', DateTime.DATE_SHORT],
+            ['DATE_MED', DateTime.DATE_MED],
+            ['DATE_MED_WITH_WEEKDAY', DateTime.DATE_MED_WITH_WEEKDAY],
+            ['DATE_FULL', DateTime.DATE_FULL],
+            ['DATE_HUGE', DateTime.DATE_HUGE],
+            ['TIME_SIMPLE', DateTime.TIME_SIMPLE],
+            ['TIME_WITH_SECONDS', DateTime.TIME_WITH_SECONDS],
+            ['TIME_WITH_SHORT_OFFSET', DateTime.TIME_WITH_SHORT_OFFSET],
+            ['TIME_WITH_LONG_OFFSET', DateTime.TIME_WITH_LONG_OFFSET],
+            ['TIME_24_SIMPLE', DateTime.TIME_24_SIMPLE],
+            ['TIME_24_WITH_SECONDS', DateTime.TIME_24_WITH_SECONDS],
+            ['TIME_24_WITH_SHORT_OFFSET', DateTime.TIME_24_WITH_SHORT_OFFSET],
+            ['TIME_24_WITH_LONG_OFFSET', DateTime.TIME_24_WITH_LONG_OFFSET],
+            ['DATETIME_SHORT', DateTime.DATETIME_SHORT],
+            ['DATETIME_MED', DateTime.DATETIME_MED],
+            ['DATETIME_FULL', DateTime.DATETIME_FULL],
+            ['DATETIME_HUGE', DateTime.DATETIME_HUGE],
+            ['DATETIME_SHORT_WITH_SECONDS', DateTime.DATETIME_SHORT_WITH_SECONDS],
+            ['DATETIME_MED_WITH_SECONDS', DateTime.DATETIME_MED_WITH_SECONDS],
+            ['DATETIME_FULL_WITH_SECONDS', DateTime.DATETIME_FULL_WITH_SECONDS],
+            ['DATETIME_HUGE_WITH_SECONDS', DateTime.DATETIME_HUGE_WITH_SECONDS],
+        ]);
+        const formatOptions = presetToFormatOptions.get(this._options.preset);
+        if (formatOptions === undefined) {
+            throw new Error('unknown Luxon preset');
+        }
+        return dateTime.toLocaleString(formatOptions);
+    }
+}
+export default Formatter;
+//# sourceMappingURL=time.js.map

package/dist/helpers/normalise-path.d.ts

@@ -0,0 +1,2 @@
+declare function normalisePath(pathOrFileUrl: string): string;
+export default normalisePath;

package/dist/helpers/normalise-path.js

@@ -0,0 +1,9 @@
+import { fileURLToPath } from 'node:url';
+import { normalize } from 'node:path';
+function normalisePath(pathOrFileUrl) {
+    return normalize(pathOrFileUrl.startsWith('file://')
+        ? fileURLToPath(pathOrFileUrl)
+        : pathOrFileUrl);
+}
+export default normalisePath;
+//# sourceMappingURL=normalise-path.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { type Logger } from './logger.js';
+export { PrettyStream } from './bunyan-pretty-stream.js';
+export type { PublicOptions as Options } from './options.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { PrettyStream } from './bunyan-pretty-stream.js';
+//# sourceMappingURL=index.js.map

package/dist/{src/logger.d.ts → logger.d.ts}

@@ -1,3 +1,3 @@
-import bunyan from 'bunyan';
+import type bunyan from 'bunyan';
 type Logger = Pick<ReturnType<typeof bunyan.createLogger>, 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'>;
-export { Logger };
+export type { Logger };

package/dist/logger.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger.js.map