patchright-core 1.51.3 → 1.52.0

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -1,39 +1,37 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 ariaSnapshot_exports = {};
+__export(ariaSnapshot_exports, {
+  KeyParser: () => KeyParser,
+  ParserError: () => ParserError,
+  parseAriaSnapshot: () => parseAriaSnapshot,
+  parseAriaSnapshotUnsafe: () => parseAriaSnapshotUnsafe,
+  valueOrRegex: () => valueOrRegex
 });
-exports.ParserError = exports.KeyParser = void 0;
-exports.parseAriaSnapshot = parseAriaSnapshot;
-exports.parseAriaSnapshotUnsafe = parseAriaSnapshotUnsafe;
-exports.valueOrRegex = valueOrRegex;
-/**
- * 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.
- */
-
-// https://www.w3.org/TR/wai-aria-1.2/#role_definitions
-
-// We pass parsed template between worlds using JSON, make it easy.
-
+module.exports = __toCommonJS(ariaSnapshot_exports);
 function parseAriaSnapshotUnsafe(yaml, text) {
   const result = parseAriaSnapshot(yaml, text);
-  if (result.errors.length) throw new Error(result.errors[0].message);
+  if (result.errors.length)
+    throw new Error(result.errors[0].message);
   return result.fragment;
 }
 function parseAriaSnapshot(yaml, text, options = {}) {
-  var _fragment$children;
   const lineCounter = new yaml.LineCounter();
   const parseOptions = {
     keepSourceTokens: true,
@@ -42,10 +40,10 @@ function parseAriaSnapshot(yaml, text, options = {}) {
   };
   const yamlDoc = yaml.parseDocument(text, parseOptions);
   const errors = [];
-  const convertRange = range => {
+  const convertRange = (range) => {
     return [lineCounter.linePos(range[0]), lineCounter.linePos(range[1])];
   };
-  const addError = error => {
+  const addError = (error) => {
     errors.push({
       message: error.message,
       range: [lineCounter.linePos(error.pos[0]), lineCounter.linePos(error.pos[1])]
@@ -53,7 +51,7 @@ function parseAriaSnapshot(yaml, text, options = {}) {
   };
   const convertSeq = (container, seq) => {
     for (const item of seq.items) {
-      const itemIsString = item instanceof yaml.Scalar && typeof item.value === 'string';
+      const itemIsString = item instanceof yaml.Scalar && typeof item.value === "string";
       if (itemIsString) {
         const childNode = KeyParser.parse(item, parseOptions, errors);
         if (childNode) {
@@ -68,7 +66,7 @@ function parseAriaSnapshot(yaml, text, options = {}) {
         continue;
       }
       errors.push({
-        message: 'Sequence items should be strings or maps',
+        message: "Sequence items should be strings or maps",
         range: convertRange(item.range || seq.range)
       });
     }
@@ -76,46 +74,65 @@ function parseAriaSnapshot(yaml, text, options = {}) {
   const convertMap = (container, map) => {
     for (const entry of map.items) {
       container.children = container.children || [];
-      // Key must by a string
-      const keyIsString = entry.key instanceof yaml.Scalar && typeof entry.key.value === 'string';
+      const keyIsString = entry.key instanceof yaml.Scalar && typeof entry.key.value === "string";
       if (!keyIsString) {
         errors.push({
-          message: 'Only string keys are supported',
+          message: "Only string keys are supported",
           range: convertRange(entry.key.range || map.range)
         });
         continue;
       }
       const key = entry.key;
       const value = entry.value;
-
-      // - text: "text"
-      if (key.value === 'text') {
-        const valueIsString = value instanceof yaml.Scalar && typeof value.value === 'string';
+      if (key.value === "text") {
+        const valueIsString = value instanceof yaml.Scalar && typeof value.value === "string";
         if (!valueIsString) {
           errors.push({
-            message: 'Text value should be a string',
+            message: "Text value should be a string",
             range: convertRange(entry.value.range || map.range)
           });
           continue;
         }
         container.children.push({
-          kind: 'text',
+          kind: "text",
           text: valueOrRegex(value.value)
         });
         continue;
       }
-
-      // role "name": ...
+      if (key.value === "/children") {
+        const valueIsString = value instanceof yaml.Scalar && typeof value.value === "string";
+        if (!valueIsString || value.value !== "contain" && value.value !== "equal" && value.value !== "deep-equal") {
+          errors.push({
+            message: 'Strict value should be "contain", "equal" or "deep-equal"',
+            range: convertRange(entry.value.range || map.range)
+          });
+          continue;
+        }
+        container.containerMode = value.value;
+        continue;
+      }
+      if (key.value.startsWith("/")) {
+        const valueIsString = value instanceof yaml.Scalar && typeof value.value === "string";
+        if (!valueIsString) {
+          errors.push({
+            message: "Property value should be a string",
+            range: convertRange(entry.value.range || map.range)
+          });
+          continue;
+        }
+        container.props = container.props ?? {};
+        container.props[key.value.slice(1)] = valueOrRegex(value.value);
+        continue;
+      }
       const childNode = KeyParser.parse(key, parseOptions, errors);
-      if (!childNode) continue;
-
-      // - role "name": "text"
+      if (!childNode)
+        continue;
       const valueIsScalar = value instanceof yaml.Scalar;
       if (valueIsScalar) {
         const type = typeof value.value;
-        if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+        if (type !== "string" && type !== "number" && type !== "boolean") {
           errors.push({
-            message: 'Node value should be a string or a sequence',
+            message: "Node value should be a string or a sequence",
             range: convertRange(entry.value.range || map.range)
           });
           continue;
@@ -123,15 +140,12 @@ function parseAriaSnapshot(yaml, text, options = {}) {
         container.children.push({
           ...childNode,
           children: [{
-            kind: 'text',
+            kind: "text",
             text: valueOrRegex(String(value.value))
           }]
         });
         continue;
       }
-
-      // - role "name":
-      //   - child
       const valueIsSequence = value instanceof yaml.YAMLSeq;
       if (valueIsSequence) {
         container.children.push(childNode);
@@ -139,62 +153,36 @@ function parseAriaSnapshot(yaml, text, options = {}) {
         continue;
       }
       errors.push({
-        message: 'Map values should be strings or sequences',
+        message: "Map values should be strings or sequences",
         range: convertRange(entry.value.range || map.range)
       });
     }
   };
-  const fragment = {
-    kind: 'role',
-    role: 'fragment'
-  };
+  const fragment = { kind: "role", role: "fragment" };
   yamlDoc.errors.forEach(addError);
-  if (errors.length) return {
-    errors,
-    fragment
-  };
+  if (errors.length)
+    return { errors, fragment };
   if (!(yamlDoc.contents instanceof yaml.YAMLSeq)) {
     errors.push({
       message: 'Aria snapshot must be a YAML sequence, elements starting with " -"',
-      range: yamlDoc.contents ? convertRange(yamlDoc.contents.range) : [{
-        line: 0,
-        col: 0
-      }, {
-        line: 0,
-        col: 0
-      }]
+      range: yamlDoc.contents ? convertRange(yamlDoc.contents.range) : [{ line: 0, col: 0 }, { line: 0, col: 0 }]
     });
   }
-  if (errors.length) return {
-    errors,
-    fragment
-  };
+  if (errors.length)
+    return { errors, fragment };
   convertSeq(fragment, yamlDoc.contents);
-  if (errors.length) return {
-    errors,
-    fragment: emptyFragment
-  };
-  if (((_fragment$children = fragment.children) === null || _fragment$children === void 0 ? void 0 : _fragment$children.length) === 1) return {
-    fragment: fragment.children[0],
-    errors
-  };
-  return {
-    fragment,
-    errors
-  };
+  if (errors.length)
+    return { errors, fragment: emptyFragment };
+  if (fragment.children?.length === 1)
+    return { fragment: fragment.children[0], errors };
+  return { fragment, errors };
 }
-const emptyFragment = {
-  kind: 'role',
-  role: 'fragment'
-};
+const emptyFragment = { kind: "role", role: "fragment" };
 function normalizeWhitespace(text) {
-  // TODO: why is this different from normalizeWhitespace in stringUtils.ts?
-  return text.replace(/[\u200b\u00ad]/g, '').replace(/[\r\n\s\t]+/g, ' ').trim();
+  return text.replace(/[\u200b\u00ad]/g, "").replace(/[\r\n\s\t]+/g, " ").trim();
 }
 function valueOrRegex(value) {
-  return value.startsWith('/') && value.endsWith('/') && value.length > 1 ? {
-    pattern: value.slice(1, -1)
-  } : normalizeWhitespace(value);
+  return value.startsWith("/") && value.endsWith("/") && value.length > 1 ? { pattern: value.slice(1, -1) } : normalizeWhitespace(value);
 }
 class KeyParser {
   static parse(text, options, errors) {
@@ -202,7 +190,7 @@ class KeyParser {
       return new KeyParser(text.value)._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';
+        const message = options.prettyErrors === false ? e.message : e.message + ":\n\n" + text.value + "\n" + " ".repeat(e.pos) + "^\n";
         errors.push({
           message,
           range: [options.lineCounter.linePos(text.range[0]), options.lineCounter.linePos(text.range[0] + e.pos)]
@@ -213,18 +201,16 @@ class KeyParser {
     }
   }
   constructor(input) {
-    this._input = void 0;
-    this._pos = void 0;
-    this._length = void 0;
     this._input = input;
     this._pos = 0;
     this._length = input.length;
   }
   _peek() {
-    return this._input[this._pos] || '';
+    return this._input[this._pos] || "";
   }
   _next() {
-    if (this._pos < this._length) return this._input[this._pos++];
+    if (this._pos < this._length)
+      return this._input[this._pos++];
     return null;
   }
   _eof() {
@@ -234,23 +220,26 @@ class KeyParser {
     return !this._eof() && /\s/.test(this._peek());
   }
   _skipWhitespace() {
-    while (this._isWhitespace()) this._pos++;
+    while (this._isWhitespace())
+      this._pos++;
   }
   _readIdentifier(type) {
-    if (this._eof()) this._throwError(`Unexpected end of input when expecting ${type}`);
+    if (this._eof())
+      this._throwError(`Unexpected end of input when expecting ${type}`);
     const start = this._pos;
-    while (!this._eof() && /[a-zA-Z]/.test(this._peek())) this._pos++;
+    while (!this._eof() && /[a-zA-Z]/.test(this._peek()))
+      this._pos++;
     return this._input.slice(start, this._pos);
   }
   _readString() {
-    let result = '';
+    let result = "";
     let escaped = false;
     while (!this._eof()) {
       const ch = this._next();
       if (escaped) {
         result += ch;
         escaped = false;
-      } else if (ch === '\\') {
+      } else if (ch === "\\") {
         escaped = true;
       } else if (ch === '"') {
         return result;
@@ -258,13 +247,13 @@ class KeyParser {
         result += ch;
       }
     }
-    this._throwError('Unterminated string');
+    this._throwError("Unterminated string");
   }
   _throwError(message, offset = 0) {
     throw new ParserError(message, offset || this._pos);
   }
   _readRegex() {
-    let result = '';
+    let result = "";
     let escaped = false;
     let insideClass = false;
     while (!this._eof()) {
@@ -272,24 +261,22 @@ class KeyParser {
       if (escaped) {
         result += ch;
         escaped = false;
-      } else if (ch === '\\') {
+      } else if (ch === "\\") {
         escaped = true;
         result += ch;
-      } else if (ch === '/' && !insideClass) {
-        return {
-          pattern: result
-        };
-      } else if (ch === '[') {
+      } else if (ch === "/" && !insideClass) {
+        return { pattern: result };
+      } else if (ch === "[") {
         insideClass = true;
         result += ch;
-      } else if (ch === ']' && insideClass) {
+      } else if (ch === "]" && insideClass) {
         result += ch;
         insideClass = false;
       } else {
         result += ch;
       }
     }
-    this._throwError('Unterminated regex');
+    this._throwError("Unterminated regex");
   }
   _readStringOrRegex() {
     const ch = this._peek();
@@ -297,7 +284,7 @@ class KeyParser {
       this._next();
       return normalizeWhitespace(this._readString());
     }
-    if (ch === '/') {
+    if (ch === "/") {
       this._next();
       return this._readRegex();
     }
@@ -307,23 +294,25 @@ class KeyParser {
     let errorPos = this._pos;
     while (true) {
       this._skipWhitespace();
-      if (this._peek() === '[') {
+      if (this._peek() === "[") {
         this._next();
         this._skipWhitespace();
         errorPos = this._pos;
-        const flagName = this._readIdentifier('attribute');
+        const flagName = this._readIdentifier("attribute");
         this._skipWhitespace();
-        let flagValue = '';
-        if (this._peek() === '=') {
+        let flagValue = "";
+        if (this._peek() === "=") {
           this._next();
           this._skipWhitespace();
           errorPos = this._pos;
-          while (this._peek() !== ']' && !this._isWhitespace() && !this._eof()) flagValue += this._next();
+          while (this._peek() !== "]" && !this._isWhitespace() && !this._eof())
+            flagValue += this._next();
         }
         this._skipWhitespace();
-        if (this._peek() !== ']') this._throwError('Expected ]');
-        this._next(); // Consume ']'
-        this._applyAttribute(result, flagName, flagValue || 'true', errorPos);
+        if (this._peek() !== "]")
+          this._throwError("Expected ]");
+        this._next();
+        this._applyAttribute(result, flagName, flagValue || "true", errorPos);
       } else {
         break;
       }
@@ -331,62 +320,65 @@ class KeyParser {
   }
   _parse() {
     this._skipWhitespace();
-    const role = this._readIdentifier('role');
+    const role = this._readIdentifier("role");
     this._skipWhitespace();
-    const name = this._readStringOrRegex() || '';
-    const result = {
-      kind: 'role',
-      role,
-      name
-    };
+    const name = this._readStringOrRegex() || "";
+    const result = { kind: "role", role, name };
     this._readAttributes(result);
     this._skipWhitespace();
-    if (!this._eof()) this._throwError('Unexpected input');
+    if (!this._eof())
+      this._throwError("Unexpected input");
     return result;
   }
   _applyAttribute(node, key, value, errorPos) {
-    if (key === 'checked') {
-      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "checked\" attribute must be a boolean or "mixed"', errorPos);
-      node.checked = value === 'true' ? true : value === 'false' ? false : 'mixed';
+    if (key === "checked") {
+      this._assert(value === "true" || value === "false" || value === "mixed", 'Value of "checked" attribute must be a boolean or "mixed"', errorPos);
+      node.checked = value === "true" ? true : value === "false" ? false : "mixed";
       return;
     }
-    if (key === 'disabled') {
-      this._assert(value === 'true' || value === 'false', 'Value of "disabled" attribute must be a boolean', errorPos);
-      node.disabled = value === 'true';
+    if (key === "disabled") {
+      this._assert(value === "true" || value === "false", 'Value of "disabled" attribute must be a boolean', errorPos);
+      node.disabled = value === "true";
       return;
     }
-    if (key === 'expanded') {
-      this._assert(value === 'true' || value === 'false', 'Value of "expanded" attribute must be a boolean', errorPos);
-      node.expanded = value === 'true';
+    if (key === "expanded") {
+      this._assert(value === "true" || value === "false", 'Value of "expanded" attribute must be a boolean', errorPos);
+      node.expanded = value === "true";
       return;
     }
-    if (key === 'level') {
+    if (key === "level") {
       this._assert(!isNaN(Number(value)), 'Value of "level" attribute must be a number', errorPos);
       node.level = Number(value);
       return;
     }
-    if (key === 'pressed') {
-      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "pressed" attribute must be a boolean or "mixed"', errorPos);
-      node.pressed = value === 'true' ? true : value === 'false' ? false : 'mixed';
+    if (key === "pressed") {
+      this._assert(value === "true" || value === "false" || value === "mixed", 'Value of "pressed" attribute must be a boolean or "mixed"', errorPos);
+      node.pressed = value === "true" ? true : value === "false" ? false : "mixed";
       return;
     }
-    if (key === 'selected') {
-      this._assert(value === 'true' || value === 'false', 'Value of "selected" attribute must be a boolean', errorPos);
-      node.selected = value === 'true';
+    if (key === "selected") {
+      this._assert(value === "true" || value === "false", 'Value of "selected" attribute must be a boolean', errorPos);
+      node.selected = value === "true";
       return;
     }
     this._assert(false, `Unsupported attribute [${key}]`, errorPos);
   }
   _assert(value, message, valuePos) {
-    if (!value) this._throwError(message || 'Assertion error', valuePos);
+    if (!value)
+      this._throwError(message || "Assertion error", valuePos);
   }
 }
-exports.KeyParser = KeyParser;
 class ParserError extends Error {
   constructor(message, pos) {
     super(message);
-    this.pos = void 0;
     this.pos = pos;
   }
 }
-exports.ParserError = ParserError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyParser,
+  ParserError,
+  parseAriaSnapshot,
+  parseAriaSnapshotUnsafe,
+  valueOrRegex
+});

package/lib/utils/isomorphic/assert.js

@@ -1,25 +1,31 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 assert_exports = {};
+__export(assert_exports, {
+  assert: () => assert
 });
-exports.assert = assert;
-/**
- * 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(assert_exports);
 function assert(value, message) {
-  if (!value) throw new Error(message || 'Assertion error');
-}
+  if (!value)
+    throw new Error(message || "Assertion error");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assert
+});

package/lib/utils/isomorphic/builtins.js

@@ -0,0 +1,90 @@
+"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 builtins_exports = {};
+__export(builtins_exports, {
+  Date: () => Date,
+  Intl: () => Intl,
+  Map: () => Map,
+  Set: () => Set,
+  builtins: () => builtins,
+  cancelAnimationFrame: () => cancelAnimationFrame,
+  cancelIdleCallback: () => cancelIdleCallback,
+  clearInterval: () => clearInterval,
+  clearTimeout: () => clearTimeout,
+  performance: () => performance,
+  requestAnimationFrame: () => requestAnimationFrame,
+  requestIdleCallback: () => requestIdleCallback,
+  setInterval: () => setInterval,
+  setTimeout: () => setTimeout
+});
+module.exports = __toCommonJS(builtins_exports);
+function builtins(global) {
+  global = global ?? globalThis;
+  if (!global["__playwright_builtins__"]) {
+    const builtins2 = {
+      setTimeout: global.setTimeout?.bind(global),
+      clearTimeout: global.clearTimeout?.bind(global),
+      setInterval: global.setInterval?.bind(global),
+      clearInterval: global.clearInterval?.bind(global),
+      requestAnimationFrame: global.requestAnimationFrame?.bind(global),
+      cancelAnimationFrame: global.cancelAnimationFrame?.bind(global),
+      requestIdleCallback: global.requestIdleCallback?.bind(global),
+      cancelIdleCallback: global.cancelIdleCallback?.bind(global),
+      performance: global.performance,
+      eval: global.eval?.bind(global),
+      Intl: global.Intl,
+      Date: global.Date,
+      Map: global.Map,
+      Set: global.Set
+    };
+    Object.defineProperty(global, "__playwright_builtins__", { value: builtins2, configurable: false, enumerable: false, writable: false });
+  }
+  return global["__playwright_builtins__"];
+}
+const instance = builtins();
+const setTimeout = instance.setTimeout;
+const clearTimeout = instance.clearTimeout;
+const setInterval = instance.setInterval;
+const clearInterval = instance.clearInterval;
+const requestAnimationFrame = instance.requestAnimationFrame;
+const cancelAnimationFrame = instance.cancelAnimationFrame;
+const requestIdleCallback = instance.requestIdleCallback;
+const cancelIdleCallback = instance.cancelIdleCallback;
+const performance = instance.performance;
+const Intl = instance.Intl;
+const Date = instance.Date;
+const Map = instance.Map;
+const Set = instance.Set;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Date,
+  Intl,
+  Map,
+  Set,
+  builtins,
+  cancelAnimationFrame,
+  cancelIdleCallback,
+  clearInterval,
+  clearTimeout,
+  performance,
+  requestAnimationFrame,
+  requestIdleCallback,
+  setInterval,
+  setTimeout
+});