rebrowser-playwright-core 1.49.0 → 1.52.0

package/lib/server/javascript.js

@@ -1,47 +1,61 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var javascript_exports = {};
+__export(javascript_exports, {
+  ExecutionContext: () => ExecutionContext,
+  JSHandle: () => JSHandle,
+  JavaScriptErrorInEvaluate: () => JavaScriptErrorInEvaluate,
+  evaluate: () => evaluate,
+  evaluateExpression: () => evaluateExpression,
+  isJavaScriptErrorInEvaluate: () => isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression: () => normalizeEvaluationExpression,
+  parseEvaluationResultValue: () => parseEvaluationResultValue,
+  parseUnserializableValue: () => parseUnserializableValue,
+  serializeAsCallArgument: () => serializeAsCallArgument,
+  sparseArrayToString: () => sparseArrayToString
 });
-exports.JavaScriptErrorInEvaluate = exports.JSHandle = exports.ExecutionContext = void 0;
-exports.evaluate = evaluate;
-exports.evaluateExpression = evaluateExpression;
-exports.isJavaScriptErrorInEvaluate = isJavaScriptErrorInEvaluate;
-exports.normalizeEvaluationExpression = normalizeEvaluationExpression;
-exports.parseUnserializableValue = parseUnserializableValue;
-exports.sparseArrayToString = sparseArrayToString;
-var utilityScriptSource = _interopRequireWildcard(require("../generated/utilityScriptSource"));
-var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
-var _instrumentation = require("./instrumentation");
-var _manualPromise = require("../utils/manualPromise");
-var _utils = require("../utils");
-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 ExecutionContext extends _instrumentation.SdkObject {
+module.exports = __toCommonJS(javascript_exports);
+var import_instrumentation = require("./instrumentation");
+var utilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
+var import_utils = require("../utils");
+var import_builtins = require("../utils/isomorphic/builtins");
+var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+const utilityScriptSerializers = (0, import_utilityScriptSerializers.source)((0, import_builtins.builtins)());
+const parseEvaluationResultValue = utilityScriptSerializers.parseEvaluationResultValue;
+const serializeAsCallArgument = utilityScriptSerializers.serializeAsCallArgument;
+class ExecutionContext extends import_instrumentation.SdkObject {
   constructor(parent, delegate, worldNameForTest) {
-    super(parent, 'execution-context');
-    this._delegate = void 0;
-    this._utilityScriptPromise = void 0;
-    this._contextDestroyedScope = new _manualPromise.LongStandingScope();
-    this.worldNameForTest = void 0;
+    super(parent, "execution-context");
+    this._contextDestroyedScope = new import_manualPromise.LongStandingScope();
     this.worldNameForTest = worldNameForTest;
-    this._delegate = delegate;
+    this.delegate = delegate;
   }
   contextDestroyed(reason) {
     this._contextDestroyedScope.close(new Error(reason));
@@ -50,90 +64,76 @@ class ExecutionContext extends _instrumentation.SdkObject {
     return this._contextDestroyedScope.race(promise);
   }
   rawEvaluateJSON(expression) {
-    return this._raceAgainstContextDestroyed(this._delegate.rawEvaluateJSON(expression));
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateJSON(expression));
   }
   rawEvaluateHandle(expression) {
-    return this._raceAgainstContextDestroyed(this._delegate.rawEvaluateHandle(expression));
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, expression));
   }
-  evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds) {
-    return this._raceAgainstContextDestroyed(this._delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds));
+  async evaluateWithArguments(expression, returnByValue, values, handles) {
+    const utilityScript = await this._utilityScript();
+    return this._raceAgainstContextDestroyed(this.delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, handles));
   }
