rebrowser-playwright-core 1.49.1 → 1.52.0

package/lib/utils/isomorphic/colors.js

@@ -0,0 +1,72 @@
+"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 colors_exports = {};
+__export(colors_exports, {
+  noColors: () => noColors,
+  webColors: () => webColors
+});
+module.exports = __toCommonJS(colors_exports);
+const webColors = {
+  enabled: true,
+  reset: (text) => applyStyle(0, 0, text),
+  bold: (text) => applyStyle(1, 22, text),
+  dim: (text) => applyStyle(2, 22, text),
+  italic: (text) => applyStyle(3, 23, text),
+  underline: (text) => applyStyle(4, 24, text),
+  inverse: (text) => applyStyle(7, 27, text),
+  hidden: (text) => applyStyle(8, 28, text),
+  strikethrough: (text) => applyStyle(9, 29, text),
+  black: (text) => applyStyle(30, 39, text),
+  red: (text) => applyStyle(31, 39, text),
+  green: (text) => applyStyle(32, 39, text),
+  yellow: (text) => applyStyle(33, 39, text),
+  blue: (text) => applyStyle(34, 39, text),
+  magenta: (text) => applyStyle(35, 39, text),
+  cyan: (text) => applyStyle(36, 39, text),
+  white: (text) => applyStyle(37, 39, text),
+  gray: (text) => applyStyle(90, 39, text),
+  grey: (text) => applyStyle(90, 39, text)
+};
+const noColors = {
+  enabled: false,
+  reset: (t) => t,
+  bold: (t) => t,
+  dim: (t) => t,
+  italic: (t) => t,
+  underline: (t) => t,
+  inverse: (t) => t,
+  hidden: (t) => t,
+  strikethrough: (t) => t,
+  black: (t) => t,
+  red: (t) => t,
+  green: (t) => t,
+  yellow: (t) => t,
+  blue: (t) => t,
+  magenta: (t) => t,
+  cyan: (t) => t,
+  white: (t) => t,
+  gray: (t) => t,
+  grey: (t) => t
+};
+const applyStyle = (open, close, text) => `\x1B[${open}m${text}\x1B[${close}m`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  noColors,
+  webColors
+});

package/lib/utils/isomorphic/cssParser.js

@@ -1,74 +1,77 @@
 "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 cssParser_exports = {};
+__export(cssParser_exports, {
+  InvalidSelectorError: () => InvalidSelectorError,
+  isInvalidSelectorError: () => isInvalidSelectorError,
+  parseCSS: () => parseCSS,
+  serializeSelector: () => serializeSelector
 });
-exports.InvalidSelectorError = void 0;
-exports.isInvalidSelectorError = isInvalidSelectorError;
-exports.parseCSS = parseCSS;
-exports.serializeSelector = serializeSelector;
-var css = _interopRequireWildcard(require("./cssTokenizer"));
-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 InvalidSelectorError extends Error {}
-exports.InvalidSelectorError = InvalidSelectorError;
+module.exports = __toCommonJS(cssParser_exports);
+var import_builtins = require("./builtins");
+var css = __toESM(require("./cssTokenizer"));
+class InvalidSelectorError extends Error {
+}
 function isInvalidSelectorError(error) {
   return error instanceof InvalidSelectorError;
 }
