@visulima/pail 4.0.0-alpha.11 → 4.0.0-alpha.12

package/dist/middleware/next/handler.d.ts

@@ -1,36 +1,103 @@
-import type { PailMiddlewareOptions } from "../shared/create-middleware-logger.d.ts";
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-B-t8ZnhI.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'safe-stable-stringify';
+/**
+* Minimal type definitions to avoid requiring next as a dependency.
+*/
+interface NextRequest {
+  headers: Headers;
+  nextUrl: {
+    pathname: string;
+  };
+}
+interface NextResponse {
+  headers: Headers;
+}
+interface NextResponseConstructor {
+  next: (options?: {
+    request?: {
+      headers?: Headers;
+    };
+  }) => NextResponse;
+}
+/**
+* Options for the Next.js pail middleware.
+*/
+interface PailNextMiddlewareOptions {
+  /**
+  * Glob patterns for paths to exclude from logging.
+  * Excluded paths won't get request IDs or timing headers.
+  * @example ["/_next/**", "/favicon.ico"]
+  */
+  exclude?: string[];
+  /**
+  * Glob patterns for paths to include in logging.
+  * If not set, all non-excluded paths are included.
+  */
+  include?: string[];
+}
+/**
+* Create a Next.js edge middleware that sets `x-request-id` and `x-pail-start`
+* headers on the request for downstream use by `withPail()`.
+*
+* This middleware runs at the edge and prepares request metadata.
+* The actual wide event logging happens in `withPail()`.
+* @param NextResponseClass The NextResponse class from "next/server.js"
+* @param options Middleware configuration
+* @returns A middleware function
+* @example
+* ```typescript
+* // middleware.ts
+* import { NextResponse } from "next/server.js";
+* import { pailMiddleware } from "@visulima/pail/middleware/next";
+*
+* const middleware = pailMiddleware(NextResponse, {
+*   exclude: ["/_next/**", "/favicon.ico"],
+* });
+*
+* export default middleware;
+* ```
+*/
+declare const pailMiddleware: (NextResponseClass: NextResponseConstructor, options?: PailNextMiddlewareOptions) => (request: NextRequest) => NextResponse;
+/**
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a `withPail()` wrapped handler or server action.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of a withPail context
+*/
+declare const useLogger: () => WideEvent;
 type NextPailOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Create a `withPail` wrapper function for Next.js route handlers and server actions.
- *
- * Wraps handler execution in AsyncLocalStorage so that `useLogger()` works
- * anywhere in the async call stack. The wide event is automatically emitted
- * when the handler completes or throws.
- * @param options Configuration options
- * @returns A `withPail` wrapper function
- * @example
- * ```typescript
- * // lib/pail.ts
- * import { createPail } from "@visulima/pail";
- * import { createWithPail } from "@visulima/pail/middleware/next";
- *
- * const logger = createPail();
- * export const withPail = createWithPail({ pail: logger });
- *
- * // app/api/users/route.ts
- * import { withPail } from "@/lib/pail";
- * import { useLogger } from "@visulima/pail/middleware/next";
- *
- * export const GET = withPail(async (request: Request) => {
- *   const log = useLogger();
- *   log.set({ user: { id: 1 } });
- *   return Response.json({ ok: true });
- * });
- * ```
- */
-export declare const createWithPail: <T extends string = string>(options: NextPailOptions<T>) => <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn> | TReturn) => ((...args: TArgs) => Promise<TReturn>);
-export type { NextPailOptions };
-export type { WideEvent } from "../../wide-event.d.ts";
-export type { PailNextMiddlewareOptions } from "./middleware/next/middleware.d.ts";
-export { pailMiddleware } from "./middleware/next/middleware.d.ts";
-export { useLogger } from "./storage.d.ts";
+* Create a `withPail` wrapper function for Next.js route handlers and server actions.
+*
+* Wraps handler execution in AsyncLocalStorage so that `useLogger()` works
+* anywhere in the async call stack. The wide event is automatically emitted
+* when the handler completes or throws.
+* @param options Configuration options
+* @returns A `withPail` wrapper function
+* @example
+* ```typescript
+* // lib/pail.ts
+* import { createPail } from "@visulima/pail";
+* import { createWithPail } from "@visulima/pail/middleware/next";
+*
+* const logger = createPail();
+* export const withPail = createWithPail({ pail: logger });
+*
+* // app/api/users/route.ts
+* import { withPail } from "@/lib/pail";
+* import { useLogger } from "@visulima/pail/middleware/next";
+*
+* export const GET = withPail(async (request: Request) => {
+*   const log = useLogger();
+*   log.set({ user: { id: 1 } });
+*   return Response.json({ ok: true });
+* });
+* ```
+*/
+declare const createWithPail: <T extends string = string>(options: NextPailOptions<T>) => <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn> | TReturn) => (...args: TArgs) => Promise<TReturn>;
+export { type NextPailOptions, type PailNextMiddlewareOptions, type WideEvent, createWithPail, pailMiddleware, useLogger };

