@oxog/log 1.0.0

package/dist/plugins/index.cjs

@@ -0,0 +1,854 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/index.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  addCorrelationId: () => addCorrelationId,
+  addSourceLocation: () => addSourceLocation,
+  addTimestamp: () => addTimestamp,
+  browserPlugin: () => browserPlugin,
+  bufferEntry: () => bufferEntry,
+  bufferPlugin: () => bufferPlugin,
+  clearBuffer: () => clearBuffer,
+  clearTimers: () => clearTimers,
+  correlationPlugin: () => correlationPlugin,
+  createTimer: () => createTimer,
+  detectFormat: () => detectFormat,
+  endGroup: () => endGroup,
+  endTimer: () => endTimer,
+  ensureCorrelationId: () => ensureCorrelationId,
+  flushBuffer: () => flushBuffer,
+  flushBufferSync: () => flushBufferSync,
+  formatEntry: () => formatEntry,
+  formatPlugin: () => formatPlugin,
+  fromIso: () => fromIso,
+  generateCorrelationId: () => generateCorrelationId,
+  getActiveTimers: () => getActiveTimers,
+  getBufferSize: () => getBufferSize,
+  getConsoleMethod: () => getConsoleMethod,
+  getCorrelationId: () => getCorrelationId,
+  getEffectiveFormat: () => getEffectiveFormat,
+  getLevelName: () => getLevelName,
+  getLevelStyles: () => getLevelStyles,
+  hasTimer: () => hasTimer,
+  isGroupingEnabled: () => isGroupingEnabled,
+  isLevelEnabled: () => isLevelEnabled,
+  levelPlugin: () => levelPlugin,
+  now: () => now,
+  nowIso: () => nowIso,
+  parseLevel: () => parseLevel,
+  redactEntry: () => redactEntry,
+  redactPlugin: () => redactPlugin,
+  setCorrelationId: () => setCorrelationId,
+  setLevel: () => setLevel,
+  sourcePlugin: () => sourcePlugin,
+  startGroup: () => startGroup,
+  startTimer: () => startTimer,
+  stopFlushInterval: () => stopFlushInterval,
+  timestampPlugin: () => timestampPlugin,
+  timingPlugin: () => timingPlugin,
+  toIso: () => toIso,
+  writeToBrowserConsole: () => writeToBrowserConsole
+});
+module.exports = __toCommonJS(plugins_exports);
+
+// src/constants.ts
+var LOG_LEVELS = {
+  trace: 10 /* Trace */,
+  debug: 20 /* Debug */,
+  info: 30 /* Info */,
+  warn: 40 /* Warn */,
+  error: 50 /* Error */,
+  fatal: 60 /* Fatal */
+};
+var LEVEL_NAMES = {
+  [10 /* Trace */]: "trace",
+  [20 /* Debug */]: "debug",
+  [30 /* Info */]: "info",
+  [40 /* Warn */]: "warn",
+  [50 /* Error */]: "error",
+  [60 /* Fatal */]: "fatal"
+};
+var DEFAULT_BUFFER_OPTIONS = {
+  size: 100,
+  flushInterval: 1e3
+};
+var LEVEL_COLORS = {
+  trace: "gray",
+  debug: "cyan",
+  info: "blue",
+  warn: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+var LEVEL_LABELS = {
+  trace: "TRACE",
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR",
+  fatal: "FATAL"
+};
+var REDACTED_VALUE = "[REDACTED]";
+var IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var IS_BROWSER = typeof window !== "undefined" && typeof window.document !== "undefined";
+var IS_DEV = IS_NODE && process.env["NODE_ENV"] !== "production";
+var IS_TTY = IS_NODE && process.stdout?.isTTY === true;
+
+// src/plugins/core/level.ts
+function levelPlugin() {
+  return {
+    name: "level",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.level === void 0) {
+        ctx.level = LOG_LEVELS.info;
+      }
+    }
+  };
+}
+function isLevelEnabled(ctx, levelName) {
+  const levelValue = LOG_LEVELS[levelName];
+  return levelValue >= ctx.level;
+}
+function getLevelName(ctx) {
+  return LEVEL_NAMES[ctx.level] ?? "info";
+}
+function setLevel(ctx, levelName) {
+  const levelValue = LOG_LEVELS[levelName];
+  if (levelValue !== void 0) {
+    ctx.level = levelValue;
+  }
+}
+function parseLevel(level) {
+  if (typeof level === "number") {
+    return level;
+  }
+  return LOG_LEVELS[level] ?? LOG_LEVELS.info;
+}
+
+// src/utils/format.ts
+function formatJson(entry) {
+  return JSON.stringify(entry, jsonReplacer);
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Error) {
+    const errorObj = value;
+    const result = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+    for (const key of Object.keys(errorObj)) {
+      if (!(key in result)) {
+        result[key] = errorObj[key];
+      }
+    }
+    return result;
+  }
+  if (typeof value === "object" && value !== null) {
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof Map) {
+      return Object.fromEntries(value);
+    }
+    if (value instanceof Set) {
+      return Array.from(value);
+    }
+  }
+  return value;
+}
+function safeStringify(value, indent) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    value,
+    (_key, val) => {
+      const replaced = jsonReplacer(_key, val);
+      if (typeof replaced === "object" && replaced !== null) {
+        if (seen.has(replaced)) {
+          return "[Circular]";
+        }
+        seen.add(replaced);
+      }
+      return replaced;
+    },
+    indent
+  );
+}
+function formatPretty(entry, pigment, options = {}) {
+  const parts = [];
+  const { timestamp = true, source = true } = options;
+  if (timestamp && entry.time) {
+    const time = formatTime(entry.time);
+    parts.push(pigment ? pigment.gray(`[${time}]`) : `[${time}]`);
+  }
+  const levelLabel = LEVEL_LABELS[entry.levelName] || entry.levelName.toUpperCase();
+  const levelColor = LEVEL_COLORS[entry.levelName] || "white";
+  if (pigment) {
+    const colorFn = pigment[levelColor];
+    parts.push(colorFn ? colorFn(levelLabel) : levelLabel);
+  } else {
+    parts.push(levelLabel);
+  }
+  if (source && entry.file) {
+    const location = entry.line ? `${entry.file}:${entry.line}` : entry.file;
+    parts.push(pigment ? pigment.dim(`(${location})`) : `(${location})`);
+  }
+  if (entry.msg) {
+    parts.push(entry.msg);
+  }
+  const extra = getExtraFields(entry);
+  if (Object.keys(extra).length > 0) {
+    const extraStr = safeStringify(extra);
+    parts.push(pigment ? pigment.dim(extraStr) : extraStr);
+  }
+  if (entry.err?.stack) {
+    parts.push("\n" + (pigment ? pigment.red(entry.err.stack) : entry.err.stack));
+  }
+  return parts.join(" ");
+}
+function getExtraFields(entry) {
+  const standardFields = /* @__PURE__ */ new Set([
+    "level",
+    "levelName",
+    "time",
+    "msg",
+    "file",
+    "line",
+    "column",
+    "correlationId",
+    "duration",
+    "err",
+    "name"
+  ]);
+  const extra = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (!standardFields.has(key)) {
+      extra[key] = value;
+    }
+  }
+  return extra;
+}
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+
+// src/utils/env.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isDev() {
+  if (!isNode()) return false;
+  return process.env["NODE_ENV"] !== "production";
+}
+function isTTY() {
+  if (!isNode()) return false;
+  return process.stdout?.isTTY === true;
+}
+
+// src/plugins/core/format.ts
+function formatPlugin() {
+  return {
+    name: "format",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.format === void 0) {
+        ctx.format = detectFormat();
+      } else if (ctx.format === "auto") {
+        ctx.format = detectFormat();
+      }
+    }
+  };
+}
+function detectFormat() {
+  if (isDev() && isTTY()) {
+    return "pretty";
+  }
+  return "json";
+}
+function formatEntry(ctx, entry) {
+  const format = ctx.format === "auto" ? detectFormat() : ctx.format;
+  if (format === "pretty") {
+    return formatPretty(entry, ctx.pigment, {
+      timestamp: ctx.timestamp,
+      source: ctx.source
+    });
+  }
+  return formatJson(entry);
+}
+function getEffectiveFormat(ctx) {
+  if (ctx.format === "auto") {
+    return detectFormat();
+  }
+  return ctx.format;
+}
+
+// src/plugins/core/timestamp.ts
+function timestampPlugin() {
+  return {
+    name: "timestamp",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (ctx.timestamp === void 0) {
+        ctx.timestamp = true;
+      }
+    }
+  };
+}
+function now() {
+  return Date.now();
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toIso(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+function fromIso(isoString) {
+  return new Date(isoString).getTime();
+}
+function addTimestamp(entry) {
+  if (entry.time === void 0) {
+    entry.time = Date.now();
+  }
+  return entry;
+}
+
+// src/utils/redact.ts
+function redactFields(obj, paths, placeholder = REDACTED_VALUE) {
+  if (!obj || typeof obj !== "object" || paths.length === 0) {
+    return obj;
+  }
+  const result = deepClone(obj);
+  for (const path of paths) {
+    redactPath(result, path.split("."), placeholder);
+  }
+  return result;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    for (const [key, value] of obj) {
+      result2.set(key, deepClone(value));
+    }
+    return result2;
+  }
+  if (obj instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    for (const value of obj) {
+      result2.add(deepClone(value));
+    }
+    return result2;
+  }
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = deepClone(obj[key]);
+  }
+  return result;
+}
+function redactPath(obj, pathParts, placeholder) {
+  if (pathParts.length === 0 || !obj || typeof obj !== "object") {
+    return;
+  }
+  const [current, ...rest] = pathParts;
+  if (!current) return;
+  if (current === "*") {
+    for (const key of Object.keys(obj)) {
+      if (rest.length === 0) {
+        obj[key] = placeholder;
+      } else {
+        const value = obj[key];
+        if (value && typeof value === "object") {
+          redactPath(value, rest, placeholder);
+        }
+      }
+    }
+    return;
+  }
+  if (current === "[*]" && Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      if (rest.length === 0) {
+        obj[i] = placeholder;
+      } else {
+        const value = obj[i];
+        if (value && typeof value === "object") {
+          redactPath(value, rest, placeholder);
+        }
+      }
+    }
+    return;
+  }
+  if (!(current in obj)) {
+    return;
+  }
+  if (rest.length === 0) {
+    obj[current] = placeholder;
+  } else {
+    const value = obj[current];
+    if (value && typeof value === "object") {
+      redactPath(value, rest, placeholder);
+    }
+  }
+}
+
+// src/plugins/optional/redact.ts
+function redactPlugin(options = {}) {
+  return {
+    name: "redact",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      const paths = options.paths || ctx.redactPaths || [];
+      const placeholder = options.placeholder || REDACTED_VALUE;
+      ctx.redactPaths = paths;
+      kernel.redact = (entry) => {
+        return redactEntry(entry, paths, placeholder);
+      };
+    }
+  };
+}
+function redactEntry(entry, paths, placeholder = REDACTED_VALUE) {
+  if (paths.length === 0) {
+    return entry;
+  }
+  return redactFields(entry, paths, placeholder);
+}
+
+// src/utils/source.ts
+function getSourceLocation(depth = 0) {
+  const err = new Error();
+  const stack = err.stack;
+  if (!stack) {
+    return void 0;
+  }
+  const frames = parseStack(stack);
+  const targetIndex = 2 + depth;
+  if (targetIndex >= frames.length) {
+    return void 0;
+  }
+  return frames[targetIndex];
+}
+function parseStack(stack) {
+  const lines = stack.split("\n");
+  const frames = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("at ")) {
+      continue;
+    }
+    const frame = parseV8Frame(trimmed);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+function parseV8Frame(line) {
+  let content = line.slice(3);
+  if (content.startsWith("async ")) {
+    content = content.slice(6);
+  }
+  const parenMatch = content.match(/^(.+?)\s+\((.+):(\d+):(\d+)\)$/);
+  if (parenMatch) {
+    const [, fn, path, lineStr, colStr] = parenMatch;
+    return {
+      fn: fn?.trim() || void 0,
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10),
+      column: parseInt(colStr || "0", 10)
+    };
+  }
+  const simpleMatch = content.match(/^(.+):(\d+):(\d+)$/);
+  if (simpleMatch) {
+    const [, path, lineStr, colStr] = simpleMatch;
+    return {
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10),
+      column: parseInt(colStr || "0", 10)
+    };
+  }
+  const noColMatch = content.match(/^(.+):(\d+)$/);
+  if (noColMatch) {
+    const [, path, lineStr] = noColMatch;
+    return {
+      path,
+      file: extractFileName(path || ""),
+      line: parseInt(lineStr || "0", 10)
+    };
+  }
+  return void 0;
+}
+function extractFileName(path) {
+  let cleanPath = path.replace(/^file:\/\//, "");
+  cleanPath = cleanPath.replace(/\\/g, "/");
+  cleanPath = cleanPath.split("?")[0]?.split("#")[0] || cleanPath;
+  const parts = cleanPath.split("/");
+  return parts[parts.length - 1] || cleanPath;
+}
+
+// src/plugins/optional/source.ts
+function sourcePlugin(options = {}) {
+  return {
+    name: "source",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      ctx.source = true;
+      const depth = options.depth ?? 4;
+      kernel.getSource = () => {
+        return getSourceLocation(depth);
+      };
+    }
+  };
+}
+function addSourceLocation(entry, depth = 4, options = {}) {
+  const location = getSourceLocation(depth);
+  if (location) {
+    entry.file = options.includeFullPath ? location.path : location.file;
+    entry.line = location.line;
+    if (options.includeColumn && location.column) {
+      entry.column = location.column;
+    }
+  }
+  return entry;
+}
+
+// src/plugins/optional/correlation.ts
+var correlationOptions = {};
+function correlationPlugin(options = {}) {
+  return {
+    name: "correlation",
+    version: "1.0.0",
+    install(_kernel) {
+      correlationOptions = options;
+    }
+  };
+}
+function generateCorrelationId() {
+  if (correlationOptions.generator) {
+    return correlationOptions.generator();
+  }
+  const prefix = correlationOptions.prefix ?? "cid";
+  const random = Math.random().toString(36).substring(2, 10);
+  const timestamp = Date.now().toString(36);
+  return `${prefix}_${timestamp}${random}`;
+}
+function addCorrelationId(entry, correlationId) {
+  entry.correlationId = correlationId;
+  return entry;
+}
+function getCorrelationId(ctx) {
+  return ctx.correlationId;
+}
+function setCorrelationId(ctx, correlationId) {
+  ctx.correlationId = correlationId;
+}
+function ensureCorrelationId(ctx) {
+  if (!ctx.correlationId) {
+    ctx.correlationId = generateCorrelationId();
+  }
+  return ctx.correlationId;
+}
+
+// src/plugins/optional/timing.ts
+function timingPlugin() {
+  return {
+    name: "timing",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      if (!ctx.timers) {
+        ctx.timers = /* @__PURE__ */ new Map();
+      }
+    },
+    onDestroy() {
+    }
+  };
+}
+function startTimer(ctx, label) {
+  ctx.timers.set(label, performance.now());
+}
+function endTimer(ctx, label) {
+  const start = ctx.timers.get(label);
+  if (start === void 0) {
+    return void 0;
+  }
+  const duration = performance.now() - start;
+  ctx.timers.delete(label);
+  return Math.round(duration * 100) / 100;
+}
+function hasTimer(ctx, label) {
+  return ctx.timers.has(label);
+}
+function getActiveTimers(ctx) {
+  return Array.from(ctx.timers.keys());
+}
+function clearTimers(ctx) {
+  ctx.timers.clear();
+}
+function createTimer(ctx, label) {
+  startTimer(ctx, label);
+  return () => endTimer(ctx, label);
+}
+
+// src/plugins/optional/buffer.ts
+function bufferPlugin(options = {}) {
+  return {
+    name: "buffer",
+    version: "1.0.0",
+    install(kernel) {
+      const ctx = kernel.getContext();
+      ctx.buffer = [];
+      ctx.bufferOptions = {
+        size: options.size ?? DEFAULT_BUFFER_OPTIONS.size,
+        flushInterval: options.flushInterval ?? DEFAULT_BUFFER_OPTIONS.flushInterval
+      };
+      const flushInterval = ctx.bufferOptions.flushInterval ?? DEFAULT_BUFFER_OPTIONS.flushInterval;
+      if (flushInterval > 0) {
+        ctx.flushTimerId = setInterval(() => {
+          flushBuffer(ctx).catch(() => {
+          });
+        }, flushInterval);
+      }
+    },
+    async onDestroy() {
+    }
+  };
+}
+function bufferEntry(ctx, entry) {
+  ctx.buffer.push(entry);
+  if (ctx.buffer.length >= (ctx.bufferOptions.size ?? DEFAULT_BUFFER_OPTIONS.size)) {
+    flushBufferSync(ctx);
+    return true;
+  }
+  return false;
+}
+async function flushBuffer(ctx) {
+  if (ctx.buffer.length === 0) {
+    return [];
+  }
+  const entries = ctx.buffer;
+  ctx.buffer = [];
+  await Promise.all(
+    entries.flatMap(
+      (entry) => ctx.transports.map(
+        (transport) => Promise.resolve(transport.write(entry)).catch(() => {
+        })
+      )
+    )
+  );
+  ctx.emitter.emit("flush", void 0);
+  return entries;
+}
+function flushBufferSync(ctx) {
+  if (ctx.buffer.length === 0) {
+    return [];
+  }
+  const entries = ctx.buffer;
+  ctx.buffer = [];
+  for (const entry of entries) {
+    for (const transport of ctx.transports) {
+      try {
+        transport.write(entry);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function getBufferSize(ctx) {
+  return ctx.buffer.length;
+}
+function clearBuffer(ctx) {
+  const entries = ctx.buffer;
+  ctx.buffer = [];
+  return entries;
+}
+function stopFlushInterval(ctx) {
+  if (ctx.flushTimerId) {
+    clearInterval(ctx.flushTimerId);
+    ctx.flushTimerId = void 0;
+  }
+}
+
+// src/plugins/optional/browser.ts
+var browserOptions = {};
+function browserPlugin(options = {}) {
+  return {
+    name: "browser",
+    version: "1.0.0",
+    install(_kernel) {
+      browserOptions = options;
+    }
+  };
+}
+function getConsoleMethod(levelName) {
+  switch (levelName) {
+    case "trace":
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+    case "fatal":
+      return "error";
+    default:
+      return "log";
+  }
+}
+function getLevelStyles(levelName) {
+  if (browserOptions.styles?.[levelName]) {
+    return browserOptions.styles[levelName];
+  }
+  const colors = {
+    trace: "#888888",
+    debug: "#00bcd4",
+    info: "#2196f3",
+    warn: "#ff9800",
+    error: "#f44336",
+    fatal: "#9c27b0"
+  };
+  return `color: ${colors[levelName] ?? "#000000"}; font-weight: bold;`;
+}
+function writeToBrowserConsole(entry, styled = true) {
+  if (!isBrowser()) return;
+  const method = getConsoleMethod(entry.levelName);
+  const consoleObj = console;
+  if (styled) {
+    const styles = getLevelStyles(entry.levelName);
+    const label = `%c[${entry.levelName.toUpperCase()}]`;
+    const {
+      level: _level,
+      levelName: _levelName,
+      time: _time,
+      msg,
+      file: _file,
+      line: _line,
+      column: _column,
+      correlationId: _correlationId,
+      ...extra
+    } = entry;
+    if (Object.keys(extra).length > 0) {
+      consoleObj[method](label, styles, msg, extra);
+    } else {
+      consoleObj[method](label, styles, msg);
+    }
+  } else {
+    consoleObj[method](`[${entry.levelName.toUpperCase()}]`, entry.msg, entry);
+  }
+}
+function startGroup(label, collapsed = false) {
+  if (!isBrowser()) return;
+  if (collapsed) {
+    console.groupCollapsed(label);
+  } else {
+    console.group(label);
+  }
+}
+function endGroup() {
+  if (!isBrowser()) return;
+  console.groupEnd();
+}
+function isGroupingEnabled() {
+  return browserOptions.grouping ?? true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCorrelationId,
+  addSourceLocation,
+  addTimestamp,
+  browserPlugin,
+  bufferEntry,
+  bufferPlugin,
+  clearBuffer,
+  clearTimers,
+  correlationPlugin,
+  createTimer,
+  detectFormat,
+  endGroup,
+  endTimer,
+  ensureCorrelationId,
+  flushBuffer,
+  flushBufferSync,
+  formatEntry,
+  formatPlugin,
+  fromIso,
+  generateCorrelationId,
+  getActiveTimers,
+  getBufferSize,
+  getConsoleMethod,
+  getCorrelationId,
+  getEffectiveFormat,
+  getLevelName,
+  getLevelStyles,
+  hasTimer,
+  isGroupingEnabled,
+  isLevelEnabled,
+  levelPlugin,
+  now,
+  nowIso,
+  parseLevel,
+  redactEntry,
+  redactPlugin,
+  setCorrelationId,
+  setLevel,
+  sourcePlugin,
+  startGroup,
+  startTimer,
+  stopFlushInterval,
+  timestampPlugin,
+  timingPlugin,
+  toIso,
+  writeToBrowserConsole
+});
+//# sourceMappingURL=index.cjs.map