phantomwright-driver-core 1.57.0

package/lib/generated/webSocketMockSource.js

@@ -0,0 +1,336 @@
+"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);
+var webSocketMockSource_exports = {};
+__export(webSocketMockSource_exports, {
+  source: () => source
+});
+module.exports = __toCommonJS(webSocketMockSource_exports);
+const source = `
+var __commonJS = obj => {
+  let required = false;
+  let result;
+  return function __require() {
+    if (!required) {
+      required = true;
+      let fn;
+      for (const name in obj) { fn = obj[name]; break; }
+      const module = { exports: {} };
+      fn(module.exports, module);
+      result = module.exports;
+    }
+    return result;
+  }
+};
+var __export = (target, all) => {for (var name in all) target[name] = all[name];};
+var __toESM = mod => ({ ...mod, 'default': mod });
+var __toCommonJS = mod => ({ ...mod, __esModule: true });
+
+
+// packages/injected/src/webSocketMock.ts
+var webSocketMock_exports = {};
+__export(webSocketMock_exports, {
+  inject: () => inject
+});
+module.exports = __toCommonJS(webSocketMock_exports);
+function inject(globalThis) {
+  if (globalThis.__pwWebSocketDispatch)
+    return;
+  function generateId() {
+    const bytes = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(bytes);
+    const hex = "0123456789abcdef";
+    return [...bytes].map((value) => {
+      const high = Math.floor(value / 16);
+      const low = value % 16;
+      return hex[high] + hex[low];
+    }).join("");
+  }
+  function bufferToData(b) {
+    let s = "";
+    for (let i = 0; i < b.length; i++)
+      s += String.fromCharCode(b[i]);
+    return { data: globalThis.btoa(s), isBase64: true };
+  }
+  function stringToBuffer(s) {
+    s = globalThis.atob(s);
+    const b = new Uint8Array(s.length);
+    for (let i = 0; i < s.length; i++)
+      b[i] = s.charCodeAt(i);
+    return b.buffer;
+  }
+  function messageToData(message, cb) {
+    if (message instanceof globalThis.Blob)
+      return message.arrayBuffer().then((buffer) => cb(bufferToData(new Uint8Array(buffer))));
+    if (typeof message === "string")
+      return cb({ data: message, isBase64: false });
+    if (ArrayBuffer.isView(message))
+      return cb(bufferToData(new Uint8Array(message.buffer, message.byteOffset, message.byteLength)));
+    return cb(bufferToData(new Uint8Array(message)));
+  }
+  function dataToMessage(data, binaryType) {
+    if (!data.isBase64)
+      return data.data;
+    const buffer = stringToBuffer(data.data);
+    return binaryType === "arraybuffer" ? buffer : new Blob([buffer]);
+  }
+  const binding = globalThis.__pwWebSocketBinding;
+  const NativeWebSocket = globalThis.WebSocket;
+  const idToWebSocket = /* @__PURE__ */ new Map();
+  globalThis.__pwWebSocketDispatch = (request) => {
+    const ws = idToWebSocket.get(request.id);
+    if (!ws)
+      return;
+    if (request.type === "connect")
+      ws._apiConnect();
+    if (request.type === "passthrough")
+      ws._apiPassThrough();
+    if (request.type === "ensureOpened")
+      ws._apiEnsureOpened();
+    if (request.type === "sendToPage")
+      ws._apiSendToPage(dataToMessage(request.data, ws.binaryType));
+    if (request.type === "closePage")
+      ws._apiClosePage(request.code, request.reason, request.wasClean);
+    if (request.type === "sendToServer")
+      ws._apiSendToServer(dataToMessage(request.data, ws.binaryType));
+    if (request.type === "closeServer")
+      ws._apiCloseServer(request.code, request.reason, request.wasClean);
+  };
+  const _WebSocketMock = class _WebSocketMock extends EventTarget {
+    constructor(url, protocols) {
+      var _a, _b;
+      super();
+      // WebSocket.CLOSED
+      this.CONNECTING = 0;
+      // WebSocket.CONNECTING
+      this.OPEN = 1;
+      // WebSocket.OPEN
+      this.CLOSING = 2;
+      // WebSocket.CLOSING
+      this.CLOSED = 3;
+      // WebSocket.CLOSED
+      this._oncloseListener = null;
+      this._onerrorListener = null;
+      this._onmessageListener = null;
+      this._onopenListener = null;
+      this.bufferedAmount = 0;
+      this.extensions = "";
+      this.protocol = "";
+      this.readyState = 0;
+      this._origin = "";
+      this._passthrough = false;
+      this._wsBufferedMessages = [];
+      this._binaryType = "blob";
+      this.url = new URL(url, globalThis.window.document.baseURI).href.replace(/^http/, "ws");
+      this._origin = (_b = (_a = URL.parse(this.url)) == null ? void 0 : _a.origin) != null ? _b : "";
+      this._protocols = protocols;
+      this._id = generateId();
+      idToWebSocket.set(this._id, this);
+      binding({ type: "onCreate", id: this._id, url: this.url });
+    }
+    // --- native WebSocket implementation ---
+    get binaryType() {
+      return this._binaryType;
+    }
+    set binaryType(type) {
+      this._binaryType = type;
+      if (this._ws)
+        this._ws.binaryType = type;
+    }
+    get onclose() {
+      return this._oncloseListener;
+    }
+    set onclose(listener) {
+      if (this._oncloseListener)
+        this.removeEventListener("close", this._oncloseListener);
+      this._oncloseListener = listener;
+      if (this._oncloseListener)
+        this.addEventListener("close", this._oncloseListener);
+    }
+    get onerror() {
+      return this._onerrorListener;
+    }
+    set onerror(listener) {
+      if (this._onerrorListener)
+        this.removeEventListener("error", this._onerrorListener);
+      this._onerrorListener = listener;
+      if (this._onerrorListener)
+        this.addEventListener("error", this._onerrorListener);
+    }
+    get onopen() {
+      return this._onopenListener;
+    }
+    set onopen(listener) {
+      if (this._onopenListener)
+        this.removeEventListener("open", this._onopenListener);
+      this._onopenListener = listener;
+      if (this._onopenListener)
+        this.addEventListener("open", this._onopenListener);
+    }
+    get onmessage() {
+      return this._onmessageListener;
+    }
+    set onmessage(listener) {
+      if (this._onmessageListener)
+        this.removeEventListener("message", this._onmessageListener);
+      this._onmessageListener = listener;
+      if (this._onmessageListener)
+        this.addEventListener("message", this._onmessageListener);
+    }
+    send(message) {
+      if (this.readyState === _WebSocketMock.CONNECTING)
+        throw new DOMException(\`Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.\`);
+      if (this.readyState !== _WebSocketMock.OPEN)
+        throw new DOMException(\`WebSocket is already in CLOSING or CLOSED state.\`);
+      if (this._passthrough) {
+        if (this._ws)
+          this._apiSendToServer(message);
+      } else {
+        messageToData(message, (data) => binding({ type: "onMessageFromPage", id: this._id, data }));
+      }
+    }
+    close(code, reason) {
+      if (code !== void 0 && code !== 1e3 && (code < 3e3 || code > 4999))
+        throw new DOMException(\`Failed to execute 'close' on 'WebSocket': The close code must be either 1000, or between 3000 and 4999. \${code} is neither.\`);
+      if (this.readyState === _WebSocketMock.OPEN || this.readyState === _WebSocketMock.CONNECTING)
+        this.readyState = _WebSocketMock.CLOSING;
+      if (this._passthrough)
+        this._apiCloseServer(code, reason, true);
+      else
+        binding({ type: "onClosePage", id: this._id, code, reason, wasClean: true });
+    }
+    // --- methods called from the routing API ---
+    _apiEnsureOpened() {
+      if (!this._ws)
+        this._ensureOpened();
+    }
+    _apiSendToPage(message) {
+      this._ensureOpened();
+      if (this.readyState !== _WebSocketMock.OPEN)
+        throw new DOMException(\`WebSocket is already in CLOSING or CLOSED state.\`);
+      this.dispatchEvent(new MessageEvent("message", { data: message, origin: this._origin, cancelable: true }));
+    }
+    _apiSendToServer(message) {
+      if (!this._ws)
+        throw new Error("Cannot send a message before connecting to the server");
+      if (this._ws.readyState === _WebSocketMock.CONNECTING)
+        this._wsBufferedMessages.push(message);
+      else
+        this._ws.send(message);
+    }
+    _apiConnect() {
+      if (this._ws)
+        throw new Error("Can only connect to the server once");
+      this._ws = new NativeWebSocket(this.url, this._protocols);
+      this._ws.binaryType = this._binaryType;
+      this._ws.onopen = () => {
+        for (const message of this._wsBufferedMessages)
+          this._ws.send(message);
+        this._wsBufferedMessages = [];
+        this._ensureOpened();
+      };
+      this._ws.onclose = (event) => {
+        this._onWSClose(event.code, event.reason, event.wasClean);
+      };
+      this._ws.onmessage = (event) => {
+        if (this._passthrough)
+          this._apiSendToPage(event.data);
+        else
+          messageToData(event.data, (data) => binding({ type: "onMessageFromServer", id: this._id, data }));
+      };
+      this._ws.onerror = () => {
+        const event = new Event("error", { cancelable: true });
+        this.dispatchEvent(event);
+      };
+    }
+    // This method connects to the server, and passes all messages through,
+    // as if WebSocketMock was not engaged.
+    _apiPassThrough() {
+      this._passthrough = true;
+      this._apiConnect();
+    }
+    _apiCloseServer(code, reason, wasClean) {
+      if (!this._ws) {
+        this._onWSClose(code, reason, wasClean);
+        return;
+      }
+      if (this._ws.readyState === _WebSocketMock.CONNECTING || this._ws.readyState === _WebSocketMock.OPEN)
+        this._ws.close(code, reason);
+    }
+    _apiClosePage(code, reason, wasClean) {
+      if (this.readyState === _WebSocketMock.CLOSED)
+        return;
+      this.readyState = _WebSocketMock.CLOSED;
+      this.dispatchEvent(new CloseEvent("close", { code, reason, wasClean, cancelable: true }));
+      this._maybeCleanup();
+      if (this._passthrough)
+        this._apiCloseServer(code, reason, wasClean);
+      else
+        binding({ type: "onClosePage", id: this._id, code, reason, wasClean });
+    }
+    // --- internals ---
+    _ensureOpened() {
+      var _a;
+      if (this.readyState !== _WebSocketMock.CONNECTING)
+        return;
+      this.extensions = ((_a = this._ws) == null ? void 0 : _a.extensions) || "";
+      if (this._ws)
+        this.protocol = this._ws.protocol;
+      else if (Array.isArray(this._protocols))
+        this.protocol = this._protocols[0] || "";
+      else
+        this.protocol = this._protocols || "";
+      this.readyState = _WebSocketMock.OPEN;
+      this.dispatchEvent(new Event("open", { cancelable: true }));
+    }
+    _onWSClose(code, reason, wasClean) {
+      if (this._passthrough)
+        this._apiClosePage(code, reason, wasClean);
+      else
+        binding({ type: "onCloseServer", id: this._id, code, reason, wasClean });
+      if (this._ws) {
+        this._ws.onopen = null;
+        this._ws.onclose = null;
+        this._ws.onmessage = null;
+        this._ws.onerror = null;
+        this._ws = void 0;
+        this._wsBufferedMessages = [];
+      }
+      this._maybeCleanup();
+    }
+    _maybeCleanup() {
+      if (this.readyState === _WebSocketMock.CLOSED && !this._ws)
+        idToWebSocket.delete(this._id);
+    }
+  };
+  _WebSocketMock.CONNECTING = 0;
+  // WebSocket.CONNECTING
+  _WebSocketMock.OPEN = 1;
+  // WebSocket.OPEN
+  _WebSocketMock.CLOSING = 2;
+  // WebSocket.CLOSING
+  _WebSocketMock.CLOSED = 3;
+  let WebSocketMock = _WebSocketMock;
+  globalThis.WebSocket = class WebSocket extends WebSocketMock {
+  };
+}
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  source
+});

package/lib/inProcessFactory.js

@@ -0,0 +1,60 @@
+"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);
+var inProcessFactory_exports = {};
+__export(inProcessFactory_exports, {
+  createInProcessPlaywright: () => createInProcessPlaywright
+});
+module.exports = __toCommonJS(inProcessFactory_exports);
+var import_androidServerImpl = require("./androidServerImpl");
+var import_browserServerImpl = require("./browserServerImpl");
+var import_server = require("./server");
+var import_nodePlatform = require("./server/utils/nodePlatform");
+var import_connection = require("./client/connection");
+function createInProcessPlaywright() {
+  const playwright = (0, import_server.createPlaywright)({ sdkLanguage: process.env.PW_LANG_NAME || "javascript" });
+  const clientConnection = new import_connection.Connection(import_nodePlatform.nodePlatform);
+  clientConnection.useRawBuffers();
+  const dispatcherConnection = new import_server.DispatcherConnection(
+    true
+    /* local */
+  );
+  dispatcherConnection.onmessage = (message) => clientConnection.dispatch(message);
+  clientConnection.onmessage = (message) => dispatcherConnection.dispatch(message);
+  const rootScope = new import_server.RootDispatcher(dispatcherConnection);
+  new import_server.PlaywrightDispatcher(rootScope, playwright);
+  const playwrightAPI = clientConnection.getObjectWithKnownName("Playwright");
+  playwrightAPI.chromium._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("chromium");
+  playwrightAPI.firefox._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("firefox");
+  playwrightAPI.webkit._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("webkit");
+  playwrightAPI._android._serverLauncher = new import_androidServerImpl.AndroidServerLauncherImpl();
+  dispatcherConnection.onmessage = (message) => setImmediate(() => clientConnection.dispatch(message));
+  clientConnection.onmessage = (message) => setImmediate(() => dispatcherConnection.dispatch(message));
+  clientConnection.toImpl = (x) => {
+    if (x instanceof import_connection.Connection)
+      return x === clientConnection ? dispatcherConnection : void 0;
+    if (!x)
+      return dispatcherConnection._dispatcherByGuid.get("");
+    return dispatcherConnection._dispatcherByGuid.get(x._guid)._object;
+  };
+  return playwrightAPI;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInProcessPlaywright
+});

package/lib/inprocess.js

@@ -0,0 +1,3 @@
+"use strict";
+var import_inProcessFactory = require("./inProcessFactory");
+module.exports = (0, import_inProcessFactory.createInProcessPlaywright)();

package/lib/outofprocess.js

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var outofprocess_exports = {};
+__export(outofprocess_exports, {
+  start: () => start
+});
+module.exports = __toCommonJS(outofprocess_exports);
+var childProcess = __toESM(require("child_process"));
+var import_path = __toESM(require("path"));
+var import_connection = require("./client/connection");
+var import_pipeTransport = require("./server/utils/pipeTransport");
+var import_manualPromise = require("./utils/isomorphic/manualPromise");
+var import_nodePlatform = require("./server/utils/nodePlatform");
+async function start(env = {}) {
+  const client = new PlaywrightClient(env);
+  const playwright = await client._playwright;
+  playwright.driverProcess = client._driverProcess;
+  return { playwright, stop: () => client.stop() };
+}
+class PlaywrightClient {
+  constructor(env) {
+    this._closePromise = new import_manualPromise.ManualPromise();
+    this._driverProcess = childProcess.fork(import_path.default.join(__dirname, "..", "cli.js"), ["run-driver"], {
+      stdio: "pipe",
+      detached: true,
+      env: {
+        ...process.env,
+        ...env
+      }
+    });
+    this._driverProcess.unref();
+    this._driverProcess.stderr.on("data", (data) => process.stderr.write(data));
+    const connection = new import_connection.Connection(import_nodePlatform.nodePlatform);
+    const transport = new import_pipeTransport.PipeTransport(this._driverProcess.stdin, this._driverProcess.stdout);
+    connection.onmessage = (message) => transport.send(JSON.stringify(message));
+    transport.onmessage = (message) => connection.dispatch(JSON.parse(message));
+    transport.onclose = () => this._closePromise.resolve();
+    this._playwright = connection.initializePlaywright();
+  }
+  async stop() {
+    this._driverProcess.stdin.destroy();
+    this._driverProcess.stdout.destroy();
+    this._driverProcess.stderr.destroy();
+    await this._closePromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  start
+});

package/lib/protocol/serializers.js

@@ -0,0 +1,192 @@
+"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);
+var serializers_exports = {};
+__export(serializers_exports, {
+  parseSerializedValue: () => parseSerializedValue,
+  serializeValue: () => serializeValue
+});
+module.exports = __toCommonJS(serializers_exports);
+function parseSerializedValue(value, handles) {
+  return innerParseSerializedValue(value, handles, /* @__PURE__ */ new Map(), []);
+}
+function innerParseSerializedValue(value, handles, refs, accessChain) {
+  if (value.ref !== void 0)
+    return refs.get(value.ref);
+  if (value.n !== void 0)
+    return value.n;
+  if (value.s !== void 0)
+    return value.s;
+  if (value.b !== void 0)
+    return value.b;
+  if (value.v !== void 0) {
+    if (value.v === "undefined")
+      return void 0;
+    if (value.v === "null")
+      return null;
+    if (value.v === "NaN")
+      return NaN;
+    if (value.v === "Infinity")
+      return Infinity;
+    if (value.v === "-Infinity")
+      return -Infinity;
+    if (value.v === "-0")
+      return -0;
+  }
+  if (value.d !== void 0)
+    return new Date(value.d);
+  if (value.u !== void 0)
+    return new URL(value.u);
+  if (value.bi !== void 0)
+    return BigInt(value.bi);
+  if (value.e !== void 0) {
+    const error = new Error(value.e.m);
+    error.name = value.e.n;
+    error.stack = value.e.s;
+    return error;
+  }
+  if (value.r !== void 0)
+    return new RegExp(value.r.p, value.r.f);
+  if (value.ta !== void 0) {
+    const ctor = typedArrayKindToConstructor[value.ta.k];
+    return new ctor(value.ta.b.buffer, value.ta.b.byteOffset, value.ta.b.length / ctor.BYTES_PER_ELEMENT);
+  }
+  if (value.a !== void 0) {
+    const result = [];
+    refs.set(value.id, result);
+    for (let i = 0; i < value.a.length; i++)
+      result.push(innerParseSerializedValue(value.a[i], handles, refs, [...accessChain, i]));
+    return result;
+  }
+  if (value.o !== void 0) {
+    const result = {};
+    refs.set(value.id, result);
+    for (const { k, v } of value.o)
+      result[k] = innerParseSerializedValue(v, handles, refs, [...accessChain, k]);
+    return result;
+  }
+  if (value.h !== void 0) {
+    if (handles === void 0)
+      throw new Error("Unexpected handle");
+    return handles[value.h];
+  }
+  throw new Error(`Attempting to deserialize unexpected value${accessChainToDisplayString(accessChain)}: ${value}`);
+}
+function serializeValue(value, handleSerializer) {
+  return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: /* @__PURE__ */ new Map() }, []);
+}
+function innerSerializeValue(value, handleSerializer, visitorInfo, accessChain) {
+  const handle = handleSerializer(value);
+  if ("fallThrough" in handle)
+    value = handle.fallThrough;
+  else
+    return handle;
+  if (typeof value === "symbol")
+    return { v: "undefined" };
+  if (Object.is(value, void 0))
+    return { v: "undefined" };
+  if (Object.is(value, null))
+    return { v: "null" };
+  if (Object.is(value, NaN))
+    return { v: "NaN" };
+  if (Object.is(value, Infinity))
+    return { v: "Infinity" };
+  if (Object.is(value, -Infinity))
+    return { v: "-Infinity" };
+  if (Object.is(value, -0))
+    return { v: "-0" };
+  if (typeof value === "boolean")
+    return { b: value };
+  if (typeof value === "number")
+    return { n: value };
+  if (typeof value === "string")
+    return { s: value };
+  if (typeof value === "bigint")
+    return { bi: value.toString() };
+  if (isError(value))
+    return { e: { n: value.name, m: value.message, s: value.stack || "" } };
+  if (isDate(value))
+    return { d: value.toJSON() };
+  if (isURL(value))
+    return { u: value.toJSON() };
+  if (isRegExp(value))
+    return { r: { p: value.source, f: value.flags } };
+  const typedArrayKind = constructorToTypedArrayKind.get(value.constructor);
+  if (typedArrayKind)
+    return { ta: { b: Buffer.from(value.buffer, value.byteOffset, value.byteLength), k: typedArrayKind } };
+  const id = visitorInfo.visited.get(value);
+  if (id)
+    return { ref: id };
+  if (Array.isArray(value)) {
+    const a = [];
+    const id2 = ++visitorInfo.lastId;
+    visitorInfo.visited.set(value, id2);
+    for (let i = 0; i < value.length; ++i)
+      a.push(innerSerializeValue(value[i], handleSerializer, visitorInfo, [...accessChain, i]));
+    return { a, id: id2 };
+  }
+  if (typeof value === "object") {
+    const o = [];
+    const id2 = ++visitorInfo.lastId;
+    visitorInfo.visited.set(value, id2);
+    for (const name of Object.keys(value))
+      o.push({ k: name, v: innerSerializeValue(value[name], handleSerializer, visitorInfo, [...accessChain, name]) });
+    return { o, id: id2 };
+  }
+  throw new Error(`Attempting to serialize unexpected value${accessChainToDisplayString(accessChain)}: ${value}`);
+}
+function accessChainToDisplayString(accessChain) {
+  const chainString = accessChain.map((accessor, i) => {
+    if (typeof accessor === "string")
+      return i ? `.${accessor}` : accessor;
+    return `[${accessor}]`;
+  }).join("");
+  return chainString.length > 0 ? ` at position "${chainString}"` : "";
+}
+function isRegExp(obj) {
+  return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+function isDate(obj) {
+  return obj instanceof Date || Object.prototype.toString.call(obj) === "[object Date]";
+}
+function isURL(obj) {
+  return obj instanceof URL || Object.prototype.toString.call(obj) === "[object URL]";
+}
+function isError(obj) {
+  const proto = obj ? Object.getPrototypeOf(obj) : null;
+  return obj instanceof Error || proto?.name === "Error" || proto && isError(proto);
+}
+const typedArrayKindToConstructor = {
+  i8: Int8Array,
+  ui8: Uint8Array,
+  ui8c: Uint8ClampedArray,
+  i16: Int16Array,
+  ui16: Uint16Array,
+  i32: Int32Array,
+  ui32: Uint32Array,
+  f32: Float32Array,
+  f64: Float64Array,
+  bi64: BigInt64Array,
+  bui64: BigUint64Array
+};
+const constructorToTypedArrayKind = new Map(Object.entries(typedArrayKindToConstructor).map(([k, v]) => [v, k]));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSerializedValue,
+  serializeValue
+});