@crawlee/puppeteer 3.0.0-alpha.2 → 3.0.0-alpha.20

package/internals/puppeteer-crawler.d.ts

@@ -0,0 +1,149 @@
+import { BrowserCrawler, BrowserCrawlerHandleRequest, BrowserCrawlerOptions, BrowserCrawlingContext, BrowserHook } from '@crawlee/browser';
+import { PuppeteerPlugin } from '@crawlee/browser-pool';
+import { HTTPResponse, LaunchOptions, Page } from 'puppeteer';
+import { PuppeteerLaunchContext } from './puppeteer-launcher';
+import { DirectNavigationOptions } from './utils/puppeteer_utils';
+export declare type PuppeteerController = ReturnType<PuppeteerPlugin['_createController']>;
+export declare type PuppeteerCrawlContext = BrowserCrawlingContext<Page, HTTPResponse, PuppeteerController>;
+export declare type PuppeteerHook = BrowserHook<PuppeteerCrawlContext, PuppeteerGoToOptions>;
+export declare type PuppeteerRequestHandlerParam = BrowserCrawlingContext<Page, HTTPResponse, PuppeteerController>;
+export declare type PuppeteerRequestHandler = BrowserCrawlerHandleRequest<PuppeteerRequestHandlerParam>;
+export declare type PuppeteerGoToOptions = Parameters<Page['goto']>[1];
+export interface PuppeteerCrawlerOptions extends BrowserCrawlerOptions<PuppeteerCrawlContext, PuppeteerGoToOptions, {
+    browserPlugins: [PuppeteerPlugin];
+}> {
+    /**
+     * Options used by {@link launchPuppeteer} to start new Puppeteer instances.
+     */
+    launchContext?: PuppeteerLaunchContext;
+    /**
+     * Async functions that are sequentially evaluated before the navigation. Good for setting additional cookies
+     * or browser properties before navigation. The function accepts two parameters, `crawlingContext` and `gotoOptions`,
+     * which are passed to the `page.goto()` function the crawler calls to navigate.
+     * Example:
+     * ```
+     * preNavigationHooks: [
+     *     async (crawlingContext, gotoOptions) => {
+     *         const { page } = crawlingContext;
+     *         await page.evaluate((attr) => { window.foo = attr; }, 'bar');
+     *     },
+     * ]
+     * ```
+     */
+    preNavigationHooks?: PuppeteerHook[];
+    /**
+     * Async functions that are sequentially evaluated after the navigation. Good for checking if the navigation was successful.
+     * The function accepts `crawlingContext` as the only parameter.
+     * Example:
+     * ```
+     * postNavigationHooks: [
+     *     async (crawlingContext) => {
+     *         const { page } = crawlingContext;
+     *         if (hasCaptcha(page)) {
+     *             await solveCaptcha (page);
+     *         }
+     *     },
+     * ]
+     * ```
+     */
+    postNavigationHooks?: PuppeteerHook[];
+}
+/**
+ * Provides a simple framework for parallel crawling of web pages
+ * using headless Chrome with [Puppeteer](https://github.com/puppeteer/puppeteer).
+ * The URLs to crawl are fed either from a static list of URLs
+ * or from a dynamic queue of URLs enabling recursive crawling of websites.
+ *
+ * Since `PuppeteerCrawler` uses headless Chrome to download web pages and extract data,
+ * it is useful for crawling of websites that require to execute JavaScript.
+ * If the target website doesn't need JavaScript, consider using {@link CheerioCrawler},
+ * which downloads the pages using raw HTTP requests and is about 10x faster.
+ *
+ * The source URLs are represented using {@link Request} objects that are fed from
+ * {@link RequestList} or {@link RequestQueue} instances provided by the {@link PuppeteerCrawlerOptions.requestList}
+ * or {@link PuppeteerCrawlerOptions.requestQueue} constructor options, respectively.
+ *
+ * If both {@link PuppeteerCrawlerOptions.requestList} and {@link PuppeteerCrawlerOptions.requestQueue} are used,
+ * the instance first processes URLs from the {@link RequestList} and automatically enqueues all of them
+ * to {@link RequestQueue} before it starts their processing. This ensures that a single URL is not crawled multiple times.
+ *
+ * The crawler finishes when there are no more {@link Request} objects to crawl.
+ *
+ * `PuppeteerCrawler` opens a new Chrome page (i.e. tab) for each {@link Request} object to crawl
+ * and then calls the function provided by user as the {@link PuppeteerCrawlerOptions.handlePageFunction} option.
+ *
+ * New pages are only opened when there is enough free CPU and memory available,
+ * using the functionality provided by the {@link AutoscaledPool} class.
+ * All {@link AutoscaledPool} configuration options can be passed to the {@link PuppeteerCrawlerOptions.autoscaledPoolOptions}
+ * parameter of the `PuppeteerCrawler` constructor. For user convenience, the `minConcurrency` and `maxConcurrency`
+ * {@link AutoscaledPoolOptions} are available directly in the `PuppeteerCrawler` constructor.
+ *
+ * Note that the pool of Puppeteer instances is internally managed by the [BrowserPool](https://github.com/apify/browser-pool) class.
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ * const crawler = new PuppeteerCrawler({
+ *     requestList,
+ *     handlePageFunction: async ({ page, request }) => {
+ *         // This function is called to extract data from a single web page
+ *         // 'page' is an instance of Puppeteer.Page with page.goto(request.url) already called
+ *         // 'request' is an instance of Request class with information about the page to load
+ *         await Actor.pushData({
+ *             title: await page.title(),
+ *             url: request.url,
+ *             succeeded: true,
+ *         })
+ *     },
+ *     handleFailedRequestFunction: async ({ request }) => {
+ *         // This function is called when the crawling of a request failed too many times
+ *         await Actor.pushData({
+ *             url: request.url,
+ *             succeeded: false,
+ *             errors: request.errorMessages,
+ *         })
+ *     },
+ * });
+ *
+ * await crawler.run();
+ * ```
+ * @category Crawlers
+ */
+export declare class PuppeteerCrawler extends BrowserCrawler<{
+    browserPlugins: [PuppeteerPlugin];
+}, LaunchOptions, PuppeteerCrawlContext> {
+    protected static optionsShape: {
+        browserPoolOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        handlePageFunction: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        gotoFunction: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        gotoTimeoutSecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        navigationTimeoutSecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        preNavigationHooks: import("ow").ArrayPredicate<unknown> & import("ow").BasePredicate<unknown[] | undefined>;
+        postNavigationHooks: import("ow").ArrayPredicate<unknown> & import("ow").BasePredicate<unknown[] | undefined>;
+        launchContext: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        sessionPoolOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        persistCookiesPerSession: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        useSessionPool: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        proxyConfiguration: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        requestList: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        requestQueue: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        requestHandler: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        handleRequestFunction: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        requestHandlerTimeoutSecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        handleRequestTimeoutSecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        failedRequestHandler: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        handleFailedRequestFunction: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        maxRequestRetries: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxRequestsPerCrawl: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        autoscaledPoolOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        minConcurrency: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxConcurrency: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        log: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+    };
+    /**
+     * All `PuppeteerCrawler` parameters are passed via an options object.
+     */
+    constructor(options: PuppeteerCrawlerOptions);
+    protected _navigationHandler(crawlingContext: PuppeteerCrawlContext, gotoOptions: DirectNavigationOptions): Promise<any>;
+}
+//# sourceMappingURL=puppeteer-crawler.d.ts.map

