@crawlee/puppeteer 4.0.0-beta.15 → 4.0.0-beta.151

package/internals/puppeteer-launcher.d.ts

@@ -3,6 +3,7 @@ import { BrowserLauncher, Configuration } from '@crawlee/browser';
 import { PuppeteerPlugin } from '@crawlee/browser-pool';
 // @ts-ignore optional peer dependency or compatibility with es2022
 import type { Browser } from 'puppeteer';
+import { z } from 'zod';
 /**
  * Apify extends the launch options of Puppeteer.
  * You can use any of the Puppeteer compatible
@@ -66,30 +67,42 @@ export interface PuppeteerLaunchContext extends BrowserLaunchContext<PuppeteerPl
  * @ignore
  */
 export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin, unknown> {
-    readonly config: Configuration;
+    readonly configuration: Configuration;
+    /**
+     * @internal
+     */
     protected static optionsShape: {
+        proxyUrl: z.ZodOptional<z.ZodURL>;
+        useChrome: z.ZodOptional<z.ZodBoolean>;
+        useIncognitoPages: z.ZodOptional<z.ZodBoolean>;
+        browserPerProxy: z.ZodOptional<z.ZodBoolean>;
+        ignoreProxyCertificate: z.ZodOptional<z.ZodBoolean>;
+        userDataDir: z.ZodOptional<z.ZodString>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        launcher: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        proxyUrl: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        useChrome: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        launchOptions: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
+        userAgent: z.ZodOptional<z.ZodString>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        useIncognitoPages: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        browserPerProxy: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        userDataDir: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
+        launcher: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
+    };
+    /** @internal */
+    protected static optionsSchema: z.ZodObject<{
+        proxyUrl: z.ZodOptional<z.ZodURL>;
+        useChrome: z.ZodOptional<z.ZodBoolean>;
+        useIncognitoPages: z.ZodOptional<z.ZodBoolean>;
+        browserPerProxy: z.ZodOptional<z.ZodBoolean>;
+        ignoreProxyCertificate: z.ZodOptional<z.ZodBoolean>;
+        userDataDir: z.ZodOptional<z.ZodString>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        launchOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        launchOptions: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
+        userAgent: z.ZodOptional<z.ZodString>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        userAgent: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
-    };
+        launcher: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
+    }, z.core.$strict>;
     /**
      * All `PuppeteerLauncher` parameters are passed via an launchContext object.
      */
-    constructor(launchContext?: PuppeteerLaunchContext, config?: Configuration);
-    protected _getDefaultHeadlessOption(): boolean;
+    constructor(launchContext?: PuppeteerLaunchContext, configuration?: Configuration);
+    protected getDefaultHeadlessOption(): boolean;
 }
 /**
  * Launches headless Chrome using Puppeteer pre-configured to work within the Apify platform.
@@ -119,9 +132,8 @@ export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin,
  * @param [launchContext]
  *   All `PuppeteerLauncher` parameters are passed via an launchContext object.
  *   If you want to pass custom `puppeteer.launch(options)` options you can use the `PuppeteerLaunchContext.launchOptions` property.
- * @param [config]
+ * @param [configuration]
  * @returns
  *   Promise that resolves to Puppeteer's `Browser` instance.
  */
-export declare function launchPuppeteer(launchContext?: PuppeteerLaunchContext, config?: Configuration): Promise<Browser>;
-//# sourceMappingURL=puppeteer-launcher.d.ts.map
+export declare function launchPuppeteer(launchContext?: PuppeteerLaunchContext, configuration?: Configuration): Promise<Browser>;

package/internals/puppeteer-launcher.js

@@ -1,31 +1,36 @@
 import { BrowserLauncher, Configuration } from '@crawlee/browser';
 import { PuppeteerPlugin } from '@crawlee/browser-pool';
