patchright-core 1.48.2

package/lib/server/bidi/bidiConnection.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kBrowserCloseMessageId = exports.BidiSession = exports.BidiConnection = void 0;
+var _events = require("events");
+var _utils = require("../../utils");
+var _debugLogger = require("../../utils/debugLogger");
+var _helper = require("../helper");
+var _protocolError = require("../protocolError");
+/**
+ * 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.
+ */
+
+// BidiPlaywright uses this special id to issue Browser.close command which we
+// should ignore.
+const kBrowserCloseMessageId = exports.kBrowserCloseMessageId = 0;
+class BidiConnection {
+  constructor(transport, onDisconnect, protocolLogger, browserLogsCollector) {
+    this._transport = void 0;
+    this._onDisconnect = void 0;
+    this._protocolLogger = void 0;
+    this._browserLogsCollector = void 0;
+    this._browserDisconnectedLogs = void 0;
+    this._lastId = 0;
+    this._closed = false;
+    this.browserSession = void 0;
+    this._browsingContextToSession = new Map();
+    this._transport = transport;
+    this._onDisconnect = onDisconnect;
+    this._protocolLogger = protocolLogger;
+    this._browserLogsCollector = browserLogsCollector;
+    this.browserSession = new BidiSession(this, '', message => {
+      this.rawSend(message);
+    });
+    this._transport.onmessage = this._dispatchMessage.bind(this);
+    // onclose should be set last, since it can be immediately called.
+    this._transport.onclose = this._onClose.bind(this);
+  }
+  nextMessageId() {
+    return ++this._lastId;
+  }
+  rawSend(message) {
+    this._protocolLogger('send', message);
+    this._transport.send(message);
+  }
+  _dispatchMessage(message) {
+    this._protocolLogger('receive', message);
+    const object = message;
+    // Bidi messages do not have a common session identifier, so we
+    // route them based on BrowsingContext.
+    if (object.type === 'event') {
+      var _object$params$source;
+      // Route page events to the right session.
+      let context;
+      if ('context' in object.params) context = object.params.context;else if (object.method === 'log.entryAdded' || object.method === 'script.message') context = (_object$params$source = object.params.source) === null || _object$params$source === void 0 ? void 0 : _object$params$source.context;
+      if (context) {
+        const session = this._browsingContextToSession.get(context);
+        if (session) {
+          session.dispatchMessage(message);
+          return;
+        }
+      }
+    } else if (message.id) {
+      // Find caller session.
+      for (const session of this._browsingContextToSession.values()) {
+        if (session.hasCallback(message.id)) {
+          session.dispatchMessage(message);
+          return;
+        }
+      }
+    }
+    this.browserSession.dispatchMessage(message);
+  }
+  _onClose(reason) {
+    this._closed = true;
+    this._transport.onmessage = undefined;
+    this._transport.onclose = undefined;
+    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
+    this.browserSession.dispose();
+    this._onDisconnect();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  close() {
+    if (!this._closed) this._transport.close();
+  }
+  createMainFrameBrowsingContextSession(bowsingContextId) {
+    const result = new BidiSession(this, bowsingContextId, message => this.rawSend(message));
+    this._browsingContextToSession.set(bowsingContextId, result);
+    return result;
+  }
+}
+exports.BidiConnection = BidiConnection;
+class BidiSession extends _events.EventEmitter {
+  constructor(connection, sessionId, rawSend) {
+    super();
+    this.connection = void 0;
+    this.sessionId = void 0;
+    this._disposed = false;
+    this._rawSend = void 0;
+    this._callbacks = new Map();
+    this._crashed = false;
+    this._browsingContexts = new Set();
+    this.on = void 0;
+    this.addListener = void 0;
+    this.off = void 0;
+    this.removeListener = void 0;
+    this.once = void 0;
+    this.setMaxListeners(0);
+    this.connection = connection;
+    this.sessionId = sessionId;
+    this._rawSend = rawSend;
+    this.on = super.on;
+    this.off = super.removeListener;
+    this.addListener = super.addListener;
+    this.removeListener = super.removeListener;
+    this.once = super.once;
+  }
+  addFrameBrowsingContext(context) {
+    this._browsingContexts.add(context);
+    this.connection._browsingContextToSession.set(context, this);
+  }
+  removeFrameBrowsingContext(context) {
+    this._browsingContexts.delete(context);
+    this.connection._browsingContextToSession.delete(context);
+  }
+  async send(method, params) {
+    if (this._crashed || this._disposed || this.connection._browserDisconnectedLogs) throw new _protocolError.ProtocolError(this._crashed ? 'crashed' : 'closed', undefined, this.connection._browserDisconnectedLogs);
+    const id = this.connection.nextMessageId();
+    const messageObj = {
+      id,
+      method,
+      params
+    };
+    this._rawSend(messageObj);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(id, {
+        resolve,
+        reject,
+        error: new _protocolError.ProtocolError('error', method)
+      });
+    });
+  }
+  sendMayFail(method, params) {
+    return this.send(method, params).catch(error => _debugLogger.debugLogger.log('error', error));
+  }
+  markAsCrashed() {
+    this._crashed = true;
+  }
+  isDisposed() {
+    return this._disposed;
+  }
+  dispose() {
+    this._disposed = true;
+    this.connection._browsingContextToSession.delete(this.sessionId);
+    for (const context of this._browsingContexts) this.connection._browsingContextToSession.delete(context);
+    this._browsingContexts.clear();
+    for (const callback of this._callbacks.values()) {
+      callback.error.type = this._crashed ? 'crashed' : 'closed';
+      callback.error.logs = this.connection._browserDisconnectedLogs;
+      callback.reject(callback.error);
+    }
+    this._callbacks.clear();
+  }
+  hasCallback(id) {
+    return this._callbacks.has(id);
+  }
+  dispatchMessage(message) {
+    const object = message;
+    if (object.id === kBrowserCloseMessageId) return;
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.type === 'error') {
+        callback.error.setMessage(object.error + '\nMessage: ' + object.message);
+        callback.reject(callback.error);
+      } else if (object.type === 'success') {
+        callback.resolve(object.result);
+      } else {
+        callback.error.setMessage('Internal error, unexpected response type: ' + JSON.stringify(object));
+        callback.reject(callback.error);
+      }
+    } else if (object.id) {
+      // Response might come after session has been disposed and rejected all callbacks.
+      (0, _utils.assert)(this.isDisposed());
+    } else {
+      Promise.resolve().then(() => this.emit(object.method, object.params));
+    }
+  }
+}
+exports.BidiSession = BidiSession;

