@skrillex1224/playwright-toolkit 3.0.15 → 3.0.17

package/dist/browser.js

@@ -34,6 +34,7 @@ var require_constants = __commonJS({
     "use strict";
     var WIN_SLASH = "\\\\/";
     var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
     var DOT_LITERAL = "\\.";
     var PLUS_LITERAL = "\\+";
     var QMARK_LITERAL = "\\?";
@@ -84,6 +85,7 @@ var require_constants = __commonJS({
       SEP: "\\"
     };
     var POSIX_REGEX_SOURCE = {
+      __proto__: null,
       alnum: "a-zA-Z0-9",
       alpha: "a-zA-Z",
       ascii: "\\x00-\\x7F",
@@ -100,6 +102,7 @@ var require_constants = __commonJS({
       xdigit: "A-Fa-f0-9"
     };
     module.exports = {
+      DEFAULT_MAX_EXTGLOB_RECURSION,
       MAX_LENGTH: 1024 * 64,
       POSIX_REGEX_SOURCE,
       // regular expressions
@@ -263,19 +266,19 @@ var require_utils = __commonJS({
       if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
       return `${input.slice(0, idx)}\\${input.slice(idx)}`;
     };
-    exports.removePrefix = (input, state = {}) => {
+    exports.removePrefix = (input, state2 = {}) => {
       let output = input;
       if (output.startsWith("./")) {
         output = output.slice(2);
-        state.prefix = "./";
+        state2.prefix = "./";
       }
       return output;
     };
-    exports.wrapOutput = (input, state = {}, options = {}) => {
+    exports.wrapOutput = (input, state2 = {}, options = {}) => {
       const prepend = options.contains ? "" : "^";
       const append = options.contains ? "" : "$";
       let output = `${prepend}(?:${input})${append}`;
-      if (state.negated === true) {
+      if (state2.negated === true) {
         output = `(?:^(?!${output}).*$)`;
       }
       return output;
@@ -561,7 +564,7 @@ var require_scan = __commonJS({
           base = utils.removeBackslashes(base);
         }
       }
-      const state = {
+      const state2 = {
         prefix,
         input,
         start,
@@ -576,11 +579,11 @@ var require_scan = __commonJS({
         negatedExtglob
       };
       if (opts.tokens === true) {
-        state.maxDepth = 0;
+        state2.maxDepth = 0;
         if (!isPathSeparator(code)) {
           tokens.push(token);
         }
-        state.tokens = tokens;
+        state2.tokens = tokens;
       }
       if (opts.parts === true || opts.tokens === true) {
         let prevIndex;
@@ -596,7 +599,7 @@ var require_scan = __commonJS({
               tokens[idx].value = value;
             }
             depth(tokens[idx]);
-            state.maxDepth += tokens[idx].depth;
+            state2.maxDepth += tokens[idx].depth;
           }
           if (idx !== 0 || value !== "") {
             parts.push(value);
@@ -609,13 +612,13 @@ var require_scan = __commonJS({
           if (opts.tokens) {
             tokens[tokens.length - 1].value = value;
             depth(tokens[tokens.length - 1]);
-            state.maxDepth += tokens[tokens.length - 1].depth;
+            state2.maxDepth += tokens[tokens.length - 1].depth;
           }
         }
-        state.slashes = slashes;
-        state.parts = parts;
+        state2.slashes = slashes;
+        state2.parts = parts;
       }
-      return state;
+      return state2;
     };
     module.exports = scan;
   }
@@ -650,6 +653,213 @@ var require_parse = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
+    var splitTopLevel = (input) => {
+      const parts = [];
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let value = "";
+      let escaped = false;
+      for (const ch of input) {
+        if (escaped === true) {
+          value += ch;
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch;
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[") {
+            bracket++;
+          } else if (ch === "]" && bracket > 0) {
+            bracket--;
+          } else if (bracket === 0) {
+            if (ch === "(") {
+              paren++;
+            } else if (ch === ")" && paren > 0) {
+              paren--;
+            } else if (ch === "|" && paren === 0) {
+              parts.push(value);
+              value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      parts.push(value);
+      return parts;
+    };
+    var isPlainBranch = (branch) => {
+      let escaped = false;
+      for (const ch of branch) {
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var normalizeSimpleBranch = (branch) => {
+      let value = branch.trim();
+      let changed = true;
+      while (changed === true) {
+        changed = false;
+        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+          value = value.slice(2, -1);
+          changed = true;
+        }
+      }
+      if (!isPlainBranch(value)) {
+        return;
+      }
+      return value.replace(/\\(.)/g, "$1");
+    };
+    var hasRepeatedCharPrefixOverlap = (branches) => {
+      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i = 0; i < values.length; i++) {
+        for (let j = i + 1; j < values.length; j++) {
+          const a = values[i];
+          const b = values[j];
+          const char = a[0];
+          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+            continue;
+          }
+          if (a === b || a.startsWith(b) || b.startsWith(a)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+        return;
+      }
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let escaped = false;
+      for (let i = 1; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote === 1) {
+          continue;
+        }
+        if (ch === "[") {
+          bracket++;
+          continue;
+        }
+        if (ch === "]" && bracket > 0) {
+          bracket--;
+          continue;
+        }
+        if (bracket > 0) {
+          continue;
+        }
+        if (ch === "(") {
+          paren++;
+          continue;
+        }
+        if (ch === ")") {
+          paren--;
+          if (paren === 0) {
+            if (requireEnd === true && i !== pattern.length - 1) {
+              return;
+            }
+            return {
+              type: pattern[0],
+              body: pattern.slice(2, i),
+              end: i
+            };
+          }
+        }
+      }
+    };
+    var getStarExtglobSequenceOutput = (pattern) => {
+      let index = 0;
+      const chars = [];
+      while (index < pattern.length) {
+        const match = parseRepeatedExtglob(pattern.slice(index), false);
+        if (!match || match.type !== "*") {
+          return;
+        }
+        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+        if (branches.length !== 1) {
+          return;
+        }
+        const branch = normalizeSimpleBranch(branches[0]);
+        if (!branch || branch.length !== 1) {
+          return;
+        }
+        chars.push(branch);
+        index += match.end + 1;
+      }
+      if (chars.length < 1) {
+        return;
+      }
+      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+      return `${source}*`;
+    };
+    var repeatedExtglobRecursion = (pattern) => {
+      let depth = 0;
+      let value = pattern.trim();
+      let match = parseRepeatedExtglob(value);
+      while (match) {
+        depth++;
+        value = match.body.trim();
+        match = parseRepeatedExtglob(value);
+      }
+      return depth;
+    };
+    var analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === false) {
+        return { risky: false };
+      }
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const branches = splitTopLevel(body).map((branch) => branch.trim());
+      if (branches.length > 1) {
+        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+          return { risky: true };
+        }
+      }
+      for (const branch of branches) {
+        const safeOutput = getStarExtglobSequenceOutput(branch);
+        if (safeOutput) {
+          return { risky: true, safeOutput };
+        }
+        if (repeatedExtglobRecursion(branch) > max) {
+          return { risky: true };
+        }
+      }
+      return { risky: false };
+    };
     var parse = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
@@ -692,7 +902,7 @@ var require_parse = __commonJS({
       if (typeof opts.noext === "boolean") {
         opts.noextglob = opts.noext;
       }
-      const state = {
+      const state2 = {
         input,
         index: -1,
         start: 0,
@@ -709,57 +919,57 @@ var require_parse = __commonJS({
         globstar: false,
         tokens
       };
-      input = utils.removePrefix(input, state);
+      input = utils.removePrefix(input, state2);
       len = input.length;
       const extglobs = [];
       const braces = [];
       const stack = [];
       let prev = bos;
       let value;
-      const eos = () => state.index === len - 1;
-      const peek = state.peek = (n = 1) => input[state.index + n];
-      const advance = state.advance = () => input[++state.index] || "";
-      const remaining = () => input.slice(state.index + 1);
+      const eos = () => state2.index === len - 1;
+      const peek = state2.peek = (n = 1) => input[state2.index + n];
+      const advance = state2.advance = () => input[++state2.index] || "";
+      const remaining = () => input.slice(state2.index + 1);
       const consume = (value2 = "", num = 0) => {
-        state.consumed += value2;
-        state.index += num;
+        state2.consumed += value2;
+        state2.index += num;
       };
       const append = (token) => {
-        state.output += token.output != null ? token.output : token.value;
+        state2.output += token.output != null ? token.output : token.value;
         consume(token.value);
       };
       const negate = () => {
         let count = 1;
         while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
           advance();
-          state.start++;
+          state2.start++;
           count++;
         }
         if (count % 2 === 0) {
           return false;
         }
-        state.negated = true;
-        state.start++;
+        state2.negated = true;
+        state2.start++;
         return true;
       };
       const increment = (type) => {
-        state[type]++;
+        state2[type]++;
         stack.push(type);
       };
       const decrement = (type) => {
-        state[type]--;
+        state2[type]--;
         stack.pop();
       };
       const push = (tok) => {
         if (prev.type === "globstar") {
-          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isBrace = state2.braces > 0 && (tok.type === "comma" || tok.type === "brace");
           const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
           if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
-            state.output = state.output.slice(0, -prev.output.length);
+            state2.output = state2.output.slice(0, -prev.output.length);
             prev.type = "star";
             prev.value = "*";
             prev.output = star;
-            state.output += prev.output;
+            state2.output += prev.output;
           }
         }
         if (extglobs.length && tok.type !== "paren") {
@@ -778,15 +988,37 @@ var require_parse = __commonJS({
       const extglobOpen = (type, value2) => {
         const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
         token.prev = prev;
-        token.parens = state.parens;
-        token.output = state.output;
+        token.parens = state2.parens;
+        token.output = state2.output;
+        token.startIndex = state2.index;
+        token.tokensIndex = tokens.length;
         const output = (opts.capture ? "(" : "") + token.open;
         increment("parens");
-        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push({ type, value: value2, output: state2.output ? "" : ONE_CHAR });
         push({ type: "paren", extglob: true, value: advance(), output });
         extglobs.push(token);
       };
       const extglobClose = (token) => {
+        const literal = input.slice(token.startIndex, state2.index + 1);
+        const body = input.slice(token.startIndex + 2, state2.index);
+        const analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+          const open = tokens[token.tokensIndex];
+          open.type = "text";
+          open.value = literal;
+          open.output = safeOutput || utils.escapeRegex(literal);
+          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+            tokens[i].value = "";
+            tokens[i].output = "";
+            delete tokens[i].suffix;
+          }
+          state2.output = token.output + open.output;
+          state2.backtrack = true;
+          push({ type: "paren", extglob: true, value, output: "" });
+          decrement("parens");
+          return;
+        }
         let output = token.close + (opts.capture ? ")" : "");
         let rest;
         if (token.type === "negate") {
@@ -802,7 +1034,7 @@ var require_parse = __commonJS({
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
-            state.negatedExtglob = true;
+            state2.negatedExtglob = true;
           }
         }
         push({ type: "paren", extglob: true, value, output });
@@ -845,11 +1077,11 @@ var require_parse = __commonJS({
           }
         }
         if (output === input && opts.contains === true) {
-          state.output = input;
-          return state;
+          state2.output = input;
+          return state2;
         }
-        state.output = utils.wrapOutput(output, state, options);
-        return state;
+        state2.output = utils.wrapOutput(output, state2, options);
+        return state2;
       }
       while (!eos()) {
         value = advance();
@@ -873,7 +1105,7 @@ var require_parse = __commonJS({
           let slashes = 0;
           if (match && match[0].length > 2) {
             slashes = match[0].length;
-            state.index += slashes;
+            state2.index += slashes;
             if (slashes % 2 !== 0) {
               value += "\\";
             }
@@ -883,12 +1115,12 @@ var require_parse = __commonJS({
           } else {
             value += advance();
           }
-          if (state.brackets === 0) {
+          if (state2.brackets === 0) {
             push({ type: "text", value });
             continue;
           }
         }
-        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+        if (state2.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
           if (opts.posix !== false && value === ":") {
             const inner = prev.value.slice(1);
             if (inner.includes("[")) {
@@ -900,7 +1132,7 @@ var require_parse = __commonJS({
                 const posix = POSIX_REGEX_SOURCE[rest2];
                 if (posix) {
                   prev.value = pre + posix;
-                  state.backtrack = true;
+                  state2.backtrack = true;
                   advance();
                   if (!bos.output && tokens.indexOf(prev) === 1) {
                     bos.output = ONE_CHAR;
@@ -923,14 +1155,14 @@ var require_parse = __commonJS({
           append({ value });
           continue;
         }
-        if (state.quotes === 1 && value !== '"') {
+        if (state2.quotes === 1 && value !== '"') {
           value = utils.escapeRegex(value);
           prev.value += value;
           append({ value });
           continue;
         }
         if (value === '"') {
-          state.quotes = state.quotes === 1 ? 0 : 1;
+          state2.quotes = state2.quotes === 1 ? 0 : 1;
           if (opts.keepQuotes === true) {
             push({ type: "text", value });
           }
@@ -942,15 +1174,15 @@ var require_parse = __commonJS({
           continue;
         }
         if (value === ")") {
-          if (state.parens === 0 && opts.strictBrackets === true) {
+          if (state2.parens === 0 && opts.strictBrackets === true) {
             throw new SyntaxError(syntaxError("opening", "("));
           }
           const extglob = extglobs[extglobs.length - 1];
-          if (extglob && state.parens === extglob.parens + 1) {
+          if (extglob && state2.parens === extglob.parens + 1) {
             extglobClose(extglobs.pop());
             continue;
           }
-          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          push({ type: "paren", value, output: state2.parens ? ")" : "\\)" });
           decrement("parens");
           continue;
         }
@@ -971,7 +1203,7 @@ var require_parse = __commonJS({
             push({ type: "text", value, output: `\\${value}` });
             continue;
           }
-          if (state.brackets === 0) {
+          if (state2.brackets === 0) {
             if (opts.strictBrackets === true) {
               throw new SyntaxError(syntaxError("opening", "["));
             }
@@ -989,14 +1221,14 @@ var require_parse = __commonJS({
             continue;
           }
           const escaped = utils.escapeRegex(prev.value);
-          state.output = state.output.slice(0, -prev.value.length);
+          state2.output = state2.output.slice(0, -prev.value.length);
           if (opts.literalBrackets === true) {
-            state.output += escaped;
+            state2.output += escaped;
             prev.value = escaped;
             continue;
           }
           prev.value = `(${capture}${escaped}|${prev.value})`;
-          state.output += prev.value;
+          state2.output += prev.value;
           continue;
         }
         if (value === "{" && opts.nobrace !== true) {
@@ -1005,8 +1237,8 @@ var require_parse = __commonJS({
             type: "brace",
             value,
             output: "(",
-            outputIndex: state.output.length,
-            tokensIndex: state.tokens.length
+            outputIndex: state2.output.length,
+            tokensIndex: state2.tokens.length
           };
           braces.push(open);
           push(open);
@@ -1032,16 +1264,16 @@ var require_parse = __commonJS({
               }
             }
             output = expandRange(range, opts);
-            state.backtrack = true;
+            state2.backtrack = true;
           }
           if (brace.comma !== true && brace.dots !== true) {
-            const out = state.output.slice(0, brace.outputIndex);
-            const toks = state.tokens.slice(brace.tokensIndex);
+            const out = state2.output.slice(0, brace.outputIndex);
+            const toks = state2.tokens.slice(brace.tokensIndex);
             brace.value = brace.output = "\\{";
             value = output = "\\}";
-            state.output = out;
+            state2.output = out;
             for (const t of toks) {
-              state.output += t.output || t.value;
+              state2.output += t.output || t.value;
             }
           }
           push({ type: "brace", value, output });
@@ -1067,10 +1299,10 @@ var require_parse = __commonJS({
           continue;
         }
         if (value === "/") {
-          if (prev.type === "dot" && state.index === state.start + 1) {
-            state.start = state.index + 1;
-            state.consumed = "";
-            state.output = "";
+          if (prev.type === "dot" && state2.index === state2.start + 1) {
+            state2.start = state2.index + 1;
+            state2.consumed = "";
+            state2.output = "";
             tokens.pop();
             prev = bos;
             continue;
@@ -1079,7 +1311,7 @@ var require_parse = __commonJS({
           continue;
         }
         if (value === ".") {
-          if (state.braces > 0 && prev.type === "dot") {
+          if (state2.braces > 0 && prev.type === "dot") {
             if (prev.value === ".") prev.output = DOT_LITERAL;
             const brace = braces[braces.length - 1];
             prev.type = "dots";
@@ -1088,7 +1320,7 @@ var require_parse = __commonJS({
             brace.dots = true;
             continue;
           }
-          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+          if (state2.braces + state2.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
             push({ type: "text", value, output: DOT_LITERAL });
             continue;
           }
@@ -1124,7 +1356,7 @@ var require_parse = __commonJS({
               continue;
             }
           }
-          if (opts.nonegate !== true && state.index === 0) {
+          if (opts.nonegate !== true && state2.index === 0) {
             negate();
             continue;
           }
@@ -1138,7 +1370,7 @@ var require_parse = __commonJS({
             push({ type: "plus", value, output: PLUS_LITERAL });
             continue;
           }
-          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state2.parens > 0) {
             push({ type: "plus", value });
             continue;
           }
@@ -1160,7 +1392,7 @@ var require_parse = __commonJS({
           const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
           if (match) {
             value += match[0];
-            state.index += match[0].length;
+            state2.index += match[0].length;
           }
           push({ type: "text", value });
           continue;
@@ -1170,8 +1402,8 @@ var require_parse = __commonJS({
           prev.star = true;
           prev.value += value;
           prev.output = star;
-          state.backtrack = true;
-          state.globstar = true;
+          state2.backtrack = true;
+          state2.globstar = true;
           consume(value);
           continue;
         }
@@ -1193,14 +1425,14 @@ var require_parse = __commonJS({
             push({ type: "star", value, output: "" });
             continue;
           }
-          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isBrace = state2.braces > 0 && (prior.type === "comma" || prior.type === "brace");
           const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
           if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
             push({ type: "star", value, output: "" });
             continue;
           }
           while (rest.slice(0, 3) === "/**") {
-            const after = input[state.index + 4];
+            const after = input[state2.index + 4];
             if (after && after !== "/") {
               break;
             }
@@ -1211,31 +1443,31 @@ var require_parse = __commonJS({
             prev.type = "globstar";
             prev.value += value;
             prev.output = globstar(opts);
-            state.output = prev.output;
-            state.globstar = true;
+            state2.output = prev.output;
+            state2.globstar = true;
             consume(value);
             continue;
           }
           if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
-            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            state2.output = state2.output.slice(0, -(prior.output + prev.output).length);
             prior.output = `(?:${prior.output}`;
             prev.type = "globstar";
             prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
             prev.value += value;
-            state.globstar = true;
-            state.output += prior.output + prev.output;
+            state2.globstar = true;
+            state2.output += prior.output + prev.output;
             consume(value);
             continue;
           }
           if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
             const end = rest[1] !== void 0 ? "|$" : "";
-            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            state2.output = state2.output.slice(0, -(prior.output + prev.output).length);
             prior.output = `(?:${prior.output}`;
             prev.type = "globstar";
             prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
             prev.value += value;
-            state.output += prior.output + prev.output;
-            state.globstar = true;
+            state2.output += prior.output + prev.output;
+            state2.globstar = true;
             consume(value + advance());
             push({ type: "slash", value: "/", output: "" });
             continue;
@@ -1244,18 +1476,18 @@ var require_parse = __commonJS({
             prev.type = "globstar";
             prev.value += value;
             prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-            state.output = prev.output;
-            state.globstar = true;
+            state2.output = prev.output;
+            state2.globstar = true;
             consume(value + advance());
             push({ type: "slash", value: "/", output: "" });
             continue;
           }
-          state.output = state.output.slice(0, -prev.output.length);
+          state2.output = state2.output.slice(0, -prev.output.length);
           prev.type = "globstar";
           prev.output = globstar(opts);
           prev.value += value;
-          state.output += prev.output;
-          state.globstar = true;
+          state2.output += prev.output;
+          state2.globstar = true;
           consume(value);
           continue;
         }
@@ -1273,52 +1505,52 @@ var require_parse = __commonJS({
           push(token);
           continue;
         }
-        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+        if (state2.index === state2.start || prev.type === "slash" || prev.type === "dot") {
           if (prev.type === "dot") {
-            state.output += NO_DOT_SLASH;
+            state2.output += NO_DOT_SLASH;
             prev.output += NO_DOT_SLASH;
           } else if (opts.dot === true) {
-            state.output += NO_DOTS_SLASH;
+            state2.output += NO_DOTS_SLASH;
             prev.output += NO_DOTS_SLASH;
           } else {
-            state.output += nodot;
+            state2.output += nodot;
             prev.output += nodot;
           }
           if (peek() !== "*") {
-            state.output += ONE_CHAR;
+            state2.output += ONE_CHAR;
             prev.output += ONE_CHAR;
           }
         }
         push(token);
       }
-      while (state.brackets > 0) {
+      while (state2.brackets > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-        state.output = utils.escapeLast(state.output, "[");
+        state2.output = utils.escapeLast(state2.output, "[");
         decrement("brackets");
       }
-      while (state.parens > 0) {
+      while (state2.parens > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-        state.output = utils.escapeLast(state.output, "(");
+        state2.output = utils.escapeLast(state2.output, "(");
         decrement("parens");
       }
-      while (state.braces > 0) {
+      while (state2.braces > 0) {
         if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-        state.output = utils.escapeLast(state.output, "{");
+        state2.output = utils.escapeLast(state2.output, "{");
         decrement("braces");
       }
       if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
         push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
       }
-      if (state.backtrack === true) {
-        state.output = "";
-        for (const token of state.tokens) {
-          state.output += token.output != null ? token.output : token.value;
+      if (state2.backtrack === true) {
+        state2.output = "";
+        for (const token of state2.tokens) {
+          state2.output += token.output != null ? token.output : token.value;
           if (token.suffix) {
-            state.output += token.suffix;
+            state2.output += token.suffix;
           }
         }
       }
-      return state;
+      return state2;
     };
     parse.fastpaths = (input, options) => {
       const opts = { ...options };
@@ -1342,7 +1574,7 @@ var require_parse = __commonJS({
       const nodot = opts.dot ? NO_DOTS : NO_DOT;
       const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
       const capture = opts.capture ? "" : "?:";
-      const state = { negated: false, prefix: "" };
+      const state2 = { negated: false, prefix: "" };
       let star = opts.bash === true ? ".*?" : STAR;
       if (opts.capture) {
         star = `(${star})`;
@@ -1378,7 +1610,7 @@ var require_parse = __commonJS({
           }
         }
       };
-      const output = utils.removePrefix(input, state);
+      const output = utils.removePrefix(input, state2);
       let source = create(output);
       if (source && opts.strictSlashes !== true) {
         source += `${SLASH_LITERAL}?`;
@@ -1403,8 +1635,8 @@ var require_picomatch = __commonJS({
         const fns = glob.map((input) => picomatch2(input, options, returnState));
         const arrayMatcher = (str) => {
           for (const isMatch of fns) {
-            const state2 = isMatch(str);
-            if (state2) return state2;
+            const state3 = isMatch(str);
+            if (state3) return state3;
           }
           return false;
         };
@@ -1417,7 +1649,7 @@ var require_picomatch = __commonJS({
       const opts = options || {};
       const posix = opts.windows;
       const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
-      const state = regex.state;
+      const state2 = regex.state;
       delete regex.state;
       let isIgnored = () => false;
       if (opts.ignore) {
@@ -1426,7 +1658,7 @@ var require_picomatch = __commonJS({
       }
       const matcher = (input, returnObject = false) => {
         const { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix });
-        const result = { glob, state, regex, posix, input, output, match, isMatch };
+        const result = { glob, state: state2, regex, posix, input, output, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
         }
@@ -1447,7 +1679,7 @@ var require_picomatch = __commonJS({
         return returnObject ? result : true;
       };
       if (returnState) {
-        matcher.state = state;
+        matcher.state = state2;
       }
       return matcher;
     };
@@ -1485,20 +1717,20 @@ var require_picomatch = __commonJS({
       return parse(pattern, { ...options, fastpaths: false });
     };
     picomatch2.scan = (input, options) => scan(input, options);
-    picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    picomatch2.compileRe = (state2, options, returnOutput = false, returnState = false) => {
       if (returnOutput === true) {
-        return state.output;
+        return state2.output;
       }
       const opts = options || {};
       const prepend = opts.contains ? "" : "^";
       const append = opts.contains ? "" : "$";
-      let source = `${prepend}(?:${state.output})${append}`;
-      if (state && state.negated === true) {
+      let source = `${prepend}(?:${state2.output})${append}`;
+      if (state2 && state2.negated === true) {
         source = `^(?!${source}).*$`;
       }
       const regex = picomatch2.toRegex(source, options);
       if (returnState === true) {
-        regex.state = state;
+        regex.state = state2;
       }
       return regex;
     };
@@ -2512,9 +2744,12 @@ __export(constants_exports, {
   ActorInfo: () => ActorInfo,
   Code: () => Code,
   Device: () => Device,
+  Mode: () => Mode,
   PresetOfLiveViewKey: () => PresetOfLiveViewKey,
   Status: () => Status,
-  normalizeDevice: () => normalizeDevice
+  mode: () => mode,
+  normalizeDevice: () => normalizeDevice,
+  normalizeMode: () => normalizeMode
 });
 var Code = {
   Success: 0,
@@ -2534,6 +2769,14 @@ var Device = Object.freeze({
   Desktop: "desktop",
   Mobile: "mobile"
 });
+var Mode = Object.freeze({
+  Default: "default",
+  Cloak: "cloak"
+});
+var mode = Object.freeze({
+  default: Mode.Default,
+  cloak: Mode.Cloak
+});
 var normalizeDevice = (value, fallback = Device.Desktop) => {
   const normalizedFallback = String(fallback || "").trim().toLowerCase() === Device.Mobile ? Device.Mobile : Device.Desktop;
   const raw = String(value || "").trim().toLowerCase();
@@ -2541,6 +2784,13 @@ var normalizeDevice = (value, fallback = Device.Desktop) => {
   if (raw === Device.Desktop) return Device.Desktop;
   return normalizedFallback;
 };
+var normalizeMode = (value, fallback = Mode.Default) => {
+  const normalizedFallback = String(fallback || "").trim().toLowerCase() === Mode.Cloak ? Mode.Cloak : Mode.Default;
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === Mode.Cloak) return Mode.Cloak;
+  if (raw === Mode.Default) return Mode.Default;
+  return normalizedFallback;
+};
 var createActorInfo = (info) => {
   const normalizeDomain = (value) => {
     if (!value) return "";
@@ -2555,7 +2805,7 @@ var createActorInfo = (info) => {
   const normalizeShare = (value) => {
     const raw = value && typeof value === "object" ? value : {};
     const modeRaw = String(raw.mode || "dom").trim().toLowerCase();
-    const mode = ["dom", "response", "custom"].includes(modeRaw) ? modeRaw : "dom";
+    const mode2 = ["dom", "response", "custom"].includes(modeRaw) ? modeRaw : "dom";
     const prefix = String(raw.prefix || "").trim();
     const rawXurl = Array.isArray(raw.xurl) ? raw.xurl : [];
     const normalizeMatcherList = (input) => {
@@ -2600,7 +2850,7 @@ var createActorInfo = (info) => {
       xurl.push(...extraPaths);
     }
     return {
-      mode,
+      mode: mode2,
       prefix,
       xurl
     };
@@ -2608,7 +2858,6 @@ var createActorInfo = (info) => {
   const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path2 }) => {
     const safeProtocol = String(protocol2).trim();
     const safeDomain = normalizeDomain(domain2);
-    if (!safeDomain) return "";
     const safePath = normalizePath(path2);
     return `${safeProtocol}://${safeDomain}${safePath}`;
   };
@@ -2816,18 +3065,6 @@ var ActorInfo = {
       prefix: "",
       xurl: []
     }
-  }),
-  // 通用网页抓取 Actor：入口 URL 来自 query，因此这里只声明统一的 Actor 元信息。
-  webpage: createActorInfo({
-    key: "webpage",
-    name: "\u901A\u7528\u7F51\u9875",
-    domain: "",
-    path: "/",
-    share: {
-      mode: "dom",
-      prefix: "",
-      xurl: []
-    }
   })
 };
 
@@ -2916,6 +3153,7 @@ var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
 
 // src/runtime-env.js
 var BROWSER_PROFILE_SCHEMA_VERSION = 1;
+var SUPPORTED_CLOAK_FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["linux", "macos", "windows"]);
 var rememberedRuntimeState = null;
 var isPlainObject = (value) => value && typeof value === "object" && !Array.isArray(value);
 var normalizeKnownDevice = (value) => {
@@ -2924,6 +3162,22 @@ var normalizeKnownDevice = (value) => {
   if (raw === Device.Desktop) return Device.Desktop;
   return "";
 };
+var normalizeCloakSeed = (value) => {
+  const numericSeed = Number(value);
+  if (Number.isSafeInteger(numericSeed) && numericSeed > 0) {
+    return numericSeed;
+  }
+  const raw = String(value || "").trim();
+  if (!/^\d+$/.test(raw)) {
+    return 0;
+  }
+  const parsedSeed = Number(raw);
+  return Number.isSafeInteger(parsedSeed) && parsedSeed > 0 ? parsedSeed : 0;
+};
+var normalizeCloakFingerprintPlatform = (value) => {
+  const raw = String(value || "").trim().toLowerCase();
+  return SUPPORTED_CLOAK_FINGERPRINT_PLATFORMS.has(raw) ? raw : "";
+};
 var deepClone = (value) => {
   if (value == null) return value;
   try {
@@ -3297,6 +3551,14 @@ var normalizeBrowserProfileCore = (value) => {
   if (Number.isFinite(browserMajorVersion) && browserMajorVersion > 0) {
     profile.browser_major_version = browserMajorVersion;
   }
+  const cloakSeed = normalizeCloakSeed(source.cloak_seed);
+  if (cloakSeed > 0) {
+    profile.cloak_seed = cloakSeed;
+  }
+  const cloakFingerprintPlatform = normalizeCloakFingerprintPlatform(source.cloak_fingerprint_platform);
+  if (cloakFingerprintPlatform) {
+    profile.cloak_fingerprint_platform = cloakFingerprintPlatform;
+  }
   const schemaVersion = Number(source.schema_version || 0);
   if (Number.isFinite(schemaVersion) && schemaVersion > 0) {
     profile.schema_version = schemaVersion;
@@ -3384,8 +3646,8 @@ var normalizeBrowserProfile = (value) => {
     payload: buildBrowserProfilePayload(core, observed)
   };
 };
-var rememberRuntimeState = (state) => {
-  rememberedRuntimeState = deepClone(state);
+var rememberRuntimeState = (state2) => {
+  rememberedRuntimeState = deepClone(state2);
   return rememberedRuntimeState;
 };
 var normalizeRuntimeState = (source = {}, actor = "") => {
@@ -3445,7 +3707,7 @@ var RuntimeEnv = {
     } else {
       delete normalizedRuntime.browser_profile;
     }
-    const state = {
+    const state2 = {
       actor: resolvedActor,
       device,
       runtime: normalizedRuntime,
@@ -3459,73 +3721,73 @@ var RuntimeEnv = {
       browserProfileCore: browserProfile.core,
       browserProfileObserved: browserProfile.observed
     };
-    rememberRuntimeState(state);
-    return state;
+    rememberRuntimeState(state2);
+    return state2;
   },
   // buildEnvPatch 只构造允许回写到后端 env 的字段集合。
   buildEnvPatch(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    const browserProfile = buildBrowserProfilePayload(state.browserProfileCore, state.browserProfileObserved);
+    const state2 = normalizeRuntimeState(source, actor);
+    const browserProfile = buildBrowserProfilePayload(state2.browserProfileCore, state2.browserProfileObserved);
     const envPatch = {
-      ...Array.isArray(state.cookies) && state.cookies.length > 0 ? { cookies: state.cookies } : {},
-      ...Object.keys(state.localStorage || {}).length > 0 ? { local_storage: state.localStorage } : {},
-      ...Object.keys(state.sessionStorage || {}).length > 0 ? { session_storage: state.sessionStorage } : {},
+      ...Array.isArray(state2.cookies) && state2.cookies.length > 0 ? { cookies: state2.cookies } : {},
+      ...Object.keys(state2.localStorage || {}).length > 0 ? { local_storage: state2.localStorage } : {},
+      ...Object.keys(state2.sessionStorage || {}).length > 0 ? { session_storage: state2.sessionStorage } : {},
       ...Object.keys(browserProfile).length > 0 ? { browser_profile: browserProfile } : {}
     };
     return Object.keys(envPatch).length > 0 ? envPatch : null;
   },
   // hasLoginState 只判断 runtime 是否存在有效载荷，不再区分具体字段来源。
   hasLoginState(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    return isPlainObject(state.runtime) && Object.keys(state.runtime || {}).length > 0;
+    const state2 = normalizeRuntimeState(source, actor);
+    return isPlainObject(state2.runtime) && Object.keys(state2.runtime || {}).length > 0;
   },
   rememberState(source = {}) {
-    const state = normalizeRuntimeState(source);
-    rememberRuntimeState(state);
+    const state2 = normalizeRuntimeState(source);
+    rememberRuntimeState(state2);
     return RuntimeEnv.peekRememberedState();
   },
   peekRememberedState() {
     return rememberedRuntimeState ? deepClone(rememberedRuntimeState) : null;
   },
   getBrowserProfileCore(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    return deepClone(state.browserProfileCore || {});
+    const state2 = normalizeRuntimeState(source, actor);
+    return deepClone(state2.browserProfileCore || {});
   },
   setBrowserProfileCore(source = {}, core = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
+    const state2 = normalizeRuntimeState(source, actor);
     const normalizedCore = normalizeBrowserProfileCore({
       ...core,
-      device: normalizeKnownDevice(core == null ? void 0 : core.device) || state.device
+      device: normalizeKnownDevice(core == null ? void 0 : core.device) || state2.device
     });
-    state.browserProfileCore = normalizedCore;
-    state.browserProfile = buildBrowserProfilePayload(normalizedCore, state.browserProfileObserved);
-    if (Object.keys(state.browserProfile).length > 0) {
-      state.runtime.browser_profile = state.browserProfile;
+    state2.browserProfileCore = normalizedCore;
+    state2.browserProfile = buildBrowserProfilePayload(normalizedCore, state2.browserProfileObserved);
+    if (Object.keys(state2.browserProfile).length > 0) {
+      state2.runtime.browser_profile = state2.browserProfile;
     } else {
-      delete state.runtime.browser_profile;
+      delete state2.runtime.browser_profile;
     }
-    rememberRuntimeState(state);
-    return state;
+    rememberRuntimeState(state2);
+    return state2;
   },
   // applyToPage 只负责把登录态相关字段注入页面：
   // cookies / localStorage / sessionStorage。
   // 指纹、时区、UA、viewport 的回放发生在 launch.js 启动阶段，不在这里做。
   async applyToPage(page, source = {}, options = {}) {
     if (!page) return;
-    let state = normalizeRuntimeState(source, (options == null ? void 0 : options.actor) || "");
+    let state2 = normalizeRuntimeState(source, (options == null ? void 0 : options.actor) || "");
     if (typeof (options == null ? void 0 : options.preapply) === "function") {
-      state = await options.preapply(state) || state;
-      rememberRuntimeState(state);
+      state2 = await options.preapply(state2) || state2;
+      rememberRuntimeState(state2);
     }
     Object.defineProperty(page, PageRuntimeStateKey, {
       configurable: true,
       enumerable: false,
       writable: true,
-      value: state
+      value: state2
     });
-    const localStorage = state.localStorage || {};
-    const sessionStorage = state.sessionStorage || {};
-    const cookies = (state.cookies || []).map((cookie) => {
+    const localStorage = state2.localStorage || {};
+    const sessionStorage = state2.sessionStorage || {};
+    const cookies = (state2.cookies || []).map((cookie) => {
       const normalized = { ...cookie };
       if (!normalized.path) {
         normalized.path = "/";
@@ -3563,8 +3825,8 @@ var RuntimeEnv = {
   },
   // captureEnvPatch 在任务结束时采集最新环境快照，用于 pushSuccess / pushFailed 自动回写。
   async captureEnvPatch(page, source = {}, options = {}) {
-    const state = normalizeRuntimeState(source, (options == null ? void 0 : options.actor) || "");
-    const baseline = RuntimeEnv.buildEnvPatch(state) || {};
+    const state2 = normalizeRuntimeState(source, (options == null ? void 0 : options.actor) || "");
+    const baseline = RuntimeEnv.buildEnvPatch(state2) || {};
     if (!page || typeof page.evaluate !== "function" || typeof page.context !== "function") {
       return Object.keys(baseline).length > 0 ? baseline : null;
     }
@@ -3583,7 +3845,7 @@ var RuntimeEnv = {
           cookies
         },
         {
-          browserProfileCore: state.browserProfileCore
+          browserProfileCore: state2.browserProfileCore
         }
       );
       return RuntimeEnv.mergeEnvPatches(baseline, capturedPatch);
@@ -3593,8 +3855,28 @@ var RuntimeEnv = {
   }
 };
 
+// src/internals/context.js
+var state = {
+  mode: Mode.Default
+};
+var ToolkitContext = {
+  get mode() {
+    return state.mode;
+  },
+  setMode(mode2 = Mode.Default) {
+    state.mode = normalizeMode(mode2, Mode.Default);
+    return state.mode;
+  }
+};
+var setToolkitMode = (mode2 = Mode.Default) => ToolkitContext.setMode(mode2);
+
 // entrys/browser.js
+var ToolkitMode = Object.freeze({
+  default: Mode.Default,
+  cloak: Mode.Cloak
+});
 var usePlaywrightToolKit = () => {
+  setToolkitMode(Mode.Default);
   return {
     Logger,
     Display,
@@ -3607,6 +3889,7 @@ var usePlaywrightToolKit = () => {
     }
   };
 };
+usePlaywrightToolKit.Mode = ToolkitMode;
 export {
   usePlaywrightToolKit
 };