@stablyai/internal-playwright-core 0.1.0

package/lib/image_tools/stats.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FastStats = void 0;
+exports.ssim = ssim;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Image channel has a 8-bit depth.
+const DYNAMIC_RANGE = 2 ** 8 - 1;
+function ssim(stats, x1, y1, x2, y2) {
+  const mean1 = stats.meanC1(x1, y1, x2, y2);
+  const mean2 = stats.meanC2(x1, y1, x2, y2);
+  const var1 = stats.varianceC1(x1, y1, x2, y2);
+  const var2 = stats.varianceC2(x1, y1, x2, y2);
+  const cov = stats.covariance(x1, y1, x2, y2);
+  const c1 = (0.01 * DYNAMIC_RANGE) ** 2;
+  const c2 = (0.03 * DYNAMIC_RANGE) ** 2;
+  return (2 * mean1 * mean2 + c1) * (2 * cov + c2) / (mean1 ** 2 + mean2 ** 2 + c1) / (var1 + var2 + c2);
+}
+class FastStats {
+  constructor(c1, c2) {
+    this.c1 = void 0;
+    this.c2 = void 0;
+    this._partialSumC1 = void 0;
+    this._partialSumC2 = void 0;
+    this._partialSumMult = void 0;
+    this._partialSumSq1 = void 0;
+    this._partialSumSq2 = void 0;
+    this.c1 = c1;
+    this.c2 = c2;
+    const {
+      width,
+      height
+    } = c1;
+    this._partialSumC1 = new Array(width * height);
+    this._partialSumC2 = new Array(width * height);
+    this._partialSumSq1 = new Array(width * height);
+    this._partialSumSq2 = new Array(width * height);
+    this._partialSumMult = new Array(width * height);
+    const recalc = (mx, idx, initial, x, y) => {
+      mx[idx] = initial;
+      if (y > 0) mx[idx] += mx[(y - 1) * width + x];
+      if (x > 0) mx[idx] += mx[y * width + x - 1];
+      if (x > 0 && y > 0) mx[idx] -= mx[(y - 1) * width + x - 1];
+    };
+    for (let y = 0; y < height; ++y) {
+      for (let x = 0; x < width; ++x) {
+        const idx = y * width + x;
+        recalc(this._partialSumC1, idx, this.c1.data[idx], x, y);
+        recalc(this._partialSumC2, idx, this.c2.data[idx], x, y);
+        recalc(this._partialSumSq1, idx, this.c1.data[idx] * this.c1.data[idx], x, y);
+        recalc(this._partialSumSq2, idx, this.c2.data[idx] * this.c2.data[idx], x, y);
+        recalc(this._partialSumMult, idx, this.c1.data[idx] * this.c2.data[idx], x, y);
+      }
+    }
+  }
+  _sum(partialSum, x1, y1, x2, y2) {
+    const width = this.c1.width;
+    let result = partialSum[y2 * width + x2];
+    if (y1 > 0) result -= partialSum[(y1 - 1) * width + x2];
+    if (x1 > 0) result -= partialSum[y2 * width + x1 - 1];
+    if (x1 > 0 && y1 > 0) result += partialSum[(y1 - 1) * width + x1 - 1];
+    return result;
+  }
+  meanC1(x1, y1, x2, y2) {
+    const N = (y2 - y1 + 1) * (x2 - x1 + 1);
+    return this._sum(this._partialSumC1, x1, y1, x2, y2) / N;
+  }
+  meanC2(x1, y1, x2, y2) {
+    const N = (y2 - y1 + 1) * (x2 - x1 + 1);
+    return this._sum(this._partialSumC2, x1, y1, x2, y2) / N;
+  }
+  varianceC1(x1, y1, x2, y2) {
+    const N = (y2 - y1 + 1) * (x2 - x1 + 1);
+    return (this._sum(this._partialSumSq1, x1, y1, x2, y2) - this._sum(this._partialSumC1, x1, y1, x2, y2) ** 2 / N) / N;
+  }
+  varianceC2(x1, y1, x2, y2) {
+    const N = (y2 - y1 + 1) * (x2 - x1 + 1);
+    return (this._sum(this._partialSumSq2, x1, y1, x2, y2) - this._sum(this._partialSumC2, x1, y1, x2, y2) ** 2 / N) / N;
+  }
+  covariance(x1, y1, x2, y2) {
+    const N = (y2 - y1 + 1) * (x2 - x1 + 1);
+    return (this._sum(this._partialSumMult, x1, y1, x2, y2) - this._sum(this._partialSumC1, x1, y1, x2, y2) * this._sum(this._partialSumC2, x1, y1, x2, y2) / N) / N;
+  }
+}
+exports.FastStats = FastStats;

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/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "InjectedScript", {
+  enumerable: true,
+  get: function () {
+    return _injectedScript.InjectedScript;
+  }
+});
+Object.defineProperty(exports, "asLocator", {
+  enumerable: true,
+  get: function () {
+    return _utils.asLocator;
+  }
+});
+var _injectedScript = require("./server/injected/injectedScript");
+var _utils = require("./utils");

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/debug.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slowMoActions = exports.pausesBeforeInputActions = exports.commandsWithTracingSnapshots = void 0;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file is generated by generate_channels.js, do not edit manually.
+
+const slowMoActions = exports.slowMoActions = new Set(['Page.goBack', 'Page.goForward', 'Page.reload', 'Page.keyboardDown', 'Page.keyboardUp', 'Page.keyboardInsertText', 'Page.keyboardType', 'Page.keyboardPress', 'Page.mouseMove', 'Page.mouseDown', 'Page.mouseUp', 'Page.mouseClick', 'Page.mouseWheel', 'Page.touchscreenTap', 'Frame.blur', 'Frame.check', 'Frame.click', 'Frame.dragAndDrop', 'Frame.dblclick', 'Frame.dispatchEvent', 'Frame.fill', 'Frame.focus', 'Frame.goto', 'Frame.hover', 'Frame.press', 'Frame.selectOption', 'Frame.setInputFiles', 'Frame.tap', 'Frame.type', 'Frame.uncheck', 'ElementHandle.check', 'ElementHandle.click', 'ElementHandle.dblclick', 'ElementHandle.dispatchEvent', 'ElementHandle.fill', 'ElementHandle.focus', 'ElementHandle.hover', 'ElementHandle.press', 'ElementHandle.scrollIntoViewIfNeeded', 'ElementHandle.selectOption', 'ElementHandle.selectText', 'ElementHandle.setInputFiles', 'ElementHandle.tap', 'ElementHandle.type', 'ElementHandle.uncheck']);
+const commandsWithTracingSnapshots = exports.commandsWithTracingSnapshots = new Set(['EventTarget.waitForEventInfo', 'BrowserContext.waitForEventInfo', 'Page.waitForEventInfo', 'WebSocket.waitForEventInfo', 'ElectronApplication.waitForEventInfo', 'AndroidDevice.waitForEventInfo', 'Page.emulateMedia', 'Page.goBack', 'Page.goForward', 'Page.reload', 'Page.expectScreenshot', 'Page.screenshot', 'Page.setViewportSize', 'Page.keyboardDown', 'Page.keyboardUp', 'Page.keyboardInsertText', 'Page.keyboardType', 'Page.keyboardPress', 'Page.mouseMove', 'Page.mouseDown', 'Page.mouseUp', 'Page.mouseClick', 'Page.mouseWheel', 'Page.touchscreenTap', 'Frame.evalOnSelector', 'Frame.evalOnSelectorAll', 'Frame.addScriptTag', 'Frame.addStyleTag', 'Frame.blur', 'Frame.check', 'Frame.click', 'Frame.dragAndDrop', 'Frame.dblclick', 'Frame.dispatchEvent', 'Frame.evaluateExpression', 'Frame.evaluateExpressionHandle', 'Frame.fill', 'Frame.focus', 'Frame.getAttribute', 'Frame.goto', 'Frame.hover', 'Frame.innerHTML', 'Frame.innerText', 'Frame.inputValue', 'Frame.isChecked', 'Frame.isDisabled', 'Frame.isEnabled', 'Frame.isHidden', 'Frame.isVisible', 'Frame.isEditable', 'Frame.press', 'Frame.selectOption', 'Frame.setContent', 'Frame.setInputFiles', 'Frame.tap', 'Frame.textContent', 'Frame.type', 'Frame.uncheck', 'Frame.waitForTimeout', 'Frame.waitForFunction', 'Frame.waitForSelector', 'Frame.expect', 'JSHandle.evaluateExpression', 'ElementHandle.evaluateExpression', 'JSHandle.evaluateExpressionHandle', 'ElementHandle.evaluateExpressionHandle', 'ElementHandle.evalOnSelector', 'ElementHandle.evalOnSelectorAll', 'ElementHandle.check', 'ElementHandle.click', 'ElementHandle.dblclick', 'ElementHandle.dispatchEvent', 'ElementHandle.fill', 'ElementHandle.focus', 'ElementHandle.hover', 'ElementHandle.innerHTML', 'ElementHandle.innerText', 'ElementHandle.inputValue', 'ElementHandle.isChecked', 'ElementHandle.isDisabled', 'ElementHandle.isEditable', 'ElementHandle.isEnabled', 'ElementHandle.isHidden', 'ElementHandle.isVisible', 'ElementHandle.press', 'ElementHandle.screenshot', 'ElementHandle.scrollIntoViewIfNeeded', 'ElementHandle.selectOption', 'ElementHandle.selectText', 'ElementHandle.setInputFiles', 'ElementHandle.tap', 'ElementHandle.textContent', 'ElementHandle.type', 'ElementHandle.uncheck', 'ElementHandle.waitForElementState', 'ElementHandle.waitForSelector']);
+const pausesBeforeInputActions = exports.pausesBeforeInputActions = new Set(['Frame.check', 'Frame.click', 'Frame.dragAndDrop', 'Frame.dblclick', 'Frame.fill', 'Frame.hover', 'Frame.press', 'Frame.selectOption', 'Frame.setInputFiles', 'Frame.tap', 'Frame.type', 'Frame.uncheck', 'ElementHandle.check', 'ElementHandle.click', 'ElementHandle.dblclick', 'ElementHandle.fill', 'ElementHandle.hover', 'ElementHandle.press', 'ElementHandle.selectOption', 'ElementHandle.setInputFiles', 'ElementHandle.tap', 'ElementHandle.type', 'ElementHandle.uncheck']);

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
+});

