patchright-core 1.48.2

package/lib/server/chromium/videoRecorder.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VideoRecorder = void 0;
+var _utils = require("../../utils");
+var _page = require("../page");
+var _processLauncher = require("../../utils/processLauncher");
+var _progress = require("../progress");
+var _instrumentation = require("../instrumentation");
+/**
+ * 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.
+ */
+
+const fps = 25;
+class VideoRecorder {
+  static async launch(page, ffmpegPath, options) {
+    if (!options.outputFile.endsWith('.webm')) throw new Error('File must have .webm extension');
+    const controller = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), page);
+    controller.setLogName('browser');
+    return await controller.run(async progress => {
+      const recorder = new VideoRecorder(page, ffmpegPath, progress);
+      await recorder._launch(options);
+      return recorder;
+    });
+  }
+  constructor(page, ffmpegPath, progress) {
+    this._process = null;
+    this._gracefullyClose = null;
+    this._lastWritePromise = Promise.resolve();
+    this._lastFrameTimestamp = 0;
+    this._lastFrameBuffer = null;
+    this._lastWriteTimestamp = 0;
+    this._progress = void 0;
+    this._frameQueue = [];
+    this._isStopped = false;
+    this._ffmpegPath = void 0;
+    this._progress = progress;
+    this._ffmpegPath = ffmpegPath;
+    page.on(_page.Page.Events.ScreencastFrame, frame => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1000));
+  }
+  async _launch(options) {
+    // How to tune the codec:
+    // 1. Read vp8 documentation to figure out the options.
+    //   https://www.webmproject.org/docs/encoder-parameters/
+    // 2. Use the following command to map the options to ffmpeg arguments.
+    //   $ ./third_party/ffmpeg/ffmpeg-mac -h encoder=vp8
+    // 3. A bit more about passing vp8 options to ffmpeg.
+    //   https://trac.ffmpeg.org/wiki/Encode/VP8
+    // 4. Tuning for VP9:
+    //   https://developers.google.com/media/vp9/live-encoding
+    //
+    // How to stress-test video recording (runs 10 recorders in parallel to book all cpus available):
+    //   $ node ./utils/video_stress.js
+    //
+    // We use the following vp8 options:
+    //   "-qmin 0 -qmax 50" - quality variation from 0 to 50.
+    //     Suggested here: https://trac.ffmpeg.org/wiki/Encode/VP8
+    //   "-crf 8" - constant quality mode, 4-63, lower means better quality.
+    //   "-deadline realtime -speed 8" - do not use too much cpu to keep up with incoming frames.
+    //   "-b:v 1M" - video bitrate. Default value is too low for vp8
+    //     Suggested here: https://trac.ffmpeg.org/wiki/Encode/VP8
+    //   Note that we can switch to "-qmin 20 -qmax 50 -crf 30" for smaller video size but worse quality.
+    //
+    // We use "pad" and "crop" video filters (-vf option) to resize incoming frames
+    // that might be of the different size to the desired video size.
+    //   https://ffmpeg.org/ffmpeg-filters.html#pad-1
+    //   https://ffmpeg.org/ffmpeg-filters.html#crop
+    //
+    // We use "image2pipe" mode to pipe frames and get a single video - https://trac.ffmpeg.org/wiki/Slideshow
+    //   "-f image2pipe -c:v mjpeg -i -" forces input to be read from standard input, and forces
+    //     mjpeg input image format.
+    //   "-avioflags direct" reduces general buffering.
+    //   "-fpsprobesize 0 -probesize 32 -analyzeduration 0" reduces initial buffering
+    //     while analyzing input fps and other stats.
+    //
+    // "-y" means overwrite output.
+    // "-an" means no audio.
+    // "-threads 1" means using one thread. This drastically reduces stalling when
+    //   cpu is overbooked. By default vp8 tries to use all available threads?
+
+    const w = options.width;
+    const h = options.height;
+    const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(' ');
+    args.push(options.outputFile);
+    const progress = this._progress;
+    const {
+      launchedProcess,
+      gracefullyClose
+    } = await (0, _processLauncher.launchProcess)({
+      command: this._ffmpegPath,
+      args,
+      stdio: 'stdin',
+      log: message => progress.log(message),
+      tempDirectories: [],
+      attemptToGracefullyClose: async () => {
+        progress.log('Closing stdin...');
+        launchedProcess.stdin.end();
+      },
+      onExit: (exitCode, signal) => {
+        progress.log(`ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
+      }
+    });
+    launchedProcess.stdin.on('finish', () => {
+      progress.log('ffmpeg finished input.');
+    });
+    launchedProcess.stdin.on('error', () => {
+      progress.log('ffmpeg error.');
+    });
+    this._process = launchedProcess;
+    this._gracefullyClose = gracefullyClose;
+  }
+  writeFrame(frame, timestamp) {
+    (0, _utils.assert)(this._process);
+    if (this._isStopped) return;
+    if (this._lastFrameBuffer) {
+      const durationSec = timestamp - this._lastFrameTimestamp;
+      const repeatCount = Math.max(1, Math.round(fps * durationSec));
+      for (let i = 0; i < repeatCount; ++i) this._frameQueue.push(this._lastFrameBuffer);
+      this._lastWritePromise = this._lastWritePromise.then(() => this._sendFrames());
+    }
+    this._lastFrameBuffer = frame;
+    this._lastFrameTimestamp = timestamp;
+    this._lastWriteTimestamp = (0, _utils.monotonicTime)();
+  }
+  async _sendFrames() {
+    while (this._frameQueue.length) await this._sendFrame(this._frameQueue.shift());
+  }
+  async _sendFrame(frame) {
+    return new Promise(f => this._process.stdin.write(frame, f)).then(error => {
+      if (error) this._progress.log(`ffmpeg failed to write: ${String(error)}`);
+    });
+  }
+  async stop() {
+    if (this._isStopped) return;
+    this.writeFrame(Buffer.from([]), this._lastFrameTimestamp + ((0, _utils.monotonicTime)() - this._lastWriteTimestamp) / 1000);
+    this._isStopped = true;
+    await this._lastWritePromise;
+    await this._gracefullyClose();
+  }
+}
+exports.VideoRecorder = VideoRecorder;

package/lib/server/clock.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Clock = void 0;
+var clockSource = _interopRequireWildcard(require("../generated/clockSource"));
+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 Clock {
+  constructor(browserContext) {
+    this._browserContext = void 0;
+    this._scriptInstalled = false;
+    this._browserContext = browserContext;
+  }
+  markAsUninstalled() {
+    this._scriptInstalled = false;
+  }
+  async fastForward(ticks) {
+    await this._installIfNeeded();
+    const ticksMillis = parseTicks(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
+  }
+  async install(time) {
+    await this._installIfNeeded();
+    const timeMillis = time !== undefined ? parseTime(time) : Date.now();
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
+  }
+  async pauseAt(ticks) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
+  }
+  async resume() {
+    await this._installIfNeeded();
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
+  }
+  async setFixedTime(time) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(time);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
+  }
+  async setSystemTime(time) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(time);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
+  }
+  async runFor(ticks) {
+    await this._installIfNeeded();
+    const ticksMillis = parseTicks(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
+  }
+  async _installIfNeeded() {
+    if (this._scriptInstalled) return;
+    this._scriptInstalled = true;
+    const script = `(() => {
+      const module = {};
+      ${clockSource.source}
+      globalThis.__pwClock = (module.exports.inject())(globalThis);
+    })();`;
+    await this._browserContext.addInitScript(script);
+    await this._evaluateInFrames(script);
+  }
+  async _evaluateInFrames(script) {
+    // Dont ask me why this works
+    await Promise.all(this._browserContext.pages().map(async page => {
+      await Promise.all(page.frames().map(async frame => {
+        try {
+          await frame.evaluateExpression("");
+        } catch (e) {}
+      }));
+    }));
+    await this._browserContext.safeNonStallingEvaluateInAllFrames(script, 'main', {
+      throwOnJSErrors: true
+    });
+  }
+}
+
+/**
+ * Parse strings like '01:10:00' (meaning 1 hour, 10 minutes, 0 seconds) into
+ * number of milliseconds. This is used to support human-readable strings passed
+ * to clock.tick()
+ */
+exports.Clock = Clock;
+function parseTicks(value) {
+  if (typeof value === 'number') return value;
+  if (!value) return 0;
+  const str = value;
+  const strings = str.split(':');
+  const l = strings.length;
+  let i = l;
+  let ms = 0;
+  let parsed;
+  if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+    throw new Error(`Clock only understands numbers, 'mm:ss' and 'hh:mm:ss'`);
+  }
+  while (i--) {
+    parsed = parseInt(strings[i], 10);
+    if (parsed >= 60) throw new Error(`Invalid time ${str}`);
+    ms += parsed * Math.pow(60, l - i - 1);
+  }
+  return ms * 1000;
+}
+function parseTime(epoch) {
+  if (!epoch) return 0;
+  if (typeof epoch === 'number') return epoch;
+  const parsed = new Date(epoch);
+  if (!isFinite(parsed.getTime())) throw new Error(`Invalid date: ${epoch}`);
+  return parsed.getTime();
+}

package/lib/server/codegen/csharp.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CSharpLanguageGenerator = void 0;
+var _language = require("./language");
+var _utils = require("../../utils");
+var _deviceDescriptors = require("../deviceDescriptors");
+/**
+ * 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 CSharpLanguageGenerator {
+  constructor(mode) {
+    this.id = void 0;
+    this.groupName = '.NET C#';
+    this.name = void 0;
+    this.highlighter = 'csharp';
+    this._mode = void 0;
+    if (mode === 'library') {
+      this.name = 'Library';
+      this.id = 'csharp';
+    } else if (mode === 'mstest') {
+      this.name = 'MSTest';
+      this.id = 'csharp-mstest';
+    } else if (mode === 'nunit') {
+      this.name = 'NUnit';
+      this.id = 'csharp-nunit';
+    } else {
+      throw new Error(`Unknown C# language mode: ${mode}`);
+    }
+    this._mode = mode;
+  }
+  generateAction(actionInContext) {
+    const action = this._generateActionInner(actionInContext);
+    if (action) return action;
+    return '';
+  }
+  _generateActionInner(actionInContext) {
+    const action = actionInContext.action;
+    if (this._mode !== 'library' && (action.name === 'openPage' || action.name === 'closePage')) return '';
+    let pageAlias = actionInContext.frame.pageAlias;
+    if (this._mode !== 'library') pageAlias = pageAlias.replace('page', 'Page');
+    const formatter = new CSharpFormatter(this._mode === 'library' ? 0 : 8);
+    if (action.name === 'openPage') {
+      formatter.add(`var ${pageAlias} = await context.NewPageAsync();`);
+      if (action.url && action.url !== 'about:blank' && action.url !== 'chrome://newtab/') formatter.add(`await ${pageAlias}.GotoAsync(${quote(action.url)});`);
+      return formatter.format();
+    }
+    const locators = actionInContext.frame.framePath.map(selector => `.${this._asLocator(selector)}.ContentFrame`);
+    const subject = `${pageAlias}${locators.join('')}`;
+    const signals = (0, _language.toSignalMap)(action);
+    if (signals.dialog) {
+      formatter.add(`    void ${pageAlias}_Dialog${signals.dialog.dialogAlias}_EventHandler(object sender, IDialog dialog)
+      {
+          Console.WriteLine($"Dialog message: {dialog.Message}");
+          dialog.DismissAsync();
+          ${pageAlias}.Dialog -= ${pageAlias}_Dialog${signals.dialog.dialogAlias}_EventHandler;
+      }
+      ${pageAlias}.Dialog += ${pageAlias}_Dialog${signals.dialog.dialogAlias}_EventHandler;`);
+    }
+    const lines = [];
+    lines.push(this._generateActionCall(subject, actionInContext));
+    if (signals.download) {
+      lines.unshift(`var download${signals.download.downloadAlias} = await ${pageAlias}.RunAndWaitForDownloadAsync(async () =>\n{`);
+      lines.push(`});`);
+    }
+    if (signals.popup) {
+      lines.unshift(`var ${signals.popup.popupAlias} = await ${pageAlias}.RunAndWaitForPopupAsync(async () =>\n{`);
+      lines.push(`});`);
+    }
+    for (const line of lines) formatter.add(line);
+    return formatter.format();
+  }
+  _generateActionCall(subject, actionInContext) {
+    const action = actionInContext.action;
+    switch (action.name) {
+      case 'openPage':
+        throw Error('Not reached');
+      case 'closePage':
+        return `await ${subject}.CloseAsync();`;
+      case 'click':
+        {
+          let method = 'Click';
+          if (action.clickCount === 2) method = 'DblClick';
+          const options = (0, _language.toClickOptionsForSourceCode)(action);
+          if (!Object.entries(options).length) return `await ${subject}.${this._asLocator(action.selector)}.${method}Async();`;
+          const optionsString = formatObject(options, '    ', 'Locator' + method + 'Options');
+          return `await ${subject}.${this._asLocator(action.selector)}.${method}Async(${optionsString});`;
+        }
+      case 'check':
+        return `await ${subject}.${this._asLocator(action.selector)}.CheckAsync();`;
+      case 'uncheck':
+        return `await ${subject}.${this._asLocator(action.selector)}.UncheckAsync();`;
+      case 'fill':
+        return `await ${subject}.${this._asLocator(action.selector)}.FillAsync(${quote(action.text)});`;
+      case 'setInputFiles':
+        return `await ${subject}.${this._asLocator(action.selector)}.SetInputFilesAsync(${formatObject(action.files)});`;
+      case 'press':
+        {
+          const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
+          const shortcut = [...modifiers, action.key].join('+');
+          return `await ${subject}.${this._asLocator(action.selector)}.PressAsync(${quote(shortcut)});`;
+        }
+      case 'navigate':
+        return `await ${subject}.GotoAsync(${quote(action.url)});`;
+      case 'select':
+        return `await ${subject}.${this._asLocator(action.selector)}.SelectOptionAsync(${formatObject(action.options)});`;
+      case 'assertText':
+        return `await Expect(${subject}.${this._asLocator(action.selector)}).${action.substring ? 'ToContainTextAsync' : 'ToHaveTextAsync'}(${quote(action.text)});`;
+      case 'assertChecked':
+        return `await Expect(${subject}.${this._asLocator(action.selector)})${action.checked ? '' : '.Not'}.ToBeCheckedAsync();`;
+      case 'assertVisible':
+        return `await Expect(${subject}.${this._asLocator(action.selector)}).ToBeVisibleAsync();`;
+      case 'assertValue':
+        {
+          const assertion = action.value ? `ToHaveValueAsync(${quote(action.value)})` : `ToBeEmptyAsync()`;
+          return `await Expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
+        }
+    }
+  }
+  _asLocator(selector) {
+    return (0, _utils.asLocator)('csharp', selector);
+  }
+  generateHeader(options) {
+    if (this._mode === 'library') return this.generateStandaloneHeader(options);
+    return this.generateTestRunnerHeader(options);
+  }
+  generateStandaloneHeader(options) {
+    const formatter = new CSharpFormatter(0);
+    formatter.add(`
+      using Microsoft.Playwright;
+      using System;
+      using System.Threading.Tasks;
+
+      using var playwright = await Playwright.CreateAsync();
+      await using var browser = await playwright.${toPascal(options.browserName)}.LaunchAsync(${formatObject(options.launchOptions, '    ', 'BrowserTypeLaunchOptions')});
+      var context = await browser.NewContextAsync(${formatContextOptions(options.contextOptions, options.deviceName)});`);
+    formatter.newLine();
+    return formatter.format();
+  }
+  generateTestRunnerHeader(options) {
+    const formatter = new CSharpFormatter(0);
+    formatter.add(`
+      using Microsoft.Playwright.${this._mode === 'nunit' ? 'NUnit' : 'MSTest'};
+      using Microsoft.Playwright;
+
+      ${this._mode === 'nunit' ? `[Parallelizable(ParallelScope.Self)]
+      [TestFixture]` : '[TestClass]'}
+      public class Tests : PageTest
+      {`);
+    const formattedContextOptions = formatContextOptions(options.contextOptions, options.deviceName);
+    if (formattedContextOptions) {
+      formatter.add(`public override BrowserNewContextOptions ContextOptions()
+      {
+          return ${formattedContextOptions};
+      }`);
+      formatter.newLine();
+    }
+    formatter.add(`    [${this._mode === 'nunit' ? 'Test' : 'TestMethod'}]
+    public async Task MyTest()
+    {`);
+    return formatter.format();
+  }
+  generateFooter(saveStorage) {
+    const offset = this._mode === 'library' ? '' : '        ';
+    let storageStateLine = saveStorage ? `\n${offset}await context.StorageStateAsync(new BrowserContextStorageStateOptions\n${offset}{\n${offset}    Path = ${quote(saveStorage)}\n${offset}});\n` : '';
+    if (this._mode !== 'library') storageStateLine += `    }\n}\n`;
+    return storageStateLine;
+  }
+}
+exports.CSharpLanguageGenerator = CSharpLanguageGenerator;
+function formatObject(value, indent = '    ', name = '') {
+  if (typeof value === 'string') {
+    if (['permissions', 'colorScheme', 'modifiers', 'button', 'recordHarContent', 'recordHarMode', 'serviceWorkers'].includes(name)) return `${getClassName(name)}.${toPascal(value)}`;
+    return quote(value);
+  }
+  if (Array.isArray(value)) return `new[] { ${value.map(o => formatObject(o, indent, name)).join(', ')} }`;
+  if (typeof value === 'object') {
+    const keys = Object.keys(value).filter(key => value[key] !== undefined).sort();
+    if (!keys.length) return name ? `new ${getClassName(name)}` : '';
+    const tokens = [];
+    for (const key of keys) {
+      const property = getPropertyName(key);
+      tokens.push(`${property} = ${formatObject(value[key], indent, key)},`);
+    }
+    if (name) return `new ${getClassName(name)}\n{\n${indent}${tokens.join(`\n${indent}`)}\n${indent}}`;
+    return `{\n${indent}${tokens.join(`\n${indent}`)}\n${indent}}`;
+  }
+  if (name === 'latitude' || name === 'longitude') return String(value) + 'm';
+  return String(value);
+}
+function getClassName(value) {
+  switch (value) {
+    case 'viewport':
+      return 'ViewportSize';
+    case 'proxy':
+      return 'ProxySettings';
+    case 'permissions':
+      return 'ContextPermission';
+    case 'modifiers':
+      return 'KeyboardModifier';
+    case 'button':
+      return 'MouseButton';
+    case 'recordHarMode':
+      return 'HarMode';
+    case 'recordHarContent':
+      return 'HarContentPolicy';
+    case 'serviceWorkers':
+      return 'ServiceWorkerPolicy';
+    default:
+      return toPascal(value);
+  }
+}
+function getPropertyName(key) {
+  switch (key) {
+    case 'storageState':
+      return 'StorageStatePath';
+    case 'viewport':
+      return 'ViewportSize';
+    default:
+      return toPascal(key);
+  }
+}
+function toPascal(value) {
+  return value[0].toUpperCase() + value.slice(1);
+}
+function convertContextOptions(options) {
+  const result = {
+    ...options
+  };
+  if (options.recordHar) {
+    result['recordHarPath'] = options.recordHar.path;
+    result['recordHarContent'] = options.recordHar.content;
+    result['recordHarMode'] = options.recordHar.mode;
+    result['recordHarOmitContent'] = options.recordHar.omitContent;
+    result['recordHarUrlFilter'] = options.recordHar.urlFilter;
+    delete result.recordHar;
+  }
+  return result;
+}
+function formatContextOptions(options, deviceName) {
+  const device = deviceName && _deviceDescriptors.deviceDescriptors[deviceName];
+  if (!device) {
+    if (!Object.entries(options).length) return '';
+    return formatObject(convertContextOptions(options), '    ', 'BrowserNewContextOptions');
+  }
+  options = (0, _language.sanitizeDeviceOptions)(device, options);
+  if (!Object.entries(options).length) return `playwright.Devices[${quote(deviceName)}]`;
+  return formatObject(convertContextOptions(options), '    ', `BrowserNewContextOptions(playwright.Devices[${quote(deviceName)}])`);
+}
+class CSharpFormatter {
+  constructor(offset = 0) {
+    this._baseIndent = void 0;
+    this._baseOffset = void 0;
+    this._lines = [];
+    this._baseIndent = ' '.repeat(4);
+    this._baseOffset = ' '.repeat(offset);
+  }
+  prepend(text) {
+    this._lines = text.trim().split('\n').map(line => line.trim()).concat(this._lines);
+  }
+  add(text) {
+    this._lines.push(...text.trim().split('\n').map(line => line.trim()));
+  }
+  newLine() {
+    this._lines.push('');
+  }
+  format() {
+    let spaces = '';
+    let previousLine = '';
+    return this._lines.map(line => {
+      if (line === '') return line;
+      if (line.startsWith('}') || line.startsWith(']') || line.includes('});') || line === ');') spaces = spaces.substring(this._baseIndent.length);
+      const extraSpaces = /^(for|while|if).*\(.*\)$/.test(previousLine) ? this._baseIndent : '';
+      previousLine = line;
+      line = spaces + extraSpaces + line;
+      if (line.endsWith('{') || line.endsWith('[') || line.endsWith('(')) spaces += this._baseIndent;
+      if (line.endsWith('));')) spaces = spaces.substring(this._baseIndent.length);
+      return this._baseOffset + line;
+    }).join('\n');
+  }
+}
+function quote(text) {
+  return (0, _utils.escapeWithQuotes)(text, '\"');
+}