package/internals/puppeteer-crawler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppeteer-crawler.d.ts","sourceRoot":"","sources":["../../src/internals/puppeteer-crawler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,cAAc,EACd,2BAA2B,EAC3B,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACd,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAAsB,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAqB,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAgB,MAAM,yBAAyB,CAAC;AAEhF,oBAAY,mBAAmB,GAAG,UAAU,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC,CAAC;AAEnF,oBAAY,qBAAqB,GAAG,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,mBAAmB,CAAC,CAAA;AAEnG,oBAAY,aAAa,GAAG,WAAW,CAAC,qBAAqB,EAAE,oBAAoB,CAAC,CAAC;AAErF,oBAAY,4BAA4B,GAAG,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,mBAAmB,CAAC,CAAA;AAE1G,oBAAY,uBAAuB,GAAG,2BAA2B,CAAC,4BAA4B,CAAC,CAAC;AAEhG,oBAAY,oBAAoB,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/D,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB,CAClE,qBAAqB,EACrB,oBAAoB,EACpB;IAAE,cAAc,EAAE,CAAC,eAAe,CAAC,CAAA;CAAE,CACxC;IACG;;OAEG;IACH,aAAa,CAAC,EAAE,sBAAsB,CAAC;IAEvC;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IAErC;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CAAC,EAAE,aAAa,EAAE,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,qBAAa,gBAAiB,SAAQ,cAAc,CAAC;IAAE,cAAc,EAAE,CAAC,eAAe,CAAC,CAAA;CAAE,EAAE,aAAa,EAAE,qBAAqB,CAAC;IAC7H,iBAA0B,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGpC;IAEF;;OAEG;gBACS,OAAO,EAAE,uBAAuB;cAwBnB,kBAAkB,CAAC,eAAe,EAAE,qBAAqB,EAAE,WAAW,EAAE,uBAAuB;CAS3H"}