-import ow from 'ow';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
+import { z } from 'zod';
 /**
  * `PuppeteerLauncher` is based on the `BrowserLauncher`. It launches `puppeteer` browser instance.
  * @ignore
  */
 export class PuppeteerLauncher extends BrowserLauncher {
-    config;
+    configuration;
+    /**
+     * @internal
+     */
     static optionsShape = {
         ...BrowserLauncher.optionsShape,
-        launcher: ow.optional.object,
+        launcher: schemas.anyObject.optional(),
     };
+    /** @internal */
+    static optionsSchema = z.strictObject(PuppeteerLauncher.optionsShape);
     /**
      * All `PuppeteerLauncher` parameters are passed via an launchContext object.
      */
-    constructor(launchContext = {}, config = Configuration.getGlobalConfig()) {
-        ow(launchContext, 'PuppeteerLauncher', ow.object.exactShape(PuppeteerLauncher.optionsShape));
-        const { launcher = BrowserLauncher.requireLauncherOrThrow('puppeteer', 'apify/actor-node-puppeteer-chrome'), ...browserLauncherOptions } = launchContext;
+    constructor(launchContext = {}, configuration = Configuration.getGlobalConfiguration()) {
+        const { launcher = BrowserLauncher.requireLauncherOrThrow('puppeteer', 'apify/actor-node-puppeteer-chrome'), ...browserLauncherOptions } = parseArgument(launchContext, PuppeteerLauncher.optionsSchema, 'PuppeteerLaunchContext');
         super({
             ...browserLauncherOptions,
             launcher,
-        }, config);
-        this.config = config;
+        }, configuration);
+        this.configuration = configuration;
         this.Plugin = PuppeteerPlugin;
     }
-    _getDefaultHeadlessOption() {
-        const headless = super._getDefaultHeadlessOption();
+    getDefaultHeadlessOption() {
+        const headless = super.getDefaultHeadlessOption();
         return headless ? 'new' : headless;
     }
 }
