@graphty/graphty-element 2.0.0 → 2.2.0

package/dist/chunks/GraphtyLogger-5KEttFUo.js

@@ -0,0 +1,752 @@
+import { G as c } from "./GraphtyError-BwcnblTH.js";
+import { c as $ } from "./types-B7bX5c0K.js";
+function G(e) {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set();
+  let s = null;
+  return {
+    register(i, n) {
+      const o = e.idOf(i);
+      if (typeof o != "string" || o === "")
+        throw new c({
+          code: "E_BAD_COMMAND",
+          message: `a ${e.kind} registration needs an id`,
+          source: "registry",
+          details: { kind: e.kind, field: "id" }
+        });
+      if (e.builtInIds().includes(o))
+        throw new c({
+          code: "E_DUPLICATE_PLUGIN",
+          message: `"${o}" is the id of a ${e.kind} the element ships, and a built-in id may not be taken: a saved document that named it yesterday has to mean the same thing today`,
+          source: "registry",
+          details: { kind: e.kind, name: o, builtIn: !0 }
+        });
+      const u = t.get(o);
+      if (u !== void 0) {
+        if (e.implementationOf(u) === e.implementationOf(i))
+          return;
+        if (n?.strict === !0)
+          throw new c({
+            code: "E_DUPLICATE_PLUGIN",
+            message: `a ${e.kind} named "${o}" is already registered`,
+            source: "registry",
+            details: { kind: e.kind, name: o }
+          });
+        r.has(o) || (r.add(o), console.warn(
+          `graphty: a second ${e.kind} named "${o}" replaced the first. Register one implementation per name, or pass { strict: true } to make this throw.`
+        ));
+      }
+      t.set(o, i), s = null;
+    },
+    entries() {
+      return Object.freeze([...t.values()]);
+    },
+    descriptors() {
+      return s ??= Object.freeze([...t.values()].map((i) => e.descriptorOf(i))), s;
+    },
+    byId(i) {
+      return t.get(i);
+    },
+    clearForTesting() {
+      t.clear(), r.clear(), s = null;
+    }
+  };
+}
+const _ = G({
+  kind: "sink",
+  idOf: (e) => e.descriptor.id,
+  descriptorOf: (e) => e.descriptor,
+  implementationOf: (e) => e.create,
+  builtInIds: () => $
+});
+function Oe(e, t) {
+  const r = e.descriptor;
+  if (r === void 0 || typeof r != "object")
+    throw new c({
+      code: "E_BAD_COMMAND",
+      message: "registerLogSink takes a registration with a descriptor",
+      source: "registry",
+      details: { kind: "sink", field: "descriptor" }
+    });
+  if (typeof e.create != "function")
+    throw new c({
+      code: "E_BAD_COMMAND",
+      message: `the log destination "${String(r.id)}" was registered without a create function`,
+      source: "registry",
+      details: { kind: "sink", name: String(r.id), field: "create" }
+    });
+  _.register(e, t);
+}
+function U() {
+  return _.descriptors();
+}
+function v(e) {
+  return _.byId(e);
+}
+function Te() {
+  _.clearForTesting();
+}
+const F = Object.freeze([
+  {
+    id: "console",
+    plainName: "Browser console",
+    description: "Writes each record to the developer console, one line per record.",
+    options: [
+      {
+        name: "colors",
+        plainName: "Coloured output",
+        type: "boolean",
+        // TRUE BECAUSE THAT IS WHAT THE ELEMENT ACTUALLY DOES. The console the element
+        // attaches reads `format.colors ?? true`, so a descriptor saying false made a
+        // settings panel built from this table show "Coloured output: off" while the
+        // element was colouring, and `configure({ sinks: [{ use: "console" }] })`
+        // silently turned colour off by filling in a default nobody chose.
+        default: !0,
+        description: "Tint each line by its level."
+      }
+    ]
+  },
+  {
+    id: "remote",
+    plainName: "Remote log server",
+    description: "Batches records and posts them to a log server, for a device whose console nobody can see -- a headset, a phone, a kiosk.",
+    options: [
+      {
+        name: "serverUrl",
+        plainName: "Server address",
+        type: "string",
+        description: "Where records are posted, such as http://localhost:9080."
+      },
+      {
+        name: "sessionPrefix",
+        plainName: "Session prefix",
+        type: "string",
+        default: "graphty",
+        description: "Prefixes the session id each batch is filed under."
+      },
+      {
+        name: "batchIntervalMs",
+        plainName: "Batch interval",
+        type: "integer",
+        default: 100,
+        min: 0,
+        description: "How long records are collected before a batch is sent, in milliseconds."
+      },
+      {
+        name: "maxRetries",
+        plainName: "Retries",
+        type: "integer",
+        default: 3,
+        min: 0,
+        description: "How many times a failed batch is resent before it is dropped."
+      },
+      {
+        name: "retryDelayMs",
+        plainName: "Retry delay",
+        type: "integer",
+        default: 1e3,
+        min: 0,
+        description: "How long to wait between retries, in milliseconds."
+      },
+      {
+        name: "throttleMs",
+        plainName: "Throttle window",
+        type: "integer",
+        default: 5e3,
+        min: 0,
+        description: "How long a repeated message is suppressed for, in milliseconds."
+      }
+    ]
+  }
+]);
+function j(e) {
+  return F.find((t) => t.id === e) ?? v(e)?.descriptor;
+}
+const x = 3;
+function B(e, t) {
+  let r = Array.from({ length: t.length + 1 }, (s, i) => i);
+  for (let s = 1; s <= e.length; s++) {
+    const i = [s];
+    for (let n = 1; n <= t.length; n++) {
+      const o = (r[n - 1] ?? 0) + (e[s - 1] === t[n - 1] ? 0 : 1);
+      i[n] = Math.min(o, (r[n] ?? 0) + 1, (i[n - 1] ?? 0) + 1);
+    }
+    r = i;
+  }
+  return r[t.length] ?? Math.max(e.length, t.length);
+}
+function W(e, t) {
+  return t.map((r) => ({ name: r, distance: B(e.toLowerCase(), r.toLowerCase()) })).filter((r) => r.distance <= x).sort((r, s) => r.distance - s.distance).slice(0, 3).map((r) => r.name);
+}
+function O(e) {
+  return typeof e == "number" ? e : void 0;
+}
+function K(e, t, r) {
+  const s = { kind: r.kind, id: r.id, option: e.name, value: t };
+  if (e.type === "enum" && e.values !== void 0) {
+    const i = e.values.map((n) => n.value);
+    if (typeof t != "string" || !i.includes(t))
+      throw new c({
+        code: "E_OPTION_RANGE",
+        message: `"${e.name}" accepts ${i.map((n) => `"${n}"`).join(", ")}`,
+        source: "config",
+        details: { ...s, values: i }
+      });
+    return;
+  }
+  if (e.type === "number" || e.type === "integer") {
+    if (typeof t != "number" || !Number.isFinite(t))
+      throw new c({
+        code: "E_OPTION_RANGE",
+        message: `"${e.name}" takes a number`,
+        source: "config",
+        details: s
+      });
+    if (e.type === "integer" && !Number.isInteger(t))
+      throw new c({
+        code: "E_OPTION_RANGE",
+        message: `"${e.name}" takes a whole number`,
+        source: "config",
+        details: s
+      });
+    const i = O(e.min), n = O(e.max);
+    if (i !== void 0 && t < i || n !== void 0 && t > n)
+      throw new c({
+        code: "E_OPTION_RANGE",
+        message: `"${e.name}" is limited to ${i ?? "any"} through ${n ?? "any"}`,
+        source: "config",
+        details: { ...s, min: i, max: n }
+      });
+    return;
+  }
+  if (e.type === "boolean" && typeof t != "boolean")
+    throw new c({
+      code: "E_OPTION_RANGE",
+      message: `"${e.name}" takes true or false`,
+      source: "config",
+      details: s
+    });
+}
+function T(e, t, r) {
+  const s = new Map(e.map((n) => [n.name, n]));
+  for (const n of Object.keys(t))
+    if (!s.has(n)) {
+      const o = e.map((u) => u.name);
+      throw new c({
+        code: "E_UNKNOWN_OPTION",
+        message: `the ${r.kind} "${r.id}" has no option named "${n}"`,
+        source: "config",
+        details: {
+          kind: r.kind,
+          id: r.id,
+          option: n,
+          available: o,
+          candidates: W(n, o)
+        }
+      });
+    }
+  const i = {};
+  for (const n of e) {
+    const o = t[n.name];
+    if (o === void 0) {
+      n.default !== void 0 && (i[n.name] = n.default);
+      continue;
+    }
+    K(n, o, r), i[n.name] = o;
+  }
+  return i;
+}
+var l = /* @__PURE__ */ ((e) => (e[e.SILENT = 0] = "SILENT", e[e.ERROR = 1] = "ERROR", e[e.WARN = 2] = "WARN", e[e.INFO = 3] = "INFO", e[e.DEBUG = 4] = "DEBUG", e[e.TRACE = 5] = "TRACE", e))(l || {});
+const H = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+  trace: 5
+  /* TRACE */
+}, N = {
+  0: "SILENT",
+  1: "ERROR",
+  2: "WARN",
+  3: "INFO",
+  4: "DEBUG",
+  5: "TRACE"
+};
+function be(e) {
+  return H[e.toLowerCase()];
+}
+const y = {
+  enabled: !1,
+  level: l.INFO,
+  modules: "*",
+  format: {
+    timestamp: !0,
+    module: !0,
+    colors: !0
+  }
+};
+let a = { ...y, format: { ...y.format } };
+function z(e) {
+  a = {
+    enabled: e.enabled ?? a.enabled,
+    level: e.level ?? a.level,
+    modules: e.modules ?? a.modules,
+    moduleLevels: e.moduleLevels ?? a.moduleLevels,
+    format: {
+      timestamp: e.format?.timestamp ?? a.format.timestamp,
+      timestampFormat: e.format?.timestampFormat ?? a.format.timestampFormat,
+      module: e.format?.module ?? a.format.module,
+      colors: e.format?.colors ?? a.format.colors
+    }
+  };
+}
+function b(e) {
+  const t = a.moduleLevels;
+  if (t === void 0)
+    return a.level;
+  for (let r = e.length - 1; r >= 0; r--) {
+    const s = t[e[r]];
+    if (s !== void 0)
+      return s;
+  }
+  return a.level;
+}
+function m() {
+  return { ...a, format: { ...a.format } };
+}
+function k(e) {
+  if (!a.enabled || e.length === 0)
+    return !1;
+  if (a.modules === "*")
+    return !0;
+  const t = a.modules;
+  for (const r of t)
+    if (e.includes(r))
+      return !0;
+  return !1;
+}
+function ke() {
+  a = { ...y, format: { ...y.format } };
+}
+function R(e, t) {
+  const { format: r } = m(), s = t?.timestamp ?? r.timestamp, i = t?.module ?? r.module, n = [];
+  return s && n.push(`[${e.timestamp.toISOString()}]`), i && n.push(`[${e.category.join(".")}]`), n.push(`[${N[e.level]}]`), n.push(e.message), n.join(" ");
+}
+const I = /* @__PURE__ */ Symbol.for("graphty.lazy");
+function Me(e) {
+  let t, r = !1;
+  const s = () => (r || (t = e(), r = !0), t);
+  return s[I] = !0, s;
+}
+function J(e) {
+  return typeof e == "function" && I in e;
+}
+function V(e) {
+  const t = {};
+  for (const [r, s] of Object.entries(e))
+    t[r] = J(s) ? s() : s;
+  return t;
+}
+function q(e) {
+  switch (e) {
+    case l.ERROR:
+      return "error";
+    case l.WARN:
+      return "warn";
+    case l.INFO:
+      return "info";
+    default:
+      return "debug";
+  }
+}
+function Y(e) {
+  const t = { ...e.data };
+  return e.error && (t.error = e.error.stack ?? e.error.message), Object.keys(t).length > 0 ? t : void 0;
+}
+function S(e = {}) {
+  const t = e.formatter ?? R, r = e.colors ?? !0;
+  return {
+    name: "console",
+    write(s) {
+      const i = t(s), n = r ? q(s.level) : "log", o = Y(s);
+      o ? console[n](i, o) : console[n](i);
+    }
+  };
+}
+function M(e) {
+  try {
+    if (e === "__REMOTE_LOG_PROJECT_MARKER__")
+      return typeof __REMOTE_LOG_PROJECT_MARKER__ < "u" ? __REMOTE_LOG_PROJECT_MARKER__ : void 0;
+    if (e === "__REMOTE_LOG_WORKTREE_PATH__")
+      return typeof __REMOTE_LOG_WORKTREE_PATH__ < "u" ? __REMOTE_LOG_WORKTREE_PATH__ : void 0;
+  } catch {
+    return;
+  }
+}
+const X = 1e3, Z = 3, Q = 1e3, ee = "session", te = 5e3;
+function re(e) {
+  const t = Date.now().toString(36), r = Math.random().toString(36).substring(2, 8);
+  return `${e}-${t}-${r}`;
+}
+class ne {
+  /**
+   * Creates a new RemoteLogClient.
+   * @param options - Configuration options
+   */
+  constructor(t) {
+    this.pendingLogs = [], this.batchTimer = null, this.isClosed = !1, this.flushPromise = null, this.throttleLastTimes = /* @__PURE__ */ new Map(), this.serverUrl = t.serverUrl, this.sessionId = re(t.sessionPrefix ?? ee), this.batchIntervalMs = t.batchIntervalMs ?? X, this.maxRetries = t.maxRetries ?? Z, this.retryDelayMs = t.retryDelayMs ?? Q, this.throttlePatterns = t.throttlePatterns ?? [], this.timeoutMs = t.timeoutMs ?? te, this.projectMarker = t.projectMarker ?? M("__REMOTE_LOG_PROJECT_MARKER__"), this.worktreePath = t.worktreePath ?? M("__REMOTE_LOG_WORKTREE_PATH__");
+  }
+  /**
+   * Checks if a message should be throttled based on configured patterns.
+   * Updates the last time tracking if the message is allowed through.
+   * @param message - The message to check
+   * @returns true if the message should be dropped (throttled)
+   */
+  shouldThrottle(t) {
+    const r = Date.now();
+    for (const { pattern: s, intervalMs: i } of this.throttlePatterns)
+      if (s.test(t)) {
+        const n = s.source, o = this.throttleLastTimes.get(n) ?? 0;
+        return r - o < i ? !0 : (this.throttleLastTimes.set(n, r), !1);
+      }
+    return !1;
+  }
+  /**
+   * Logs a message at the specified level.
+   * @param level - Log level (e.g., "INFO", "DEBUG", "WARN", "ERROR")
+   * @param message - The log message
+   * @param data - Optional additional data to include
+   */
+  log(t, r, s) {
+    if (this.isClosed || this.shouldThrottle(r))
+      return;
+    const i = {
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      level: t,
+      message: r,
+      ...s !== void 0 && { data: s }
+    };
+    this.pendingLogs.push(i), this.scheduleBatchSend();
+  }
+  /**
+   * Schedules a batch send after the configured interval.
+   * If a timer is already scheduled, does nothing.
+   */
+  scheduleBatchSend() {
+    this.batchTimer !== null || this.isClosed || (this.batchTimer = setTimeout(() => {
+      this.batchTimer = null, this.sendBatch();
+    }, this.batchIntervalMs));
+  }
+  /**
+   * Sends the current batch of logs to the server.
+   * Uses retry logic with exponential backoff on failure.
+   */
+  async sendBatch() {
+    if (this.pendingLogs.length === 0)
+      return;
+    const t = this.pendingLogs;
+    this.pendingLogs = [], await this.sendWithRetry(t);
+  }
+  /**
+   * Sends logs with retry logic using exponential backoff.
+   * @param logs - The log entries to send
+   */
+  async sendWithRetry(t) {
+    let r = null;
+    for (let s = 0; s <= this.maxRetries; s++)
+      try {
+        await this.sendRequest(t);
+        return;
+      } catch (i) {
+        if (r = i instanceof Error ? i : new Error(String(i)), s < this.maxRetries) {
+          const n = this.retryDelayMs * Math.pow(2, s);
+          await this.sleep(n);
+        }
+      }
+    console.error("[RemoteLogClient] Failed to send logs after retries:", r?.message);
+  }
+  /**
+   * Makes the actual HTTP request to send logs.
+   * @param logs - The log entries to send
+   * @throws Error if the request fails or times out
+   */
+  async sendRequest(t) {
+    const r = {
+      sessionId: this.sessionId,
+      logs: t
+    };
+    this.projectMarker !== void 0 && (r.projectMarker = this.projectMarker), this.worktreePath !== void 0 && (r.worktreePath = this.worktreePath);
+    const s = new AbortController(), i = setTimeout(() => {
+      s.abort();
+    }, this.timeoutMs);
+    try {
+      const n = await fetch(`${this.serverUrl}/log`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(r),
+        signal: s.signal
+      });
+      if (!n.ok)
+        throw new Error(`HTTP ${n.status}: ${n.statusText}`);
+    } finally {
+      clearTimeout(i);
+    }
+  }
+  /**
+   * Helper to sleep for the specified duration.
+   * @param ms - Milliseconds to sleep
+   * @returns A promise that resolves after the specified time
+   */
+  sleep(t) {
+    return new Promise((r) => setTimeout(r, t));
+  }
+  /**
+   * Immediately flushes all pending logs to the server.
+   * Useful before page unload or when immediate delivery is needed.
+   */
+  async flush() {
+    this.batchTimer !== null && (clearTimeout(this.batchTimer), this.batchTimer = null), this.flushPromise !== null && await this.flushPromise, this.pendingLogs.length > 0 && (this.flushPromise = this.sendBatch(), await this.flushPromise, this.flushPromise = null);
+  }
+  /**
+   * Closes the client, flushing any pending logs and stopping the batch timer.
+   * After calling close(), no more logs will be accepted.
+   */
+  async close() {
+    this.isClosed || (this.isClosed = !0, await this.flush());
+  }
+}
+function se(e) {
+  const t = [R(e, { timestamp: !1, module: !0 })];
+  if (e.data && Object.keys(e.data).length > 0)
+    try {
+      t.push(JSON.stringify(e.data));
+    } catch {
+      t.push("[non-serializable data]");
+    }
+  return e.error && (t.push(`
+Error: ${e.error.message}`), e.error.stack && t.push(`
+${e.error.stack}`)), t.join(" ");
+}
+function L(e) {
+  const t = e.serverUrl.replace(/\/$/, ""), r = e.sessionPrefix ?? "graphty", s = e.batchIntervalMs ?? 100, i = e.maxRetries ?? 3, n = e.retryDelayMs ?? 1e3, o = e.throttleMs ?? 5e3, u = e.throttlePatterns?.map((f) => ({
+    pattern: f,
+    intervalMs: o
+  })), h = new ne({
+    serverUrl: t,
+    sessionPrefix: r,
+    batchIntervalMs: s,
+    maxRetries: i,
+    retryDelayMs: n,
+    throttlePatterns: u
+  });
+  return {
+    name: "remote",
+    write(f) {
+      const D = se(f), C = N[f.level];
+      h.log(C, D, f.data);
+    },
+    async flush() {
+      await h.flush();
+    },
+    /*
+     * The client holds a batch timer, and before `dispose` existed nothing ever stopped it:
+     * removing this destination left it posting to a server the page had stopped listening
+     * to. `close` sends what is buffered first, so records already accepted are not lost.
+     */
+    async dispose() {
+      await h.close();
+    }
+  };
+}
+const E = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+let w;
+function ie(e) {
+  return e.join(".");
+}
+function A(e) {
+  if (e.dispose)
+    try {
+      const t = e.dispose();
+      t instanceof Promise && t.catch((r) => {
+        console.error(`[GraphtyLogger] Error disposing sink "${e.name}":`, r);
+      });
+    } catch (t) {
+      console.error(`[GraphtyLogger] Error disposing sink "${e.name}":`, t);
+    }
+}
+function oe(e, t) {
+  return e.level !== void 0 && t.level > e.level ? !1 : e.categories !== void 0 && e.categories.length > 0 ? e.categories.some((r) => t.category.includes(r)) : !0;
+}
+function ae(e) {
+  e.data && Object.freeze(e.data), Object.freeze(e);
+  for (const t of d.values())
+    if (oe(t, e))
+      try {
+        t.write(e);
+      } catch (r) {
+        console.error(`[GraphtyLogger] Error in sink "${t.name}":`, r);
+      }
+}
+function le(e) {
+  const t = (i, n, o, u) => {
+    if (!m().enabled || !k(e) || i > b(e))
+      return;
+    const f = o ? V(o) : void 0;
+    ae({
+      timestamp: /* @__PURE__ */ new Date(),
+      level: i,
+      category: e,
+      message: n,
+      data: f,
+      error: u
+    });
+  }, r = (i) => (n, o) => {
+    t(i, n, o);
+  }, s = (i) => m().enabled && k(e) && b(e) >= i;
+  return {
+    trace: r(l.TRACE),
+    debug: r(l.DEBUG),
+    info: r(l.INFO),
+    warn: r(l.WARN),
+    error: (i, n, o) => {
+      t(l.ERROR, i, o, n);
+    },
+    isTraceEnabled: () => s(l.TRACE),
+    isDebugEnabled: () => s(l.DEBUG)
+  };
+}
+function ce(e) {
+  return S({ colors: e.colors === !0 });
+}
+function g(e) {
+  return typeof e == "number" ? e : void 0;
+}
+function ue(e) {
+  return L({
+    serverUrl: typeof e.serverUrl == "string" ? e.serverUrl : "",
+    sessionPrefix: typeof e.sessionPrefix == "string" ? e.sessionPrefix : void 0,
+    batchIntervalMs: g(e.batchIntervalMs),
+    maxRetries: g(e.maxRetries),
+    retryDelayMs: g(e.retryDelayMs),
+    throttleMs: g(e.throttleMs)
+  });
+}
+const P = /* @__PURE__ */ new Map([
+  ["console", ce],
+  ["remote", ue]
+]);
+function fe() {
+  return [...P.keys(), ...U().map((e) => e.id)];
+}
+function de(e) {
+  throw new c({
+    code: "E_UNKNOWN_SINK",
+    message: `nothing is registered as the log destination "${e}". Register it with registerLogSink before naming it in a configuration.`,
+    source: "config",
+    details: { kind: "sink", name: e, available: fe() }
+  });
+}
+function me(e) {
+  const t = e.use, r = e.options ?? {}, s = v(t);
+  if (s)
+    return s.create(T(s.descriptor.options, r, { kind: "sink", id: t }));
+  const i = P.get(t), n = j(t);
+  return (!i || !n) && de(t), i(T(n.options, r, { kind: "sink", id: t }));
+}
+function p(e) {
+  const t = d.get(e.name);
+  t && t !== e && A(t), d.set(e.name, e);
+}
+function he(e) {
+  z(e), p(S({ colors: m().format.colors ?? !0 }));
+  const { remoteLogUrl: t } = e;
+  t && t !== w && (w = t, p(L({ serverUrl: t })));
+  for (const r of e.sinks ?? [])
+    p("write" in r ? r : me(r));
+  return E.clear(), Promise.resolve();
+}
+function ge(e) {
+  const t = d.get(e);
+  return t ? (d.delete(e), A(t), e === "remote" && (w = void 0), !0) : !1;
+}
+function pe() {
+  return Array.from(d.values());
+}
+async function ye() {
+  const e = [];
+  for (const t of d.values())
+    t.flush && e.push(
+      t.flush().catch((r) => {
+        console.error(`[GraphtyLogger] Error flushing sink "${t.name}":`, r);
+      })
+    );
+  await Promise.all(e);
+}
+function _e(e) {
+  const t = ie(e), r = E.get(t);
+  if (r)
+    return r;
+  const s = le(e);
+  return E.set(t, s), s;
+}
+function Ee() {
+  return m().enabled;
+}
+const ve = {
+  /**
+   * Configure the logging system.
+   */
+  configure: he,
+  /**
+   * Get a logger for the specified category.
+   */
+  getLogger: _e,
+  /**
+   * Check if logging is enabled.
+   */
+  isEnabled: Ee,
+  /**
+   * Add a custom sink to the logger.
+   */
+  addSink: p,
+  /**
+   * Remove a sink by name.
+   */
+  removeSink: ge,
+  /**
+   * Get all registered sinks.
+   */
+  getSinks: pe,
+  /**
+   * Flush all sinks that support flushing.
+   */
+  flush: ye,
+  /**
+   * Render a record the way the element renders its own console line.
+   */
+  formatRecord: R
+};
+export {
+  ve as G,
+  F as L,
+  U as a,
+  T as b,
+  Te as c,
+  l as d,
+  H as e,
+  N as f,
+  z as g,
+  S as h,
+  L as i,
+  R as j,
+  m as k,
+  j as l,
+  k as m,
+  Me as n,
+  ke as o,
+  be as p,
+  G as q,
+  Oe as r
+};