package/internals/puppeteer-crawler.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerCrawler = void 0;
+const tslib_1 = require("tslib");
+const browser_1 = require("@crawlee/browser");
+const ow_1 = tslib_1.__importDefault(require("ow"));
+const puppeteer_launcher_1 = require("./puppeteer-launcher");
+const puppeteer_utils_1 = require("./utils/puppeteer_utils");
+/**
+ * Provides a simple framework for parallel crawling of web pages
+ * using headless Chrome with [Puppeteer](https://github.com/puppeteer/puppeteer).
+ * The URLs to crawl are fed either from a static list of URLs
+ * or from a dynamic queue of URLs enabling recursive crawling of websites.
+ *
+ * Since `PuppeteerCrawler` uses headless Chrome to download web pages and extract data,
+ * it is useful for crawling of websites that require to execute JavaScript.
+ * If the target website doesn't need JavaScript, consider using {@link CheerioCrawler},
+ * which downloads the pages using raw HTTP requests and is about 10x faster.
+ *
+ * The source URLs are represented using {@link Request} objects that are fed from
+ * {@link RequestList} or {@link RequestQueue} instances provided by the {@link PuppeteerCrawlerOptions.requestList}
+ * or {@link PuppeteerCrawlerOptions.requestQueue} constructor options, respectively.
+ *
+ * If both {@link PuppeteerCrawlerOptions.requestList} and {@link PuppeteerCrawlerOptions.requestQueue} are used,
+ * the instance first processes URLs from the {@link RequestList} and automatically enqueues all of them
+ * to {@link RequestQueue} before it starts their processing. This ensures that a single URL is not crawled multiple times.
+ *
+ * The crawler finishes when there are no more {@link Request} objects to crawl.
+ *
+ * `PuppeteerCrawler` opens a new Chrome page (i.e. tab) for each {@link Request} object to crawl
+ * and then calls the function provided by user as the {@link PuppeteerCrawlerOptions.handlePageFunction} option.
+ *
+ * New pages are only opened when there is enough free CPU and memory available,
+ * using the functionality provided by the {@link AutoscaledPool} class.
+ * All {@link AutoscaledPool} configuration options can be passed to the {@link PuppeteerCrawlerOptions.autoscaledPoolOptions}
+ * parameter of the `PuppeteerCrawler` constructor. For user convenience, the `minConcurrency` and `maxConcurrency`
+ * {@link AutoscaledPoolOptions} are available directly in the `PuppeteerCrawler` constructor.
+ *
+ * Note that the pool of Puppeteer instances is internally managed by the [BrowserPool](https://github.com/apify/browser-pool) class.
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ * const crawler = new PuppeteerCrawler({
+ *     requestList,
+ *     handlePageFunction: async ({ page, request }) => {
+ *         // This function is called to extract data from a single web page
+ *         // 'page' is an instance of Puppeteer.Page with page.goto(request.url) already called
+ *         // 'request' is an instance of Request class with information about the page to load
+ *         await Actor.pushData({
+ *             title: await page.title(),
+ *             url: request.url,
+ *             succeeded: true,
+ *         })
+ *     },
+ *     handleFailedRequestFunction: async ({ request }) => {
+ *         // This function is called when the crawling of a request failed too many times
+ *         await Actor.pushData({
+ *             url: request.url,
+ *             succeeded: false,
+ *             errors: request.errorMessages,
+ *         })
+ *     },
+ * });
+ *
+ * await crawler.run();
+ * ```
+ * @category Crawlers
+ */
+class PuppeteerCrawler extends browser_1.BrowserCrawler {
+    /**
+     * All `PuppeteerCrawler` parameters are passed via an options object.
+     */
+    constructor(options) {
+        (0, ow_1.default)(options, 'PuppeteerCrawlerOptions', ow_1.default.object.exactShape(PuppeteerCrawler.optionsShape));
+        const { launchContext = {}, browserPoolOptions = {}, proxyConfiguration, ...browserCrawlerOptions } = options;
+        if (launchContext.proxyUrl) {
+            throw new Error('PuppeteerCrawlerOptions.launchContext.proxyUrl is not allowed in PuppeteerCrawler.'
+                + 'Use PuppeteerCrawlerOptions.proxyConfiguration');
+        }
+        const puppeteerLauncher = new puppeteer_launcher_1.PuppeteerLauncher(launchContext);
+        browserPoolOptions.browserPlugins = [
+            puppeteerLauncher.createBrowserPlugin(),
+        ];
+        super({ ...browserCrawlerOptions, launchContext, proxyConfiguration, browserPoolOptions });
+    }
+    async _navigationHandler(crawlingContext, gotoOptions) {
+        // TODO remove deprecated options in v3
+        if (this.gotoFunction) {
+            this.log.deprecated('PuppeteerCrawlerOptions.gotoFunction is deprecated. Use "preNavigationHooks" and "postNavigationHooks" instead.');
+            return this.gotoFunction(crawlingContext, gotoOptions);
+        }
+        return (0, puppeteer_utils_1.gotoExtended)(crawlingContext.page, crawlingContext.request, gotoOptions);
+    }
+}
+exports.PuppeteerCrawler = PuppeteerCrawler;
+Object.defineProperty(PuppeteerCrawler, "optionsShape", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...browser_1.BrowserCrawler.optionsShape,
+        browserPoolOptions: ow_1.default.optional.object,
+    }
+});
+//# sourceMappingURL=puppeteer-crawler.js.map