package/lib/server/bidi/bidiExecutionContext.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BidiExecutionContext = void 0;
+var _utilityScriptSerializers = require("../isomorphic/utilityScriptSerializers");
+var js = _interopRequireWildcard(require("../javascript"));
+var _bidiDeserializer = require("./third_party/bidiDeserializer");
+var bidi = _interopRequireWildcard(require("./third_party/bidiProtocol"));
+var _bidiSerializer = require("./third_party/bidiSerializer");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * 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 BidiExecutionContext {
+  constructor(session, realmInfo) {
+    this._session = void 0;
+    this._target = void 0;
+    this._session = session;
+    if (realmInfo.type === 'window') {
+      // Simple realm does not seem to work for Window contexts.
+      this._target = {
+        context: realmInfo.context,
+        sandbox: realmInfo.sandbox
+      };
+    } else {
+      this._target = {
+        realm: realmInfo.realm
+      };
+    }
+  }
+  async rawEvaluateJSON(expression) {
+    const response = await this._session.send('script.evaluate', {
+      expression,
+      target: this._target,
+      serializationOptions: {
+        maxObjectDepth: 10,
+        maxDomDepth: 10
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'success') return _bidiDeserializer.BidiDeserializer.deserialize(response.result);
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  async rawEvaluateHandle(expression) {
+    const response = await this._session.send('script.evaluate', {
+      expression,
+      target: this._target,
+      resultOwnership: bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'success') {
+      if ('handle' in response.result) return response.result.handle;
+      throw new js.JavaScriptErrorInEvaluate('Cannot get handle: ' + JSON.stringify(response.result));
+    }
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  rawCallFunctionNoReply(func, ...args) {
+    throw new Error('Method not implemented.');
+  }
+  async evaluateWithArguments(functionDeclaration, returnByValue, utilityScript, values, objectIds) {
+    const response = await this._session.send('script.callFunction', {
+      functionDeclaration,
+      target: this._target,
+      arguments: [{
+        handle: utilityScript._objectId
+      }, ...values.map(_bidiSerializer.BidiSerializer.serialize), ...objectIds.map(handle => ({
+        handle
+      }))],
+      resultOwnership: returnByValue ? undefined : bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: returnByValue ? {} : {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    if (response.type === 'success') {
+      if (returnByValue) return (0, _utilityScriptSerializers.parseEvaluationResultValue)(_bidiDeserializer.BidiDeserializer.deserialize(response.result));
+      const objectId = 'handle' in response.result ? response.result.handle : undefined;
+      return utilityScript._context.createHandle({
+        objectId,
+        ...response.result
+      });
+    }
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  async getProperties(context, objectId) {
+    throw new Error('Method not implemented.');
+  }
+  createHandle(context, jsRemoteObject) {
+    const remoteObject = jsRemoteObject;
+    return new js.JSHandle(context, remoteObject.type, renderPreview(remoteObject), jsRemoteObject.objectId, remoteObjectValue(remoteObject));
+  }
+  async releaseHandle(objectId) {
+    await this._session.send('script.disown', {
+      target: this._target,
+      handles: [objectId]
+    });
+  }
+  async rawCallFunction(functionDeclaration, arg) {
+    const response = await this._session.send('script.callFunction', {
+      functionDeclaration,
+      target: this._target,
+      arguments: [arg],
+      resultOwnership: bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    if (response.type === 'success') return response.result;
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+}
+exports.BidiExecutionContext = BidiExecutionContext;
+function renderPreview(remoteObject) {
+  if (remoteObject.type === 'undefined') return 'undefined';
+  if (remoteObject.type === 'null') return 'null';
+  if ('value' in remoteObject) return String(remoteObject.value);
+  return `<${remoteObject.type}>`;
+}
+function remoteObjectValue(remoteObject) {
+  if (remoteObject.type === 'undefined') return undefined;
+  if (remoteObject.type === 'null') return null;
+  if (remoteObject.type === 'number' && typeof remoteObject.value === 'string') return js.parseUnserializableValue(remoteObject.value);
+  if ('value' in remoteObject) return remoteObject.value;
+  return undefined;
+}

package/lib/server/bidi/bidiFirefox.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BidiFirefox = void 0;
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../../utils");
+var _browserType = require("../browserType");
+var _bidiBrowser = require("./bidiBrowser");
+var _bidiConnection = require("./bidiConnection");
+var _firefoxPrefs = require("./third_party/firefoxPrefs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 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 BidiFirefox extends _browserType.BrowserType {
+  constructor(parent) {
+    super(parent, 'bidi');
+    this._useBidi = true;
+  }
+  async connectToTransport(transport, options) {
+    return _bidiBrowser.BidiBrowser.connect(this.attribution.playwright, transport, options);
+  }
+  doRewriteStartupLog(error) {
+    if (!error.logs) return error;
+    // https://github.com/microsoft/playwright/issues/6500
+    if (error.logs.includes(`as root in a regular user's session is not supported.`)) error.logs = '\n' + (0, _utils.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.\nWorkaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? ' in your GitHub Actions workflow file' : ''} when running Playwright.`, 1);
+    if (error.logs.includes('no DISPLAY environment variable specified')) error.logs = '\n' + (0, _utils.wrapInASCIIBox)(_browserType.kNoXServerRunningError, 1);
+    return error;
+  }
+  amendEnvironment(env, userDataDir, executable, browserArguments) {
+    if (!_path.default.isAbsolute(_os.default.homedir())) throw new Error(`Cannot launch Firefox with relative home directory. Did you set ${_os.default.platform() === 'win32' ? 'USERPROFILE' : 'HOME'} to a relative path?`);
+    env = {
+      ...env,
+      'MOZ_CRASHREPORTER': '1',
+      'MOZ_CRASHREPORTER_NO_REPORT': '1',
+      'MOZ_CRASHREPORTER_SHUTDOWN': '1'
+    };
+    if (_os.default.platform() === 'linux') {
+      // Always remove SNAP_NAME and SNAP_INSTANCE_NAME env variables since they
+      // confuse Firefox: in our case, builds never come from SNAP.
+      // See https://github.com/microsoft/playwright/issues/20555
+      return {
+        ...env,
+        SNAP_NAME: undefined,
+        SNAP_INSTANCE_NAME: undefined
+      };
+    }
+    return env;
+  }
+  attemptToGracefullyCloseBrowser(transport) {
+    transport.send({
+      method: 'browser.close',
+      params: {},
+      id: _bidiConnection.kBrowserCloseMessageId
+    });
+  }
+  async prepareUserDataDir(options, userDataDir) {
+    await (0, _firefoxPrefs.createProfile)({
+      path: userDataDir,
+      preferences: options.firefoxUserPrefs || {}
+    });
+  }
+  defaultArgs(options, isPersistent, userDataDir) {
+    const {
+      args = [],
+      headless
+    } = options;
+    const userDataDirArg = args.find(arg => arg.startsWith('-profile') || arg.startsWith('--profile'));
+    if (userDataDirArg) throw this._createUserDataDirArgMisuseError('--profile');
+    const firefoxArguments = ['--remote-debugging-port=0'];
+    if (headless) firefoxArguments.push('--headless');else firefoxArguments.push('--foreground');
+    firefoxArguments.push(`--profile`, userDataDir);
+    firefoxArguments.push(...args);
+    return firefoxArguments;
+  }
+  readyState(options) {
+    (0, _utils.assert)(options.useWebSocket);
+    return new FirefoxReadyState();
+  }
+}
+exports.BidiFirefox = BidiFirefox;
+class FirefoxReadyState extends _browserType.BrowserReadyState {
+  onBrowserOutput(message) {
+    // Bidi WebSocket in Firefox.
+    const match = message.match(/WebDriver BiDi listening on (ws:\/\/.*)$/);
+    if (match) this._wsEndpoint.resolve(match[1] + '/session');
+  }
+}

package/lib/server/bidi/bidiInput.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RawTouchscreenImpl = exports.RawMouseImpl = exports.RawKeyboardImpl = void 0;
+var bidi = _interopRequireWildcard(require("./third_party/bidiProtocol"));
+var _bidiKeyboard = require("./third_party/bidiKeyboard");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * 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 RawKeyboardImpl {
+  constructor(session) {
+    this._session = void 0;
+    this._session = session;
+  }
+  setSession(session) {
+    this._session = session;
+  }
+  async keydown(modifiers, code, keyCode, keyCodeWithoutLocation, key, location, autoRepeat, text) {
+    const actions = [];
+    actions.push({
+      type: 'keyDown',
+      value: (0, _bidiKeyboard.getBidiKeyValue)(key)
+    });
+    // TODO: add modifiers?
+    await this._performActions(actions);
+  }
+  async keyup(modifiers, code, keyCode, keyCodeWithoutLocation, key, location) {
+    const actions = [];
+    actions.push({
+      type: 'keyUp',
+      value: (0, _bidiKeyboard.getBidiKeyValue)(key)
+    });
+    await this._performActions(actions);
+  }
+  async sendText(text) {
+    const actions = [];
+    for (const char of text) {
+      const value = (0, _bidiKeyboard.getBidiKeyValue)(char);
+      actions.push({
+        type: 'keyDown',
+        value
+      });
+      actions.push({
+        type: 'keyUp',
+        value
+      });
+    }
+    await this._performActions(actions);
+  }
+  async _performActions(actions) {
+    await this._session.send('input.performActions', {
+      context: this._session.sessionId,
+      actions: [{
+        type: 'key',
+        id: 'pw_keyboard',
+        actions
+      }]
+    });
+  }
+}
+exports.RawKeyboardImpl = RawKeyboardImpl;
+class RawMouseImpl {
+  constructor(session) {
+    this._session = void 0;
+    this._session = session;
+  }
+  async move(x, y, button, buttons, modifiers, forClick) {
+    // Bidi throws when x/y are not integers.
+    x = Math.round(x);
+    y = Math.round(y);
+    await this._performActions([{
+      type: 'pointerMove',
+      x,
+      y
+    }]);
+  }
+  async down(x, y, button, buttons, modifiers, clickCount) {
+    await this._performActions([{
+      type: 'pointerDown',
+      button: toBidiButton(button)
+    }]);
+  }
+  async up(x, y, button, buttons, modifiers, clickCount) {
+    await this._performActions([{
+      type: 'pointerUp',
+      button: toBidiButton(button)
+    }]);
+  }
+  async wheel(x, y, buttons, modifiers, deltaX, deltaY) {
+    // Bidi throws when x/y are not integers.
+    x = Math.round(x);
+    y = Math.round(y);
+    await this._session.send('input.performActions', {
+      context: this._session.sessionId,
+      actions: [{
+        type: 'wheel',
+        id: 'pw_mouse_wheel',
+        actions: [{
+          type: 'scroll',
+          x,
+          y,
+          deltaX,
+          deltaY
+        }]
+      }]
+    });
+  }
+  async _performActions(actions) {
+    await this._session.send('input.performActions', {
+      context: this._session.sessionId,
+      actions: [{
+        type: 'pointer',
+        id: 'pw_mouse',
+        parameters: {
+          pointerType: bidi.Input.PointerType.Mouse
+        },
+        actions
+      }]
+    });
+  }
+}
+exports.RawMouseImpl = RawMouseImpl;
+class RawTouchscreenImpl {
+  constructor(session) {
+    this._session = void 0;
+    this._session = session;
+  }
+  async tap(x, y, modifiers) {}
+}
+exports.RawTouchscreenImpl = RawTouchscreenImpl;
+function toBidiButton(button) {
+  switch (button) {
+    case 'left':
+      return 0;
+    case 'right':
+      return 2;
+    case 'middle':
+      return 1;
+  }
+  throw new Error('Unknown button: ' + button);
+}