-
-// Note: '>=' is used internally for text engine to preserve backwards compatibility.
-
-// TODO: consider
-//   - key=value
-//   - operators like `=`, `|=`, `~=`, `*=`, `/`
-//   - <empty>~=value
-//   - argument modes: "parse all", "parse commas", "just a string"
-
 function parseCSS(selector, customNames) {
   let tokens;
   try {
     tokens = css.tokenize(selector);
-    if (!(tokens[tokens.length - 1] instanceof css.EOFToken)) tokens.push(new css.EOFToken());
+    if (!(tokens[tokens.length - 1] instanceof css.EOFToken))
+      tokens.push(new css.EOFToken());
   } catch (e) {
-    const newMessage = e.message + ` while parsing selector "${selector}"`;
-    const index = (e.stack || '').indexOf(e.message);
-    if (index !== -1) e.stack = e.stack.substring(0, index) + newMessage + e.stack.substring(index + e.message.length);
+    const newMessage = e.message + ` while parsing css selector "${selector}". Did you mean to CSS.escape it?`;
+    const index = (e.stack || "").indexOf(e.message);
+    if (index !== -1)
+      e.stack = e.stack.substring(0, index) + newMessage + e.stack.substring(index + e.message.length);
     e.message = newMessage;
     throw e;
   }
-  const unsupportedToken = tokens.find(token => {
-    return token instanceof css.AtKeywordToken || token instanceof css.BadStringToken || token instanceof css.BadURLToken || token instanceof css.ColumnToken || token instanceof css.CDOToken || token instanceof css.CDCToken || token instanceof css.SemicolonToken ||
-    // TODO: Consider using these for something, e.g. to escape complex strings.
+  const unsupportedToken = tokens.find((token) => {
+    return token instanceof css.AtKeywordToken || token instanceof css.BadStringToken || token instanceof css.BadURLToken || token instanceof css.ColumnToken || token instanceof css.CDOToken || token instanceof css.CDCToken || token instanceof css.SemicolonToken || // TODO: Consider using these for something, e.g. to escape complex strings.
     // For example :xpath{ (//div/bar[@attr="foo"])[2]/baz }
     // Or this way :xpath( {complex-xpath-goes-here("hello")} )
-    token instanceof css.OpenCurlyToken || token instanceof css.CloseCurlyToken ||
-    // TODO: Consider treating these as strings?
+    token instanceof css.OpenCurlyToken || token instanceof css.CloseCurlyToken || // TODO: Consider treating these as strings?
     token instanceof css.URLToken || token instanceof css.PercentageToken;
   });
-  if (unsupportedToken) throw new InvalidSelectorError(`Unsupported token "${unsupportedToken.toSource()}" while parsing selector "${selector}"`);
+  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 Set();
+  const names = new import_builtins.Set();
   function unexpected() {
-    return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing selector "${selector}"`);
+    return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   }
   function skipWhitespace() {
-    while (tokens[pos] instanceof css.WhitespaceToken) pos++;
+    while (tokens[pos] instanceof css.WhitespaceToken)
+      pos++;
   }
   function isIdent(p = pos) {
     return tokens[p] instanceof css.IdentToken;
@@ -92,92 +95,78 @@ function parseCSS(selector, customNames) {
     return tokens[p] instanceof css.FunctionToken;
   }
   function isStar(p = pos) {
-    return tokens[p] instanceof css.DelimToken && tokens[p].value === '*';
+    return tokens[p] instanceof css.DelimToken && tokens[p].value === "*";
   }
   function isEOF(p = pos) {
     return tokens[p] instanceof css.EOFToken;
   }
   function isClauseCombinator(p = pos) {
-    return tokens[p] instanceof css.DelimToken && ['>', '+', '~'].includes(tokens[p].value);
+    return tokens[p] instanceof css.DelimToken && [">", "+", "~"].includes(tokens[p].value);
   }
   function isSelectorClauseEnd(p = pos) {
     return isComma(p) || isCloseParen(p) || isEOF(p) || isClauseCombinator(p) || tokens[p] instanceof css.WhitespaceToken;
   }
   function consumeFunctionArguments() {
-    const result = [consumeArgument()];
+    const result2 = [consumeArgument()];
     while (true) {
       skipWhitespace();
-      if (!isComma()) break;
+      if (!isComma())
+        break;
       pos++;
-      result.push(consumeArgument());
+      result2.push(consumeArgument());
     }
-    return result;
+    return result2;
   }
   function consumeArgument() {
     skipWhitespace();
-    if (isNumber()) return tokens[pos++].value;
-    if (isString()) return tokens[pos++].value;
+    if (isNumber())
+      return tokens[pos++].value;
+    if (isString())
+      return tokens[pos++].value;
     return consumeComplexSelector();
   }
   function consumeComplexSelector() {
-    const result = {
-      simples: []
-    };
+    const result2 = { simples: [] };
     skipWhitespace();
     if (isClauseCombinator()) {
-      // Put implicit ":scope" at the start. https://drafts.csswg.org/selectors-4/#relative
-      result.simples.push({
-        selector: {
-          functions: [{
-            name: 'scope',
-            args: []
-          }]
-        },
-        combinator: ''
-      });
+      result2.simples.push({ selector: { functions: [{ name: "scope", args: [] }] }, combinator: "" });
     } else {
-      result.simples.push({
-        selector: consumeSimpleSelector(),
-        combinator: ''
-      });
+      result2.simples.push({ selector: consumeSimpleSelector(), combinator: "" });
     }
     while (true) {
       skipWhitespace();
       if (isClauseCombinator()) {
-        result.simples[result.simples.length - 1].combinator = tokens[pos++].value;
+        result2.simples[result2.simples.length - 1].combinator = tokens[pos++].value;
         skipWhitespace();
       } else if (isSelectorClauseEnd()) {
         break;
       }
-      result.simples.push({
-        combinator: '',
-        selector: consumeSimpleSelector()
-      });
+      result2.simples.push({ combinator: "", selector: consumeSimpleSelector() });
     }
-    return result;
+    return result2;
   }
   function consumeSimpleSelector() {
-    let rawCSSString = '';
+    let rawCSSString = "";
     const functions = [];
     while (!isSelectorClauseEnd()) {
       if (isIdent() || isStar()) {
         rawCSSString += tokens[pos++].toSource();
       } else if (tokens[pos] instanceof css.HashToken) {
         rawCSSString += tokens[pos++].toSource();
-      } else if (tokens[pos] instanceof css.DelimToken && tokens[pos].value === '.') {
+      } else if (tokens[pos] instanceof css.DelimToken && tokens[pos].value === ".") {
         pos++;
-        if (isIdent()) rawCSSString += '.' + tokens[pos++].toSource();else throw unexpected();
+        if (isIdent())
+          rawCSSString += "." + tokens[pos++].toSource();
+        else
+          throw unexpected();
       } else if (tokens[pos] instanceof css.ColonToken) {
         pos++;
         if (isIdent()) {
           if (!customNames.has(tokens[pos].value.toLowerCase())) {
-            rawCSSString += ':' + tokens[pos++].toSource();
+            rawCSSString += ":" + tokens[pos++].toSource();
           } else {
             const name = tokens[pos++].value.toLowerCase();
-            functions.push({
-              name,
-              args: []
-            });
+            functions.push({ name, args: [] });
             names.add(name);
           }
         } else if (isFunction()) {
@@ -185,66 +174,73 @@ function parseCSS(selector, customNames) {
           if (!customNames.has(name)) {
             rawCSSString += `:${name}(${consumeBuiltinFunctionArguments()})`;
           } else {
-            functions.push({
-              name,
-              args: consumeFunctionArguments()
-            });
+            functions.push({ name, args: consumeFunctionArguments() });
             names.add(name);
           }
           skipWhitespace();
-          if (!isCloseParen()) throw unexpected();
+          if (!isCloseParen())
+            throw unexpected();
           pos++;
         } else {
           throw unexpected();
         }
       } else if (tokens[pos] instanceof css.OpenSquareToken) {
-        rawCSSString += '[';
+        rawCSSString += "[";
         pos++;
-        while (!(tokens[pos] instanceof css.CloseSquareToken) && !isEOF()) rawCSSString += tokens[pos++].toSource();
-        if (!(tokens[pos] instanceof css.CloseSquareToken)) throw unexpected();
-        rawCSSString += ']';
+        while (!(tokens[pos] instanceof css.CloseSquareToken) && !isEOF())
+          rawCSSString += tokens[pos++].toSource();
+        if (!(tokens[pos] instanceof css.CloseSquareToken))
+          throw unexpected();
+        rawCSSString += "]";
         pos++;
       } else {
         throw unexpected();
       }
     }
-    if (!rawCSSString && !functions.length) throw unexpected();
-    return {
-      css: rawCSSString || undefined,
-      functions
-    };
+    if (!rawCSSString && !functions.length)
+      throw unexpected();
+    return { css: rawCSSString || void 0, functions };
   }
   function consumeBuiltinFunctionArguments() {
-    let s = '';
-    let balance = 1; // First open paren is a part of a function token.
+    let s = "";
+    let balance = 1;
     while (!isEOF()) {
-      if (isOpenParen() || isFunction()) balance++;
-      if (isCloseParen()) balance--;
-      if (!balance) break;
+      if (isOpenParen() || isFunction())
+        balance++;
+      if (isCloseParen())
+        balance--;
+      if (!balance)
+        break;
       s += tokens[pos++].toSource();
     }
     return s;
   }
   const result = consumeFunctionArguments();
-  if (!isEOF()) throw unexpected();
-  if (result.some(arg => typeof arg !== 'object' || !('simples' in arg))) throw new InvalidSelectorError(`Error while parsing selector "${selector}"`);
-  return {
-    selector: result,
-    names: Array.from(names)
-  };
+  if (!isEOF())
+    throw unexpected();
+  if (result.some((arg) => typeof arg !== "object" || !("simples" in arg)))
+    throw new InvalidSelectorError(`Error while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
+  return { selector: result, names: Array.from(names) };
 }
 function serializeSelector(args) {
-  return args.map(arg => {
-    if (typeof arg === 'string') return `"${arg}"`;
-    if (typeof arg === 'number') return String(arg);
-    return arg.simples.map(({
-      selector,
-      combinator
-    }) => {
-      let s = selector.css || '';
-      s = s + selector.functions.map(func => `:${func.name}(${serializeSelector(func.args)})`).join('');
-      if (combinator) s += ' ' + combinator;
+  return args.map((arg) => {
+    if (typeof arg === "string")
+      return `"${arg}"`;
+    if (typeof arg === "number")
+      return String(arg);
+    return arg.simples.map(({ selector, combinator }) => {
+      let s = selector.css || "";
+      s = s + selector.functions.map((func) => `:${func.name}(${serializeSelector(func.args)})`).join("");
+      if (combinator)
+        s += " " + combinator;
       return s;
-    }).join(' ');
-  }).join(', ');
-}
+    }).join(" ");
+  }).join(", ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvalidSelectorError,
+  isInvalidSelectorError,
+  parseCSS,
+  serializeSelector
+});