package/internals/puppeteer-crawler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppeteer-crawler.js","sourceRoot":"","sources":["../../src/internals/puppeteer-crawler.ts"],"names":[],"mappings":";;;;AAAA,8CAM0B;AAK1B,oDAAoB;AAEpB,6DAAiF;AACjF,6DAAgF;AA0DhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAa,gBAAiB,SAAQ,wBAA2F;IAM7H;;OAEG;IACH,YAAY,OAAgC;QACxC,IAAA,YAAE,EAAC,OAAO,EAAE,yBAAyB,EAAE,YAAE,CAAC,MAAM,CAAC,UAAU,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;QAE5F,MAAM,EACF,aAAa,GAAG,EAAE,EAClB,kBAAkB,GAAG,EAAwB,EAC7C,kBAAkB,EAClB,GAAG,qBAAqB,EAC3B,GAAG,OAAO,CAAC;QAEZ,IAAI,aAAa,CAAC,QAAQ,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oFAAoF;kBAC9F,gDAAgD,CAAC,CAAC;SAC3D;QAED,MAAM,iBAAiB,GAAG,IAAI,sCAAiB,CAAC,aAAa,CAAC,CAAC;QAE/D,kBAAkB,CAAC,cAAc,GAAG;YAChC,iBAAiB,CAAC,mBAAmB,EAAE;SAC1C,CAAC;QAEF,KAAK,CAAC,EAAE,GAAG,qBAAqB,EAAE,aAAa,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC/F,CAAC;IAEkB,KAAK,CAAC,kBAAkB,CAAC,eAAsC,EAAE,WAAoC;QACpH,uCAAuC;QACvC,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,iHAAiH,CAAC,CAAC;YAEvI,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,WAAyB,CAAC,CAAC;SACxE;QACD,OAAO,IAAA,8BAAY,EAAC,eAAe,CAAC,IAAI,EAAE,eAAe,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACpF,CAAC;;AAzCL,4CA0CC;AAzCG;;;;WAAyC;QACrC,GAAG,wBAAc,CAAC,YAAY;QAC9B,kBAAkB,EAAE,YAAE,CAAC,QAAQ,CAAC,MAAM;KACzC;GAAC"}

