rechrome 1.35.0 → 1.36.0

package/vendor/playwright-cli/node_modules/playwright-core/lib/client/android.js

@@ -1,361 +0,0 @@
-"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 android_exports = {};
-__export(android_exports, {
-  Android: () => Android,
-  AndroidDevice: () => AndroidDevice,
-  AndroidInput: () => AndroidInput,
-  AndroidSocket: () => AndroidSocket,
-  AndroidWebView: () => AndroidWebView
-});
-module.exports = __toCommonJS(android_exports);
-var import_eventEmitter = require("./eventEmitter");
-var import_browserContext = require("./browserContext");
-var import_channelOwner = require("./channelOwner");
-var import_errors = require("./errors");
-var import_events = require("./events");
-var import_waiter = require("./waiter");
-var import_timeoutSettings = require("./timeoutSettings");
-var import_rtti = require("../utils/isomorphic/rtti");
-var import_time = require("../utils/isomorphic/time");
-var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
-var import_connect = require("./connect");
-class Android extends import_channelOwner.ChannelOwner {
-  static from(android) {
-    return android._object;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
-  }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  async devices(options = {}) {
-    const { devices } = await this._channel.devices(options);
-    return devices.map((d) => AndroidDevice.from(d));
-  }
-  async launchServer(options = {}) {
-    if (!this._serverLauncher)
-      throw new Error("Launching server is not supported");
-    return await this._serverLauncher.launchServer(options);
-  }
-  async connect(endpoint, options = {}) {
-    return await this._wrapApiCall(async () => {
-      const deadline = options.timeout ? (0, import_time.monotonicTime)() + options.timeout : 0;
-      const headers = { "x-playwright-browser": "android", ...options.headers };
-      const connectParams = { endpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
-      const connection = await (0, import_connect.connectToEndpoint)(this._connection, connectParams);
-      let device;
-      connection.on("close", () => {
-        device?._didClose();
-      });
-      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
-        const playwright = await connection.initializePlaywright();
-        if (!playwright._initializer.preConnectedAndroidDevice) {
-          connection.close();
-          throw new Error("Malformed endpoint. Did you use Android.launchServer method?");
-        }
-        device = AndroidDevice.from(playwright._initializer.preConnectedAndroidDevice);
-        device._shouldCloseConnectionOnClose = true;
-        device.on(import_events.Events.AndroidDevice.Close, () => connection.close());
-        return device;
-      }, deadline);
-      if (!result.timedOut) {
-        return result.result;
-      } else {
-        connection.close();
-        throw new Error(`Timeout ${options.timeout}ms exceeded`);
-      }
-    });
-  }
-}
-class AndroidDevice extends import_channelOwner.ChannelOwner {
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._webViews = /* @__PURE__ */ new Map();
-    this._shouldCloseConnectionOnClose = false;
-    this._android = parent;
-    this.input = new AndroidInput(this);
-    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, parent._timeoutSettings);
-    this._channel.on("webViewAdded", ({ webView }) => this._onWebViewAdded(webView));
-    this._channel.on("webViewRemoved", ({ socketName }) => this._onWebViewRemoved(socketName));
-    this._channel.on("close", () => this._didClose());
-  }
-  static from(androidDevice) {
-    return androidDevice._object;
-  }
-  _onWebViewAdded(webView) {
-    const view = new AndroidWebView(this, webView);
-    this._webViews.set(webView.socketName, view);
-    this.emit(import_events.Events.AndroidDevice.WebView, view);
-  }
-  _onWebViewRemoved(socketName) {
-    const view = this._webViews.get(socketName);
-    this._webViews.delete(socketName);
-    if (view)
-      view.emit(import_events.Events.AndroidWebView.Close);
-  }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  serial() {
-    return this._initializer.serial;
-  }
-  model() {
-    return this._initializer.model;
-  }
-  webViews() {
-    return [...this._webViews.values()];
-  }
-  async webView(selector, options) {
-    const predicate = (v) => {
-      if (selector.pkg)
-        return v.pkg() === selector.pkg;
-      if (selector.socketName)
-        return v._socketName() === selector.socketName;
-      return false;
-    };
-    const webView = [...this._webViews.values()].find(predicate);
-    if (webView)
-      return webView;
-    return await this.waitForEvent("webview", { ...options, predicate });
-  }
-  async wait(selector, options = {}) {
-    await this._channel.wait({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async fill(selector, text, options = {}) {
-    await this._channel.fill({ androidSelector: toSelectorChannel(selector), text, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async press(selector, key, options = {}) {
-    await this.tap(selector, options);
-    await this.input.press(key);
-  }
-  async tap(selector, options = {}) {
-    await this._channel.tap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async drag(selector, dest, options = {}) {
-    await this._channel.drag({ androidSelector: toSelectorChannel(selector), dest, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async fling(selector, direction, options = {}) {
-    await this._channel.fling({ androidSelector: toSelectorChannel(selector), direction, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async longTap(selector, options = {}) {
-    await this._channel.longTap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async pinchClose(selector, percent, options = {}) {
-    await this._channel.pinchClose({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async pinchOpen(selector, percent, options = {}) {
-    await this._channel.pinchOpen({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async scroll(selector, direction, percent, options = {}) {
-    await this._channel.scroll({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async swipe(selector, direction, percent, options = {}) {
-    await this._channel.swipe({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
-  }
-  async info(selector) {
-    return (await this._channel.info({ androidSelector: toSelectorChannel(selector) })).info;
-  }
-  async screenshot(options = {}) {
-    const { binary } = await this._channel.screenshot();
-    if (options.path)
-      await this._platform.fs().promises.writeFile(options.path, binary);
-    return binary;
-  }
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-  async close() {
-    try {
-      if (this._shouldCloseConnectionOnClose)
-        this._connection.close();
-      else
-        await this._channel.close();
-    } catch (e) {
-      if ((0, import_errors.isTargetClosedError)(e))
-        return;
-      throw e;
-    }
-  }
-  _didClose() {
-    this.emit(import_events.Events.AndroidDevice.Close, this);
-  }
-  async shell(command) {
-    const { result } = await this._channel.shell({ command });
-    return result;
-  }
-  async open(command) {
-    return AndroidSocket.from((await this._channel.open({ command })).socket);
-  }
-  async installApk(file, options) {
-    await this._channel.installApk({ file: await loadFile(this._platform, file), args: options && options.args });
-  }
-  async push(file, path, options) {
-    await this._channel.push({ file: await loadFile(this._platform, file), path, mode: options ? options.mode : void 0 });
-  }
-  async launchBrowser(options = {}) {
-    const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
-    const result = await this._channel.launchBrowser(contextOptions);
-    const context = import_browserContext.BrowserContext.from(result.context);
-    const selectors = this._android._playwright.selectors;
-    selectors._contextsForSelectors.add(context);
-    context.once(import_events.Events.BrowserContext.Close, () => selectors._contextsForSelectors.delete(context));
-    await context._initializeHarFromOptions(options.recordHar);
-    return context;
-  }
-  async waitForEvent(event, optionsOrPredicate = {}) {
-    return await this._wrapApiCall(async () => {
-      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
-      const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
-      const waiter = import_waiter.Waiter.createForEvent(this, event);
-      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
-      if (event !== import_events.Events.AndroidDevice.Close)
-        waiter.rejectOnEvent(this, import_events.Events.AndroidDevice.Close, () => new import_errors.TargetClosedError());
-      const result = await waiter.waitForEvent(this, event, predicate);
-      waiter.dispose();
-      return result;
-    });
-  }
-}
-class AndroidSocket extends import_channelOwner.ChannelOwner {
-  static from(androidDevice) {
-    return androidDevice._object;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._channel.on("data", ({ data }) => this.emit(import_events.Events.AndroidSocket.Data, data));
-    this._channel.on("close", () => this.emit(import_events.Events.AndroidSocket.Close));
-  }
-  async write(data) {
-    await this._channel.write({ data });
-  }
-  async close() {
-    await this._channel.close();
-  }
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-}
-async function loadFile(platform, file) {
-  if ((0, import_rtti.isString)(file))
-    return await platform.fs().promises.readFile(file);
-  return file;
-}
-class AndroidInput {
-  constructor(device) {
-    this._device = device;
-  }
-  async type(text) {
-    await this._device._channel.inputType({ text });
-  }
-  async press(key) {
-    await this._device._channel.inputPress({ key });
-  }
-  async tap(point) {
-    await this._device._channel.inputTap({ point });
-  }
-  async swipe(from, segments, steps) {
-    await this._device._channel.inputSwipe({ segments, steps });
-  }
-  async drag(from, to, steps) {
-    await this._device._channel.inputDrag({ from, to, steps });
-  }
-}
-function toSelectorChannel(selector) {
-  const {
-    checkable,
-    checked,
-    clazz,
-    clickable,
-    depth,
-    desc,
-    enabled,
-    focusable,
-    focused,
-    hasChild,
-    hasDescendant,
-    longClickable,
-    pkg,
-    res,
-    scrollable,
-    selected,
-    text
-  } = selector;
-  const toRegex = (value) => {
-    if (value === void 0)
-      return void 0;
-    if ((0, import_rtti.isRegExp)(value))
-      return value.source;
-    return "^" + value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d") + "$";
-  };
-  return {
-    checkable,
-    checked,
-    clazz: toRegex(clazz),
-    pkg: toRegex(pkg),
-    desc: toRegex(desc),
-    res: toRegex(res),
-    text: toRegex(text),
-    clickable,
-    depth,
-    enabled,
-    focusable,
-    focused,
-    hasChild: hasChild ? { androidSelector: toSelectorChannel(hasChild.selector) } : void 0,
-    hasDescendant: hasDescendant ? { androidSelector: toSelectorChannel(hasDescendant.selector), maxDepth: hasDescendant.maxDepth } : void 0,
-    longClickable,
-    scrollable,
-    selected
-  };
-}
-class AndroidWebView extends import_eventEmitter.EventEmitter {
-  constructor(device, data) {
-    super(device._platform);
-    this._device = device;
-    this._data = data;
-  }
-  pid() {
-    return this._data.pid;
-  }
-  pkg() {
-    return this._data.pkg;
-  }
-  _socketName() {
-    return this._data.socketName;
-  }
-  async page() {
-    if (!this._pagePromise)
-      this._pagePromise = this._fetchPage();
-    return await this._pagePromise;
-  }
-  async _fetchPage() {
-    const { context } = await this._device._channel.connectToWebView({ socketName: this._data.socketName });
-    return import_browserContext.BrowserContext.from(context).pages()[0];
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Android,
-  AndroidDevice,
-  AndroidInput,
-  AndroidSocket,
-  AndroidWebView
-});

package/vendor/playwright-cli/node_modules/playwright-core/lib/client/api.js

@@ -1,137 +0,0 @@
-"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 api_exports = {};
-__export(api_exports, {
-  APIRequest: () => import_fetch.APIRequest,
-  APIRequestContext: () => import_fetch.APIRequestContext,
-  APIResponse: () => import_fetch.APIResponse,
-  Android: () => import_android.Android,
-  AndroidDevice: () => import_android.AndroidDevice,
-  AndroidInput: () => import_android.AndroidInput,
-  AndroidSocket: () => import_android.AndroidSocket,
-  AndroidWebView: () => import_android.AndroidWebView,
-  Browser: () => import_browser.Browser,
-  BrowserContext: () => import_browserContext.BrowserContext,
-  BrowserType: () => import_browserType.BrowserType,
-  CDPSession: () => import_cdpSession.CDPSession,
-  Clock: () => import_clock.Clock,
-  ConsoleMessage: () => import_consoleMessage.ConsoleMessage,
-  Coverage: () => import_coverage.Coverage,
-  Debugger: () => import_debugger.Debugger,
-  Dialog: () => import_dialog.Dialog,
-  Download: () => import_download.Download,
-  Electron: () => import_electron.Electron,
-  ElectronApplication: () => import_electron.ElectronApplication,
-  ElementHandle: () => import_elementHandle.ElementHandle,
-  FileChooser: () => import_fileChooser.FileChooser,
-  Frame: () => import_frame.Frame,
-  FrameLocator: () => import_locator.FrameLocator,
-  JSHandle: () => import_jsHandle.JSHandle,
-  Keyboard: () => import_input.Keyboard,
-  Locator: () => import_locator.Locator,
-  Mouse: () => import_input.Mouse,
-  Page: () => import_page.Page,
-  Playwright: () => import_playwright.Playwright,
-  Request: () => import_network.Request,
-  Response: () => import_network.Response,
-  Route: () => import_network.Route,
-  Selectors: () => import_selectors.Selectors,
-  TimeoutError: () => import_errors.TimeoutError,
-  Touchscreen: () => import_input.Touchscreen,
-  Tracing: () => import_tracing.Tracing,
-  Video: () => import_video.Video,
-  WebError: () => import_webError.WebError,
-  WebSocket: () => import_network.WebSocket,
-  WebSocketRoute: () => import_network.WebSocketRoute,
-  Worker: () => import_worker.Worker
-});
-module.exports = __toCommonJS(api_exports);
-var import_android = require("./android");
-var import_browser = require("./browser");
-var import_browserContext = require("./browserContext");
-var import_browserType = require("./browserType");
-var import_clock = require("./clock");
-var import_consoleMessage = require("./consoleMessage");
-var import_coverage = require("./coverage");
-var import_debugger = require("./debugger");
-var import_dialog = require("./dialog");
-var import_download = require("./download");
-var import_electron = require("./electron");
-var import_locator = require("./locator");
-var import_elementHandle = require("./elementHandle");
-var import_fileChooser = require("./fileChooser");
-var import_errors = require("./errors");
-var import_frame = require("./frame");
-var import_input = require("./input");
-var import_jsHandle = require("./jsHandle");
-var import_network = require("./network");
-var import_fetch = require("./fetch");
-var import_page = require("./page");
-var import_selectors = require("./selectors");
-var import_tracing = require("./tracing");
-var import_video = require("./video");
-var import_worker = require("./worker");
-var import_cdpSession = require("./cdpSession");
-var import_playwright = require("./playwright");
-var import_webError = require("./webError");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APIRequest,
-  APIRequestContext,
-  APIResponse,
-  Android,
-  AndroidDevice,
-  AndroidInput,
-  AndroidSocket,
-  AndroidWebView,
-  Browser,
-  BrowserContext,
-  BrowserType,
-  CDPSession,
-  Clock,
-  ConsoleMessage,
-  Coverage,
-  Debugger,
-  Dialog,
-  Download,
-  Electron,
-  ElectronApplication,
-  ElementHandle,
-  FileChooser,
-  Frame,
-  FrameLocator,
-  JSHandle,
-  Keyboard,
-  Locator,
-  Mouse,
-  Page,
-  Playwright,
-  Request,
-  Response,
-  Route,
-  Selectors,
-  TimeoutError,
-  Touchscreen,
-  Tracing,
-  Video,
-  WebError,
-  WebSocket,
-  WebSocketRoute,
-  Worker
-});

package/vendor/playwright-cli/node_modules/playwright-core/lib/client/artifact.js

@@ -1,79 +0,0 @@
-"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 artifact_exports = {};
-__export(artifact_exports, {
-  Artifact: () => Artifact
-});
-module.exports = __toCommonJS(artifact_exports);
-var import_channelOwner = require("./channelOwner");
-var import_stream = require("./stream");
-var import_fileUtils = require("./fileUtils");
-class Artifact extends import_channelOwner.ChannelOwner {
-  static from(channel) {
-    return channel._object;
-  }
-  async pathAfterFinished() {
-    if (this._connection.isRemote())
-      throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
-    return (await this._channel.pathAfterFinished()).value;
-  }
-  async saveAs(path) {
-    if (!this._connection.isRemote()) {
-      await this._channel.saveAs({ path });
-      return;
-    }
-    const result = await this._channel.saveAsStream();
-    const stream = import_stream.Stream.from(result.stream);
-    await (0, import_fileUtils.mkdirIfNeeded)(this._platform, path);
-    await new Promise((resolve, reject) => {
-      stream.stream().pipe(this._platform.fs().createWriteStream(path)).on("finish", resolve).on("error", reject);
-    });
-  }
-  async failure() {
-    return (await this._channel.failure()).error || null;
-  }
-  async createReadStream() {
-    const result = await this._channel.stream();
-    const stream = import_stream.Stream.from(result.stream);
-    return stream.stream();
-  }
-  async readIntoBuffer() {
-    const stream = await this.createReadStream();
-    return await new Promise((resolve, reject) => {
-      const chunks = [];
-      stream.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      stream.on("end", () => {
-        resolve(Buffer.concat(chunks));
-      });
-      stream.on("error", reject);
-    });
-  }
-  async cancel() {
-    return await this._channel.cancel();
-  }
-  async delete() {
-    return await this._channel.delete();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Artifact
-});