package/dist/middleware/sveltekit.d.ts

@@ -1,123 +1,125 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A SvelteKit-like event object with access to the pail logger via `locals.log`.
- * @example
- * ```typescript
- * // In a SvelteKit load function or action:
- * import type { PailSvelteKitEvent } from "@visulima/pail/middleware/sveltekit";
- *
- * export const load = async (event: PailSvelteKitEvent) => {
- *   event.locals.log?.set({ user: { id: 1 } });
- * };
- * ```
- */
+* A SvelteKit-like event object with access to the pail logger via `locals.log`.
+* @example
+* ```typescript
+* // In a SvelteKit load function or action:
+* import type { PailSvelteKitEvent } from "@visulima/pail/middleware/sveltekit";
+*
+* export const load = async (event: PailSvelteKitEvent) => {
+*   event.locals.log?.set({ user: { id: 1 } });
+* };
+* ```
+*/
 interface PailSvelteKitEvent {
-    [key: string]: unknown;
-    locals: Record<string, unknown> & {
-        log?: WideEvent;
-    };
-    request: Request;
-    url: URL;
+  [key: string]: unknown;
+  locals: Record<string, unknown> & {
+    log?: WideEvent;
+  };
+  request: Request;
+  url: URL;
 }
 /**
- * Options passed to SvelteKit's resolve function.
- */
+* Options passed to SvelteKit's resolve function.
+*/
 interface PailSvelteKitResolveOptions {
-    filterSerializedResponseHeaders?: (name: string) => boolean;
-    preload?: (input: {
-        type: string;
-    }) => boolean;
-    transformPageChunk?: (input: {
-        html: string;
-    }) => string;
+  filterSerializedResponseHeaders?: (name: string) => boolean;
+  preload?: (input: {
+    type: string;
+  }) => boolean;
+  transformPageChunk?: (input: {
+    html: string;
+  }) => string;
 }
 /**
- * SvelteKit resolve function type.
- */
+* SvelteKit resolve function type.
+*/
 type PailSvelteKitResolve = (event: PailSvelteKitEvent, options?: PailSvelteKitResolveOptions) => Promise<Response>;
 /**
- * Input for the SvelteKit handle hook.
- */
+* Input for the SvelteKit handle hook.
+*/
 interface PailSvelteKitHandleInput {
-    event: PailSvelteKitEvent;
-    resolve: PailSvelteKitResolve;
+  event: PailSvelteKitEvent;
+  resolve: PailSvelteKitResolve;
 }
 /**
- * SvelteKit handle hook function type returned by `pailHandle()`.
- */
+* SvelteKit handle hook function type returned by `pailHandle()`.
+*/
 type PailSvelteKitHandle = (input: PailSvelteKitHandleInput) => Promise<Response>;
 /**
- * Input for the SvelteKit handleError hook.
- */
+* Input for the SvelteKit handleError hook.
+*/
 interface PailSvelteKitHandleErrorInput {
-    error: unknown;
-    event: PailSvelteKitEvent;
-    message: string;
-    status: number;
+  error: unknown;
+  event: PailSvelteKitEvent;
+  message: string;
+  status: number;
 }
 /**
- * SvelteKit handleError hook function type returned by `pailHandleError()`.
- */
+* SvelteKit handleError hook function type returned by `pailHandleError()`.
+*/
 type PailSvelteKitHandleError = (input: PailSvelteKitHandleErrorInput) => void;
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handled by the pail SvelteKit handle hook.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the hook context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail SvelteKit handle hook.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the hook context
+*/
 declare const useLogger: () => WideEvent;
 type SvelteKitHandleOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Create a SvelteKit `handle` hook that attaches a WideEvent logger to each request.