package/internals/puppeteer-launcher.d.ts

@@ -0,0 +1,115 @@
+import { Browser } from 'puppeteer';
+import { PuppeteerPlugin } from '@crawlee/browser-pool';
+import { BrowserLaunchContext, BrowserLauncher } from '@crawlee/browser';
+/**
+ * Apify extends the launch options of Puppeteer.
+ * You can use any of the Puppeteer compatible
+ * [`LaunchOptions`](https://pptr.dev/#?product=Puppeteer&show=api-puppeteerlaunchoptions)
+ * options by providing the `launchOptions` property.
+ *
+ * **Example:**
+ * ```js
+ * // launch a headless Chrome (not Chromium)
+ * const launchContext = {
+ *     // Apify helpers
+ *     useChrome: true,
+ *     proxyUrl: 'http://user:password@some.proxy.com'
+ *     // Native Puppeteer options
+ *     launchOptions: {
+ *         headless: true,
+ *         args: ['--some-flag'],
+ *     }
+ * }
+ * ```
+ */
+export interface PuppeteerLaunchContext extends BrowserLaunchContext<PuppeteerPlugin['launchOptions'], unknown> {
+    /**
+     *  `puppeteer.launch` [options](https://pptr.dev/#?product=Puppeteer&version=v13.5.1&show=api-puppeteerlaunchoptions)
+     */
+    launchOptions?: PuppeteerPlugin['launchOptions'];
+    /**
+     * URL to a HTTP proxy server. It must define the port number,
+     * and it may also contain proxy username and password.
+     *
+     * Example: `http://bob:pass123@proxy.example.com:1234`.
+     */
+    proxyUrl?: string;
+    /**
+     * If `true` and `executablePath` is not set,
+     * Puppeteer will launch full Google Chrome browser available on the machine
+     * rather than the bundled Chromium. The path to Chrome executable
+     * is taken from the `APIFY_CHROME_EXECUTABLE_PATH` environment variable if provided,
+     * or defaults to the typical Google Chrome executable location specific for the operating system.
+     * By default, this option is `false`.
+     * @default false
+     */
+    useChrome?: boolean;
+    /**
+     * Already required module (`Object`). This enables usage of various Puppeteer
+     * wrappers such as `puppeteer-extra`.
+     *
+     * Take caution, because it can cause all kinds of unexpected errors and weird behavior.
+     * Apify SDK is not tested with any other library besides `puppeteer` itself.
+     */
+    launcher?: unknown;
+    /**
+     * With this option selected, all pages will be opened in a new incognito browser context.
+     * This means they will not share cookies nor cache and their resources will not be throttled by one another.
+     * @default false
+     */
+    useIncognitoPages?: boolean;
+}
+/**
+ * `PuppeteerLauncher` is based on the `BrowserLauncher`. It launches `puppeteer` browser instance.
+ * @ignore
+ */
+export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin, unknown> {
+    protected static optionsShape: {
+        launcher: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        proxyUrl: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
+        useChrome: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        useIncognitoPages: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        userDataDir: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
+        launchOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        userAgent: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
+    };
+    /**
+     * All `PuppeteerLauncher` parameters are passed via an launchContext object.
+     */
+    constructor(launchContext?: PuppeteerLaunchContext);
+}
+/**
+ * Launches headless Chrome using Puppeteer pre-configured to work within the Apify platform.
+ * The function has the same argument and the return value as `puppeteer.launch()`.
+ * See [Puppeteer documentation](https://github.com/puppeteer/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions) for more details.
+ *
+ * The `launchPuppeteer()` function alters the following Puppeteer options:
+ *
+ * - Passes the setting from the `APIFY_HEADLESS` environment variable to the `headless` option,
+ *   unless it was already defined by the caller or `APIFY_XVFB` environment variable is set to `1`.
+ *   Note that Apify Actor cloud platform automatically sets `APIFY_HEADLESS=1` to all running actors.
+ * - Takes the `proxyUrl` option, validates it and adds it to `args` as `--proxy-server=XXX`.
+ *   The proxy URL must define a port number and have one of the following schemes: `http://`,
+ *   `https://`, `socks4://` or `socks5://`.
+ *   If the proxy is HTTP (i.e. has the `http://` scheme) and contains username or password,
+ *   the `launchPuppeteer` functions sets up an anonymous proxy HTTP
+ *   to make the proxy work with headless Chrome. For more information, read the
+ *   [blog post about proxy-chain library](https://blog.apify.com/how-to-make-headless-chrome-and-puppeteer-use-a-proxy-server-with-authentication-249a21a79212).
+ *
+ * To use this function, you need to have the [puppeteer](https://www.npmjs.com/package/puppeteer)
+ * NPM package installed in your project.
+ * When running on the Apify cloud, you can achieve that simply
+ * by using the `apify/actor-node-chrome` base Docker image for your actor - see
+ * [Apify Actor documentation](https://docs.apify.com/actor/build#base-images)
+ * for details.
+ *
+ * For an example of usage, see the [Puppeteer proxy Example](/docs/examples/puppeteer-with-proxy).
+ *
+ * @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.
+ * @returns
+ *   Promise that resolves to Puppeteer's `Browser` instance.
+ */
+export declare function launchPuppeteer(launchContext?: PuppeteerLaunchContext): Promise<Browser>;
+//# sourceMappingURL=puppeteer-launcher.d.ts.map