@@ -57,12 +62,11 @@ export class PuppeteerLauncher extends BrowserLauncher {
  * @param [launchContext]
  *   All `PuppeteerLauncher` parameters are passed via an launchContext object.
  *   If you want to pass custom `puppeteer.launch(options)` options you can use the `PuppeteerLaunchContext.launchOptions` property.
- * @param [config]
+ * @param [configuration]
  * @returns
  *   Promise that resolves to Puppeteer's `Browser` instance.
  */
-export async function launchPuppeteer(launchContext, config = Configuration.getGlobalConfig()) {
-    const puppeteerLauncher = new PuppeteerLauncher(launchContext, config);
+export async function launchPuppeteer(launchContext, configuration = Configuration.getGlobalConfiguration()) {
+    const puppeteerLauncher = new PuppeteerLauncher(launchContext, configuration);
     return puppeteerLauncher.launch();
 }
-//# sourceMappingURL=puppeteer-launcher.js.map

package/internals/utils/puppeteer_request_interception.d.ts

@@ -58,4 +58,3 @@ export declare function addInterceptRequestHandler(page: Page, handler: Intercep
  * @param handler Request interception handler.
  */
 export declare function removeInterceptRequestHandler(page: Page, handler: InterceptHandler): Promise<void>;
-//# sourceMappingURL=puppeteer_request_interception.d.ts.map

package/internals/utils/puppeteer_request_interception.js

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
-import ow from 'ow';
-import log from '@apify/log';
+import { serviceLocator } from '@crawlee/browser';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
+const pageSchema = schemas.objectWithKeys(['goto', 'evaluate']);
 // We use weak maps here so that the content gets discarded after page gets closed.
 const pageInterceptRequestHandlersMap = new WeakMap(); // Maps page to an array of request interception handlers.
 const pageInterceptRequestMasterHandlerMap = new WeakMap(); // Maps page to master request interception handler.
@@ -137,8 +138,8 @@ async function handleRequest(request, interceptRequestHandlers) {
  * @param handler Request interception handler.
  */
 export async function addInterceptRequestHandler(page, handler) {
-    ow(page, ow.object.hasKeys('goto', 'evaluate'));
-    ow(handler, ow.function);
+    parseArgument(page, pageSchema);
+    parseArgument(handler, schemas.anyFunction);
     if (!pageInterceptRequestHandlersMap.has(page)) {
         pageInterceptRequestHandlersMap.set(page, []);
     }
@@ -174,8 +175,8 @@ export async function addInterceptRequestHandler(page, handler) {
  * @param handler Request interception handler.
  */
 export async function removeInterceptRequestHandler(page, handler) {
-    ow(page, ow.object.hasKeys('goto', 'evaluate'));
-    ow(handler, ow.function);
+    parseArgument(page, pageSchema);
+    parseArgument(handler, schemas.anyFunction);
     const handlersArray = pageInterceptRequestHandlersMap.get(page).filter((item) => item !== handler);
     pageInterceptRequestHandlersMap.set(page, handlersArray);
     if (handlersArray.length === 0) {
@@ -194,7 +195,7 @@ export async function removeInterceptRequestHandler(page, handler) {
                         interceptedRequestsInProgress.removeListener('delete', onDelete);
                     }
                     catch (error) {
-                        log.debug('Error while disabling request interception', { error });
+                        serviceLocator.getLogger().debug('Error while disabling request interception', { error });
                     }
                 }
             };
@@ -207,4 +208,3 @@ async function disableRequestInterception(page) {
     const requestHandler = pageInterceptRequestMasterHandlerMap.get(page);
     page.off('request', requestHandler);
 }
-//# sourceMappingURL=puppeteer_request_interception.js.map

package/internals/utils/puppeteer_utils.d.ts

@@ -20,7 +20,7 @@
 import type { Request } from '@crawlee/browser';
 import { Configuration } from '@crawlee/browser';
 import type { BatchAddRequestsResult, Dictionary } from '@crawlee/types';
-import { type CheerioRoot } from '@crawlee/utils';
+import type { CheerioAPI } from 'cheerio';
 import type { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping.js';
 // @ts-ignore optional peer dependency or compatibility with es2022
 import type { HTTPResponse, Page, ResponseForRequest } from 'puppeteer';
@@ -129,7 +129,7 @@ export declare function injectJQuery(page: Page, options?: {
  * @param page Puppeteer [`Page`](https://pptr.dev/api/puppeteer.page) object.
  * @param ignoreShadowRoots
  */
-export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean, ignoreIframes?: boolean): Promise<CheerioRoot>;
+export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean, ignoreIframes?: boolean): Promise<CheerioAPI>;
 /**
  * Forces the Puppeteer browser tab to block loading URLs that match a provided pattern.
  * This is useful to speed up crawling of websites, since it reduces the amount
@@ -305,9 +305,9 @@ export interface SaveSnapshotOptions {
     keyValueStoreName?: string | null;
     /**
      * Configuration of the crawler that will be used to save the snapshot.
-     * @default Configuration.getGlobalConfig()
+     * @default Configuration.getGlobalConfiguration()
      */
-    config?: Configuration;
+    configuration?: Configuration;
 }
 /**
  * Saves a full screenshot and HTML of the current page into a Key-Value store.
@@ -315,8 +315,6 @@ export interface SaveSnapshotOptions {
  * @param [options]
  */
 export declare function saveSnapshot(page: Page, options?: SaveSnapshotOptions): Promise<void>;
-export declare function closeCookieModals(page: Page): Promise<void>;
-/** @internal */
 export interface PuppeteerContextUtils {
     /**
      * Injects a JavaScript file into current `page`.
@@ -378,7 +376,7 @@ export interface PuppeteerContextUtils {
      * });
      * ```
      */
-    parseWithCheerio(selector?: string, timeoutMs?: number): Promise<CheerioRoot>;
+    parseWithCheerio(selector?: string, timeoutMs?: number): Promise<CheerioAPI>;
     /**
      * The function finds elements matching a specific CSS selector in a Puppeteer page,
      * clicks all those elements using a mouse move and a left mouse button click and intercepts
@@ -388,8 +386,7 @@ export interface PuppeteerContextUtils {
      * in `href` elements, but rather navigations are triggered in click handlers.
      * If you're looking to find URLs in `href` attributes of the page, see {@link enqueueLinks}.
      *
-     * Optionally, the function allows you to filter the target links' URLs using an array of {@link PseudoUrl} objects
-     * and override settings of the enqueued {@link Request} objects.
+     * Optionally, the function allows you to filter the target links' URLs using an array of glob or regexp patterns.
      *
      * **IMPORTANT**: To be able to do this, this function uses various mutations on the page,
      * such as changing the Z-index of elements being clicked and their visibility. Therefore,
@@ -410,9 +407,9 @@ export interface PuppeteerContextUtils {
      * async requestHandler({ enqueueLinksByClickingElements }) {
      *     await enqueueLinksByClickingElements({
      *         selector: 'a.product-detail',
-     *         globs: [
-     *             'https://www.example.com/handbags/**'
-     *             'https://www.example.com/purses/**'
+     *         include: [
+     *             'https://www.example.com/handbags/**',
+     *             'https://www.example.com/purses/**',
      *         ],
      *     });
      * });
@@ -420,7 +417,7 @@ export interface PuppeteerContextUtils {
      *
      * @returns Promise that resolves to {@link BatchAddRequestsResult} object.
      */
-    enqueueLinksByClickingElements(options: Omit<EnqueueLinksByClickingElementsOptions, 'page' | 'requestQueue'>): Promise<BatchAddRequestsResult>;
+    enqueueLinksByClickingElements(options: Omit<EnqueueLinksByClickingElementsOptions, 'page' | 'requestManager'>): Promise<BatchAddRequestsResult>;
     /**
      * Forces the Puppeteer browser tab to block loading URLs that match a provided pattern.
      * This is useful to speed up crawling of websites, since it reduces the amount
@@ -550,19 +547,6 @@ export interface PuppeteerContextUtils {
      * Saves a full screenshot and HTML of the current page into a Key-Value store.
      */
     saveSnapshot(options?: SaveSnapshotOptions): Promise<void>;
-    /**
-     * Tries to close cookie consent modals on the page. Based on the I Don't Care About Cookies browser extension.
-     *
-     * Note that this method requires the idcac-playwright package to be installed.
-     * Crawlee does not include it by default due to licensing issues.
-     *
-     * To use this method, please install the package manually by running:
-     *
-     * ```bash
-     * npm install idcac-playwright
-     * ```
-     */
-    closeCookieModals(): Promise<void>;
 }
 export { enqueueLinksByClickingElements, addInterceptRequestHandler, removeInterceptRequestHandler };
 /** @internal */
@@ -578,6 +562,4 @@ export declare const puppeteerUtils: {
     infiniteScroll: typeof infiniteScroll;
     saveSnapshot: typeof saveSnapshot;
     parseWithCheerio: typeof parseWithCheerio;
-    closeCookieModals: typeof closeCookieModals;
 };
-//# sourceMappingURL=puppeteer_utils.d.ts.map

package/internals/utils/puppeteer_utils.js

@@ -20,19 +20,49 @@
 import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import vm from 'node:vm';
-import { Configuration, KeyValueStore, validators } from '@crawlee/browser';
+import { Configuration, KeyValueStore, serviceLocator, validators } from '@crawlee/browser';
 import { expandShadowRoots, sleep } from '@crawlee/utils';
-import * as cheerio from 'cheerio';
-import ow from 'ow';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
+import { z } from 'zod';
 import { LruCache } from '@apify/datastructures';
-import log_ from '@apify/log';
 import { enqueueLinksByClickingElements } from '../enqueue-links/click-elements.js';
 import { addInterceptRequestHandler, removeInterceptRequestHandler } from './puppeteer_request_interception.js';
 const require = createRequire(import.meta.url);
 const jqueryPath = require.resolve('jquery');
 const MAX_INJECT_FILE_CACHE_SIZE = 10;
 const DEFAULT_BLOCK_REQUEST_URL_PATTERNS = ['.css', '.jpg', '.jpeg', '.png', '.svg', '.gif', '.woff', '.pdf', '.zip'];
-const log = log_.child({ prefix: 'Puppeteer Utils' });
+const filePathSchema = z.string();
+const injectFileOptionsSchema = z.strictObject({
+    surviveNavigations: z.boolean().optional(),
+});
+const responseUrlRulesSchema = schemas.arrayOf(z.union([z.string(), z.instanceof(RegExp)]), 'strings or RegExps');
+const gotoExtendedRequestSchema = z.looseObject({
+    url: z.url(),
+    method: z.string().optional(),
+    headers: schemas.anyObject.optional(),
+    payload: z.union([z.string(), z.instanceof(Uint8Array)]).optional(),
+});
+const blockRequestsOptionsSchema = z.strictObject({
+    urlPatterns: schemas.arrayOf(z.string(), 'strings').default(DEFAULT_BLOCK_REQUEST_URL_PATTERNS),
+    extraUrlPatterns: schemas.arrayOf(z.string(), 'strings').default(() => []),
+});
+const infiniteScrollOptionsSchema = z.strictObject({
+    timeoutSecs: schemas.anyNumber.default(0),
+    maxScrollHeight: schemas.anyNumber.default(0),
+    waitForSecs: schemas.anyNumber.default(4),
+    scrollDownAndUp: z.boolean().default(false),
+    buttonSelector: z.string().optional(),
+    stopScrollCallback: schemas.anyFunction.optional(),
+});
+const saveSnapshotOptionsSchema = z.strictObject({
+    key: z.string().min(1).default('SNAPSHOT'),
+    screenshotQuality: schemas.anyNumber.default(50),
+    saveScreenshot: z.boolean().default(true),
+    saveHtml: z.boolean().default(true),
+    keyValueStoreName: z.string().optional(),
+    configuration: schemas.anyObject.optional(),
+});
+const getLog = () => serviceLocator.getChildLog('Puppeteer Utils');
 /**
  * Cache contents of previously injected files to limit file system access.
  */
@@ -49,21 +79,19 @@ const injectedFilesCache = new LruCache({ maxLength: MAX_INJECT_FILE_CACHE_SIZE
  * @param [options]
  */
 export async function injectFile(page, filePath, options = {}) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(filePath, ow.string);
-    ow(options, ow.object.exactShape({
-        surviveNavigations: ow.optional.boolean,
-    }));
+    parseArgument(page, validators.browserPage);
+    parseArgument(filePath, filePathSchema);
+    const { surviveNavigations } = parseArgument(options, injectFileOptionsSchema);
     let contents = injectedFilesCache.get(filePath);
     if (!contents) {
         contents = await readFile(filePath, 'utf8');
         injectedFilesCache.add(filePath, contents);
     }
     const evalP = page.evaluate(contents);
-    if (options.surviveNavigations) {
+    if (surviveNavigations) {
         page.on('framenavigated', async () => page
             .evaluate(contents)
-            .catch((error) => log.warning('An error occurred during the script injection!', { error })));
+            .catch((error) => getLog().warning('An error occurred during the script injection!', { error })));
     }
     return evalP;
 }
@@ -94,7 +122,7 @@ export async function injectFile(page, filePath, options = {}) {
  * @param [options.surviveNavigations] Opt-out option to disable the JQuery reinjection after navigation.
  */
 export async function injectJQuery(page, options) {
-    ow(page, ow.object.validate(validators.browserPage));
+    parseArgument(page, validators.browserPage);
     return injectFile(page, jqueryPath, { surviveNavigations: options?.surviveNavigations ?? true });
 }
 /**
@@ -110,7 +138,7 @@ export async function injectJQuery(page, options) {
  * @param ignoreShadowRoots
  */
 export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIframes = false) {
-    ow(page, ow.object.validate(validators.browserPage));
+    parseArgument(page, validators.browserPage);
     if (page.frames().length > 1 && !ignoreIframes) {
         const frames = await page.$$('iframe');
         await Promise.all(frames.map(async (frame) => {
@@ -135,7 +163,7 @@ export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIf
                 }
             }
             catch (error) {
-                log.warning(`Failed to extract iframe content: ${error}`);
+                getLog().warning(`Failed to extract iframe content: ${error}`);
             }
         }));
     }
@@ -143,7 +171,8 @@ export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIf
         ? null
         : (await page.evaluate(`(${expandShadowRoots.toString()})(document)`));
     const pageContent = html || (await page.content());
-    return cheerio.load(pageContent);
+    const { load } = await import('cheerio');
+    return load(pageContent);
 }
 /**
  * Forces the Puppeteer browser tab to block loading URLs that match a provided pattern.
@@ -188,12 +217,8 @@ export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIf
  * @param [options]
  */
 export async function blockRequests(page, options = {}) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(options, ow.object.exactShape({
-        urlPatterns: ow.optional.array.ofType(ow.string),
-        extraUrlPatterns: ow.optional.array.ofType(ow.string),
-    }));
-    const { urlPatterns = DEFAULT_BLOCK_REQUEST_URL_PATTERNS, extraUrlPatterns = [] } = options;
+    parseArgument(page, validators.browserPage);
+    const { urlPatterns, extraUrlPatterns } = parseArgument(options, blockRequestsOptionsSchema);
     const patternsToBlock = [...urlPatterns, ...extraUrlPatterns];
     // We use CDP commands instead of request interception as the latter disables caching, which is not ideal
     await sendCDPCommand(page, 'Network.setBlockedURLs', { urls: patternsToBlock });
@@ -221,7 +246,9 @@ export async function sendCDPCommand(page, command, ...args) {
  * @deprecated
  */
 export const blockResources = async (page, resourceTypes = ['stylesheet', 'font', 'image', 'media']) => {
-    log.deprecated('utils.puppeteer.blockResources() has a high impact on performance in recent versions of Puppeteer. ' +
+    serviceLocator
+        .getLogger()
+        .deprecated('utils.puppeteer.blockResources() has a high impact on performance in recent versions of Puppeteer. ' +
         'Until this resolves, please use utils.puppeteer.blockRequests()');
     await addInterceptRequestHandler(page, async (request) => {
         const type = request.resourceType();
@@ -248,10 +275,12 @@ export const blockResources = async (page, resourceTypes = ['stylesheet', 'font'
  * @deprecated
  */
 export async function cacheResponses(page, cache, responseUrlRules) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(cache, ow.object);
-    ow(responseUrlRules, ow.array.ofType(ow.any(ow.string, ow.regExp)));
-    log.deprecated('utils.puppeteer.cacheResponses() has a high impact on performance ' +
+    parseArgument(page, validators.browserPage);
+    parseArgument(cache, schemas.anyObject);
+    parseArgument(responseUrlRules, responseUrlRulesSchema);
+    serviceLocator
+        .getLogger()
+        .deprecated('utils.puppeteer.cacheResponses() has a high impact on performance ' +
         "in recent versions of Puppeteer so it's use is discouraged until this issue resolves.");
     await addInterceptRequestHandler(page, async (request) => {
         const url = request.url();
@@ -321,7 +350,7 @@ export function compileScript(scriptString, context = Object.create(null)) {
         func = vm.runInNewContext(funcString, context); // "Secure" the context by removing prototypes, unless custom context is provided.
     }
     catch (err) {
-        log.exception(err, 'Cannot compile script!');
+        getLog().exception(err, 'Cannot compile script!');
         throw err;
     }
     if (typeof func !== 'function')
@@ -341,23 +370,20 @@ export function compileScript(scriptString, context = Object.create(null)) {
  * @param [gotoOptions] Custom options for `page.goto()`.
  */
 export async function gotoExtended(page, request, gotoOptions = {}) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(request, ow.object.partialShape({
-        url: ow.string.url,
-        method: ow.optional.string,
-        headers: ow.optional.object,
-        payload: ow.optional.any(ow.string, ow.uint8Array),
-    }));
-    ow(gotoOptions, ow.object);
+    parseArgument(page, validators.browserPage);
+    parseArgument(request, gotoExtendedRequestSchema);
+    parseArgument(gotoOptions, schemas.anyObject);
     gotoOptions = { ...gotoOptions };
     if (gotoOptions.waitUntil === 'networkidle') {
         gotoOptions.waitUntil = 'networkidle0';
     }
     const { url, method, headers, payload } = request;
     const isEmpty = (o) => !o || Object.keys(o).length === 0;
-    if (method !== 'GET' || payload || !isEmpty(headers)) {
+    if (method !== 'GET' || payload) {
         // This is not deprecated, we use it to log only once.
-        log.deprecated('Using other request methods than GET, rewriting headers and adding payloads has a high impact on performance ' +
+        serviceLocator
+            .getLogger()
+            .deprecated('Using other request methods than GET, rewriting headers and adding payloads has a high impact on performance ' +
             'in recent versions of Puppeteer. Use only when necessary.');
         let wasCalled = false;
         const interceptRequestHandler = async (interceptedRequest) => {
@@ -380,6 +406,19 @@ export async function gotoExtended(page, request, gotoOptions = {}) {
         };
         await addInterceptRequestHandler(page, interceptRequestHandler);
     }
+    else if (!isEmpty(headers)) {
+        const extraHeaders = { ...headers };
+        // Chrome bundled with Puppeteer 25+ ignores a `User-Agent` passed via `setExtraHTTPHeaders()`, it has to be set explicitly.
+        for (const name of Object.keys(extraHeaders)) {
+            if (name.toLowerCase() === 'user-agent') {
+                await page.setUserAgent(extraHeaders[name]);
+                delete extraHeaders[name];
+            }
+        }
+        if (!isEmpty(extraHeaders)) {
+            await page.setExtraHTTPHeaders(extraHeaders);
+        }
+    }
     return page.goto(url, gotoOptions);
 }
 /**
@@ -389,16 +428,8 @@ export async function gotoExtended(page, request, gotoOptions = {}) {
  * @param [options]
  */
 export async function infiniteScroll(page, options = {}) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(options, ow.object.exactShape({
-        timeoutSecs: ow.optional.number,
-        maxScrollHeight: ow.optional.number,
-        waitForSecs: ow.optional.number,
-        scrollDownAndUp: ow.optional.boolean,
-        buttonSelector: ow.optional.string,
-        stopScrollCallback: ow.optional.function,
-    }));
-    const { timeoutSecs = 0, maxScrollHeight = 0, waitForSecs = 4, scrollDownAndUp = false, buttonSelector, stopScrollCallback, } = options;
+    parseArgument(page, validators.browserPage);
+    const { timeoutSecs, maxScrollHeight, waitForSecs, scrollDownAndUp, buttonSelector, stopScrollCallback } = parseArgument(options, infiniteScrollOptionsSchema);
     let finished;
     const startTime = Date.now();
     const CHECK_INTERVAL_MILLIS = 1000;
@@ -490,19 +521,11 @@ export async function infiniteScroll(page, options = {}) {
  * @param [options]
  */
 export async function saveSnapshot(page, options = {}) {
-    ow(page, ow.object.validate(validators.browserPage));
-    ow(options, ow.object.exactShape({
-        key: ow.optional.string.nonEmpty,
-        screenshotQuality: ow.optional.number,
-        saveScreenshot: ow.optional.boolean,
-        saveHtml: ow.optional.boolean,
-        keyValueStoreName: ow.optional.string,
-        config: ow.optional.object,
-    }));
-    const { key = 'SNAPSHOT', screenshotQuality = 50, saveScreenshot = true, saveHtml = true, keyValueStoreName, config, } = options;
+    parseArgument(page, validators.browserPage);
+    const { key, screenshotQuality, saveScreenshot, saveHtml, keyValueStoreName, configuration } = parseArgument(options, saveSnapshotOptionsSchema);
     try {
-        const store = await KeyValueStore.open(keyValueStoreName, {
-            config: config ?? Configuration.getGlobalConfig(),
+        const store = await KeyValueStore.open(keyValueStoreName ? { name: keyValueStoreName } : null, {
+            configuration: configuration ?? Configuration.getGlobalConfiguration(),
         });
         if (saveScreenshot) {
             const screenshotName = `${key}.jpg`;
@@ -523,35 +546,6 @@ export async function saveSnapshot(page, options = {}) {
         throw new Error(`saveSnapshot with key ${key} failed.\nCause:${err.message}`);
     }
 }
-let idcacPlaywright = null;
-async function getIdcacPlaywright() {
-    if (idcacPlaywright)
-        return idcacPlaywright;
-    try {
-        idcacPlaywright = await import('idcac-playwright');
-    }
-    catch (error) {
-        log.warning(`Failed to import 'idcac-playwright'.
-
-We recently made idcac-playwright an optional dependency due to licensing issues.
-To use this feature, please install it manually by running
-
-npm install idcac-playwright
-
-Original error message follows:
-
-${error.message}
-`);
-    }
-    return idcacPlaywright;
-}
-export async function closeCookieModals(page) {
-    ow(page, ow.object.validate(validators.browserPage));
-    const idcac = await getIdcacPlaywright();
-    if (idcac?.getInjectableScript()) {
-        await page.evaluate(idcac.getInjectableScript());
-    }
-}
 export { enqueueLinksByClickingElements, addInterceptRequestHandler, removeInterceptRequestHandler };
 /** @internal */
 export const puppeteerUtils = {
@@ -566,6 +560,4 @@ export const puppeteerUtils = {
     infiniteScroll,
     saveSnapshot,
     parseWithCheerio,
-    closeCookieModals,
 };
-//# sourceMappingURL=puppeteer_utils.js.map