@xcrap/puppeteer-client 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marcuth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,177 @@
+# 🕷️ Xcrap Pupeeteer Client
+
+**Xcrap Puppeteer Client** is a package of the Xcrap framework that implements an HTTP client using the [Puppeteer](https://www.npmjs.com/package/puppeteer) library.
+## 📦 Installation
+
+There are no secrets to installing it, just use your favorite dependency manager. Here is an example using NPM:
+
+```cmd
+npm i @xcrap/puppeteer-client @xcrap/core
+```
+
+> You need to install `@xcrap/parser` and `@xcrap/core` as well because I left them as `peerDependencies`, which means that the package needs `@xcrap/parser` and `@xcrap/core` as dependencies, however, the ones that the user has installed in the project will be used.
+
+## 🚀 Usage
+
+Like any HTTP client, `PuppteerClient` has two methods: `fetch()` to make a request for a specific URL and `fetchMany()` to make requests for multiple URLs at the same time, being able to control concurrency and delays between requests. #### Example usage
+
+```ts
+import { PuppteerClient } from "@xcrap/puppeteer-client"
+import { extract } from "@xcrap/parser"
+
+;(async() => {
+    const client = new PuppteerClient()
+    const url = "https://example.com"
+    const response = await client.fetch({ url: url })
+    const parser = response.asHtmlParser()
+    const pageTitle = await parser.parseFist({ query: "title", extractor: extract("innerText") })
+
+    console.log("Page Title:", pageTitle)
+})();
+```
+
+#### Using Actions
+
+If you want to perform operations on the page before or after requests, you can use the `actions` property, which is an array of functions. Actions are flexible enough that you can do exactly what you would normally do with Puppeteer: login, click buttons, evaluate functions, etc.
+
+```ts
+const response = await client.fetch({
+    url: "https://example.com",
+    actions: [
+        async (page) => {
+            await page.type("#username", "user")
+            await page.type("#password", "mypassword123")
+            await page.click("#submit")
+        }
+    ]
+})
+```
+
+By default, an action is executed after requests. If you want to manually define when it will be executed, you will have to pass an object instead of a simple function:
+
+```ts
+const response = await client.fetch({
+    url: "https://example.com",
+    actions: [
+        {
+            type: "afterRequest", // Executed after the request
+            exec: async (page) => {
+                await page.type("#username", "user")
+                await page.type("#password", "mypassword123")
+                await page.click("#submit")
+            }
+        },
+        {
+            type: "beforeRequest", // Executed before the request
+            func: async (page) => {
+                const width = 1920 + Math.floor(Math.random() * 100)
+                const height = 3000 + Math.floor(Math.random() * 100)
+
+                await page.setViewport({
+                    width: width,
+                    height: height,
+                    deviceScaleFactor: 1,
+                    hasTouch: false,
+                    isLandscape: false,
+                    isMobile: false,
+                })
+            }
+        }
+    ]
+})
+```
+
+#### Adding a proxy
+
+In an HTTP client that extends `BaseClient` we can add a proxy in the constructor as we can see in the following example:
+
+1. **Providing a `proxy` string:
+
+```ts
+const client = new PuppteerClient({ proxy: "http://47.251.122.81:8888" })
+```
+
+2. **Providing a function that will generate a `proxy`:**
+
+```ts
+function randomProxy() {
+        const proxies = [
+            "http://47.251.122.81:8888",
+            "http://159.203.61.169:3128"
+        ]
+
+        const randomIndex = Math.floor(Math.random() * proxies.length)
+
+        return proxies[randomIndex]
+    }
+
+    const client = new PuppteerClient({ proxy: randomProxy })
+```
+
+#### Using a custom User Agent
+
+In a client that extends `BaseClient` we can also customize the `User-Agent` of the requests. We can do this in two ways:
+
+1. **By providing a `userAgent` string:
+
+```ts
+const client = new PuppteerClient({ userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36" })
+```
+
+2. **By providing a function that will generate a `userAgent`:**
+
+```ts
+function randomUserAgent() {
+    const userAgents = [
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 9_8_4; like Mac OS X) AppleWebKit/603.37 (KHTML, like Gecko) Chrome/54.0.1244.188 Mobile Safari/601.5", "Mozilla/5.0 (Windows NT 10.3;; en-US) AppleWebKit/537.35 (KHTML, like Gecko) Chrome/47.0.1707.185 Safari/601"
+    ]
+
+    const randomIndex = Math.floor(Math.random() * userAgents.length)
+
+    return userAgents[randomIndex]
+}
+
+const client = new PuppteerClient({ userAgent: randomUserAgent })
+```
+
+#### Using custom Proxy URL
+
+In a client that extends `BaseClient` we can use proxy URLs, I don't know how to explain to you how they work, but I kind of discovered this kind of porxy when I was trying to solve the CORS problem by making a request on the client side, and then I met the *CORS Proxy*. Here I have a [template](https://gist.github.com/marcuth/9fbd321b011da44d1287faae31a8dd3a) for one for CloudFlare Workers in case you want to roll your own.
+
+Well, we can do it the same way we did with `userAgent`:
+
+1. **Providing a `proxyUrl` string:
+
+```ts
+const client = new PuppteerClient({ proxyUrl: "https://my-proxy-app.my-username.workers.dev" })
+```
+
+2. **Providing a function that will generate a `proxyUrl`:**
+
+```ts
+function randomProxyUrl() {
+const proxyUrls = [
+        "https://my-proxy-app.my-username-1.workers.dev",
+        "https://my-proxy-app.my-username-2.workers.dev"
+    ]
+
+    const randomIndex = Math.floor(Math.random() * proxyUrls.length)
+
+    return proxyUrls[randomIndex]
+}
+
+const client = new PuppteerClient({ proxyUrl: randomProxyUrl })
+```
+
+## 🤝 Contributing
+
+- Want to contribute? Follow these steps:
+- Fork the repository.
+- Create a new branch (git checkout -b feature-new).
+- Commit your changes (git commit -m 'Add new feature').
+- Push to the branch (git push origin feature-new).
+- Open a Pull Request.
+
+## 📝 License
+
+This project is licensed under the MIT License.

package/dist/constants.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPuppeteerActionType = void 0;
+exports.defaultPuppeteerActionType = "afterRequest";

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+import { PuppeteerClientActionType } from "./index";
+export declare const defaultPuppeteerActionType: `${PuppeteerClientActionType}`;

package/dist/constants.mjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPuppeteerActionType = void 0;
+exports.defaultPuppeteerActionType = "afterRequest";

package/dist/index.cjs

@@ -0,0 +1,169 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerClient = exports.PuppeteerClientActionType = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@xcrap/core");
+const puppeteer_1 = tslib_1.__importDefault(require("puppeteer"));
+const constants_1 = require("./constants");
+var PuppeteerClientActionType;
+(function (PuppeteerClientActionType) {
+    PuppeteerClientActionType["BeforeRequest"] = "beforeRequest";
+    PuppeteerClientActionType["AfterRequest"] = "afterRequest";
+})(PuppeteerClientActionType || (exports.PuppeteerClientActionType = PuppeteerClientActionType = {}));
+class PuppeteerClient extends core_1.BaseClient {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        this.options = options;
+        this.browser = undefined;
+    }
+    initBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const puppeteerArguments = [];
+            if (this.proxy) {
+                puppeteerArguments.push(`--proxy-server=${this.currentProxy}`);
+            }
+            if (this.options.args && this.options.args.length > 0) {
+                puppeteerArguments.push(...this.options.args);
+            }
+            this.browser = yield puppeteer_1.default.launch(Object.assign(Object.assign({}, this.options), { args: puppeteerArguments, headless: this.options.headless ? "shell" : false }));
+        });
+    }
+    ensureBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.browser) {
+                yield this.initBrowser();
+            }
+        });
+    }
+    closeBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.browser) {
+                yield this.browser.close();
+                this.browser = undefined;
+            }
+        });
+    }
+    configurePage(page_1, _a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (page, { javaScriptEnabled }) {
+            var _b;
+            if (this.currentUserAgent) {
+                yield page.setUserAgent((_b = this.currentUserAgent) !== null && _b !== void 0 ? _b : core_1.defaultUserAgent);
+            }
+            if (javaScriptEnabled !== undefined) {
+                yield page.setJavaScriptEnabled(javaScriptEnabled);
+            }
+        });
+    }
+    extractActions(actions) {
+        const actionsBeforeRequest = [];
+        const actionsAfterRequest = [];
+        if (!actions) {
+            actions = [];
+        }
+        for (const action of actions) {
+            const actionType = typeof action === "function" ? constants_1.defaultPuppeteerActionType : action.type;
+            const actionFunc = typeof action === "function" ? action : action.exec;
+            if (actionType === "beforeRequest") {
+                actionsBeforeRequest.push(actionFunc);
+            }
+            else {
+                actionsAfterRequest.push(actionFunc);
+            }
+        }
+        return {
+            before: actionsBeforeRequest,
+            after: actionsAfterRequest
+        };
+    }
+    executeActions(page, actions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const action of actions) {
+                yield action(page);
+            }
+        });
+    }
+    fetch(_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* ({ url, javaScriptEnabled, maxRetries = 0, actions, retries = 0, retryDelay, }) {
+            yield this.ensureBrowser();
+            const failedAttempts = [];
+            const attemptRequest = (currentRetry) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                let page = undefined;
+                try {
+                    const fullUrl = this.currentProxyUrl ? `${this.currentProxyUrl}${url}` : url;
+                    const { before: actionsBeforeRequest, after: actionsAfterRequest } = this.extractActions(actions);
+                    page = yield this.browser.newPage();
+                    yield this.configurePage(page, { javaScriptEnabled: javaScriptEnabled });
+                    yield this.executeActions(page, actionsBeforeRequest);
+                    const response = yield page.goto(fullUrl);
+                    yield this.executeActions(page, actionsAfterRequest);
+                    const content = yield page.content();
+                    yield page.close();
+                    const status = response === null || response === void 0 ? void 0 : response.status();
+                    if (status === undefined || !this.isSuccess(status)) {
+                        throw new core_1.InvalidStatusCodeError(status !== null && status !== void 0 ? status : 500);
+                    }
+                    return new core_1.HttpResponse({
+                        body: content,
+                        headers: (response === null || response === void 0 ? void 0 : response.headers()) || {},
+                        status: (response === null || response === void 0 ? void 0 : response.status()) || 200,
+                        statusText: (response === null || response === void 0 ? void 0 : response.statusText()) || "Ok",
+                        attempts: currentRetry + 1,
+                        failedAttempts: failedAttempts,
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                    failedAttempts.push({ error: errorMessage, timestamp: new Date() });
+                    if (page) {
+                        yield page.close().catch(() => { });
+                    }
+                    if (currentRetry < maxRetries) {
+                        if (retryDelay !== undefined && retryDelay > 0) {
+                            yield (0, core_1.delay)(retryDelay);
+                        }
+                        return yield attemptRequest(currentRetry + 1);
+                    }
+                    return new core_1.HttpResponse({
+                        body: errorMessage,
+                        headers: {},
+                        status: error.status || 500,
+                        statusText: "Request Failed",
+                        attempts: currentRetry + 1,
+                        failedAttempts: failedAttempts,
+                    });
+                }
+            });
+            return yield attemptRequest(retries);
+        });
+    }
+    fetchMany(_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* ({ requests, concurrency, requestDelay }) {
+            const results = [];
+            const executing = [];
+            for (let i = 0; i < requests.length; i++) {
+                const promise = this.executeRequest({
+                    request: requests[i],
+                    index: i,
+                    requestDelay: requestDelay,
+                    results: results
+                }).then(() => undefined);
+                executing.push(promise);
+                if (this.shouldThrottle(executing, concurrency)) {
+                    yield this.handleConcurrency(executing);
+                }
+            }
+            yield Promise.all(executing);
+            return results;
+        });
+    }
+    close() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.browser) {
+                yield this.closeBrowser();
+            }
+        });
+    }
+}
+exports.PuppeteerClient = PuppeteerClient;

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { ClientInterface, ClientFetchManyOptions, ClientRequestOptions, BaseClient, BaseClientOptions, HttpResponse } from "@xcrap/core";
+import { Browser, Page, LaunchOptions } from "puppeteer";
+export type PuppeteerProxy = string;
+export type PuppeteerClientOptions = BaseClientOptions<PuppeteerProxy> & LaunchOptions;
+export type PuppeteerClientActionFunction = (page: Page) => any | Promise<any>;
+export declare enum PuppeteerClientActionType {
+    BeforeRequest = "beforeRequest",
+    AfterRequest = "afterRequest"
+}
+export type PuppeteerClientAction = PuppeteerClientActionFunction | {
+    type: `${PuppeteerClientActionType}`;
+    exec: PuppeteerClientActionFunction;
+};
+export type ExtractActionsResult = {
+    before: PuppeteerClientActionFunction[];
+    after: PuppeteerClientActionFunction[];
+};
+export type PuppeterRequestOptions = Omit<ClientRequestOptions & {
+    javaScriptEnabled?: boolean;
+    actions?: PuppeteerClientAction[];
+}, "method">;
+export type ConfigurePageOptions = {
+    javaScriptEnabled: PuppeterRequestOptions["javaScriptEnabled"];
+};
+export type PuppeteerFetchManyOptions = ClientFetchManyOptions<PuppeterRequestOptions>;
+export declare class PuppeteerClient extends BaseClient<string> implements ClientInterface {
+    readonly options: PuppeteerClientOptions;
+    protected browser?: Browser;
+    constructor(options?: PuppeteerClientOptions);
+    protected initBrowser(): Promise<void>;
+    protected ensureBrowser(): Promise<void>;
+    protected closeBrowser(): Promise<void>;
+    protected configurePage(page: Page, { javaScriptEnabled }: ConfigurePageOptions): Promise<void>;
+    protected extractActions(actions: PuppeteerClientAction[] | undefined): ExtractActionsResult;
+    protected executeActions(page: Page, actions: PuppeteerClientActionFunction[]): Promise<void>;
+    fetch({ url, javaScriptEnabled, maxRetries, actions, retries, retryDelay, }: PuppeterRequestOptions): Promise<HttpResponse>;
+    fetchMany({ requests, concurrency, requestDelay }: PuppeteerFetchManyOptions): Promise<HttpResponse[]>;
+    close(): Promise<void>;
+}