package/internals/puppeteer-launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppeteer-launcher.d.ts","sourceRoot":"","sources":["../../src/internals/puppeteer-launcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC3G;;OAEG;IACH,aAAa,CAAC,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IAEjD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,eAAe,CAAC,eAAe,EAAE,OAAO,CAAC;IAC5E,iBAA0B,YAAY;;;;;;;;MAGpC;IAEF;;OAEG;gBACS,aAAa,GAAE,sBAA2B;CAezD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,eAAe,CAAC,aAAa,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI9F"}

package/internals/puppeteer-launcher.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchPuppeteer = exports.PuppeteerLauncher = void 0;
+const tslib_1 = require("tslib");
+const ow_1 = tslib_1.__importDefault(require("ow"));
+const browser_pool_1 = require("@crawlee/browser-pool");
+const browser_1 = require("@crawlee/browser");
+/**
+ * `PuppeteerLauncher` is based on the `BrowserLauncher`. It launches `puppeteer` browser instance.
+ * @ignore
+ */
+class PuppeteerLauncher extends browser_1.BrowserLauncher {
+    /**
+     * All `PuppeteerLauncher` parameters are passed via an launchContext object.
+     */
+    constructor(launchContext = {}) {
+        (0, ow_1.default)(launchContext, 'PuppeteerLauncher', ow_1.default.object.exactShape(PuppeteerLauncher.optionsShape));
+        const { launcher = browser_1.BrowserLauncher.requireLauncherOrThrow('puppeteer', 'apify/actor-node-puppeteer-chrome'), ...browserLauncherOptions } = launchContext;
+        super({
+            ...browserLauncherOptions,
+            launcher,
+        });
+        this.Plugin = browser_pool_1.PuppeteerPlugin;
+    }
+}
+exports.PuppeteerLauncher = PuppeteerLauncher;
+Object.defineProperty(PuppeteerLauncher, "optionsShape", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...browser_1.BrowserLauncher.optionsShape,
+        launcher: ow_1.default.optional.object,
+    }
+});
+/**
+ * Launches headless Chrome using Puppeteer pre-configured to work within the Apify platform.
+ * The function has the same argument and the return value as `puppeteer.launch()`.
+ * See [Puppeteer documentation](https://github.com/puppeteer/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions) for more details.
+ *
+ * The `launchPuppeteer()` function alters the following Puppeteer options:
+ *
+ * - Passes the setting from the `APIFY_HEADLESS` environment variable to the `headless` option,
+ *   unless it was already defined by the caller or `APIFY_XVFB` environment variable is set to `1`.
+ *   Note that Apify Actor cloud platform automatically sets `APIFY_HEADLESS=1` to all running actors.
+ * - Takes the `proxyUrl` option, validates it and adds it to `args` as `--proxy-server=XXX`.
+ *   The proxy URL must define a port number and have one of the following schemes: `http://`,
+ *   `https://`, `socks4://` or `socks5://`.
+ *   If the proxy is HTTP (i.e. has the `http://` scheme) and contains username or password,
+ *   the `launchPuppeteer` functions sets up an anonymous proxy HTTP
+ *   to make the proxy work with headless Chrome. For more information, read the
+ *   [blog post about proxy-chain library](https://blog.apify.com/how-to-make-headless-chrome-and-puppeteer-use-a-proxy-server-with-authentication-249a21a79212).
+ *
+ * To use this function, you need to have the [puppeteer](https://www.npmjs.com/package/puppeteer)
+ * NPM package installed in your project.
+ * When running on the Apify cloud, you can achieve that simply
+ * by using the `apify/actor-node-chrome` base Docker image for your actor - see
+ * [Apify Actor documentation](https://docs.apify.com/actor/build#base-images)
+ * for details.
+ *
+ * For an example of usage, see the [Puppeteer proxy Example](/docs/examples/puppeteer-with-proxy).
+ *
+ * @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.
+ * @returns
+ *   Promise that resolves to Puppeteer's `Browser` instance.
+ */
+async function launchPuppeteer(launchContext) {
+    const puppeteerLauncher = new PuppeteerLauncher(launchContext);
+    return puppeteerLauncher.launch();
+}
+exports.launchPuppeteer = launchPuppeteer;
+//# sourceMappingURL=puppeteer-launcher.js.map