package/lib/protocol/transport.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PipeTransport = void 0;
+var _utils = require("../utils");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PipeTransport {
+  constructor(pipeWrite, pipeRead, closeable, endian = 'le') {
+    this._pipeWrite = void 0;
+    this._data = Buffer.from([]);
+    this._waitForNextTask = (0, _utils.makeWaitForNextTask)();
+    this._closed = false;
+    this._bytesLeft = 0;
+    this.onmessage = void 0;
+    this.onclose = void 0;
+    this._endian = void 0;
+    this._closeableStream = void 0;
+    this._pipeWrite = pipeWrite;
+    this._endian = endian;
+    this._closeableStream = closeable;
+    pipeRead.on('data', buffer => this._dispatch(buffer));
+    pipeRead.on('close', () => {
+      this._closed = true;
+      if (this.onclose) this.onclose();
+    });
+    this.onmessage = undefined;
+    this.onclose = undefined;
+  }
+  send(message) {
+    if (this._closed) throw new Error('Pipe has been closed');
+    const data = Buffer.from(message, 'utf-8');
+    const dataLength = Buffer.alloc(4);
+    if (this._endian === 'be') dataLength.writeUInt32BE(data.length, 0);else dataLength.writeUInt32LE(data.length, 0);
+    this._pipeWrite.write(dataLength);
+    this._pipeWrite.write(data);
+  }
+  close() {
+    // Let it throw.
+    this._closeableStream.close();
+  }
+  _dispatch(buffer) {
+    this._data = Buffer.concat([this._data, buffer]);
+    while (true) {
+      if (!this._bytesLeft && this._data.length < 4) {
+        // Need more data.
+        break;
+      }
+      if (!this._bytesLeft) {
+        this._bytesLeft = this._endian === 'be' ? this._data.readUInt32BE(0) : this._data.readUInt32LE(0);
+        this._data = this._data.slice(4);
+      }
+      if (!this._bytesLeft || this._data.length < this._bytesLeft) {
+        // Need more data.
+        break;
+      }
+      const message = this._data.slice(0, this._bytesLeft);
+      this._data = this._data.slice(this._bytesLeft);
+      this._bytesLeft = 0;
+      this._waitForNextTask(() => {
+        if (this.onmessage) this.onmessage(message.toString('utf-8'));
+      });
+    }
+  }
+}
+exports.PipeTransport = PipeTransport;