package/dist/index.mjs

@@ -0,0 +1,167 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerClient = exports.PuppeteerClientActionType = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@xcrap/core");
+const puppeteer_1 = tslib_1.__importDefault(require("puppeteer"));
+const constants_1 = require("./constants");
+var PuppeteerClientActionType;
+(function (PuppeteerClientActionType) {
+    PuppeteerClientActionType["BeforeRequest"] = "beforeRequest";
+    PuppeteerClientActionType["AfterRequest"] = "afterRequest";
+})(PuppeteerClientActionType || (exports.PuppeteerClientActionType = PuppeteerClientActionType = {}));
+class PuppeteerClient extends core_1.BaseClient {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        this.options = options;
+        this.browser = undefined;
+    }
+    initBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const puppeteerArguments = [];
+            if (this.proxy) {
+                puppeteerArguments.push(`--proxy-server=${this.currentProxy}`);
+            }
+            if (this.options.args && this.options.args.length > 0) {
+                puppeteerArguments.push(...this.options.args);
+            }
+            this.browser = yield puppeteer_1.default.launch(Object.assign(Object.assign({}, this.options), { args: puppeteerArguments, headless: this.options.headless ? "shell" : false }));
+        });
+    }
+    ensureBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.browser) {
+                yield this.initBrowser();
+            }
+        });
+    }
+    closeBrowser() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.browser) {
+                yield this.browser.close();
+                this.browser = undefined;
+            }
+        });
+    }
+    configurePage(page_1, _a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (page, { javaScriptEnabled }) {
+            var _b;
+            if (this.currentUserAgent) {
+                yield page.setUserAgent((_b = this.currentUserAgent) !== null && _b !== void 0 ? _b : core_1.defaultUserAgent);
+            }
+            if (javaScriptEnabled !== undefined) {
+                yield page.setJavaScriptEnabled(javaScriptEnabled);
+            }
+        });
+    }
+    extractActions(actions) {
+        const actionsBeforeRequest = [];
+        const actionsAfterRequest = [];
+        if (!actions) {
+            actions = [];
+        }
+        for (const action of actions) {
+            const actionType = typeof action === "function" ? constants_1.defaultPuppeteerActionType : action.type;
+            const actionFunc = typeof action === "function" ? action : action.exec;
+            if (actionType === "beforeRequest") {
+                actionsBeforeRequest.push(actionFunc);
+            }
+            else {
+                actionsAfterRequest.push(actionFunc);
+            }
+        }
+        return {
+            before: actionsBeforeRequest,
+            after: actionsAfterRequest
+        };
+    }
+    executeActions(page, actions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const action of actions) {
+                yield action(page);
+            }
+        });
+    }
+    fetch(_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* ({ url, javaScriptEnabled, maxRetries = 0, actions, retries = 0, retryDelay, }) {
+            yield this.ensureBrowser();
+            const failedAttempts = [];
+            const attemptRequest = (currentRetry) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                let page = undefined;
+                try {
+                    const fullUrl = this.currentProxyUrl ? `${this.currentProxyUrl}${url}` : url;
+                    const { before: actionsBeforeRequest, after: actionsAfterRequest } = this.extractActions(actions);
+                    page = yield this.browser.newPage();
+                    yield this.configurePage(page, { javaScriptEnabled: javaScriptEnabled });
+                    yield this.executeActions(page, actionsBeforeRequest);
+                    const response = yield page.goto(fullUrl);
+                    yield this.executeActions(page, actionsAfterRequest);
+                    const content = yield page.content();
+                    yield page.close();
+                    const status = response === null || response === void 0 ? void 0 : response.status();
+                    if (status === undefined || !this.isSuccess(status)) {
+                        throw new core_1.InvalidStatusCodeError(status !== null && status !== void 0 ? status : 500);
+                    }
+                    return new core_1.HttpResponse({
+                        body: content,
+                        headers: (response === null || response === void 0 ? void 0 : response.headers()) || {},
+                        status: (response === null || response === void 0 ? void 0 : response.status()) || 200,
+                        statusText: (response === null || response === void 0 ? void 0 : response.statusText()) || "Ok",
+                        attempts: currentRetry + 1,
+                        failedAttempts: failedAttempts,
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                    failedAttempts.push({ error: errorMessage, timestamp: new Date() });
+                    if (page) {
+                        yield page.close().catch(() => { });
+                    }
+                    if (currentRetry < maxRetries) {
+                        if (retryDelay !== undefined && retryDelay > 0) {
+                            yield (0, core_1.delay)(retryDelay);
+                        }
+                        return yield attemptRequest(currentRetry + 1);
+                    }
+                    return new core_1.HttpResponse({
+                        body: errorMessage,
+                        headers: {},
+                        status: error.status || 500,
+                        statusText: "Request Failed",
+                        attempts: currentRetry + 1,
+                        failedAttempts: failedAttempts,
+                    });
+                }
+            });
+            return yield attemptRequest(retries);
+        });
+    }
+    fetchMany(_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* ({ requests, concurrency, requestDelay }) {
+            const results = [];
+            const executing = [];
+            for (let i = 0; i < requests.length; i++) {
+                const promise = this.executeRequest({
+                    request: requests[i],
+                    index: i,
+                    requestDelay: requestDelay,
+                    results: results
+                }).then(() => undefined);
+                executing.push(promise);
+                if (this.shouldThrottle(executing, concurrency)) {
+                    yield this.handleConcurrency(executing);
+                }
+            }
+            yield Promise.all(executing);
+            return results;
+        });
+    }
+    close() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.browser) {
+                yield this.closeBrowser();
+            }
+        });
+    }
+}
+exports.PuppeteerClient = PuppeteerClient;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@xcrap/puppeteer-client",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/*",
+    "!/**/__tests__"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "rollup -c"
+  },
+  "keywords": [
+    "xcrap",
+    "transformer",
+    "scrapy",
+    "web scraping"
+  ],
+  "author": "Marcuth",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^22.13.17",
+    "rollup": "^4.39.0",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "puppeteer": "^24.5.0"
+  },
+  "peerDependencies": {
+    "@xcrap/core": "^0.0.3",
+    "@xcrap/parser": "^0.0.2"
+  }
+}