@skrillex1224/playwright-toolkit 3.0.39 → 3.0.40

package/dist/browser.js

@@ -1398,9 +1398,9 @@ var require_picomatch = __commonJS({
     var utils = require_utils();
     var constants = require_constants();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
-    var picomatch2 = (glob, options, returnState = false) => {
+    var picomatch3 = (glob, options, returnState = false) => {
       if (Array.isArray(glob)) {
-        const fns = glob.map((input) => picomatch2(input, options, returnState));
+        const fns = glob.map((input) => picomatch3(input, options, returnState));
         const arrayMatcher = (str) => {
           for (const isMatch of fns) {
             const state3 = isMatch(str);
@@ -1416,16 +1416,16 @@ 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 regex = isState ? picomatch3.compileRe(glob, options) : picomatch3.makeRe(glob, options, false, true);
       const state2 = regex.state;
       delete regex.state;
       let isIgnored = () => false;
       if (opts.ignore) {
         const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+        isIgnored = picomatch3(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input, returnObject = false) => {
-        const { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix });
+        const { isMatch, match, output } = picomatch3.test(input, regex, options, { glob, posix });
         const result = { glob, state: state2, regex, posix, input, output, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
@@ -1451,7 +1451,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch2.test = (input, regex, options, { glob, posix } = {}) => {
+    picomatch3.test = (input, regex, options, { glob, posix } = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -1468,24 +1468,24 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch2.matchBase(input, regex, options, posix);
+          match = picomatch3.matchBase(input, regex, options, posix);
         } else {
           match = regex.exec(output);
         }
       }
       return { isMatch: Boolean(match), match, output };
     };
-    picomatch2.matchBase = (input, glob, options) => {
-      const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
+    picomatch3.matchBase = (input, glob, options) => {
+      const regex = glob instanceof RegExp ? glob : picomatch3.makeRe(glob, options);
       return regex.test(utils.basename(input));
     };
-    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
-    picomatch2.parse = (pattern, options) => {
-      if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
+    picomatch3.isMatch = (str, patterns, options) => picomatch3(patterns, options)(str);
+    picomatch3.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch3.parse(p, options));
       return parse(pattern, { ...options, fastpaths: false });
     };
-    picomatch2.scan = (input, options) => scan(input, options);
-    picomatch2.compileRe = (state2, options, returnOutput = false, returnState = false) => {
+    picomatch3.scan = (input, options) => scan(input, options);
+    picomatch3.compileRe = (state2, options, returnOutput = false, returnState = false) => {
       if (returnOutput === true) {
         return state2.output;
       }
@@ -1496,13 +1496,13 @@ var require_picomatch = __commonJS({
       if (state2 && state2.negated === true) {
         source = `^(?!${source}).*$`;
       }
-      const regex = picomatch2.toRegex(source, options);
+      const regex = picomatch3.toRegex(source, options);
       if (returnState === true) {
         regex.state = state2;
       }
       return regex;
     };
-    picomatch2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    picomatch3.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
       if (!input || typeof input !== "string") {
         throw new TypeError("Expected a non-empty string");
       }
@@ -1513,9 +1513,9 @@ var require_picomatch = __commonJS({
       if (!parsed.output) {
         parsed = parse(input, options);
       }
-      return picomatch2.compileRe(parsed, options, returnOutput, returnState);
+      return picomatch3.compileRe(parsed, options, returnOutput, returnState);
     };
-    picomatch2.toRegex = (source, options) => {
+    picomatch3.toRegex = (source, options) => {
       try {
         const opts = options || {};
         return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
@@ -1524,8 +1524,8 @@ var require_picomatch = __commonJS({
         return /$^/;
       }
     };
-    picomatch2.constants = constants;
-    module.exports = picomatch2;
+    picomatch3.constants = constants;
+    module.exports = picomatch3;
   }
 });
 
@@ -1535,14 +1535,14 @@ var require_picomatch2 = __commonJS({
     "use strict";
     var pico = require_picomatch();
     var utils = require_utils();
-    function picomatch2(glob, options, returnState = false) {
+    function picomatch3(glob, options, returnState = false) {
       if (options && (options.windows === null || options.windows === void 0)) {
         options = { ...options, windows: utils.isWindows() };
       }
       return pico(glob, options, returnState);
     }
-    Object.assign(picomatch2, pico);
-    module.exports = picomatch2;
+    Object.assign(picomatch3, pico);
+    module.exports = picomatch3;
   }
 });
 
@@ -1574,18 +1574,18 @@ var fallbackLog = {
   error: (...args) => console.error(...args),
   debug: (...args) => console.debug ? console.debug(...args) : console.log(...args)
 };
-var resolveLogMethod = (logger, name) => {
-  if (logger && typeof logger[name] === "function") {
-    return logger[name].bind(logger);
+var resolveLogMethod = (logger2, name) => {
+  if (logger2 && typeof logger2[name] === "function") {
+    return logger2[name].bind(logger2);
   }
-  if (name === "warning" && logger && typeof logger.warn === "function") {
-    return logger.warn.bind(logger);
+  if (name === "warning" && logger2 && typeof logger2.warn === "function") {
+    return logger2.warn.bind(logger2);
   }
   return fallbackLog[name];
 };
 var defaultLogger = null;
-var setDefaultLogger = (logger) => {
-  defaultLogger = logger;
+var setDefaultLogger = (logger2) => {
+  defaultLogger = logger2;
 };
 var resolveLogger = (explicitLogger) => {
   if (explicitLogger && typeof explicitLogger.info === "function") {
@@ -1612,8 +1612,8 @@ var colorize = (text, color) => {
 var createBaseLogger = (prefix = "", explicitLogger) => {
   const name = prefix ? String(prefix) : "";
   const dispatch = (methodName, icon, message, color) => {
-    const logger = resolveLogger(explicitLogger);
-    const logFn = resolveLogMethod(logger, methodName);
+    const logger2 = resolveLogger(explicitLogger);
+    const logFn = resolveLogMethod(logger2, methodName);
     const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
     const line = formatLine(name, icon, message);
     const coloredLine = colorize(line, color);
@@ -1629,6 +1629,38 @@ var createBaseLogger = (prefix = "", explicitLogger) => {
     start: (message) => dispatch("info", "\u{1F537}", message, ANSI.blue)
   };
 };
+function createInternalLogger(moduleName, explicitLogger) {
+  const baseLogger = createBaseLogger(moduleName, explicitLogger);
+  return {
+    start(methodName, params = "") {
+      const paramStr = params ? ` (${params})` : "";
+      baseLogger.start(`${methodName} \u5F00\u59CB${paramStr}`);
+    },
+    success(methodName, result = "") {
+      const resultStr = result ? ` (${result})` : "";
+      baseLogger.success(`${methodName} \u5B8C\u6210${resultStr}`);
+    },
+    fail(methodName, error) {
+      const message = error instanceof Error ? error.message : error;
+      baseLogger.error(`${methodName} \u5931\u8D25: ${message}`);
+    },
+    debug(message) {
+      baseLogger.debug(message);
+    },
+    warn(message) {
+      baseLogger.warning(message);
+    },
+    warning(message) {
+      baseLogger.warning(message);
+    },
+    info(message) {
+      baseLogger.info(message);
+    },
+    error(message) {
+      baseLogger.error(message);
+    }
+  };
+}
 
 // src/logger.js
 var stripAnsi = (input) => {
@@ -2433,7 +2465,7 @@ var createTemplateLogger = (baseLogger = createBaseLogger()) => {
 };
 var getDefaultBaseLogger = () => createBaseLogger("");
 var Logger = {
-  setLogger: (logger) => setDefaultLogger(logger),
+  setLogger: (logger2) => setDefaultLogger(logger2),
   info: (message) => getDefaultBaseLogger().info(message),
   success: (message) => getDefaultBaseLogger().success(message),
   warning: (message) => getDefaultBaseLogger().warning(message),
@@ -2441,8 +2473,8 @@ var Logger = {
   error: (message) => getDefaultBaseLogger().error(message),
   debug: (message) => getDefaultBaseLogger().debug(message),
   start: (message) => getDefaultBaseLogger().start(message),
-  useTemplate: (logger) => {
-    if (logger) return createTemplateLogger(createBaseLogger("", logger));
+  useTemplate: (logger2) => {
+    if (logger2) return createTemplateLogger(createBaseLogger("", logger2));
     return createTemplateLogger();
   }
 };
@@ -2928,12 +2960,16 @@ var ByPass = {
   resolveRouteByProxy
 };
 
+// src/runtime-env.js
+var import_picomatch2 = __toESM(require_picomatch2(), 1);
+
 // src/internals/constants.js
 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 logger = createInternalLogger("RuntimeEnv");
 var rememberedRuntimeState = null;
 var isPlainObject = (value) => value && typeof value === "object" && !Array.isArray(value);
 var normalizeKnownDevice = (value) => {
@@ -3091,6 +3127,18 @@ var uniqueStrings = (value) => {
   });
   return result;
 };
+var buildApplyExcludeMatcher = (patterns = []) => {
+  const normalized = (Array.isArray(patterns) ? patterns : []).map((pattern) => String(pattern || "").trim()).filter(Boolean);
+  return normalized.length > 0 ? (0, import_picomatch2.default)(normalized, { nocase: true }) : () => false;
+};
+var filterApplyEntries = (entries = {}, matcher = () => false) => Object.entries(entries || {}).reduce((acc, [key, value]) => {
+  if (matcher(key)) acc.skipped.push(key);
+  else acc.payload[key] = value;
+  return acc;
+}, { payload: {}, skipped: [] });
+var logApplySkipped = (type, keys = []) => {
+  if (keys.length > 0) logger.info(`applyToPage \u8DF3\u8FC7\u6CE8\u5165 ${type}: ${keys.join(", ")}`);
+};
 var normalizeHttpUrlList = (value) => uniqueStrings(
   (Array.isArray(value) ? value : [value]).map((item) => normalizeHttpUrl(item)).filter(Boolean)
 );
@@ -3565,9 +3613,24 @@ var RuntimeEnv = {
       writable: true,
       value: state2
     });
-    const localStorage = state2.localStorage || {};
-    const sessionStorage = state2.sessionStorage || {};
-    const cookies = (state2.cookies || []).map((cookie) => {
+    const exclude = (options == null ? void 0 : options.exclude) || {};
+    const localStorageResult = filterApplyEntries(
+      state2.localStorage || {},
+      buildApplyExcludeMatcher(exclude.local_storage)
+    );
+    const sessionStorageResult = filterApplyEntries(
+      state2.sessionStorage || {},
+      buildApplyExcludeMatcher(exclude.session_storage)
+    );
+    const cookieMatcher = buildApplyExcludeMatcher(exclude.cookies);
+    const skippedCookies = [];
+    const localStorage = localStorageResult.payload;
+    const sessionStorage = sessionStorageResult.payload;
+    const cookies = (state2.cookies || []).filter((cookie) => {
+      if (!cookieMatcher(cookie == null ? void 0 : cookie.name)) return true;
+      skippedCookies.push(cookie.name);
+      return false;
+    }).map((cookie) => {
       const normalized = { ...cookie };
       if (!normalized.path) {
         normalized.path = "/";
@@ -3577,6 +3640,9 @@ var RuntimeEnv = {
       }
       return normalized;
     }).filter(Boolean);
+    logApplySkipped("cookies", skippedCookies);
+    logApplySkipped("local_storage", localStorageResult.skipped);
+    logApplySkipped("session_storage", sessionStorageResult.skipped);
     if (cookies.length > 0) {
       await page.context().addCookies(cookies);
     }