vite-plugin-better-console 1.0.2

package/dist/logger.d.ts

@@ -0,0 +1,156 @@
+import type { LogLevel, LoggerOptions, LogFn, LogCallOptions } from './types.js'
+import { resolveOptions, shouldLog } from './config.js'
+import { getCaller } from './caller.js'
+import { typeOf, formatTimestamp, printMeta, printValue } from './format.js'
+
+// ─── Production warning (fires at most once per page load) ───────────────────
+
+const warnProductionOnce = (() => {
+  let fired = false
+  return () => {
+    if (fired) return
+    fired = true
+    console.log(
+      '%c better-console %c disabled in production ',
+      'background:#dc2626;color:#fff;font-size:11px;padding:3px 6px;border-radius:4px 0 0 4px;font-weight:700',
+      'background:#1e293b;color:#94a3b8;font-size:11px;padding:3px 8px;border-radius:0 4px 4px 0',
+    )
+  }
+})()
+
+// ─── Default badges per level ─────────────────────────────────────────────────
+
+const DEFAULT_BADGES: Record<LogLevel, string> = {
+  debug: 'DEBUG',
+  info:  'INFO',
+  warn:  'WARN',
+  error: 'ERROR',
+  silent: '',
+}
+
+// ─── createLogger ────────────────────────────────────────────────────────────
+
+export function createLogger(userOptions: LoggerOptions = {}): LogFn {
+  const opts = resolveOptions(userOptions)
+
+  const {
+    dev,
+    warnInProduction,
+    logLevel,
+    collapsed: defaultCollapsed,
+    showPath,
+    showLine,
+    showFn,
+    showType,
+    timestamp: defaultTimestamp,
+    timestampFormat,
+    theme,
+    badge: badgeMap,
+  } = opts
+
+  // ── Core dispatcher ────────────────────────────────────────────────────────
+
+  function logAtLevel(
+    level: LogLevel,
+    label: string,
+    value: unknown,
+    callOpts: LogCallOptions = {},
+  ): void {
+    // 1. Production guard
+    if (!dev) {
+      if (warnInProduction) warnProductionOnce()
+      return
+    }
+
+    // 2. Level filter
+    const effectiveLevel = callOpts.level ?? level
+    if (!shouldLog(effectiveLevel, logLevel)) return
+
+    // 3. enabled flag
+    if (callOpts.enabled === false) return
+
+    // 4. Resolve per-call options
+    const {
+      comment,
+      collapsed = defaultCollapsed,
+      path: overridePath,
+      line: overrideLine,
+      fn: overrideFn,
+      timestamp: showTimestamp = defaultTimestamp,
+    } = callOpts
+
+    // 5. Caller detection
+    let caller = getCaller()
+    if (overridePath != null) caller = { ...caller, path: overridePath }
+    if (overrideLine != null) caller = { ...caller, line: String(overrideLine) }
+    if (overrideFn != null)   caller = { ...caller, fn: overrideFn }
+
+    // 6. Badge label
+    const badgeText =
+      badgeMap === false
+        ? label
+        : `${(badgeMap && badgeMap[effectiveLevel]) ?? DEFAULT_BADGES[effectiveLevel]} · ${label}`
+
+    const badgeStyle = theme[`badge_${effectiveLevel}` as keyof typeof theme] ?? theme.badge_info
+
+    // 7. Open group
+    const groupFn = collapsed ? console.groupCollapsed : console.group
+    groupFn(`%c ${badgeText} `, badgeStyle)
+
+    // 8. Meta rows
+    if (showTimestamp) {
+      printMeta('time', formatTimestamp(new Date(), timestampFormat), opts)
+    }
+
+    if (showFn && caller.fn) {
+      printMeta('function', caller.fn, opts)
+    }
+
+    if (showPath && caller.path) {
+      printMeta('file', caller.path, opts)
+    }
+
+    if (showLine && caller.line) {
+      printMeta('line', caller.line, opts)
+    }
+
+    if (showType && value !== undefined) {
+      printMeta('type', typeOf(value), opts)
+    }
+
+    // 9. The value
+    printValue(value)
+
+    // 10. Optional comment
+    if (comment) {
+      printMeta('note', comment, opts)
+    }
+
+    console.groupEnd()
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  const log = (label: string, value?: unknown, options?: LogCallOptions) =>
+    logAtLevel('info', label, value, options)
+
+  log.debug = (label: string, value?: unknown, options?: LogCallOptions) =>
+    logAtLevel('debug', label, value, options)
+
+  log.info = (label: string, value?: unknown, options?: LogCallOptions) =>
+    logAtLevel('info', label, value, options)
+
+  log.warn = (label: string, value?: unknown, options?: LogCallOptions) =>
+    logAtLevel('warn', label, value, options)
+
+  log.error = (label: string, value?: unknown, options?: LogCallOptions) =>
+    logAtLevel('error', label, value, options)
+
+  log.table = (label: string, data: unknown, options: LogCallOptions = {}) =>
+    logAtLevel('info', label, data, { ...options, collapsed: false })
+
+  Object.defineProperty(log, 'dev',   { get: () => dev,      enumerable: true })
+  Object.defineProperty(log, 'level', { get: () => logLevel, enumerable: true })
+
+  return log as LogFn
+}

package/dist/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite'
+export type { BetterConsoleOptions, LoggerOptions, LogLevel, LogCallOptions, ThemeStyles } from './types.js'
+export { betterConsole } from './plugin.js'
+export default betterConsole
+
+declare function betterConsole(options?: import('./types.js').BetterConsoleOptions): Plugin

package/dist/plugin.js

@@ -0,0 +1,144 @@
+// src/plugin.ts
+var PLUGIN_NAME = "vite-plugin-better-console";
+var VIRTUAL_ID = "virtual:better-console";
+var RESOLVED_VIRTUAL = "\0virtual:better-console";
+var RUNTIME_PKG = `${PLUGIN_NAME}/runtime`;
+var ENTRY_EXTS = /* @__PURE__ */ new Set([".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts", ".cjs", ".cts", ".vue", ".svelte"]);
+function normalize(p) {
+  return p.replace(/\\/g, "/");
+}
+function resolveEntry(root, entry) {
+  const e = entry.startsWith("/") ? entry.slice(1) : entry;
+  return normalize(`${normalize(root)}/${e}`.replace(/\/+/g, "/"));
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/\\/g, "/").replace(/[.+^${}()|[\]]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\x00/g, ".*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${escaped}$`);
+}
+function matchPattern(pattern, id) {
+  if (!pattern) return false;
+  const normalized = normalize(id);
+  if (pattern instanceof RegExp) return pattern.test(normalized);
+  return globToRegex(pattern).test(normalized);
+}
+function htmlModuleEntries(html, root) {
+  const result = /* @__PURE__ */ new Set();
+  const re = /<script([^>]*)>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    const attrs = m[1];
+    if (!/type\s*=\s*["']module["']/i.test(attrs)) continue;
+    const src = attrs.match(/\bsrc\s*=\s*["']([^"']+)["']/i)?.[1];
+    if (!src || /^https?:\/\//i.test(src) || src.startsWith("//")) continue;
+    result.add(resolveEntry(root, src));
+  }
+  return result;
+}
+function rollupEntries(config) {
+  const result = /* @__PURE__ */ new Set();
+  const { root } = config;
+  const input = config.build?.rollupOptions?.input;
+  if (typeof input === "string") {
+    result.add(resolveEntry(root, input));
+  } else if (Array.isArray(input)) {
+    for (const e of input) result.add(resolveEntry(root, e));
+  } else if (input && typeof input === "object") {
+    for (const e of Object.values(input)) result.add(resolveEntry(root, e));
+  }
+  return result;
+}
+function serializeRuntimeOptions(options) {
+  const { inject: _i, injectEntries: _ie, injectPattern: _ip, ...rest } = options;
+  return JSON.stringify(rest);
+}
+function betterConsole(options = {}) {
+  const {
+    inject = true,
+    injectEntries = [],
+    injectPattern,
+    warnInProduction = true
+  } = options;
+  const serialized = serializeRuntimeOptions(options);
+  const injected = /* @__PURE__ */ new Set();
+  let entryPaths = /* @__PURE__ */ new Set();
+  let projectRoot = process.cwd();
+  let isDev = false;
+  function shouldInject(id) {
+    if (!inject) return false;
+    if (injected.has(id)) return false;
+    if (id.includes("node_modules")) return false;
+    if (id.startsWith("\0")) return false;
+    if (id.startsWith("virtual:")) return false;
+    if (id.includes(PLUGIN_NAME)) return false;
+    const norm = normalize(id);
+    if (injectEntries.some((e) => {
+      const resolved = resolveEntry(projectRoot, e);
+      return matchPattern(e, norm) || matchPattern(resolved, norm) || norm.endsWith("/" + normalize(e));
+    })) return true;
+    if (injectPattern && matchPattern(injectPattern, norm)) return true;
+    if (entryPaths.has(norm)) {
+      return ENTRY_EXTS.has(norm.slice(norm.lastIndexOf(".")));
+    }
+    return false;
+  }
+  return {
+    name: PLUGIN_NAME,
+    enforce: "pre",
+    // run before framework plugins (e.g. @vitejs/plugin-vue)
+    // 1. Inject compile-time defines so the runtime knows mode and options
+    config(_cfg, env) {
+      isDev = env.command === "serve" || env.mode !== "production";
+      return {
+        define: {
+          __BETTER_CONSOLE_DEV__: JSON.stringify(isDev),
+          __BETTER_CONSOLE_WARN__: JSON.stringify(warnInProduction),
+          __BETTER_CONSOLE_OPTIONS__: serialized
+        },
+        optimizeDeps: {
+          // Pre-bundle the runtime so HMR doesn't break on first load
+          include: [RUNTIME_PKG]
+        }
+      };
+    },
+    // 2. Save the resolved root and collect rollup entries
+    configResolved(config) {
+      projectRoot = config.root;
+      entryPaths = rollupEntries(config);
+    },
+    // 3. Collect <script type="module"> entries from index.html
+    transformIndexHtml: {
+      order: "pre",
+      handler(html) {
+        for (const path of htmlModuleEntries(html, projectRoot)) {
+          entryPaths.add(path);
+        }
+        return [];
+      }
+    },
+    // 4. Virtual module: the thin glue that imports the runtime
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return RESOLVED_VIRTUAL;
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL) {
+        return `import '${RUNTIME_PKG}'`;
+      }
+    },
+    // 5. Prepend the virtual import to every matched entry
+    transform(code, id) {
+      if (!shouldInject(id)) return null;
+      if (!isDev) return null;
+      injected.add(id);
+      return {
+        code: `import '${VIRTUAL_ID}'
+${code}`,
+        map: null
+      };
+    }
+  };
+}
+var plugin_default = betterConsole;
+export {
+  betterConsole,
+  plugin_default as default
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,34 @@
+// Injected by `vite-plugin-better-console` — do not set manually.
+declare const __BETTER_CONSOLE_DEV__:     boolean | undefined
+declare const __BETTER_CONSOLE_WARN__:    boolean | undefined
+declare const __BETTER_CONSOLE_OPTIONS__: string  | undefined
+
+export type {
+  LogLevel,
+  LoggerOptions,
+  LogCallOptions,
+  LogFn,
+  ThemeStyles,
+  BetterConsoleOptions,
+} from './types.js'
+
+export { LOG_LEVEL_RANK }                       from './types.js'
+export { DEFAULT_THEME, DEFAULT_OPTIONS, resolveOptions, shouldLog, detectDev, detectWarnInProduction } from './config.js'
+export { getCaller }                            from './caller.js'
+export { typeOf, formatTimestamp, printMeta, printValue } from './format.js'
+export { createLogger }                         from './logger.js'
+export { attachRuntime }                        from './index.js'
+
+declare const _logger: import('./types.js').LogFn
+export default _logger
+
+// ── Augment global console ─────────────────────────────────────────────────
+
+declare global {
+  interface Console {
+    /** Better-console logger (primary) */
+    better: import('./types.js').LogFn
+    /** Better-console logger (legacy alias) */
+    logger: import('./types.js').LogFn
+  }
+}

package/dist/runtime/index.js

@@ -0,0 +1,352 @@
+// src/types.ts
+var LOG_LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 99
+};
+
+// src/config.ts
+var DEFAULT_THEME = {
+  badge_debug: "display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:700;letter-spacing:.5px;background:#f3f0ff;color:#6d28d9;border:1px solid #c4b5fd",
+  badge_info: "display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:700;letter-spacing:.5px;background:#eff6ff;color:#1d4ed8;border:1px solid #93c5fd",
+  badge_warn: "display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:700;letter-spacing:.5px;background:#fffbeb;color:#b45309;border:1px solid #fcd34d",
+  badge_error: "display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:700;letter-spacing:.5px;background:#fef2f2;color:#dc2626;border:1px solid #fca5a5",
+  label: "color:#94a3b8;font-size:11px;min-width:68px;display:inline-block",
+  value: "color:#0ea5e9;font-weight:600",
+  meta: "color:#64748b;font-size:11px",
+  divider: "color:#cbd5e1"
+};
+var DEFAULT_OPTIONS = {
+  logLevel: "debug",
+  collapsed: true,
+  showPath: true,
+  showLine: true,
+  showFn: true,
+  showType: true,
+  timestamp: true,
+  timestampFormat: "locale"
+};
+function detectDev() {
+  if (typeof __BETTER_CONSOLE_DEV__ !== "undefined") {
+    return __BETTER_CONSOLE_DEV__;
+  }
+  try {
+    if (import.meta.env?.PROD) return false;
+    if (import.meta.env?.DEV) return true;
+  } catch {
+  }
+  if (typeof process !== "undefined") {
+    return true;
+  }
+  return true;
+}
+function detectWarnInProduction() {
+  if (typeof __BETTER_CONSOLE_WARN__ !== "undefined") {
+    return __BETTER_CONSOLE_WARN__;
+  }
+  return true;
+}
+function parseInjectedOptions() {
+  if (typeof __BETTER_CONSOLE_OPTIONS__ === "undefined") return {};
+  try {
+    const raw = __BETTER_CONSOLE_OPTIONS__;
+    return (typeof raw === "string" ? JSON.parse(raw) : raw) ?? {};
+  } catch {
+    return {};
+  }
+}
+function resolveOptions(overrides = {}) {
+  const injected = parseInjectedOptions();
+  return {
+    ...DEFAULT_OPTIONS,
+    ...injected,
+    ...overrides,
+    dev: overrides.dev ?? detectDev(),
+    warnInProduction: overrides.warnInProduction ?? detectWarnInProduction(),
+    theme: {
+      ...DEFAULT_THEME,
+      ...injected.theme,
+      ...overrides.theme
+    },
+    badge: overrides.badge ?? injected.badge ?? {}
+  };
+}
+function shouldLog(level, minLevel = "debug") {
+  return (LOG_LEVEL_RANK[level] ?? 0) >= (LOG_LEVEL_RANK[minLevel] ?? 0);
+}
+
+// src/caller.ts
+var SKIP_TOKENS = [
+  "vite-plugin-better-console",
+  "betterConsole",
+  "getCaller",
+  "createLogger",
+  "attachRuntime",
+  "logAtLevel",
+  "printMeta",
+  "printValue"
+];
+var RE_V8 = /^\s*at\s+(?:async\s+)?(?:([\w$.<>\[\] ]+?)\s+\()?(?:file:\/\/)?(.+?):(\d+)(?::(\d+))?\)?$/;
+var RE_FF = /^\s*(?:([\w$.<>\[\]]+)@)?(?:file:\/\/)?(.+?):(\d+)(?::(\d+))?$/;
+function parseFrame(raw) {
+  let m = raw.match(RE_V8);
+  if (m) {
+    const [, fn, path, line, col] = m;
+    if (!path) return null;
+    return { fn: fn?.trim() || void 0, path: cleanPath(path), line, col };
+  }
+  m = raw.match(RE_FF);
+  if (m) {
+    const [, fn, path, line, col] = m;
+    if (!path) return null;
+    return { fn: fn?.trim() || void 0, path: cleanPath(path), line, col };
+  }
+  return null;
+}
+function cleanPath(raw) {
+  return raw.replace(/^file:\/\//, "").replace(/\\/g, "/").replace(/\?.*$/, "").replace(/^\/\//, "/");
+}
+function isInternal(info) {
+  const haystack = `${info.path ?? ""} ${info.fn ?? ""}`.toLowerCase();
+  return SKIP_TOKENS.some((tok) => haystack.includes(tok.toLowerCase()));
+}
+function getCaller(extraSkip = 0) {
+  const stack = new Error().stack;
+  if (!stack) return {};
+  const lines = stack.split("\n").slice(1 + extraSkip);
+  for (const line of lines) {
+    const frame = parseFrame(line);
+    if (!frame) continue;
+    if (isInternal(frame)) continue;
+    return frame;
+  }
+  return {};
+}
+
+// src/format.ts
+function typeOf(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+var _start = Date.now();
+function formatTimestamp(date, format) {
+  if (typeof format === "function") return format(date);
+  switch (format) {
+    case "iso":
+      return date.toISOString();
+    case "time-only":
+      return date.toLocaleTimeString("en-GB", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+    case "date-only":
+      return date.toLocaleDateString("en-GB", {
+        year: "numeric",
+        month: "short",
+        day: "2-digit"
+      });
+    case "relative": {
+      const ms = date.getTime() - _start;
+      if (ms < 1e3) return `+${ms}ms`;
+      if (ms < 6e4) return `+${(ms / 1e3).toFixed(2)}s`;
+      return `+${(ms / 6e4).toFixed(1)}min`;
+    }
+    case "locale":
+    default: {
+      const d = date.toLocaleDateString("en-GB", {
+        year: "numeric",
+        month: "short",
+        day: "2-digit"
+      });
+      const t = date.toLocaleTimeString("en-GB", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+      return `${d} ${t}`;
+    }
+  }
+}
+function printMeta(label, value, opts) {
+  if (value == null || value === "") return;
+  console.info(
+    `%c${label.padEnd(10)}%c${value}`,
+    opts.theme.label,
+    opts.theme.value
+  );
+}
+function printValue(value) {
+  const kind = typeOf(value);
+  switch (kind) {
+    case "Map": {
+      const rows = Array.from(value, ([k, v]) => ({ key: k, value: v }));
+      console.table(rows);
+      return;
+    }
+    case "Set": {
+      const rows = Array.from(value, (v, i) => ({ index: i, value: v }));
+      console.table(rows);
+      return;
+    }
+    case "Array":
+    case "Object":
+      console.table(value);
+      return;
+    case "Date": {
+      const d = value;
+      console.info(`${d.toISOString()}  (local: ${d.toLocaleString()})`);
+      return;
+    }
+    case "Promise":
+      console.info("%cPromise { <pending> }", "color:#94a3b8;font-style:italic");
+      value.then(
+        (r) => console.info("  \u21B3 resolved \u2192", r),
+        (e) => console.info("  \u21B3 rejected \u2192", e)
+      );
+      return;
+    case "Error": {
+      const err = value;
+      console.info(err.stack ?? err.message ?? String(err));
+      return;
+    }
+    case "Function":
+      console.info(`\u0192 ${value.name || "(anonymous)"}`);
+      return;
+    case "RegExp":
+      console.info(String(value));
+      return;
+    case "Null":
+      console.info("%cnull", "color:#94a3b8;font-style:italic");
+      return;
+    case "Undefined":
+      console.info("%cundefined", "color:#94a3b8;font-style:italic");
+      return;
+    default:
+      if (value !== void 0) console.info(value);
+  }
+}
+
+// src/logger.ts
+var warnProductionOnce = /* @__PURE__ */ (() => {
+  let fired = false;
+  return () => {
+    if (fired) return;
+    fired = true;
+    console.log(
+      "%c better-console %c disabled in production ",
+      "background:#dc2626;color:#fff;font-size:11px;padding:3px 6px;border-radius:4px 0 0 4px;font-weight:700",
+      "background:#1e293b;color:#94a3b8;font-size:11px;padding:3px 8px;border-radius:0 4px 4px 0"
+    );
+  };
+})();
+var DEFAULT_BADGES = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR",
+  silent: ""
+};
+function createLogger(userOptions = {}) {
+  const opts = resolveOptions(userOptions);
+  const {
+    dev,
+    warnInProduction,
+    logLevel,
+    collapsed: defaultCollapsed,
+    showPath,
+    showLine,
+    showFn,
+    showType,
+    timestamp: defaultTimestamp,
+    timestampFormat,
+    theme,
+    badge: badgeMap
+  } = opts;
+  function logAtLevel(level, label, value, callOpts = {}) {
+    if (!dev) {
+      if (warnInProduction) warnProductionOnce();
+      return;
+    }
+    const effectiveLevel = callOpts.level ?? level;
+    if (!shouldLog(effectiveLevel, logLevel)) return;
+    if (callOpts.enabled === false) return;
+    const {
+      comment,
+      collapsed = defaultCollapsed,
+      path: overridePath,
+      line: overrideLine,
+      fn: overrideFn,
+      timestamp: showTimestamp = defaultTimestamp
+    } = callOpts;
+    let caller = getCaller();
+    if (overridePath != null) caller = { ...caller, path: overridePath };
+    if (overrideLine != null) caller = { ...caller, line: String(overrideLine) };
+    if (overrideFn != null) caller = { ...caller, fn: overrideFn };
+    const badgeText = badgeMap === false ? label : `${(badgeMap && badgeMap[effectiveLevel]) ?? DEFAULT_BADGES[effectiveLevel]} \xB7 ${label}`;
+    const badgeStyle = theme[`badge_${effectiveLevel}`] ?? theme.badge_info;
+    const groupFn = collapsed ? console.groupCollapsed : console.group;
+    groupFn(`%c ${badgeText} `, badgeStyle);
+    if (showTimestamp) {
+      printMeta("time", formatTimestamp(/* @__PURE__ */ new Date(), timestampFormat), opts);
+    }
+    if (showFn && caller.fn) {
+      printMeta("function", caller.fn, opts);
+    }
+    if (showPath && caller.path) {
+      printMeta("file", caller.path, opts);
+    }
+    if (showLine && caller.line) {
+      printMeta("line", caller.line, opts);
+    }
+    if (showType && value !== void 0) {
+      printMeta("type", typeOf(value), opts);
+    }
+    printValue(value);
+    if (comment) {
+      printMeta("note", comment, opts);
+    }
+    console.groupEnd();
+  }
+  const log = (label, value, options) => logAtLevel("info", label, value, options);
+  log.debug = (label, value, options) => logAtLevel("debug", label, value, options);
+  log.info = (label, value, options) => logAtLevel("info", label, value, options);
+  log.warn = (label, value, options) => logAtLevel("warn", label, value, options);
+  log.error = (label, value, options) => logAtLevel("error", label, value, options);
+  log.table = (label, data, options = {}) => logAtLevel("info", label, data, { ...options, collapsed: false });
+  Object.defineProperty(log, "dev", { get: () => dev, enumerable: true });
+  Object.defineProperty(log, "level", { get: () => logLevel, enumerable: true });
+  return log;
+}
+
+// src/index.ts
+function attachRuntime(logger) {
+  const instance = logger ?? createLogger(resolveOptions());
+  if (typeof console !== "undefined") {
+    ;
+    console.log = console.log;
+    console.better = instance;
+    console.logger = instance;
+  }
+  return instance;
+}
+var _logger = attachRuntime();
+var index_default = _logger;
+export {
+  DEFAULT_OPTIONS,
+  DEFAULT_THEME,
+  LOG_LEVEL_RANK,
+  attachRuntime,
+  createLogger,
+  index_default as default,
+  detectDev,
+  detectWarnInProduction,
+  formatTimestamp,
+  getCaller,
+  printMeta,
+  printValue,
+  resolveOptions,
+  shouldLog,
+  typeOf
+};