patchright-core 1.52.4 → 1.55.0

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -25,8 +25,8 @@ __export(ariaSnapshot_exports, {
   valueOrRegex: () => valueOrRegex
 });
 module.exports = __toCommonJS(ariaSnapshot_exports);
-function parseAriaSnapshotUnsafe(yaml, text) {
-  const result = parseAriaSnapshot(yaml, text);
+function parseAriaSnapshotUnsafe(yaml, text, options = {}) {
+  const result = parseAriaSnapshot(yaml, text, options);
   if (result.errors.length)
     throw new Error(result.errors[0].message);
   return result.fragment;
@@ -173,9 +173,9 @@ function parseAriaSnapshot(yaml, text, options = {}) {
   convertSeq(fragment, yamlDoc.contents);
   if (errors.length)
     return { errors, fragment: emptyFragment };
-  if (fragment.children?.length === 1)
-    return { fragment: fragment.children[0], errors };
-  return { fragment, errors };
+  if (fragment.children?.length === 1 && (!fragment.containerMode || fragment.containerMode === "contain"))
+    return { fragment: fragment.children[0], errors: [] };
+  return { fragment, errors: [] };
 }
 const emptyFragment = { kind: "role", role: "fragment" };
 function normalizeWhitespace(text) {
@@ -187,7 +187,7 @@ function valueOrRegex(value) {
 class KeyParser {
   static parse(text, options, errors) {
     try {
-      return new KeyParser(text.value)._parse();
+      return new KeyParser(text.value, options)._parse();
     } catch (e) {
       if (e instanceof ParserError) {
         const message = options.prettyErrors === false ? e.message : e.message + ":\n\n" + text.value + "\n" + " ".repeat(e.pos) + "^\n";
@@ -200,10 +200,11 @@ class KeyParser {
       throw e;
     }
   }
-  constructor(input) {
+  constructor(input, options) {
     this._input = input;
     this._pos = 0;
     this._length = input.length;
+    this._options = options;
   }
   _peek() {
     return this._input[this._pos] || "";
@@ -346,6 +347,11 @@ class KeyParser {
       node.expanded = value === "true";
       return;
     }
+    if (key === "active") {
+      this._assert(value === "true" || value === "false", 'Value of "active" attribute must be a boolean', errorPos);
+      node.active = value === "true";
+      return;
+    }
     if (key === "level") {
       this._assert(!isNaN(Number(value)), 'Value of "level" attribute must be a number', errorPos);
       node.level = Number(value);

package/lib/utils/isomorphic/cssParser.js

@@ -34,7 +34,6 @@ __export(cssParser_exports, {
   serializeSelector: () => serializeSelector
 });
 module.exports = __toCommonJS(cssParser_exports);
-var import_builtins = require("./builtins");
 var css = __toESM(require("./cssTokenizer"));
 class InvalidSelectorError extends Error {
 }
@@ -65,7 +64,7 @@ function parseCSS(selector, customNames) {
   if (unsupportedToken)
     throw new InvalidSelectorError(`Unsupported token "${unsupportedToken.toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   let pos = 0;
-  const names = new import_builtins.Set();
+  const names = /* @__PURE__ */ new Set();
   function unexpected() {
     return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   }

package/lib/utils/isomorphic/locatorGenerators.js

@@ -24,11 +24,26 @@ __export(locatorGenerators_exports, {
   JsonlLocatorFactory: () => JsonlLocatorFactory,
   PythonLocatorFactory: () => PythonLocatorFactory,
   asLocator: () => asLocator,
+  asLocatorDescription: () => asLocatorDescription,
   asLocators: () => asLocators
 });
 module.exports = __toCommonJS(locatorGenerators_exports);
 var import_selectorParser = require("./selectorParser");
 var import_stringUtils = require("./stringUtils");
+function asLocatorDescription(lang, selector) {
+  try {
+    const parsed = (0, import_selectorParser.parseSelector)(selector);
+    const lastPart = parsed.parts[parsed.parts.length - 1];
+    if (lastPart?.name === "internal:describe") {
+      const description = JSON.parse(lastPart.body);
+      if (typeof description === "string")
+        return description;
+    }
+    return innerAsLocators(new generators[lang](), parsed, false, 1)[0];
+  } catch (e) {
+    return selector;
+  }
+}
 function asLocator(lang, selector, isFrameLocator = false) {
   return asLocators(lang, selector, isFrameLocator, 1)[0];
 }
@@ -47,6 +62,8 @@ function innerAsLocators(factory, parsed, isFrameLocator = false, maxOutputSize
     const part = parts[index];
     const base = nextBase;
     nextBase = "locator";
+    if (part.name === "internal:describe")
+      continue;
     if (part.name === "nth") {
       if (part.body === "0")
         tokens.push([factory.generateLocator(base, "first", ""), factory.generateLocator(base, "nth", "0")]);
@@ -651,5 +668,6 @@ function isRegExp(obj) {
   JsonlLocatorFactory,
   PythonLocatorFactory,
   asLocator,
+  asLocatorDescription,
   asLocators
 });

package/lib/utils/isomorphic/manualPromise.js

@@ -22,7 +22,6 @@ __export(manualPromise_exports, {
   ManualPromise: () => ManualPromise
 });
 module.exports = __toCommonJS(manualPromise_exports);
-var import_builtins = require("./builtins");
 var import_stackTrace = require("./stackTrace");
 class ManualPromise extends Promise {
   constructor() {
@@ -56,7 +55,7 @@ class ManualPromise extends Promise {
 }
 class LongStandingScope {
   constructor() {
-    this._terminatePromises = new import_builtins.Map();
+    this._terminatePromises = /* @__PURE__ */ new Map();
     this._isClosed = false;
   }
   reject(error) {

package/lib/utils/isomorphic/mimeType.js

@@ -23,7 +23,6 @@ __export(mimeType_exports, {
   isTextualMimeType: () => isTextualMimeType
 });
 module.exports = __toCommonJS(mimeType_exports);
-var import_builtins = require("./builtins");
 function isJsonMimeType(mimeType) {
   return !!mimeType.match(/^(application\/json|application\/.*?\+json|text\/(x-)?json)(;\s*charset=.*)?$/);
 }
@@ -37,7 +36,7 @@ function getMimeTypeForPath(path) {
   const extension = path.substring(dotIndex + 1);
   return types.get(extension) || null;
 }
-const types = new import_builtins.Map([
+const types = /* @__PURE__ */ new Map([
   ["ez", "application/andrew-inset"],
   ["aw", "application/applixware"],
   ["atom", "application/atom+xml"],

package/lib/utils/isomorphic/multimap.js

@@ -21,10 +21,9 @@ __export(multimap_exports, {
   MultiMap: () => MultiMap
 });
 module.exports = __toCommonJS(multimap_exports);
-var import_builtins = require("./builtins");
 class MultiMap {
   constructor() {
-    this._map = new import_builtins.Map();
+    this._map = /* @__PURE__ */ new Map();
   }
   set(key, value) {
     let values = this._map.get(key);

package/lib/utils/isomorphic/oldUtilityScriptSerializers.js

@@ -0,0 +1,248 @@
+"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 oldUtilityScriptSerializers_exports = {};
+__export(oldUtilityScriptSerializers_exports, {
+  source: () => source
+});
+module.exports = __toCommonJS(oldUtilityScriptSerializers_exports);
+function source() {
+  function isRegExp(obj) {
+    try {
+      return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isDate(obj) {
+    try {
+      return obj instanceof Date || Object.prototype.toString.call(obj) === "[object Date]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isURL(obj) {
+    try {
+      return obj instanceof URL || Object.prototype.toString.call(obj) === "[object URL]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isError(obj) {
+    try {
+      return obj instanceof Error || obj && Object.getPrototypeOf(obj)?.name === "Error";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isTypedArray(obj, constructor) {
+    try {
+      return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+    } catch (error) {
+      return false;
+    }
+  }
+  const typedArrayConstructors = {
+    i8: Int8Array,
+    ui8: Uint8Array,
+    ui8c: Uint8ClampedArray,
+    i16: Int16Array,
+    ui16: Uint16Array,
+    i32: Int32Array,
+    ui32: Uint32Array,
+    // TODO: add Float16Array once it's in baseline
+    f32: Float32Array,
+    f64: Float64Array,
+    bi64: BigInt64Array,
+    bui64: BigUint64Array
+  };
+  function typedArrayToBase64(array) {
+    if ("toBase64" in array)
+      return array.toBase64();
+    const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map((b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+  }
+  function base64ToTypedArray(base64, TypedArrayConstructor) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return new TypedArrayConstructor(bytes.buffer);
+  }
+  function parseEvaluationResultValue(value, handles = [], refs = /* @__PURE__ */ new Map()) {
+    if (Object.is(value, void 0))
+      return void 0;
+    if (typeof value === "object" && value) {
+      if ("ref" in value)
+        return refs.get(value.ref);
+      if ("v" in value) {
+        if (value.v === "undefined")
+          return void 0;
+        if (value.v === "null")
+          return null;
+        if (value.v === "NaN")
+          return NaN;
+        if (value.v === "Infinity")
+          return Infinity;
+        if (value.v === "-Infinity")
+          return -Infinity;
+        if (value.v === "-0")
+          return -0;
+        return void 0;
+      }
+      if ("d" in value)
+        return new Date(value.d);
+      if ("u" in value)
+        return new URL(value.u);
+      if ("bi" in value)
+        return BigInt(value.bi);
+      if ("e" in value) {
+        const error = new Error(value.e.m);
+        error.name = value.e.n;
+        error.stack = value.e.s;
+        return error;
+      }
+      if ("r" in value)
+        return new RegExp(value.r.p, value.r.f);
+      if ("a" in value) {
+        const result = [];
+        refs.set(value.id, result);
+        for (const a of value.a)
+          result.push(parseEvaluationResultValue(a, handles, refs));
+        return result;
+      }
+      if ("o" in value) {
+        const result = {};
+        refs.set(value.id, result);
+        for (const { k, v } of value.o)
+          result[k] = parseEvaluationResultValue(v, handles, refs);
+        return result;
+      }
+      if ("h" in value)
+        return handles[value.h];
+      if ("ta" in value)
+        return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+    }
+    return value;
+  }
+  function serializeAsCallArgument(value, handleSerializer) {
+    return serialize(value, handleSerializer, { visited: /* @__PURE__ */ new Map(), lastId: 0 });
+  }
+  function serialize(value, handleSerializer, visitorInfo) {
+    if (value && typeof value === "object") {
+      if (typeof globalThis.Window === "function" && value instanceof globalThis.Window)
+        return "ref: <Window>";
+      if (typeof globalThis.Document === "function" && value instanceof globalThis.Document)
+        return "ref: <Document>";
+      if (typeof globalThis.Node === "function" && value instanceof globalThis.Node)
+        return "ref: <Node>";
+    }
+    return innerSerialize(value, handleSerializer, visitorInfo);
+  }
+  function innerSerialize(value, handleSerializer, visitorInfo) {
+    const result = handleSerializer(value);
+    if ("fallThrough" in result)
+      value = result.fallThrough;
+    else
+      return result;
+    if (typeof value === "symbol")
+      return { v: "undefined" };
+    if (Object.is(value, void 0))
+      return { v: "undefined" };
+    if (Object.is(value, null))
+      return { v: "null" };
+    if (Object.is(value, NaN))
+      return { v: "NaN" };
+    if (Object.is(value, Infinity))
+      return { v: "Infinity" };
+    if (Object.is(value, -Infinity))
+      return { v: "-Infinity" };
+    if (Object.is(value, -0))
+      return { v: "-0" };
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "bigint")
+      return { bi: value.toString() };
+    if (isError(value)) {
+      let stack;
+      if (value.stack?.startsWith(value.name + ": " + value.message)) {
+        stack = value.stack;
+      } else {
+        stack = `${value.name}: ${value.message}
+${value.stack}`;
+      }
+      return { e: { n: value.name, m: value.message, s: stack } };
+    }
+    if (isDate(value))
+      return { d: value.toJSON() };
+    if (isURL(value))
+      return { u: value.toJSON() };
+    if (isRegExp(value))
+      return { r: { p: value.source, f: value.flags } };
+    for (const [k, ctor] of Object.entries(typedArrayConstructors)) {
+      if (isTypedArray(value, ctor))
+        return { ta: { b: typedArrayToBase64(value), k } };
+    }
+    const id = visitorInfo.visited.get(value);
+    if (id)
+      return { ref: id };
+    if (Array.isArray(value)) {
+      const a = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (let i = 0; i < value.length; ++i)
+        a.push(serialize(value[i], handleSerializer, visitorInfo));
+      return { a, id: id2 };
+    }
+    if (typeof value === "object") {
+      const o = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (const name of Object.keys(value)) {
+        let item;
+        try {
+          item = value[name];
+        } catch (e) {
+          continue;
+        }
+        if (name === "toJSON" && typeof item === "function")
+          o.push({ k: name, v: { o: [], id: 0 } });
+        else
+          o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+      }
+      let jsonWrapper;
+      try {
+        if (o.length === 0 && value.toJSON && typeof value.toJSON === "function")
+          jsonWrapper = { value: value.toJSON() };
+      } catch (e) {
+      }
+      if (jsonWrapper)
+        return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+      return { o, id: id2 };
+    }
+  }
+  return { parseEvaluationResultValue, serializeAsCallArgument };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  source
+});

package/lib/utils/isomorphic/protocolFormatter.js

@@ -0,0 +1,78 @@
+"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 protocolFormatter_exports = {};
+__export(protocolFormatter_exports, {
+  formatProtocolParam: () => formatProtocolParam,
+  getActionGroup: () => getActionGroup,
+  renderTitleForCall: () => renderTitleForCall
+});
+module.exports = __toCommonJS(protocolFormatter_exports);
+var import_protocolMetainfo = require("./protocolMetainfo");
+function formatProtocolParam(params, alternatives) {
+  if (!params)
+    return void 0;
+  for (const name of alternatives.split("|")) {
+    if (name === "url") {
+      try {
+        const urlObject = new URL(params[name]);
+        if (urlObject.protocol === "data:")
+          return urlObject.protocol;
+        if (urlObject.protocol === "about:")
+          return params[name];
+        return urlObject.pathname + urlObject.search;
+      } catch (error) {
+        if (params[name] !== void 0)
+          return params[name];
+      }
+    }
+    if (name === "timeNumber" && params[name] !== void 0) {
+      return new Date(params[name]).toString();
+    }
+    const value = deepParam(params, name);
+    if (value !== void 0)
+      return value;
+  }
+}
+function deepParam(params, name) {
+  const tokens = name.split(".");
+  let current = params;
+  for (const token of tokens) {
+    if (typeof current !== "object" || current === null)
+      return void 0;
+    current = current[token];
+  }
+  if (current === void 0)
+    return void 0;
+  return String(current);
+}
+function renderTitleForCall(metadata) {
+  const titleFormat = metadata.title ?? import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method)?.title ?? metadata.method;
+  return titleFormat.replace(/\{([^}]+)\}/g, (fullMatch, p1) => {
+    return formatProtocolParam(metadata.params, p1) ?? fullMatch;
+  });
+}
+function getActionGroup(metadata) {
+  return import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method)?.group;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatProtocolParam,
+  getActionGroup,
+  renderTitleForCall
+});