"use strict";
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,
  accessBindingsController: () => accessBindingsController,
  accessUtilityScript: () => accessUtilityScript,
  evaluate: () => evaluate,
  evaluateExpression: () => evaluateExpression,
  isJavaScriptErrorInEvaluate: () => isJavaScriptErrorInEvaluate,
  kPlaywrightBinding: () => kPlaywrightBinding,
  kUtilityScriptSource: () => kUtilityScriptSource,
  normalizeEvaluationExpression: () => normalizeEvaluationExpression,
  parseUnserializableValue: () => parseUnserializableValue,
  prepareGeneratedScript: () => prepareGeneratedScript,
  runtimeGuid: () => runtimeGuid,
  sparseArrayToString: () => sparseArrayToString
});
module.exports = __toCommonJS(javascript_exports);
var import_instrumentation = require("./instrumentation");
var rawUtilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
var import_utils = require("../utils");
var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
var import_manualPromise = require("../utils/isomorphic/manualPromise");
const runtimeGuid = (0, import_utils.createGuid)();
function prepareGeneratedScript(source) {
  return source.replaceAll("$runtime_guid$", runtimeGuid).replace("kUtilityScriptIsUnderTest = false", `kUtilityScriptIsUnderTest = ${(0, import_utils.isUnderTest)()}`);
}
const kUtilityScriptSource = prepareGeneratedScript(rawUtilityScriptSource.source);
function accessUtilityScript() {
  return `globalThis['__playwright_utility_script__${runtimeGuid}']`;
}
const kPlaywrightBinding = "__playwright__binding__" + runtimeGuid;
function accessBindingsController() {
  return `globalThis['__playwright__binding__controller__${runtimeGuid}']`;
}
class ExecutionContext extends import_instrumentation.SdkObject {
  constructor(parent, delegate, worldNameForTest) {
    super(parent, "execution-context");
    this._contextDestroyedScope = new import_manualPromise.LongStandingScope();
    this.worldNameForTest = worldNameForTest;
    this.delegate = delegate;
  }
  contextDestroyed(reason) {
    this._contextDestroyedScope.close(new Error(reason));
  }
  async _raceAgainstContextDestroyed(promise) {
    return this._contextDestroyedScope.race(promise);
  }
  rawEvaluateJSON(expression) {
    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateJSON(expression));
  }
  rawEvaluateHandle(expression) {
    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, expression));
  }
  async evaluateWithArguments(expression, returnByValue, values, handles) {
    const utilityScript = await this.utilityScript();
    return this._raceAgainstContextDestroyed(this.delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, handles));
  }
  getProperties(object) {
    return this._raceAgainstContextDestroyed(this.delegate.getProperties(object));
  }
  releaseHandle(handle) {
    return this.delegate.releaseHandle(handle);
  }
  adoptIfNeeded(handle) {
    return null;
  }
  utilityScript() {
    if (!this._utilityScriptPromise) {
      const source = `
      (() => {
        const module = {};
        ${kUtilityScriptSource}
        return (module.exports.ensureUtilityScript())();
      })();`;
      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source)).then((handle) => {
        handle._setPreview("UtilityScript");
        return handle;
      });
    }
    return this._utilityScriptPromise;
  }
  async doSlowMo() {
  }
}
class JSHandle extends import_instrumentation.SdkObject {
  constructor(context, type, preview, objectId, value) {
    super(context, "handle");
    this.__jshandle = true;
    this._disposed = false;
    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"));
  }
  async evaluate(pageFunction, arg) {
    return evaluate(this._context, true, pageFunction, this, arg);
  }
  async evaluateHandle(pageFunction, 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);
    await this._context.doSlowMo();
    return value;
  }
  async evaluateExpressionHandle(expression, options, 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, propertyName2) => {
      const result2 = { __proto__: null };
      result2[propertyName2] = object[propertyName2];
      return result2;
    }, propertyName);
    const properties = await objectHandle.getProperties();
    const result = properties.get(propertyName);
    objectHandle.dispose();
    return result;
  }
  async getProperties() {
    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 script = `(utilityScript, ...args) => utilityScript.jsonValue(...args)`;
    return this._context.evaluateWithArguments(script, true, [true], [this]);
  }
  asElement() {
    return null;
  }
  dispose() {
    if (this._disposed)
      return;
    this._disposed = true;
    if (this._objectId) {
      this._context.releaseHandle(this).catch((e) => {
      });
      if (globalThis.leakedJSHandles)
        globalThis.leakedJSHandles.delete(this);
    }
  }
  toString() {
    return this._preview;
  }
  _setPreviewCallback(callback) {
    this._previewCallback = callback;
  }
  preview() {
    return this._preview;
  }
  worldNameForTest() {
    return this._context.worldNameForTest;
  }
  _setPreview(preview) {
    this._preview = preview;
    if (this._previewCallback)
      this._previewCallback(preview);
  }
}
async function evaluate(context, returnByValue, pageFunction, ...args) {
  return evaluateExpression(context, String(pageFunction), { returnByValue, isFunction: typeof pageFunction === "function" }, ...args);
}
async function evaluateExpression(context, expression, options, ...args) {
  expression = normalizeEvaluationExpression(expression, options.isFunction);
  const handles = [];
  const toDispose = [];
  const pushHandle = (handle) => {
    handles.push(handle);
    return handles.length - 1;
  };
  args = args.map((arg) => (0, import_utilityScriptSerializers.serializeAsCallArgument)(arg, (handle) => {
    if (handle instanceof JSHandle) {
      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)) };
      toDispose.push(adopted);
      return { h: pushHandle(adopted) };
    }
    return { fallThrough: handle };
  }));
  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!");
    utilityScriptObjects.push(handle);
  }
  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, utilityScriptValues, utilityScriptObjects);
  } finally {
    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;
}
function normalizeEvaluationExpression(expression, isFunction) {
  expression = expression.trim();
  if (isFunction) {
    try {
      new Function("(" + expression + ")");
    } catch (e1) {
      if (expression.startsWith("async "))
        expression = "async function " + expression.substring("async ".length);
      else
        expression = "function " + expression;
      try {
        new Function("(" + expression + ")");
      } catch (e2) {
        throw new Error("Passed function is not well-serializable!");
      }
    }
  }
  if (/^(async)?\s*function(\s|\()/.test(expression))
    expression = "(" + expression + ")";
  return expression;
}
class JavaScriptErrorInEvaluate extends Error {
}
function isJavaScriptErrorInEvaluate(error) {
  return error instanceof JavaScriptErrorInEvaluate;
}
function sparseArrayToString(entries) {
  const arrayEntries = [];
  for (const { name, value } of entries) {
    const index = +name;
    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) {
    const emptyItems = index - lastIndex - 1;
    if (emptyItems === 1)
      tokens.push(`empty`);
    else if (emptyItems > 1)
      tokens.push(`empty x ${emptyItems}`);
    tokens.push(String(value));
    lastIndex = index;
  }
  return "[" + tokens.join(", ") + "]";
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ExecutionContext,
  JSHandle,
  JavaScriptErrorInEvaluate,
  accessBindingsController,
  accessUtilityScript,
  evaluate,
  evaluateExpression,
  isJavaScriptErrorInEvaluate,
  kPlaywrightBinding,
  kUtilityScriptSource,
  normalizeEvaluationExpression,
  parseUnserializableValue,
  prepareGeneratedScript,
  runtimeGuid,
  sparseArrayToString
});
