@specific.dev/spectest 0.38.0 → 0.41.0

package/dist/index.d.ts

@@ -84,7 +84,7 @@ export interface ServiceConfig {
     hostnames?: readonly string[];
     /**
      * Expose this service over HTTPS via a TLS-terminating reverse proxy
-     * hosted in the spectest-daemon. Each entry maps a fully-qualified
+     * hosted in the harness. Each entry maps a fully-qualified
      * hostname to the HTTP port the service listens on inside its
      * container; the daemon binds the hostname on `:443` (SNI-multiplexed,
      * with a leaf cert signed by the in-VM root CA) and on `:80`, and
@@ -1038,7 +1038,7 @@ export interface TestSuite<S extends ServicesMap = ServicesMap, F extends FakesM
     tests: TestCase<unknown, S, F>[];
 }
 /**
- * A fake server hosted in the spectest-daemon. Use this to stand in for
+ * A fake server hosted in the harness. Use this to stand in for
  * external HTTP APIs (auth providers, payment gateways, …) that you can't
  * call directly from the hermetic test VM.
  *
@@ -1176,7 +1176,7 @@ export interface TypedTest<S extends ServicesMap, F extends FakesMap = FakesMap>
 export interface Project<S extends ServicesMap = ServicesMap, F extends FakesMap = FakesMap> {
     environment: EnvironmentConfig<S>;
     /**
-     * Fake servers hosted in the spectest-daemon (see {@link defineFake}).
+     * Fake servers hosted in the harness (see {@link defineFake}).
      * Keyed by stable fake name; the key becomes the slot in
      * `ctx.fakes.<key>` from test code. Populated from the `fakes` declared
      * in `defineEnvironment(...)`.

package/dist/ingress.d.ts

@@ -1,5 +1,5 @@
 import type { Project, ServiceConfig } from "./index.js";
-/** Where a DNS name points. `ingress` = the spectest-daemon listener on the
+/** Where a DNS name points. `ingress` = the harness's listener on the
  *  bridge gateway (fakes, TLS-terminated proxies); `service` = a container's
  *  live IP on spectest-net (a plain peer alias, no daemon hop). */
 export type DnsTarget = {

package/dist/inspect.d.ts

@@ -22,6 +22,29 @@ export declare function clearPendingNullish(): void;
 export declare function adoptNullishTag<T>(value: T): T;
 /** If x is wrapped, return the raw value; otherwise return x. */
 export declare function readRaw<T>(x: T): T;
+/**
+ * Strip provenance wrappers from a value AND from anything nested inside a
+ * plain object/array it holds. The inbound counterpart of {@link wrap}: for
+ * values crossing *back* into code that expects raw data — a fake's `helpers`,
+ * a k8s client method's arguments. Without it a helper that takes a value some
+ * earlier op produced gets a `Carrier`/proxy, and the first `.matchAll(...)` /
+ * typed-client call inside it throws a `TypeError` from deep in the callee,
+ * far from the call site that passed the wrapper. Coercion sinks
+ * ({@link makeCarrier}) rescue only the interpolation cases; a callee that
+ * calls a method on the value, or checks its `typeof`, still sees an object.
+ *
+ * One {@link readRaw} finishes a wrapped value: a wrapper's target is raw all
+ * the way down (the proxy wraps children lazily, on read), so there is nothing
+ * left to walk underneath it. The recursion is for the other shape — a
+ * container the *caller* built around wrapped leaves: `{ to: msg.to }`,
+ * `[row.id, row.email]`.
+ *
+ * Rebuilds only what changed, and only plain objects/arrays: a `Date`,
+ * `Buffer`, `Map`, `Response` or class instance is returned untouched rather
+ * than flattened into a plain object. Cyclic containers are left in place at
+ * the point the cycle closes.
+ */
+export declare function deepUnwrap<T>(value: T): T;
 /** The raw type behind a wrapper: a `Carrier`/`WrappedObject`/`WrappedArray`/
  *  `WrappedResponse` resolves to its `unwrap()` return type; anything else is
  *  already raw and passes through unchanged. */

package/dist/inspect.js

@@ -136,6 +136,71 @@ export function readRaw(x) {
     }
     return cur;
 }
+/**
+ * Strip provenance wrappers from a value AND from anything nested inside a
+ * plain object/array it holds. The inbound counterpart of {@link wrap}: for
+ * values crossing *back* into code that expects raw data — a fake's `helpers`,
+ * a k8s client method's arguments. Without it a helper that takes a value some
+ * earlier op produced gets a `Carrier`/proxy, and the first `.matchAll(...)` /
+ * typed-client call inside it throws a `TypeError` from deep in the callee,
+ * far from the call site that passed the wrapper. Coercion sinks
+ * ({@link makeCarrier}) rescue only the interpolation cases; a callee that
+ * calls a method on the value, or checks its `typeof`, still sees an object.
+ *
+ * One {@link readRaw} finishes a wrapped value: a wrapper's target is raw all
+ * the way down (the proxy wraps children lazily, on read), so there is nothing
+ * left to walk underneath it. The recursion is for the other shape — a
+ * container the *caller* built around wrapped leaves: `{ to: msg.to }`,
+ * `[row.id, row.email]`.
+ *
+ * Rebuilds only what changed, and only plain objects/arrays: a `Date`,
+ * `Buffer`, `Map`, `Response` or class instance is returned untouched rather
+ * than flattened into a plain object. Cyclic containers are left in place at
+ * the point the cycle closes.
+ */
+export function deepUnwrap(value) {
+    return deepUnwrapInner(value, new Set());
+}
+function deepUnwrapInner(value, seen) {
+    if (value === null || value === undefined)
+        return value;
+    const raw = readRaw(value);
+    // It was wrapped, so it's now fully raw — and recursing into it would be
+    // wrong anyway (the raw form may be an exotic object we must not rebuild).
+    if (raw !== value)
+        return raw;
+    if (typeof raw !== "object")
+        return raw;
+    const obj = raw;
+    if (seen.has(obj))
+        return obj;
+    if (Array.isArray(obj)) {
+        seen.add(obj);
+        let changed = false;
+        const out = obj.map((el) => {
+            const next = deepUnwrapInner(el, seen);
+            if (next !== el)
+                changed = true;
+            return next;
+        });
+        seen.delete(obj);
+        return changed ? out : obj;
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto !== Object.prototype && proto !== null)
+        return obj;
+    seen.add(obj);
+    let changed = false;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const next = deepUnwrapInner(v, seen);
+        if (next !== v)
+            changed = true;
+        out[k] = next;
+    }
+    seen.delete(obj);
+    return changed ? out : obj;
+}
 /**
  * Wrap a value so reads through it carry an `OpTag`. Recursion is lazy:
  * a property read on an object Proxy wraps its child on demand.

package/dist/resolver.js

@@ -27,6 +27,7 @@
 import { createSocket } from "node:dgram";
 import { request as httpRequest } from "node:http";
 import { readFile, stat } from "node:fs/promises";
+import { lookup } from "./harness/names-registry.js";
 import * as dnsPacket from "dns-packet";
 const NETWORK_NAME = process.env.SPECTEST_NETWORK ?? "spectest-net";
 const DOCKER_SOCKET = process.env.DOCKER_SOCKET ?? "/var/run/docker.sock";
@@ -37,7 +38,7 @@ const UPSTREAM_PORT = Number(process.env.SPECTEST_UPSTREAM_PORT ?? "53");
 const LISTEN_ADDR = process.env.SPECTEST_RESOLVER_ADDR ?? "127.0.0.53";
 const LISTEN_PORT = Number(process.env.SPECTEST_RESOLVER_PORT ?? "53");
 const TTL_SECONDS = Number(process.env.SPECTEST_RESOLVER_TTL ?? "5");
-/** Path the spectest-daemon writes when it brings fakes up. */
+/** Path the harness writes when it brings fakes up. */
 const FAKES_REGISTRY_PATH = process.env.SPECTEST_FAKES_REGISTRY ?? "/run/spectest-fakes.json";
 function dockerGet(path) {
     return new Promise((resolve) => {
@@ -129,13 +130,9 @@ async function lookupFake(name) {
  *  longest (most specific) matching suffix wins. */
 async function lookupWildcard(name) {
     await refreshRegistry();
-    let best = null;
-    for (const w of registryCache.wildcards) {
-        if (name.endsWith(w.suffix) && (!best || w.suffix.length > best.suffix.length)) {
-            best = w;
-        }
-    }
-    return best?.ip ?? null;
+    // Same module the harness writes with, so the two halves of this file
+    // format cannot drift apart.
+    return lookup({ hosts: {}, wildcards: registryCache.wildcards }, name);
 }
 async function forwardUpstream(query) {
     return new Promise((resolve) => {

package/dist/vendor/rrweb-plugin-console-record.umd.js

@@ -0,0 +1,521 @@
+(function (g, f) {
+    if ("object" == typeof exports && "object" == typeof module) {
+      module.exports = f();
+    } else if ("function" == typeof define && define.amd) {
+      define("rrwebPluginConsoleRecord", [], f);
+    } else if ("object" == typeof exports) {
+      exports["rrwebPluginConsoleRecord"] = f();
+    } else {
+      g["rrwebPluginConsoleRecord"] = f();
+    }
+  }(this, () => {
+var exports = {};
+var module = { exports };
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+if (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) ;
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {
+      };
+    }
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (typeof wrapped === "function") {
+      wrapped.prototype = wrapped.prototype || {};
+      Object.defineProperties(wrapped, {
+        __rrweb_original__: {
+          enumerable: false,
+          value: original
+        }
+      });
+    }
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch (e) {
+    return () => {
+    };
+  }
+}
+class StackFrame {
+  constructor(obj) {
+    __publicField(this, "fileName");
+    __publicField(this, "functionName");
+    __publicField(this, "lineNumber");
+    __publicField(this, "columnNumber");
+    this.fileName = obj.fileName || "";
+    this.functionName = obj.functionName || "";
+    this.lineNumber = obj.lineNumber;
+    this.columnNumber = obj.columnNumber;
+  }
+  toString() {
+    const lineNumber = this.lineNumber || "";
+    const columnNumber = this.columnNumber || "";
+    if (this.functionName)
+      return `${this.functionName} (${this.fileName}:${lineNumber}:${columnNumber})`;
+    return `${this.fileName}:${lineNumber}:${columnNumber}`;
+  }
+}
+const FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
+const ErrorStackParser = {
+  /**
+   * Given an Error object, extract the most information from it.
+   */
+  parse: function(error) {
+    if (!error) {
+      return [];
+    }
+    if (
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      typeof error.stacktrace !== "undefined" || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      typeof error["opera#sourceloc"] !== "undefined"
+    ) {
+      return this.parseOpera(
+        error
+      );
+    } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
+      return this.parseV8OrIE(error);
+    } else if (error.stack) {
+      return this.parseFFOrSafari(error);
+    } else {
+      console.warn(
+        "[console-record-plugin]: Failed to parse error object:",
+        error
+      );
+      return [];
+    }
+  },
+  // Separate line and column numbers from a string of the form: (URI:Line:Column)
+  extractLocation: function(urlLike) {
+    if (urlLike.indexOf(":") === -1) {
+      return [urlLike];
+    }
+    const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+    const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+    if (!parts) throw new Error(`Cannot parse given url: ${urlLike}`);
+    return [parts[1], parts[2] || void 0, parts[3] || void 0];
+  },
+  parseV8OrIE: function(error) {
+    const filtered = error.stack.split("\n").filter(function(line) {
+      return !!line.match(CHROME_IE_STACK_REGEXP);
+    }, this);
+    return filtered.map(function(line) {
+      if (line.indexOf("(eval ") > -1) {
+        line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
+      }
+      let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(");
+      const location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/);
+      sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+      const tokens = sanitizedLine.split(/\s+/).slice(1);
+      const locationParts = this.extractLocation(
+        location ? location[1] : tokens.pop()
+      );
+      const functionName = tokens.join(" ") || void 0;
+      const fileName = ["eval", "<anonymous>"].indexOf(locationParts[0]) > -1 ? void 0 : locationParts[0];
+      return new StackFrame({
+        functionName,
+        fileName,
+        lineNumber: locationParts[1],
+        columnNumber: locationParts[2]
+      });
+    }, this);
+  },
+  parseFFOrSafari: function(error) {
+    const filtered = error.stack.split("\n").filter(function(line) {
+      return !line.match(SAFARI_NATIVE_CODE_REGEXP);
+    }, this);
+    return filtered.map(function(line) {
+      if (line.indexOf(" > eval") > -1) {
+        line = line.replace(
+          / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+          ":$1"
+        );
+      }
+      if (line.indexOf("@") === -1 && line.indexOf(":") === -1) {
+        return new StackFrame({
+          functionName: line
+        });
+      } else {
+        const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
+        const matches = line.match(functionNameRegex);
+        const functionName = matches && matches[1] ? matches[1] : void 0;
+        const locationParts = this.extractLocation(
+          line.replace(functionNameRegex, "")
+        );
+        return new StackFrame({
+          functionName,
+          fileName: locationParts[0],
+          lineNumber: locationParts[1],
+          columnNumber: locationParts[2]
+        });
+      }
+    }, this);
+  },
+  parseOpera: function(e) {
+    if (!e.stacktrace || e.message.indexOf("\n") > -1 && e.message.split("\n").length > e.stacktrace.split("\n").length) {
+      return this.parseOpera9(e);
+    } else if (!e.stack) {
+      return this.parseOpera10(e);
+    } else {
+      return this.parseOpera11(e);
+    }
+  },
+  parseOpera9: function(e) {
+    const lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
+    const lines = e.message.split("\n");
+    const result = [];
+    for (let i = 2, len = lines.length; i < len; i += 2) {
+      const match = lineRE.exec(lines[i]);
+      if (match) {
+        result.push(
+          new StackFrame({
+            fileName: match[2],
+            lineNumber: parseFloat(match[1])
+          })
+        );
+      }
+    }
+    return result;
+  },
+  parseOpera10: function(e) {
+    const lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
+    const lines = e.stacktrace.split("\n");
+    const result = [];
+    for (let i = 0, len = lines.length; i < len; i += 2) {
+      const match = lineRE.exec(lines[i]);
+      if (match) {
+        result.push(
+          new StackFrame({
+            functionName: match[3] || void 0,
+            fileName: match[2],
+            lineNumber: parseFloat(match[1])
+          })
+        );
+      }
+    }
+    return result;
+  },
+  // Opera 10.65+ Error.stack very similar to FF/Safari
+  parseOpera11: function(error) {
+    const filtered = error.stack.split("\n").filter(function(line) {
+      return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
+    }, this);
+    return filtered.map(function(line) {
+      const tokens = line.split("@");
+      const locationParts = this.extractLocation(tokens.pop());
+      const functionCall = tokens.shift() || "";
+      const functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
+      return new StackFrame({
+        functionName,
+        fileName: locationParts[0],
+        lineNumber: locationParts[1],
+        columnNumber: locationParts[2]
+      });
+    }, this);
+  }
+};
+function pathToSelector(node) {
+  if (!node || !node.outerHTML) {
+    return "";
+  }
+  let path = "";
+  while (node.parentElement) {
+    let name = node.localName;
+    if (!name) {
+      break;
+    }
+    name = name.toLowerCase();
+    const parent = node.parentElement;
+    const domSiblings = [];
+    if (parent.children && parent.children.length > 0) {
+      for (let i = 0; i < parent.children.length; i++) {
+        const sibling = parent.children[i];
+        if (sibling.localName && sibling.localName.toLowerCase) {
+          if (sibling.localName.toLowerCase() === name) {
+            domSiblings.push(sibling);
+          }
+        }
+      }
+    }
+    if (domSiblings.length > 1) {
+      name += `:eq(${domSiblings.indexOf(node)})`;
+    }
+    path = name + (path ? ">" + path : "");
+    node = parent;
+  }
+  return path;
+}
+function isObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isObjTooDeep(obj, limit) {
+  if (limit === 0) {
+    return true;
+  }
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    if (isObject(obj[key]) && isObjTooDeep(obj[key], limit - 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function stringify(obj, stringifyOptions) {
+  const options = {
+    numOfKeysLimit: 50,
+    depthOfLimit: 4
+  };
+  Object.assign(options, stringifyOptions);
+  const stack = [];
+  const keys = [];
+  return JSON.stringify(
+    obj,
+    function(key, value) {
+      if (stack.length > 0) {
+        const thisPos = stack.indexOf(this);
+        ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+        ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+        if (~stack.indexOf(value)) {
+          if (stack[0] === value) {
+            value = "[Circular ~]";
+          } else {
+            value = "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+          }
+        }
+      } else {
+        stack.push(value);
+      }
+      if (value === null) return value;
+      if (value === void 0) return "undefined";
+      if (shouldIgnore(value)) {
+        return toString(value);
+      }
+      if (typeof value === "bigint") {
+        return value.toString() + "n";
+      }
+      if (value instanceof Event) {
+        const eventResult = {};
+        for (const eventKey in value) {
+          const eventValue = value[eventKey];
+          if (Array.isArray(eventValue)) {
+            eventResult[eventKey] = pathToSelector(
+              eventValue.length ? eventValue[0] : null
+            );
+          } else {
+            eventResult[eventKey] = eventValue;
+          }
+        }
+        return eventResult;
+      } else if (value instanceof Node) {
+        if (value instanceof HTMLElement) {
+          return value ? value.outerHTML : "";
+        }
+        return value.nodeName;
+      } else if (value instanceof Error) {
+        return value.stack ? value.stack + "\nEnd of stack for Error object" : value.name + ": " + value.message;
+      }
+      return value;
+    }
+  );
+  function shouldIgnore(_obj) {
+    if (isObject(_obj) && Object.keys(_obj).length > options.numOfKeysLimit) {
+      return true;
+    }
+    if (typeof _obj === "function") {
+      return true;
+    }
+    if (isObject(_obj) && isObjTooDeep(_obj, options.depthOfLimit)) {
+      return true;
+    }
+    return false;
+  }
+  function toString(_obj) {
+    let str = _obj.toString();
+    if (options.stringLengthLimit && str.length > options.stringLengthLimit) {
+      str = `${str.slice(0, options.stringLengthLimit)}...`;
+    }
+    return str;
+  }
+}
+const defaultLogOptions = {
+  level: [
+    "assert",
+    "clear",
+    "count",
+    "countReset",
+    "debug",
+    "dir",
+    "dirxml",
+    "error",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "info",
+    "log",
+    "table",
+    "time",
+    "timeEnd",
+    "timeLog",
+    "trace",
+    "warn"
+  ],
+  lengthThreshold: 1e3,
+  logger: "console"
+};
+function initLogObserver(cb, win, options) {
+  const logOptions = options ? Object.assign({}, defaultLogOptions, options) : defaultLogOptions;
+  const loggerType = logOptions.logger;
+  if (!loggerType) {
+    return () => {
+    };
+  }
+  let logger;
+  if (typeof loggerType === "string") {
+    logger = win[loggerType];
+  } else {
+    logger = loggerType;
+  }
+  let logCount = 0;
+  let inStack = false;
+  const cancelHandlers = [];
+  if (logOptions.level.includes("error")) {
+    const errorHandler = (event) => {
+      const message = event.message, error = event.error;
+      const trace = ErrorStackParser.parse(error).map(
+        (stackFrame) => stackFrame.toString()
+      );
+      const payload = [stringify(message, logOptions.stringifyOptions)];
+      cb({
+        level: "error",
+        trace,
+        payload
+      });
+    };
+    win.addEventListener("error", errorHandler);
+    cancelHandlers.push(() => {
+      win.removeEventListener("error", errorHandler);
+    });
+    const unhandledrejectionHandler = (event) => {
+      let error;
+      let payload;
+      if (event.reason instanceof Error) {
+        error = event.reason;
+        payload = [
+          stringify(
+            `Uncaught (in promise) ${error.name}: ${error.message}`,
+            logOptions.stringifyOptions
+          )
+        ];
+      } else {
+        error = new Error();
+        payload = [
+          stringify("Uncaught (in promise)", logOptions.stringifyOptions),
+          stringify(event.reason, logOptions.stringifyOptions)
+        ];
+      }
+      const trace = ErrorStackParser.parse(error).map(
+        (stackFrame) => stackFrame.toString()
+      );
+      cb({
+        level: "error",
+        trace,
+        payload
+      });
+    };
+    win.addEventListener("unhandledrejection", unhandledrejectionHandler);
+    cancelHandlers.push(() => {
+      win.removeEventListener("unhandledrejection", unhandledrejectionHandler);
+    });
+  }
+  for (const levelType of logOptions.level) {
+    cancelHandlers.push(replace(logger, levelType));
+  }
+  return () => {
+    cancelHandlers.forEach((h) => h());
+  };
+  function replace(_logger, level) {
+    if (!_logger[level]) {
+      return () => {
+      };
+    }
+    return patch(
+      _logger,
+      level,
+      (original) => {
+        return (...args) => {
+          original.apply(this, args);
+          if (level === "assert" && !!args[0]) {
+            return;
+          }
+          if (inStack) {
+            return;
+          }
+          inStack = true;
+          try {
+            const trace = ErrorStackParser.parse(new Error()).map((stackFrame) => stackFrame.toString()).splice(1);
+            const argsForPayload = level === "assert" ? args.slice(1) : args;
+            const payload = argsForPayload.map(
+              (s) => stringify(s, logOptions.stringifyOptions)
+            );
+            logCount++;
+            if (logCount < logOptions.lengthThreshold) {
+              cb({
+                level,
+                trace,
+                payload
+              });
+            } else if (logCount === logOptions.lengthThreshold) {
+              cb({
+                level: "warn",
+                trace: [],
+                payload: [
+                  stringify("The number of log records reached the threshold.")
+                ]
+              });
+            }
+          } catch (error) {
+            original("rrweb logger error:", error, ...args);
+          } finally {
+            inStack = false;
+          }
+        };
+      }
+    );
+  }
+}
+const PLUGIN_NAME = "rrweb/console@1";
+const getRecordConsolePlugin = (options) => ({
+  name: PLUGIN_NAME,
+  observer: initLogObserver,
+  options
+});
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.getRecordConsolePlugin = getRecordConsolePlugin;
+if (typeof module.exports == "object" && typeof exports == "object") {
+  var __cp = (to, from, except, desc) => {
+    if ((from && typeof from === "object") || typeof from === "function") {
+      for (let key of Object.getOwnPropertyNames(from)) {
+        if (!Object.prototype.hasOwnProperty.call(to, key) && key !== except)
+        Object.defineProperty(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = Object.getOwnPropertyDescriptor(from, key)) || desc.enumerable,
+        });
+      }
+    }
+    return to;
+  };
+  module.exports = __cp(module.exports, exports);
+}
+return module.exports;
+}))
+//# sourceMappingURL=rrweb-plugin-console-record.umd.cjs.map