-  getProperties(context, objectId) {
-    return this._raceAgainstContextDestroyed(this._delegate.getProperties(context, objectId));
+  getProperties(object) {
+    return this._raceAgainstContextDestroyed(this.delegate.getProperties(object));
   }
-  createHandle(remoteObject) {
-    return this._delegate.createHandle(this, remoteObject);
-  }
-  releaseHandle(objectId) {
-    return this._delegate.releaseHandle(objectId);
+  releaseHandle(handle) {
+    return this.delegate.releaseHandle(handle);
   }
   adoptIfNeeded(handle) {
     return null;
   }
-  utilityScript() {
+  _utilityScript() {
     if (!this._utilityScriptPromise) {
-      const source = `
+      const source2 = `
       (() => {
         const module = {};
         ${utilityScriptSource.source}
-        return new (module.exports.UtilityScript())(${(0, _utils.isUnderTest)()});
+        return new (module.exports.UtilityScript())(${(0, import_utils.isUnderTest)()});
       })();`;
-      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this._delegate.rawEvaluateHandle(source).then(objectId => new JSHandle(this, 'object', 'UtilityScript', objectId)));
+      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source2)).then((handle) => {
+        handle._setPreview("UtilityScript");
+        return handle;
+      });
     }
     return this._utilityScriptPromise;
   }
   async doSlowMo() {
-    // overridden in FrameExecutionContext
   }
 }
-exports.ExecutionContext = ExecutionContext;
-class JSHandle extends _instrumentation.SdkObject {
+class JSHandle extends import_instrumentation.SdkObject {
   constructor(context, type, preview, objectId, value) {
-    super(context, 'handle');
+    super(context, "handle");
     this.__jshandle = true;
-    this._context = void 0;
     this._disposed = false;
-    this._objectId = void 0;
-    this._value = void 0;
-    this._objectType = void 0;
-    this._preview = void 0;
-    this._previewCallback = void 0;
     this._context = context;
     this._objectId = objectId;
     this._value = value;
     this._objectType = type;
     this._preview = this._objectId ? preview || `JSHandle@${this._objectType}` : String(value);
-    if (this._objectId && globalThis.leakedJSHandles) globalThis.leakedJSHandles.set(this, new Error('Leaked JSHandle'));
+    if (this._objectId && globalThis.leakedJSHandles)
+      globalThis.leakedJSHandles.set(this, new Error("Leaked JSHandle"));
   }
   async evaluate(pageFunction, arg) {
-    return evaluate(this._context, true /* returnByValue */, pageFunction, this, arg);
+    return evaluate(this._context, true, pageFunction, this, arg);
   }
   async evaluateHandle(pageFunction, arg) {
-    return evaluate(this._context, false /* returnByValue */, pageFunction, this, arg);
+    return evaluate(this._context, false, pageFunction, this, arg);
   }
   async evaluateExpression(expression, options, arg) {
-    const value = await evaluateExpression(this._context, expression, {
-      ...options,
-      returnByValue: true
-    }, this, arg);
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
     await this._context.doSlowMo();
     return value;
   }
   async evaluateExpressionHandle(expression, options, arg) {
-    const value = await evaluateExpression(this._context, expression, {
-      ...options,
-      returnByValue: false
-    }, this, arg);
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
     await this._context.doSlowMo();
     return value;
   }
   async getProperty(propertyName) {
-    const objectHandle = await this.evaluateHandle((object, propertyName) => {
-      const result = {
-        __proto__: null
-      };
-      result[propertyName] = object[propertyName];
-      return result;
+    const objectHandle = await this.evaluateHandle((object, propertyName2) => {
+      const result2 = { __proto__: null };
+      result2[propertyName2] = object[propertyName2];
+      return result2;
     }, propertyName);
     const properties = await objectHandle.getProperties();
     const result = properties.get(propertyName);
@@ -141,27 +141,31 @@ class JSHandle extends _instrumentation.SdkObject {
     return result;
   }
   async getProperties() {
-    if (!this._objectId) return new Map();
-    return this._context.getProperties(this._context, this._objectId);
+    if (!this._objectId)
+      return /* @__PURE__ */ new Map();
+    return this._context.getProperties(this);
   }
   rawValue() {
     return this._value;
   }
   async jsonValue() {
-    if (!this._objectId) return this._value;
-    const utilityScript = await this._context.utilityScript();
+    if (!this._objectId)
+      return this._value;
     const script = `(utilityScript, ...args) => utilityScript.jsonValue(...args)`;
-    return this._context.evaluateWithArguments(script, true, utilityScript, [true], [this._objectId]);
+    return this._context.evaluateWithArguments(script, true, [true], [this]);
   }
   asElement() {
     return null;
   }
   dispose() {
-    if (this._disposed) return;
+    if (this._disposed)
+      return;
     this._disposed = true;
     if (this._objectId) {
-      this._context.releaseHandle(this._objectId).catch(e => {});
-      if (globalThis.leakedJSHandles) globalThis.leakedJSHandles.delete(this);
+      this._context.releaseHandle(this).catch((e) => {
+      });
+      if (globalThis.leakedJSHandles)
+        globalThis.leakedJSHandles.delete(this);
     }
   }
   toString() {
@@ -178,116 +182,118 @@ class JSHandle extends _instrumentation.SdkObject {
   }
   _setPreview(preview) {
     this._preview = preview;
-    if (this._previewCallback) this._previewCallback(preview);
+    if (this._previewCallback)
+      this._previewCallback(preview);
   }
 }
-exports.JSHandle = JSHandle;
 async function evaluate(context, returnByValue, pageFunction, ...args) {
-  return evaluateExpression(context, String(pageFunction), {
-    returnByValue,
-    isFunction: typeof pageFunction === 'function'
-  }, ...args);
+  return evaluateExpression(context, String(pageFunction), { returnByValue, isFunction: typeof pageFunction === "function" }, ...args);
 }
 async function evaluateExpression(context, expression, options, ...args) {
-  const utilityScript = await context.utilityScript();
   expression = normalizeEvaluationExpression(expression, options.isFunction);
   const handles = [];
   const toDispose = [];
-  const pushHandle = handle => {
+  const pushHandle = (handle) => {
     handles.push(handle);
     return handles.length - 1;
   };
-  args = args.map(arg => (0, _utilityScriptSerializers.serializeAsCallArgument)(arg, handle => {
+  args = args.map((arg) => serializeAsCallArgument(arg, (handle) => {
     if (handle instanceof JSHandle) {
-      if (!handle._objectId) return {
-        fallThrough: handle._value
-      };
-      if (handle._disposed) throw new JavaScriptErrorInEvaluate('JSHandle is disposed!');
+      if (!handle._objectId)
+        return { fallThrough: handle._value };
+      if (handle._disposed)
+        throw new JavaScriptErrorInEvaluate("JSHandle is disposed!");
       const adopted = context.adoptIfNeeded(handle);
-      if (adopted === null) return {
-        h: pushHandle(Promise.resolve(handle))
-      };
+      if (adopted === null)
+        return { h: pushHandle(Promise.resolve(handle)) };
       toDispose.push(adopted);
-      return {
-        h: pushHandle(adopted)
-      };
+      return { h: pushHandle(adopted) };
     }
-    return {
-      fallThrough: handle
-    };
+    return { fallThrough: handle };
   }));
-  const utilityScriptObjectIds = [];
+  const utilityScriptObjects = [];
   for (const handle of await Promise.all(handles)) {
-    if (handle._context !== context) throw new JavaScriptErrorInEvaluate('JSHandles can be evaluated only in the context they were created!');
-    utilityScriptObjectIds.push(handle._objectId);
+    if (handle._context !== context)
+      throw new JavaScriptErrorInEvaluate("JSHandles can be evaluated only in the context they were created!");
+    utilityScriptObjects.push(handle);
   }
-
-  // See UtilityScript for arguments.
   const utilityScriptValues = [options.isFunction, options.returnByValue, expression, args.length, ...args];
   const script = `(utilityScript, ...args) => utilityScript.evaluate(...args)`;
   try {
-    return await context.evaluateWithArguments(script, options.returnByValue || false, utilityScript, utilityScriptValues, utilityScriptObjectIds);
+    return await context.evaluateWithArguments(script, options.returnByValue || false, utilityScriptValues, utilityScriptObjects);
   } finally {
-    toDispose.map(handlePromise => handlePromise.then(handle => handle.dispose()));
+    toDispose.map((handlePromise) => handlePromise.then((handle) => handle.dispose()));
   }
 }
 function parseUnserializableValue(unserializableValue) {
-  if (unserializableValue === 'NaN') return NaN;
-  if (unserializableValue === 'Infinity') return Infinity;
-  if (unserializableValue === '-Infinity') return -Infinity;
-  if (unserializableValue === '-0') return -0;
+  if (unserializableValue === "NaN")
+    return NaN;
+  if (unserializableValue === "Infinity")
+    return Infinity;
+  if (unserializableValue === "-Infinity")
+    return -Infinity;
+  if (unserializableValue === "-0")
+    return -0;
 }
 function normalizeEvaluationExpression(expression, isFunction) {
   expression = expression.trim();
   if (isFunction) {
     try {
-      new Function('(' + expression + ')');
+      new Function("(" + expression + ")");
     } catch (e1) {
-      // This means we might have a function shorthand. Try another
-      // time prefixing 'function '.
-      if (expression.startsWith('async ')) expression = 'async function ' + expression.substring('async '.length);else expression = 'function ' + expression;
+      if (expression.startsWith("async "))
+        expression = "async function " + expression.substring("async ".length);
+      else
+        expression = "function " + expression;
       try {
-        new Function('(' + expression + ')');
+        new Function("(" + expression + ")");
       } catch (e2) {
-        // We tried hard to serialize, but there's a weird beast here.
-        throw new Error('Passed function is not well-serializable!');
+        throw new Error("Passed function is not well-serializable!");
       }
     }
   }
-  if (/^(async)?\s*function(\s|\()/.test(expression)) expression = '(' + expression + ')';
+  if (/^(async)?\s*function(\s|\()/.test(expression))
+    expression = "(" + expression + ")";
   return expression;
 }
-
-// Error inside the expression evaluation as opposed to a protocol error.
-class JavaScriptErrorInEvaluate extends Error {}
-exports.JavaScriptErrorInEvaluate = JavaScriptErrorInEvaluate;
+class JavaScriptErrorInEvaluate extends Error {
+}
 function isJavaScriptErrorInEvaluate(error) {
   return error instanceof JavaScriptErrorInEvaluate;
 }
 function sparseArrayToString(entries) {
   const arrayEntries = [];
-  for (const {
-    name,
-    value
-  } of entries) {
+  for (const { name, value } of entries) {
     const index = +name;
-    if (isNaN(index) || index < 0) continue;
-    arrayEntries.push({
-      index,
-      value
-    });
+    if (isNaN(index) || index < 0)
+      continue;
+    arrayEntries.push({ index, value });
   }
   arrayEntries.sort((a, b) => a.index - b.index);
   let lastIndex = -1;
   const tokens = [];
-  for (const {
-    index,
-    value
-  } of arrayEntries) {
+  for (const { index, value } of arrayEntries) {
     const emptyItems = index - lastIndex - 1;
-    if (emptyItems === 1) tokens.push(`empty`);else if (emptyItems > 1) tokens.push(`empty x ${emptyItems}`);
+    if (emptyItems === 1)
+      tokens.push(`empty`);
+    else if (emptyItems > 1)
+      tokens.push(`empty x ${emptyItems}`);
     tokens.push(String(value));
     lastIndex = index;
   }
-  return '[' + tokens.join(', ') + ']';
-}
+  return "[" + tokens.join(", ") + "]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExecutionContext,
+  JSHandle,
+  JavaScriptErrorInEvaluate,
+  evaluate,
+  evaluateExpression,
+  isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression,
+  parseEvaluationResultValue,
+  parseUnserializableValue,
+  serializeAsCallArgument,
+  sparseArrayToString
+});

package/lib/server/launchApp.js

@@ -1,91 +1,110 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var launchApp_exports = {};
+__export(launchApp_exports, {
+  launchApp: () => launchApp,
+  syncLocalStorageWithSettings: () => syncLocalStorageWithSettings
 });
-exports.launchApp = launchApp;
-exports.syncLocalStorageWithSettings = syncLocalStorageWithSettings;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-var _registry = require("./registry");
-var _utils = require("../utils");
-var _instrumentation = require("./instrumentation");
-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.
- */
-
+module.exports = __toCommonJS(launchApp_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils");
+var import_instrumentation = require("./instrumentation");
+var import_registry = require("./registry");
+var import_registry2 = require("./registry");
 async function launchApp(browserType, options) {
-  var _options$persistentCo, _options$persistentCo2, _options$persistentCo3;
-  const args = [...((_options$persistentCo = (_options$persistentCo2 = options.persistentContextOptions) === null || _options$persistentCo2 === void 0 ? void 0 : _options$persistentCo2.args) !== null && _options$persistentCo !== void 0 ? _options$persistentCo : [])];
-  if (browserType.name() === 'chromium') {
-    args.push('--app=data:text/html,', `--window-size=${options.windowSize.width},${options.windowSize.height}`, ...(options.windowPosition ? [`--window-position=${options.windowPosition.x},${options.windowPosition.y}`] : []), '--test-type=');
+  const args = [...options.persistentContextOptions?.args ?? []];
+  let channel = options.persistentContextOptions?.channel;
+  if (browserType.name() === "chromium") {
+    args.push(
+      "--app=data:text/html,",
+      `--window-size=${options.windowSize.width},${options.windowSize.height}`,
+      ...options.windowPosition ? [`--window-position=${options.windowPosition.x},${options.windowPosition.y}`] : [],
+      "--test-type="
+    );
+    if (!channel && !options.persistentContextOptions?.executablePath)
+      channel = (0, import_registry.findChromiumChannel)(options.sdkLanguage);
   }
-  const context = await browserType.launchPersistentContext((0, _instrumentation.serverSideCallMetadata)(), '', {
-    channel: !((_options$persistentCo3 = options.persistentContextOptions) !== null && _options$persistentCo3 !== void 0 && _options$persistentCo3.executablePath) ? (0, _registry.findChromiumChannel)(options.sdkLanguage) : undefined,
-    noDefaultViewport: true,
-    ignoreDefaultArgs: ['--enable-automation'],
-    colorScheme: 'no-override',
-    acceptDownloads: (0, _utils.isUnderTest)() ? 'accept' : 'internal-browser-default',
-    ...(options === null || options === void 0 ? void 0 : options.persistentContextOptions),
+  const context = await browserType.launchPersistentContext((0, import_instrumentation.serverSideCallMetadata)(), "", {
+    ignoreDefaultArgs: ["--enable-automation"],
+    ...options?.persistentContextOptions,
+    channel,
+    noDefaultViewport: options.persistentContextOptions?.noDefaultViewport ?? true,
+    acceptDownloads: options?.persistentContextOptions?.acceptDownloads ?? ((0, import_utils.isUnderTest)() ? "accept" : "internal-browser-default"),
+    colorScheme: options?.persistentContextOptions?.colorScheme ?? "no-override",
     args
   });
   const [page] = context.pages();
-  // Chromium on macOS opens a new tab when clicking on the dock icon.
-  // See https://github.com/microsoft/playwright/issues/9434
-  if (browserType.name() === 'chromium' && process.platform === 'darwin') {
-    context.on('page', async newPage => {
-      if (newPage.mainFrame().url() === 'chrome://new-tab-page/') {
+  if (browserType.name() === "chromium" && process.platform === "darwin") {
+    context.on("page", async (newPage) => {
+      if (newPage.mainFrame().url() === "chrome://new-tab-page/") {
         await page.bringToFront();
-        await newPage.close((0, _instrumentation.serverSideCallMetadata)());
+        await newPage.close((0, import_instrumentation.serverSideCallMetadata)());
       }
     });
   }
-  if (browserType.name() === 'chromium') await installAppIcon(page);
-  return {
-    context,
-    page
-  };
+  if (browserType.name() === "chromium")
+    await installAppIcon(page);
+  return { context, page };
 }
 async function installAppIcon(page) {
-  const icon = await _fs.default.promises.readFile(require.resolve('./chromium/appIcon.png'));
+  const icon = await import_fs.default.promises.readFile(require.resolve("./chromium/appIcon.png"));
   const crPage = page._delegate;
-  await crPage._mainFrameSession._client.send('Browser.setDockTile', {
-    image: icon.toString('base64')
+  await crPage._mainFrameSession._client.send("Browser.setDockTile", {
+    image: icon.toString("base64")
   });
 }
 async function syncLocalStorageWithSettings(page, appName) {
-  if ((0, _utils.isUnderTest)()) return;
-  const settingsFile = _path.default.join(_registry.registryDirectory, '.settings', `${appName}.json`);
-  await page.exposeBinding('_saveSerializedSettings', false, (_, settings) => {
-    _fs.default.mkdirSync(_path.default.dirname(settingsFile), {
-      recursive: true
-    });
-    _fs.default.writeFileSync(settingsFile, settings);
+  if ((0, import_utils.isUnderTest)())
+    return;
+  const settingsFile = import_path.default.join(import_registry2.registryDirectory, ".settings", `${appName}.json`);
+  await page.exposeBinding("_saveSerializedSettings", false, (_, settings2) => {
+    import_fs.default.mkdirSync(import_path.default.dirname(settingsFile), { recursive: true });
+    import_fs.default.writeFileSync(settingsFile, settings2);
   });
-  const settings = await _fs.default.promises.readFile(settingsFile, 'utf-8').catch(() => '{}');
-  await page.addInitScript(`(${String(settings => {
-    // iframes w/ snapshots, etc.
-    if (location && location.protocol === 'data:') return;
-    if (window.top !== window) return;
-    Object.entries(settings).map(([k, v]) => localStorage[k] = v);
-    window.saveSettings = () => {
-      window._saveSerializedSettings(JSON.stringify({
-        ...localStorage
-      }));
-    };
-  })})(${settings});
-  `);
-}
+  const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
+  await page.addInitScript(
+    `(${String((settings2) => {
+      if (location && location.protocol === "data:")
+        return;
+      if (window.top !== window)
+        return;
+      Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
+      window.saveSettings = () => {
+        window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+      };
+    })})(${settings});
+  `
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchApp,
+  syncLocalStorageWithSettings
+});