- *
- * The logger is available via:
- * - `event.locals.log` in server load functions and actions
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted when the response is sent or an error occurs.
- * @param options Hook configuration
- * @returns SvelteKit handle hook function
- * @example
- * ```typescript
- * // src/hooks.server.ts
- * import { createPail } from "@visulima/pail";
- * import { pailHandle, pailHandleError } from "@visulima/pail/middleware/sveltekit";
- *
- * const logger = createPail();
- *
- * export const handle = pailHandle({ pail: logger });
- * export const handleError = pailHandleError();
- * ```
- */
-export declare const pailHandle: <T extends string = string>(options: SvelteKitHandleOptions<T>) => PailSvelteKitHandle;
+* Create a SvelteKit `handle` hook that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `event.locals.log` in server load functions and actions
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted when the response is sent or an error occurs.
+* @param options Hook configuration
+* @returns SvelteKit handle hook function
+* @example
+* ```typescript
+* // src/hooks.server.ts
+* import { createPail } from "@visulima/pail";
+* import { pailHandle, pailHandleError } from "@visulima/pail/middleware/sveltekit";
+*
+* const logger = createPail();
+*
+* export const handle = pailHandle({ pail: logger });
+* export const handleError = pailHandleError();
+* ```
+*/
+declare const pailHandle: <T extends string = string>(options: SvelteKitHandleOptions<T>) => PailSvelteKitHandle;
 /**
- * Create a SvelteKit `handleError` hook that captures errors into the WideEvent logger.
- *
- * Should be used alongside `pailHandle` to ensure errors are recorded in the wide event.
- * @returns SvelteKit handleError hook function
- */
-export declare const pailHandleError: () => PailSvelteKitHandleError;
+* Create a SvelteKit `handleError` hook that captures errors into the WideEvent logger.
+*
+* Should be used alongside `pailHandle` to ensure errors are recorded in the wide event.
+* @returns SvelteKit handleError hook function
+*/
+declare const pailHandleError: () => PailSvelteKitHandleError;
 /**
- * Convenience function that returns both handle and handleError hooks.
- * @param options Hook configuration
- * @returns Object with `handle` and `handleError` hooks
- * @example
- * ```typescript
- * // src/hooks.server.ts
- * import { createPail } from "@visulima/pail";
- * import { createPailHooks } from "@visulima/pail/middleware/sveltekit";
- *
- * const logger = createPail();
- * const { handle, handleError } = createPailHooks({ pail: logger });
- *
- * export { handle, handleError };
- * ```
- */
-export declare const createPailHooks: <T extends string = string>(options: SvelteKitHandleOptions<T>) => {
-    handle: PailSvelteKitHandle;
-    handleError: PailSvelteKitHandleError;
+* Convenience function that returns both handle and handleError hooks.
+* @param options Hook configuration
+* @returns Object with `handle` and `handleError` hooks
+* @example
+* ```typescript
+* // src/hooks.server.ts
+* import { createPail } from "@visulima/pail";
+* import { createPailHooks } from "@visulima/pail/middleware/sveltekit";
+*
+* const logger = createPail();
+* const { handle, handleError } = createPailHooks({ pail: logger });
+*
+* export { handle, handleError };
+* ```
+*/
+declare const createPailHooks: <T extends string = string>(options: SvelteKitHandleOptions<T>) => {
+  handle: PailSvelteKitHandle;
+  handleError: PailSvelteKitHandleError;
 };
-export { useLogger };
-export type { PailSvelteKitEvent, PailSvelteKitHandle, PailSvelteKitHandleError, PailSvelteKitHandleErrorInput, PailSvelteKitHandleInput, PailSvelteKitResolve, PailSvelteKitResolveOptions, SvelteKitHandleOptions, };
-export type { WideEvent } from "../wide-event.d.ts";
+export { type PailSvelteKitEvent, type PailSvelteKitHandle, type PailSvelteKitHandleError, type PailSvelteKitHandleErrorInput, type PailSvelteKitHandleInput, type PailSvelteKitResolve, type PailSvelteKitResolveOptions, type SvelteKitHandleOptions, type WideEvent, createPailHooks, pailHandle, pailHandleError, useLogger };

package/dist/object-tree.d.ts

@@ -1,75 +1,72 @@
 /**
- * Function to render a node value for display
- * @param node The node to render
- * @returns A string representation or undefined if should not render
- */
-export type TreeRenderFunction = (node: unknown) => string | undefined;
+* Function to render a node value for display
+* @param node The node to render
+* @returns A string representation or undefined if should not render
+*/
+type TreeRenderFunction = (node: unknown) => string | undefined;
 /**
- * Function to sort keys during tree traversal
- * @param a First key for comparison
- * @param b Second key for comparison
- * @returns Negative if a < b, positive if a > b, 0 if equal
- */
-export type TreeSortFunction = (a: string, b: string) => number;
+* Function to sort keys during tree traversal
+* @param a First key for comparison
+* @param b Second key for comparison
+* @returns Negative if a < b, positive if a > b, 0 if equal
+*/
+type TreeSortFunction = (a: string, b: string) => number;
 /**
- * Configuration options for object tree rendering
- */
-export interface ObjectTreeOptions {
-    /** Text to display for circular references (default: " (circular ref.)") */
-    breakCircularWith?: string | null;
-    /** Whether to return as single string or array of lines (default: true) */
-    joined?: boolean;
-    /** Connector for neighbor keys (default: "├─ ") */
-    keyNeighbour?: string;
-    /** Connector for non-neighbor keys (default: "└─ ") */
-    keyNoNeighbour?: string;
-    /** Function to render node values (default: renders primitives) */
-    renderFn?: TreeRenderFunction;
-    /** Separator between key and value (default: ": ") */
-    separator?: string;
-    /** Function to sort object keys (default: natural order) */
-    sortFn?: TreeSortFunction;
-    /** Spacer for neighbor branches (default: "│  ") */
-    spacerNeighbour?: string;
-    /** Spacer for non-neighbor branches (default: "   ") */
-    spacerNoNeighbour?: string;
+* Configuration options for object tree rendering
+*/
+interface ObjectTreeOptions {
+  /** Text to display for circular references (default: " (circular ref.)") */
+  breakCircularWith?: string | null;
+  /** Whether to return as single string or array of lines (default: true) */
+  joined?: boolean;
+  /** Connector for neighbor keys (default: "├─ ") */
+  keyNeighbour?: string;
+  /** Connector for non-neighbor keys (default: "└─ ") */
+  keyNoNeighbour?: string;
+  /** Function to render node values (default: renders primitives) */
+  renderFn?: TreeRenderFunction;
+  /** Separator between key and value (default: ": ") */
+  separator?: string;
+  /** Function to sort object keys (default: natural order) */
+  sortFn?: TreeSortFunction;
+  /** Spacer for neighbor branches (default: "│  ") */
+  spacerNeighbour?: string;
+  /** Spacer for non-neighbor branches (default: "   ") */
+  spacerNoNeighbour?: string;
 }
 /**
- * Renders an object as an ASCII tree structure.
- * @param tree The object to render as a tree
- * @param options Configuration options for tree rendering
- * @returns Formatted tree as string or array of lines
- * @example
- * ```typescript
- * const obj = {
- *   name: "John",
- *   age: 30,
- *   address: {
- *     street: "Main St",
- *     city: "New York"
- *   }
- * };
- *
- * // Default output as string
- * console.log(renderObjectTree(obj));
- *
- * // Custom rendering
- * console.log(renderObjectTree(obj, {
- *   sortFn: (a, b) => a.localeCompare(b),
- *   renderFn: (node) => {
- *     if (typeof node === 'string') return node.toUpperCase();
- *     return ['boolean', 'string', 'number'].includes(typeof node)
- *       ? String(node)
- *       : undefined;
- *   }
- * }));
- *
- * // Get as array of lines
- * const lines = renderObjectTree(obj, { joined: false });
- * ```
- */
-export declare const renderObjectTree: (tree: Record<string, unknown> | unknown[], options?: ObjectTreeOptions) => string | string[];
-/**
- * Default export for CommonJS compatibility
- */
-export default renderObjectTree;
+* Renders an object as an ASCII tree structure.
+* @param tree The object to render as a tree
+* @param options Configuration options for tree rendering
+* @returns Formatted tree as string or array of lines
+* @example
+* ```typescript
+* const obj = {
+*   name: "John",
+*   age: 30,
+*   address: {
+*     street: "Main St",
+*     city: "New York"
+*   }
+* };
+*
+* // Default output as string
+* console.log(renderObjectTree(obj));
+*
+* // Custom rendering
+* console.log(renderObjectTree(obj, {
+*   sortFn: (a, b) => a.localeCompare(b),
+*   renderFn: (node) => {
+*     if (typeof node === 'string') return node.toUpperCase();
+*     return ['boolean', 'string', 'number'].includes(typeof node)
+*       ? String(node)
+*       : undefined;
+*   }
+* }));
+*
+* // Get as array of lines
+* const lines = renderObjectTree(obj, { joined: false });
+* ```
+*/
+declare const renderObjectTree: (tree: Record<string, unknown> | unknown[], options?: ObjectTreeOptions) => string | string[];
+export { ObjectTreeOptions, TreeRenderFunction, TreeSortFunction, renderObjectTree as default, renderObjectTree };

package/dist/packem_shared/{PrettyReporter-BtTr13Ha.js → PrettyReporter-CIbrmjUV.js}

@@ -1,5 +1,5 @@
 import colorize, { grey, white, underline, bold } from '@visulima/colorize/browser';
-import { f as format, g as getLongestLabel } from './index-Bx3-C0j9.js';
+import { f as format, g as getLongestLabel } from './index-6cG1Kp0t.js';
 import { L as LOG_TYPES, E as EMPTY_SYMBOL } from './constants-omsTHUWB.js';
 import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-ree2lDPw.js';
 

package/dist/packem_shared/{PrettyReporter-BCvyNzXO.js → PrettyReporter-CNJEO9g7.js}

@@ -22,7 +22,7 @@ const {
   stdout,
   stderr
 } = process$2;
-import colorize, { grey, green, cyan, red, yellow, bold, magenta, underline, greenBright, bgGrey, white } from '@visulima/colorize';
+import colorize from '@visulima/colorize';
 const {
   execFileSync
 } = __cjs_getBuiltinModule("node:child_process");
@@ -2444,6 +2444,7 @@ const getLongestLabel = (types) => {
   return labels.reduce((x, y) => x.length > y.length ? x : y, "");
 };
 
+const { bold: bold$1, cyan: cyan$1, green: green$1, grey: grey$1, magenta, red: red$1, yellow } = colorize;
 const defaultInspectorConfig = {
   indent: 2,
   quoteStyle: "single",
@@ -2452,13 +2453,13 @@ const defaultInspectorConfig = {
       bigint: yellow,
       boolean: yellow,
       date: magenta,
-      null: bold,
+      null: bold$1,
       number: yellow,
-      regexp: red,
-      special: cyan,
-      string: green,
-      symbol: green,
-      undefined: grey
+      regexp: red$1,
+      special: cyan$1,
+      string: green$1,
+      symbol: green$1,
+      undefined: grey$1
     };
     if (!Object.hasOwn(styles, style)) {
       return string_;
@@ -2467,9 +2468,10 @@ const defaultInspectorConfig = {
   }
 };
 
+const { bold, underline: underline$1 } = colorize;
 const formatLabel = (label, styles) => {
   let formattedLabel = styles.uppercase.label ? label.toUpperCase() : label;
-  formattedLabel = styles.underline.label ? underline(formattedLabel) : formattedLabel;
+  formattedLabel = styles.underline.label ? underline$1(formattedLabel) : formattedLabel;
   if (styles.bold.label) {
     formattedLabel = bold(formattedLabel);
   }
@@ -2515,6 +2517,7 @@ class AbstractPrettyReporter {
   }
 }
 
+const { bgGrey, cyan, green, greenBright, grey, red, underline, white } = colorize;
 const PAIL_DIST_REGEX = /[\\/]pail[\\/]dist/;
 const pailFileFilter = (line) => !PAIL_DIST_REGEX.test(line);
 class PrettyReporter extends AbstractPrettyReporter {

package/dist/packem_shared/abstract-json-reporter.d-BAgznjyU.d.ts

@@ -0,0 +1,61 @@
+import { stringify } from 'safe-stable-stringify';
+import { R as ReadonlyMeta, E as ExtendedRfc5424LogLevels, L as LiteralUnion, S as StringifyAwareReporter } from "./types.d-BeLumqgD.js";
+/**
+* Options for configuring JSON reporters.
+*/
+type AbstractJsonReporterOptions = {
+  /** Error serialization options */
+  error: Partial<{
+    /** Properties to exclude from error serialization */
+    exclude?: string[];
+    /** Maximum depth for error object serialization */
+    maxDepth?: number;
+    /** Whether to use toJSON methods during serialization */
+    useToJSON?: boolean;
+  }>;
+};
+/**
+* Abstract JSON Reporter.
+*
+* Base class for JSON-based reporters that provides common functionality
+* for serializing log metadata to JSON format. Handles error serialization,
+* context processing, and provides a template method for actual output.
+* @template L - The log level type
+* @example
+* ```typescript
+* class CustomJsonReporter extends AbstractJsonReporter {
+*   protected _log(message: string): void {
+*     console.log(message);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractJsonReporter<L extends string = string> implements StringifyAwareReporter<L> {
+  /** Custom stringify function for object serialization */
+  protected stringify: typeof stringify | undefined;
+  /** Error serialization options */
+  protected errorOptions: AbstractJsonReporterOptions["error"];
+  /**
+  * Creates a new AbstractJsonReporter instance.
+  * @param options Configuration options for JSON formatting and error handling
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Sets a custom stringify function for object serialization.
+  * @param function_ The stringify function to use for serialization
+  */
+  setStringify(function_: typeof stringify): void;
+  log(meta: ReadonlyMeta<L>): void;
+  /**
+  * Template method for outputting the JSON log message.
+  *
+  * Subclasses must implement this method to define how the JSON message
+  * is actually written (to console, file, network, etc.).
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level of the message
+  * @protected
+  * @abstract
+  */
+  protected abstract _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { AbstractJsonReporterOptions as A, AbstractJsonReporter as a };

package/dist/packem_shared/{abstract-pretty-reporter-CXAKYCb8.js → abstract-pretty-reporter-CkqCt5hg.js}

@@ -26,7 +26,7 @@ const {
 } = __cjs_getBuiltinModule("node:child_process");
 const fs = __cjs_getBuiltinModule("node:fs");
 const tty = __cjs_getBuiltinModule("node:tty");
-import { grey, green, cyan, red, yellow, bold, magenta, underline } from '@visulima/colorize';
+import colorize from '@visulima/colorize';
 
 const EXTENDED_RFC_5424_LOG_LEVELS = {
   alert: 7,
@@ -2561,6 +2561,7 @@ const getLongestBadge = (types) => {
   return badges.reduce((x, y) => x.length > y.length ? x : y, "");
 };
 
+const { bold: bold$1, cyan, green, grey, magenta, red, yellow } = colorize;
 const defaultInspectorConfig = {
   indent: 2,
   quoteStyle: "single",
@@ -2569,7 +2570,7 @@ const defaultInspectorConfig = {
       bigint: yellow,
       boolean: yellow,
       date: magenta,
-      null: bold,
+      null: bold$1,
       number: yellow,
       regexp: red,
       special: cyan,
@@ -2584,6 +2585,7 @@ const defaultInspectorConfig = {
   }
 };
 
+const { bold, underline } = colorize;
 const formatLabel = (label, styles) => {
   let formattedLabel = styles.uppercase.label ? label.toUpperCase() : label;
   formattedLabel = styles.underline.label ? underline(formattedLabel) : formattedLabel;