package/internals/puppeteer-launcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppeteer-launcher.js","sourceRoot":"","sources":["../../src/internals/puppeteer-launcher.ts"],"names":[],"mappings":";;;;AAAA,oDAAoB;AAEpB,wDAAwD;AACxD,8CAAyE;AAiEzE;;;GAGG;AACH,MAAa,iBAAkB,SAAQ,yBAAyC;IAM5E;;OAEG;IACH,YAAY,gBAAwC,EAAE;QAClD,IAAA,YAAE,EAAC,aAAa,EAAE,mBAAmB,EAAE,YAAE,CAAC,MAAM,CAAC,UAAU,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC;QAE7F,MAAM,EACF,QAAQ,GAAG,yBAAe,CAAC,sBAAsB,CAAC,WAAW,EAAE,mCAAmC,CAAC,EACnG,GAAG,sBAAsB,EAC5B,GAAG,aAAa,CAAC;QAElB,KAAK,CAAC;YACF,GAAG,sBAAsB;YACzB,QAAQ;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,GAAG,8BAAe,CAAC;IAClC,CAAC;;AAvBL,8CAwBC;AAvBG;;;;WAAyC;QACrC,GAAG,yBAAe,CAAC,YAAY;QAC/B,QAAQ,EAAE,YAAE,CAAC,QAAQ,CAAC,MAAM;KAC/B;GAAC;AAsBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACI,KAAK,UAAU,eAAe,CAAC,aAAsC;IACxE,MAAM,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,aAAa,CAAC,CAAC;IAE/D,OAAO,iBAAiB,CAAC,MAAM,EAAE,CAAC;AACtC,CAAC;AAJD,0CAIC"}

