rebrowser-playwright-core 1.49.1 → 1.52.0

package/lib/client/harRouter.js

@@ -1,43 +1,34 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 harRouter_exports = {};
+__export(harRouter_exports, {
+  HarRouter: () => HarRouter
 });
-exports.HarRouter = void 0;
-var _debugLogger = require("../utils/debugLogger");
-let _Symbol$asyncDispose;
-/**
- * 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.
- */
-_Symbol$asyncDispose = Symbol.asyncDispose;
+module.exports = __toCommonJS(harRouter_exports);
 class HarRouter {
   static async create(localUtils, file, notFoundAction, options) {
-    const {
-      harId,
-      error
-    } = await localUtils._channel.harOpen({
-      file
-    });
-    if (error) throw new Error(error);
+    const { harId, error } = await localUtils.harOpen({ file });
+    if (error)
+      throw new Error(error);
     return new HarRouter(localUtils, harId, notFoundAction, options);
   }
   constructor(localUtils, harId, notFoundAction, options) {
-    this._localUtils = void 0;
-    this._harId = void 0;
-    this._notFoundAction = void 0;
-    this._options = void 0;
     this._localUtils = localUtils;
     this._harId = harId;
     this._options = options;
@@ -45,55 +36,52 @@ class HarRouter {
   }
   async _handle(route) {
     const request = route.request();
-    const response = await this._localUtils._channel.harLookup({
+    const response = await this._localUtils.harLookup({
       harId: this._harId,
       url: request.url(),
       method: request.method(),
       headers: await request.headersArray(),
-      postData: request.postDataBuffer() || undefined,
+      postData: request.postDataBuffer() || void 0,
       isNavigationRequest: request.isNavigationRequest()
     });
-    if (response.action === 'redirect') {
-      _debugLogger.debugLogger.log('api', `HAR: ${route.request().url()} redirected to ${response.redirectURL}`);
+    if (response.action === "redirect") {
+      route._platform.log("api", `HAR: ${route.request().url()} redirected to ${response.redirectURL}`);
       await route._redirectNavigationRequest(response.redirectURL);
       return;
     }
-    if (response.action === 'fulfill') {
-      // If the response status is -1, the request was canceled or stalled, so we just stall it here.
-      // See https://github.com/microsoft/playwright/issues/29311.
-      // TODO: it'd be better to abort such requests, but then we likely need to respect the timing,
-      // because the request might have been stalled for a long time until the very end of the
-      // test when HAR was recorded but we'd abort it immediately.
-      if (response.status === -1) return;
+    if (response.action === "fulfill") {
+      if (response.status === -1)
+        return;
       await route.fulfill({
         status: response.status,
-        headers: Object.fromEntries(response.headers.map(h => [h.name, h.value])),
+        headers: Object.fromEntries(response.headers.map((h) => [h.name, h.value])),
         body: response.body
       });
       return;
     }
-    if (response.action === 'error') _debugLogger.debugLogger.log('api', 'HAR: ' + response.message);
-    // Report the error, but fall through to the default handler.
-
-    if (this._notFoundAction === 'abort') {
+    if (response.action === "error")
+      route._platform.log("api", "HAR: " + response.message);
+    if (this._notFoundAction === "abort") {
       await route.abort();
       return;
     }
     await route.fallback();
   }
   async addContextRoute(context) {
-    await context.route(this._options.urlMatch || '**/*', route => this._handle(route));
+    await context.route(this._options.urlMatch || "**/*", (route) => this._handle(route));
   }
   async addPageRoute(page) {
-    await page.route(this._options.urlMatch || '**/*', route => this._handle(route));
+    await page.route(this._options.urlMatch || "**/*", (route) => this._handle(route));
   }
-  async [_Symbol$asyncDispose]() {
+  async [Symbol.asyncDispose]() {
     await this.dispose();
   }
   dispose() {
-    this._localUtils._channel.harClose({
-      harId: this._harId
-    }).catch(() => {});
+    this._localUtils.harClose({ harId: this._harId }).catch(() => {
+    });
   }
 }
-exports.HarRouter = HarRouter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HarRouter
+});

package/lib/client/input.js

@@ -1,111 +1,82 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 input_exports = {};
+__export(input_exports, {
+  Keyboard: () => Keyboard,
+  Mouse: () => Mouse,
+  Touchscreen: () => Touchscreen
 });
-exports.Touchscreen = exports.Mouse = exports.Keyboard = void 0;
-/**
- * Copyright 2017 Google Inc. All rights reserved.
- * Modifications 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.
- */
-
+module.exports = __toCommonJS(input_exports);
 class Keyboard {
   constructor(page) {
-    this._page = void 0;
     this._page = page;
   }
   async down(key) {
-    await this._page._channel.keyboardDown({
-      key
-    });
+    await this._page._channel.keyboardDown({ key });
   }
   async up(key) {
-    await this._page._channel.keyboardUp({
-      key
-    });
+    await this._page._channel.keyboardUp({ key });
   }
   async insertText(text) {
-    await this._page._channel.keyboardInsertText({
-      text
-    });
+    await this._page._channel.keyboardInsertText({ text });
   }
   async type(text, options = {}) {
-    await this._page._channel.keyboardType({
-      text,
-      ...options
-    });
+    await this._page._channel.keyboardType({ text, ...options });
   }
   async press(key, options = {}) {
-    await this._page._channel.keyboardPress({
-      key,
-      ...options
-    });
+    await this._page._channel.keyboardPress({ key, ...options });
   }
 }
-exports.Keyboard = Keyboard;
 class Mouse {
   constructor(page) {
-    this._page = void 0;
     this._page = page;
   }
   async move(x, y, options = {}) {
-    await this._page._channel.mouseMove({
-      x,
-      y,
-      ...options
-    });
+    await this._page._channel.mouseMove({ x, y, ...options });
   }
   async down(options = {}) {
-    await this._page._channel.mouseDown({
-      ...options
-    });
+    await this._page._channel.mouseDown({ ...options });
   }
   async up(options = {}) {
     await this._page._channel.mouseUp(options);
   }
   async click(x, y, options = {}) {
-    await this._page._channel.mouseClick({
-      x,
-      y,
-      ...options
-    });
+    await this._page._channel.mouseClick({ x, y, ...options });
   }
   async dblclick(x, y, options = {}) {
-    await this.click(x, y, {
-      ...options,
-      clickCount: 2
-    });
+    await this.click(x, y, { ...options, clickCount: 2 });
   }
   async wheel(deltaX, deltaY) {
-    await this._page._channel.mouseWheel({
-      deltaX,
-      deltaY
-    });
+    await this._page._channel.mouseWheel({ deltaX, deltaY });
   }
 }
-exports.Mouse = Mouse;
 class Touchscreen {
   constructor(page) {
-    this._page = void 0;
     this._page = page;
   }
   async tap(x, y) {
-    await this._page._channel.touchscreenTap({
-      x,
-      y
-    });
+    await this._page._channel.touchscreenTap({ x, y });
   }
 }
-exports.Touchscreen = Touchscreen;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Keyboard,
+  Mouse,
+  Touchscreen
+});

package/lib/client/jsHandle.js

@@ -1,72 +1,57 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 jsHandle_exports = {};
+__export(jsHandle_exports, {
+  JSHandle: () => JSHandle,
+  assertMaxArguments: () => assertMaxArguments,
+  parseResult: () => parseResult,
+  serializeArgument: () => serializeArgument
 });
-exports.JSHandle = void 0;
-exports.assertMaxArguments = assertMaxArguments;
-exports.parseResult = parseResult;
-exports.serializeArgument = serializeArgument;
-var _channelOwner = require("./channelOwner");
-var _serializers = require("../protocol/serializers");
-var _errors = require("./errors");
-let _Symbol$asyncDispose;
-/**
- * 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.
- */
-_Symbol$asyncDispose = Symbol.asyncDispose;
-class JSHandle extends _channelOwner.ChannelOwner {
+module.exports = __toCommonJS(jsHandle_exports);
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+var import_serializers = require("../protocol/serializers");
+class JSHandle extends import_channelOwner.ChannelOwner {
   static from(handle) {
     return handle._object;
   }
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this._preview = void 0;
     this._preview = this._initializer.preview;
-    this._channel.on('previewUpdated', ({
-      preview
-    }) => this._preview = preview);
+    this._channel.on("previewUpdated", ({ preview }) => this._preview = preview);
   }
   async evaluate(pageFunction, arg) {
-    const result = await this._channel.evaluateExpression({
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: serializeArgument(arg)
-    });
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return parseResult(result.value);
   }
   async evaluateHandle(pageFunction, arg) {
-    const result = await this._channel.evaluateExpressionHandle({
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: serializeArgument(arg)
-    });
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return JSHandle.from(result.handle);
   }
   async getProperty(propertyName) {
-    const result = await this._channel.getProperty({
-      name: propertyName
-    });
+    const result = await this._channel.getProperty({ name: propertyName });
     return JSHandle.from(result.handle);
   }
   async getProperties() {
-    const map = new Map();
-    for (const {
-      name,
-      value
-    } of (await this._channel.getPropertyList()).properties) map.set(name, JSHandle.from(value));
+    const map = /* @__PURE__ */ new Map();
+    for (const { name, value } of (await this._channel.getPropertyList()).properties)
+      map.set(name, JSHandle.from(value));
     return map;
   }
   async jsonValue() {
@@ -75,14 +60,15 @@ class JSHandle extends _channelOwner.ChannelOwner {
   asElement() {
     return null;
   }
-  async [_Symbol$asyncDispose]() {
+  async [Symbol.asyncDispose]() {
     await this.dispose();
   }
   async dispose() {
     try {
       await this._channel.dispose();
     } catch (e) {
-      if ((0, _errors.isTargetClosedError)(e)) return;
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
       throw e;
     }
   }
@@ -90,32 +76,30 @@ class JSHandle extends _channelOwner.ChannelOwner {
     return this._preview;
   }
 }
-
-// This function takes care of converting all JSHandles to their channels,
-// so that generic channel serializer converts them to guids.
-exports.JSHandle = JSHandle;
 function serializeArgument(arg) {
   const handles = [];
-  const pushHandle = channel => {
+  const pushHandle = (channel) => {
     handles.push(channel);
     return handles.length - 1;
   };
-  const value = (0, _serializers.serializeValue)(arg, value => {
-    if (value instanceof JSHandle) return {
-      h: pushHandle(value._channel)
-    };
-    return {
-      fallThrough: value
-    };
+  const value = (0, import_serializers.serializeValue)(arg, (value2) => {
+    if (value2 instanceof JSHandle)
+      return { h: pushHandle(value2._channel) };
+    return { fallThrough: value2 };
   });
-  return {
-    value,
-    handles
-  };
+  return { value, handles };
 }
 function parseResult(value) {
-  return (0, _serializers.parseSerializedValue)(value, undefined);
+  return (0, import_serializers.parseSerializedValue)(value, void 0);
 }
 function assertMaxArguments(count, max) {
-  if (count > max) throw new Error('Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.');
-}
+  if (count > max)
+    throw new Error("Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSHandle,
+  assertMaxArguments,
+  parseResult,
+  serializeArgument
+});

package/lib/client/jsonPipe.js

@@ -1,27 +1,28 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 jsonPipe_exports = {};
+__export(jsonPipe_exports, {
+  JsonPipe: () => JsonPipe
 });
-exports.JsonPipe = void 0;
-var _channelOwner = require("./channelOwner");
-/**
- * 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 JsonPipe extends _channelOwner.ChannelOwner {
+module.exports = __toCommonJS(jsonPipe_exports);
+var import_channelOwner = require("./channelOwner");
+class JsonPipe extends import_channelOwner.ChannelOwner {
   static from(jsonPipe) {
     return jsonPipe._object;
   }
@@ -32,4 +33,7 @@ class JsonPipe extends _channelOwner.ChannelOwner {
     return this._channel;
   }
 }
-exports.JsonPipe = JsonPipe;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonPipe
+});

package/lib/client/localUtils.js

@@ -1,36 +1,61 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 localUtils_exports = {};
+__export(localUtils_exports, {
+  LocalUtils: () => LocalUtils
 });
-exports.LocalUtils = void 0;
-var _channelOwner = require("./channelOwner");
-/**
- * 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 LocalUtils extends _channelOwner.ChannelOwner {
+module.exports = __toCommonJS(localUtils_exports);
+var import_channelOwner = require("./channelOwner");
+class LocalUtils extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this.devices = void 0;
     this.markAsInternalType();
     this.devices = {};
-    for (const {
-      name,
-      descriptor
-    } of initializer.deviceDescriptors) this.devices[name] = descriptor;
+    for (const { name, descriptor } of initializer.deviceDescriptors)
+      this.devices[name] = descriptor;
+  }
+  async zip(params) {
+    return await this._channel.zip(params);
+  }
+  async harOpen(params) {
+    return await this._channel.harOpen(params);
+  }
+  async harLookup(params) {
+    return await this._channel.harLookup(params);
+  }
+  async harClose(params) {
+    return await this._channel.harClose(params);
+  }
+  async harUnzip(params) {
+    return await this._channel.harUnzip(params);
+  }
+  async tracingStarted(params) {
+    return await this._channel.tracingStarted(params);
+  }
+  async traceDiscarded(params) {
+    return await this._channel.traceDiscarded(params);
+  }
+  async addStackToTracingNoReply(params) {
+    return await this._channel.addStackToTracingNoReply(params);
   }
 }
-exports.LocalUtils = LocalUtils;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalUtils
+});