package/internals/utils/puppeteer_request_interception.d.ts

@@ -0,0 +1,60 @@
+import { HTTPRequest as PuppeteerRequest, Page } from 'puppeteer';
+export declare type InterceptHandler = (request: PuppeteerRequest) => unknown;
+/**
+ * Adds request interception handler in similar to `page.on('request', handler);` but in addition to that
+ * supports multiple parallel handlers.
+ *
+ * All the handlers are executed sequentially in the order as they were added.
+ * Each of the handlers must call one of `request.continue()`, `request.abort()` and `request.respond()`.
+ * In addition to that any of the handlers may modify the request object (method, postData, headers)
+ * by passing its overrides to `request.continue()`.
+ * If multiple handlers modify same property then the last one wins. Headers are merged separately so you can
+ * override only a value of specific header.
+ *
+ * If one the handlers calls `request.abort()` or `request.respond()` then request is not propagated further
+ * to any of the remaining handlers.
+ *
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ * // Replace images with placeholder.
+ * await addInterceptRequestHandler(page, (request) => {
+ *     if (request.resourceType() === 'image') {
+ *         return request.respond({
+ *             statusCode: 200,
+ *             contentType: 'image/jpeg',
+ *             body: placeholderImageBuffer,
+ *         });
+ *     }
+ *     return request.continue();
+ * });
+ *
+ * // Abort all the scripts.
+ * await addInterceptRequestHandler(page, (request) => {
+ *     if (request.resourceType() === 'script') return request.abort();
+ *     return request.continue();
+ * });
+ *
+ * // Change requests to post.
+ * await addInterceptRequestHandler(page, (request) => {
+ *     return request.continue({
+ *          method: 'POST',
+ *     });
+ * });
+ *
+ * await page.goto('http://example.com');
+ * ```
+ *
+ * @param page Puppeteer [`Page`](https://pptr.dev/#?product=Puppeteer&show=api-class-page) object.
+ * @param handler Request interception handler.
+ */
+export declare function addInterceptRequestHandler(page: Page, handler: InterceptHandler): Promise<void>;
+/**
+ * Removes request interception handler for given page.
+ *
+ * @param page Puppeteer [`Page`](https://pptr.dev/#?product=Puppeteer&show=api-class-page) object.
+ * @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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppeteer_request_interception.d.ts","sourceRoot":"","sources":["../../../src/internals/utils/puppeteer_request_interception.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,WAAW,IAAI,gBAAgB,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAiC/E,oBAAY,gBAAgB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;AAwEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCrG;AAED;;;;;GAKG;AACH,wBAAsB,6BAA6B,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BxG"}