perimeterx-js-core 0.5.1 → 0.6.0

package/lib/products/bot_defender/block/captcha/HtmlCaptchaBlocker.d.ts

@@ -0,0 +1,9 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class HtmlCaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
+    private readonly config;
+    constructor(config: IConfiguration<Req, Res>);
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/products/bot_defender/block/captcha/HtmlCaptchaBlocker.js

@@ -0,0 +1,20 @@
+import { ContentType, CONTENT_TYPE_HEADER_NAME, MinimalResponseImpl } from '../../../../http';
+import { createBlockData, renderHtml } from '../utils';
+import { CAPTCHA_TEMPLATE } from '../templates';
+export class HtmlCaptchaBlocker {
+    constructor(config) {
+        this.config = config;
+    }
+    createBlockResponse(context) {
+        const status = 403;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.TEXT_HTML],
+        };
+        const body = renderHtml(CAPTCHA_TEMPLATE, createBlockData(this.config, context));
+        return new MinimalResponseImpl({
+            body: body,
+            status: status,
+            headers: headers,
+        });
+    }
+}

package/lib/products/bot_defender/block/captcha/JsonCaptchaBlocker.d.ts

@@ -0,0 +1,10 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IConditionalBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class JsonCaptchaBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
+    private readonly config;
+    constructor(config: IConfiguration<Req, Res>);
+    shouldBlock(context: ReadonlyContext<Req, Res>): boolean;
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/products/bot_defender/block/captcha/JsonCaptchaBlocker.js

@@ -0,0 +1,38 @@
+import { BlockAction } from '../../../../blocker';
+import { ContentType, CONTENT_TYPE_HEADER_NAME, ACCEPT_HEADER_NAME, MinimalResponseImpl, } from '../../../../http';
+import { createBlockData } from '../utils';
+export class JsonCaptchaBlocker {
+    constructor(config) {
+        this.config = config;
+    }
+    shouldBlock(context) {
+        if (!this.config.advancedBlockingResponseEnabled) {
+            return false;
+        }
+        const acceptHeaderValue = context.requestData.request.headers.get(ACCEPT_HEADER_NAME) ||
+            context.requestData.request.headers.get(CONTENT_TYPE_HEADER_NAME) ||
+            '';
+        const acceptHeaderContainsJson = acceptHeaderValue === null || acceptHeaderValue === void 0 ? void 0 : acceptHeaderValue.split(',').some((value) => value.toLowerCase() === ContentType.APPLICATION_JSON);
+        return !context.isMobile && context.blockAction !== BlockAction.RATE_LIMIT && acceptHeaderContainsJson;
+    }
+    createBlockResponse(context) {
+        const status = 403;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+        };
+        const blockData = createBlockData(this.config, context);
+        const jsonBlockPayload = {
+            appId: blockData.appId,
+            jsClientSrc: blockData.jsClientSrc,
+            customLogo: blockData.customLogo,
+            firstPartyEnabled: blockData.firstPartyEnabled,
+            vid: blockData.vid,
+            uuid: blockData.uuid,
+            hostUrl: blockData.hostUrl,
+            blockScript: blockData.blockScript,
+            altBlockScript: blockData.altBlockScript,
+        };
+        const body = JSON.stringify(jsonBlockPayload);
+        return new MinimalResponseImpl({ status, headers, body });
+    }
+}

package/lib/products/bot_defender/block/captcha/MobileCaptchaBlocker.d.ts

@@ -0,0 +1,12 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IBase64Utils } from '../../../../utils';
+import { IConditionalBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class MobileCaptchaBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
+    private readonly config;
+    private readonly base64Utils;
+    constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
+    shouldBlock(context: ReadonlyContext<Req, Res>): boolean;
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/products/bot_defender/block/captcha/MobileCaptchaBlocker.js

@@ -0,0 +1,34 @@
+import { BLOCK_ACTION_TO_WORD_MAP } from '../../../../blocker';
+import { ContentType, CONTENT_TYPE_HEADER_NAME, MinimalResponseImpl } from '../../../../http';
+import { createBlockData, renderHtml } from '../utils';
+import { CAPTCHA_TEMPLATE } from '../templates';
+export class MobileCaptchaBlocker {
+    constructor(config, base64Utils) {
+        this.config = config;
+        this.base64Utils = base64Utils;
+    }
+    shouldBlock(context) {
+        return context.isMobile;
+    }
+    createBlockResponse(context) {
+        const status = 403;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+        };
+        const blockData = createBlockData(this.config, context);
+        const captchaPage = renderHtml(CAPTCHA_TEMPLATE, blockData);
+        const mobileBlockPayload = {
+            action: BLOCK_ACTION_TO_WORD_MAP.get(blockData.blockAction),
+            uuid: blockData.uuid,
+            vid: blockData.vid,
+            appId: blockData.appId,
+            page: this.base64Utils.base64Encode(captchaPage),
+            collectorHost: this.config.backendCollectorUrl,
+        };
+        return new MinimalResponseImpl({
+            body: JSON.stringify(mobileBlockPayload),
+            status: status,
+            headers: headers,
+        });
+    }
+}

package/lib/products/bot_defender/block/captcha/index.d.ts

@@ -0,0 +1,4 @@
+export * from './CaptchaBlocker';
+export * from './HtmlCaptchaBlocker';
+export * from './JsonCaptchaBlocker';
+export * from './MobileCaptchaBlocker';

package/lib/products/bot_defender/block/captcha/index.js

@@ -0,0 +1,4 @@
+export * from './CaptchaBlocker';
+export * from './HtmlCaptchaBlocker';
+export * from './JsonCaptchaBlocker';
+export * from './MobileCaptchaBlocker';

package/lib/products/bot_defender/block/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model';
+export * from './captcha';
+export * from './templates';
+export * from './utils';
+export * from './DefaultBotDefenderBlocker';

package/lib/products/bot_defender/block/index.js

@@ -0,0 +1,5 @@
+export * from './model';
+export * from './captcha';
+export * from './templates';
+export * from './utils';
+export * from './DefaultBotDefenderBlocker';

package/lib/{block_handler → products/bot_defender/block}/model/BlockData.d.ts

@@ -1,4 +1,4 @@
-import { BlockAction } from '../BlockAction';
+import { BlockAction } from '../../../../blocker/BlockAction';
 export declare type BlockData = {
     appId: string;
     hostUrl: string;

package/lib/products/bot_defender/block/model/BlockData.js

@@ -0,0 +1 @@
+export {};

package/lib/products/bot_defender/block/model/JsonBlockPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/products/bot_defender/block/model/MobileBlockPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/products/bot_defender/block/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BlockData';
+export * from './JsonBlockPayload';
+export * from './MobileBlockPayload';

package/lib/products/bot_defender/block/model/index.js

@@ -0,0 +1,3 @@
+export * from './BlockData';
+export * from './JsonBlockPayload';
+export * from './MobileBlockPayload';

package/lib/products/bot_defender/block/templates/captcha_template.js

@@ -0,0 +1,50 @@
+export const CAPTCHA_TEMPLATE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="description" content="px-captcha">
+    <title>Access to this page has been denied</title>
+    {{cssRef}}
+</head>
+<body>
+    <script>
+        /* PerimeterX assignments */
+        window._pxVid = '{{vid}}';
+        window._pxUuid = '{{uuid}}';
+        window._pxAppId = '{{appId}}';
+        window._pxMobile = {{isMobile}};
+        window._pxHostUrl = '{{hostUrl}}';
+        window._pxCustomLogo = '{{customLogo}}';
+        window._pxJsClientSrc = '{{jsClientSrc}}';
+        window._pxFirstPartyEnabled = {{firstPartyEnabled}};
+        var pxCaptchaSrc = '{{blockScript}}';
+
+        var script = document.createElement('script');
+        script.src = pxCaptchaSrc;
+        script.onerror = function () {
+            script = document.createElement('script');
+            script.src = '{{altBlockScript}}';
+            script.onerror = window._pxOnError;
+            document.head.appendChild(script);
+        };
+        window._pxOnError = function () {
+            var style = document.createElement('style');
+            style.innerText = '@import url(https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap);body{background-color:#fafbfc}.px-captcha-error-container{position:fixed;height:340px;background-color:#fff;font-family:Roboto,sans-serif}.px-captcha-error-header{color:#f0f1f2;font-size:29px;margin:67px 0 33px;font-weight:500;line-height:.83;text-align:center}.px-captcha-error-message{color:#f0f1f2;font-size:18px;margin:0 0 29px;line-height:1.33;text-align:center}.px-captcha-error-button{text-align:center;line-height:48px;width:253px;margin:auto;border-radius:50px;border:solid 1px #f0f1f2;font-size:20px;color:#f0f1f2}.px-captcha-error-wrapper{margin:18px 0 0}div.px-captcha-error{margin:auto;text-align:center;width:400px;height:30px;font-size:12px;background-color:#fcf0f2;color:#ce0e2d}img.px-captcha-error{margin:6px 8px -2px 0}.px-captcha-error-refid{border-top:solid 1px #f0eeee;height:27px;margin:13px 0 0;border-radius:0 0 3px 3px;background-color:#fafbfc;font-size:10px;line-height:2.5;text-align:center;color:#b1b5b8}@media (min-width:620px){.px-captcha-error-container{width:530px;top:50%;left:50%;margin-top:-170px;margin-left:-265px;border-radius:3px;box-shadow:0 2px 9px -1px rgba(0,0,0,.13)}}@media (min-width:481px) and (max-width:620px){.px-captcha-error-container{width:85%;top:50%;left:50%;margin-top:-170px;margin-left:-42.5%;border-radius:3px;box-shadow:0 2px 9px -1px rgba(0,0,0,.13)}}@media (max-width:480px){body{background-color:#fff}.px-captcha-error-header{color:#f0f1f2;font-size:29px;margin:55px 0 33px}.px-captcha-error-container{width:530px;top:50%;left:50%;margin-top:-170px;margin-left:-265px}.px-captcha-error-refid{position:fixed;width:100%;left:0;bottom:0;border-radius:0;font-size:14px;line-height:2}}@media (max-width:390px){div.px-captcha-error{font-size:10px}.px-captcha-error-refid{font-size:11px;line-height:2.5}}';
+            document.head.appendChild(style);
+            var div = document.createElement('div');
+            div.className = 'px-captcha-error-container';
+            div.innerHTML = '<div class="px-captcha-error-header">Before we continue...</div><div class="px-captcha-error-message">Press & Hold to confirm you are<br>a human (and not a bot).</div><div class="px-captcha-error-button">Press & Hold</div><div class="px-captcha-error-wrapper"><div class="px-captcha-error"><img class="px-captcha-error" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABMAAAAQCAMAAADDGrRQAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAABFUExURUdwTNYELOEGONQILd0AONwALtwEL+AAL9MFLfkJSNQGLdMJLdQJLdQGLdQKLtYFLNcELdUGLdcBL9gFL88OLdUFLNEOLglBhT4AAAAXdFJOUwC8CqgNIRgRoAS1dWWuR4RTjzgryZpYblfkcAAAAI9JREFUGNNdj+sWhCAIhAdvqGVa1r7/oy6RZ7eaH3D4ZACBIed9wlOOMtUnSrEmZ6cHa9YAIfsbCkWrdpi/c50Bk2CO9mNLdMAu03wJA3HpEnfpxbyOg6ruyx8JJi6KNstnslp1dbPd9GnqmuYq7mmcv1zjnbQw8cV0xzkqo+fX1zkjUOO7wnrInUTxJiruC3vtBNRoQQn2AAAAAElFTkSuQmCC">Please check your internet connection' + (window._pxMobile ? '' : ' or disable your ad-blocker') + '.</div></div><div class="px-captcha-error-refid">Reference ID ' + window._pxUuid + '</div>';
+            document.body.appendChild(div);
+            if (window._pxMobile) {
+                setTimeout(function() {
+                    location.href = '/px/captcha_close?status=-1';
+                }, 5000);
+            }
+        };
+        document.head.appendChild(script);
+    </script>
+    {{jsRef}}
+</body>
+</html>
+`;

package/lib/products/bot_defender/block/templates/index.d.ts

@@ -0,0 +1,2 @@
+export * from './captcha_template';
+export * from './rate_limit_template';

package/lib/products/bot_defender/block/templates/index.js

@@ -0,0 +1,2 @@
+export * from './captcha_template';
+export * from './rate_limit_template';

package/lib/products/bot_defender/block/templates/rate_limit_template.js

@@ -0,0 +1,10 @@
+export const RATE_LIMIT_TEMPLATE = `<html>
+<head>
+    <title>Too Many Requests</title>
+</head>
+<body>
+    <h1>Too Many Requests</h1>
+    <p>Reached maximum requests limitation, try again soon.</p>
+</body>
+</html>
+`;

package/lib/products/bot_defender/block/utils.d.ts

@@ -0,0 +1,5 @@
+import { IConfiguration } from '../../../config';
+import { ReadonlyContext } from '../../../context';
+import { BlockData } from './model';
+export declare const renderHtml: (htmlTemplate: string, blockData?: BlockData) => string;
+export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res>, context: ReadonlyContext<Req, Res>) => BlockData;

package/lib/products/bot_defender/block/utils.js

@@ -0,0 +1,43 @@
+import { PXVID_COOKIE_NAME } from '../../../utils';
+import { FirstPartySuffix, getMostCustomizedFirstPartyPath } from '../first_party';
+export const renderHtml = (htmlTemplate, blockData) => {
+    if (!blockData) {
+        return htmlTemplate;
+    }
+    Object.entries(blockData).forEach(([key, value]) => {
+        const replace = `{{${key}}}`;
+        const regEx = new RegExp(replace, 'g');
+        htmlTemplate = htmlTemplate.replace(regEx, `${value}`);
+    });
+    return htmlTemplate;
+};
+export const createBlockData = (config, context) => {
+    var _a, _b;
+    const captchaParams = `/captcha.js?a=${context.blockAction}&u=${context.uuid}&v=${context.vid || ''}&m=${context.isMobile ? '1' : '0'}`;
+    let jsClientSrc = `${config.backendClientUrl}/${config.appId}/main.min.js`;
+    let blockScript = `${config.backendCaptchaUrl}/${config.appId}${captchaParams}`;
+    let hostUrl = config.backendCollectorUrl;
+    if (config.firstPartyEnabled && !context.isMobile) {
+        jsClientSrc = getMostCustomizedFirstPartyPath(config, FirstPartySuffix.SENSOR);
+        blockScript = `${getMostCustomizedFirstPartyPath(config, FirstPartySuffix.CAPTCHA)}${captchaParams}`;
+        hostUrl = getMostCustomizedFirstPartyPath(config, FirstPartySuffix.XHR);
+    }
+    const cssRef = config.cssRef ? `<link rel="stylesheet" type="text/css" href="${config.cssRef}" />` : '';
+    const jsRef = config.jsRef ? `<script src="${config.jsRef}"></script>` : '';
+    const altBlockScript = `${config.altBackendCaptchaUrl}/${config.appId}${captchaParams}`;
+    return {
+        appId: config.appId,
+        vid: context.vid || ((_b = (_a = context.requestData) === null || _a === void 0 ? void 0 : _a.cookies) === null || _b === void 0 ? void 0 : _b[PXVID_COOKIE_NAME]) || '',
+        uuid: context.uuid || '',
+        isMobile: context.isMobile,
+        customLogo: config.customLogo || '',
+        blockAction: context.blockAction,
+        hostUrl,
+        cssRef,
+        jsRef,
+        jsClientSrc,
+        firstPartyEnabled: config.firstPartyEnabled,
+        blockScript,
+        altBlockScript,
+    };
+};

package/lib/products/bot_defender/filter/DefaultBotDefenderFilter.d.ts

@@ -0,0 +1,16 @@
+import { IConfiguration } from '../../../config';
+import { ReadonlyContext } from '../../../context';
+import { IFilter } from '../../../filter';
+import { IIpRangeChecker } from '../../../utils';
+export declare class DefaultBotDefenderFilter<Req, Res> implements IFilter<Req, Res> {
+    private readonly config;
+    private readonly ipRangeChecker;
+    constructor(config: IConfiguration<Req, Res>, ipRangeChecker: IIpRangeChecker);
+    shouldFilter(context: ReadonlyContext<Req, Res>): boolean;
+    private getFilterReason;
+    private shouldFilterByExtension;
+    private shouldFilterByHttpMethod;
+    private shouldFilterByIp;
+    private shouldFilterByRoute;
+    private shouldFilterByUserAgent;
+}

package/lib/products/bot_defender/filter/DefaultBotDefenderFilter.js

@@ -0,0 +1,51 @@
+import { HttpMethod } from '../../../http';
+import { FilterReason } from '../../../filter';
+import { getExtension, isRouteInPatterns } from '../../../utils';
+export class DefaultBotDefenderFilter {
+    constructor(config, ipRangeChecker) {
+        this.config = config;
+        this.ipRangeChecker = ipRangeChecker;
+    }
+    shouldFilter(context) {
+        const { requestData } = context;
+        const filterReason = this.getFilterReason(requestData);
+        return filterReason !== FilterReason.NONE;
+    }
+    getFilterReason(request) {
+        if (this.shouldFilterByExtension(request)) {
+            return FilterReason.EXTENSION;
+        }
+        if (this.shouldFilterByRoute(request.url.pathname)) {
+            return FilterReason.ROUTE;
+        }
+        if (this.shouldFilterByHttpMethod(request.method)) {
+            return FilterReason.HTTP_METHOD;
+        }
+        if (this.shouldFilterByUserAgent(request.userAgent)) {
+            return FilterReason.USER_AGENT;
+        }
+        if (this.shouldFilterByIp(request.ip)) {
+            return FilterReason.IP;
+        }
+        return FilterReason.NONE;
+    }
+    shouldFilterByExtension(requestData) {
+        if (requestData.method !== HttpMethod.GET && requestData.method !== HttpMethod.HEAD) {
+            return false;
+        }
+        const ext = getExtension(requestData.url.href);
+        return !!ext && this.config.filteredExtensions.includes(ext);
+    }
+    shouldFilterByHttpMethod(method) {
+        return this.config.filteredHttpMethods.some((filteredMethod) => filteredMethod.toUpperCase() === method);
+    }
+    shouldFilterByIp(ip) {
+        return this.config.filteredIps.some((range) => this.ipRangeChecker.isIpInRange(ip, range));
+    }
+    shouldFilterByRoute(route) {
+        return isRouteInPatterns(route, this.config.filteredRoutes);
+    }
+    shouldFilterByUserAgent(userAgent) {
+        return this.config.filteredUserAgents.includes(userAgent);
+    }
+}

package/lib/products/bot_defender/filter/index.d.ts

@@ -0,0 +1 @@
+export * from './DefaultBotDefenderFilter';

package/lib/products/bot_defender/filter/index.js

@@ -0,0 +1 @@
+export * from './DefaultBotDefenderFilter';

package/lib/products/bot_defender/first_party/DefaultBotDefenderFirstParty.d.ts

@@ -0,0 +1,20 @@
+import { IConfiguration } from '../../../config';
+import { ReadonlyContext } from '../../../context';
+import { FirstPartyData, IFirstParty } from '../../../first_party';
+export declare class DefaultBotDefenderFirstParty<Req, Res> implements IFirstParty<Req, Res> {
+    private readonly config;
+    constructor(config: IConfiguration<Req, Res>);
+    handleFirstPartyRequest(context: ReadonlyContext<Req, Res>): Promise<FirstPartyData | null>;
+    private proxySensorScriptRequest;
+    private proxyXhrRequest;
+    private static getDefaultXhrResponse;
+    private proxyCaptchaScriptRequest;
+    private getOutgoingRequest;
+    private prepareFirstPartyHeaders;
+    private setHostHeader;
+    private setXffHeader;
+    private addFirstPartyHeaders;
+    private getThirdPartySensorScriptUrl;
+    private getThirdPartyCaptchaScriptUrl;
+    private getThirdPartyXhrUrl;
+}

package/lib/products/bot_defender/first_party/DefaultBotDefenderFirstParty.js

@@ -0,0 +1,129 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { removeSensitiveHeaders } from '../../../utils';
+import { COOKIE_HEADER_NAME, HOST_HEADER_NAME, X_FORWARDED_FOR_HEADER_NAME, OutgoingRequestImpl, MinimalResponseImpl, toMutableHeaders, } from '../../../http';
+import { getFirstPartyCaptchaScriptPathPrefixes, getFirstPartySensorScriptPaths, getFirstPartyXhrPathPrefixes, } from './utils';
+import { DEFAULT_CLIENT_RESPONSE_OPTIONS, DEFAULT_GIF_RESPONSE, DEFAULT_XHR_RESPONSE, FIRST_PARTY_HEADER_NAME, FIRST_PARTY_HEADER_VALUE, X_PX_ENFORCER_TRUE_IP_HEADER_NAME, } from './constants';
+export class DefaultBotDefenderFirstParty {
+    constructor(config) {
+        this.config = config;
+    }
+    handleFirstPartyRequest(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pathname } = context.requestData.url;
+            if (getFirstPartySensorScriptPaths(this.config).includes(pathname)) {
+                return yield this.proxySensorScriptRequest(context);
+            }
+            const xhrPrefix = getFirstPartyXhrPathPrefixes(this.config).find((prefix) => pathname.startsWith(prefix));
+            if (xhrPrefix) {
+                return yield this.proxyXhrRequest(context, xhrPrefix);
+            }
+            const captchaPrefix = getFirstPartyCaptchaScriptPathPrefixes(this.config).find((prefix) => pathname.startsWith(prefix));
+            if (captchaPrefix) {
+                return yield this.proxyCaptchaScriptRequest(context, captchaPrefix);
+            }
+            return null;
+        });
+    }
+    proxySensorScriptRequest(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultResponse = new MinimalResponseImpl(DEFAULT_CLIENT_RESPONSE_OPTIONS);
+            if (!this.config.firstPartyEnabled) {
+                return { defaultResponse };
+            }
+            const url = this.getThirdPartySensorScriptUrl();
+            const request = yield this.getOutgoingRequest(url, context);
+            return { request, defaultResponse };
+        });
+    }
+    proxyXhrRequest(context, prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultResponse = DefaultBotDefenderFirstParty.getDefaultXhrResponse(context.requestData.url.pathname);
+            if (!this.config.firstPartyEnabled) {
+                return { defaultResponse };
+            }
+            const url = this.getThirdPartyXhrUrl(context, prefix);
+            const request = yield this.getOutgoingRequest(url, context);
+            return { request, defaultResponse };
+        });
+    }
+    static getDefaultXhrResponse(path) {
+        const { content, options } = path.endsWith('.gif') ? DEFAULT_GIF_RESPONSE : DEFAULT_XHR_RESPONSE;
+        return new MinimalResponseImpl({
+            body: content,
+            status: options.status,
+            headers: options.headers,
+        });
+    }
+    proxyCaptchaScriptRequest(context, prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultResponse = new MinimalResponseImpl(DEFAULT_CLIENT_RESPONSE_OPTIONS);
+            if (!this.config.firstPartyEnabled) {
+                return { defaultResponse };
+            }
+            const url = this.getThirdPartyCaptchaScriptUrl(context, prefix);
+            const request = yield this.getOutgoingRequest(url, context);
+            return { request, defaultResponse };
+        });
+    }
+    getOutgoingRequest(url, { requestData, vid }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new OutgoingRequestImpl({
+                url: url,
+                method: requestData.method,
+                headers: this.prepareFirstPartyHeaders(url, requestData, vid),
+                body: requestData.request.body,
+            });
+        });
+    }
+    prepareFirstPartyHeaders(url, requestData, vid) {
+        let headers = toMutableHeaders(requestData.headers);
+        try {
+            headers = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
+            this.setHostHeader(headers, url);
+            this.setXffHeader(headers, requestData.ip);
+            this.addFirstPartyHeaders(headers, requestData.ip);
+            if (vid) {
+                const newCookies = (headers[COOKIE_HEADER_NAME] || []).concat([`pxvid=${vid}`]);
+                headers[COOKIE_HEADER_NAME] = [newCookies.join('; ')];
+            }
+        }
+        catch (e) {
+            this.config.logger.error(`Caught error preparing first party headers: ${e}`);
+        }
+        return headers;
+    }
+    setHostHeader(headers, url) {
+        headers[HOST_HEADER_NAME] = [new URL(url).host];
+    }
+    setXffHeader(headers, ip) {
+        const xffValue = headers[X_FORWARDED_FOR_HEADER_NAME] || [];
+        headers[X_FORWARDED_FOR_HEADER_NAME] = xffValue.concat([ip]);
+    }
+    addFirstPartyHeaders(headers, ip) {
+        headers[FIRST_PARTY_HEADER_NAME] = [FIRST_PARTY_HEADER_VALUE];
+        headers[X_PX_ENFORCER_TRUE_IP_HEADER_NAME] = [ip];
+    }
+    getThirdPartySensorScriptUrl() {
+        return `${this.config.backendClientUrl}/${this.config.appId}/main.min.js`;
+    }
+    getThirdPartyCaptchaScriptUrl(context, prefix) {
+        const originalUrl = context.requestData.url;
+        const { appId, backendCaptchaUrl } = this.config;
+        const regExString = `${originalUrl.origin}${prefix}`;
+        const regEx = new RegExp(regExString, 'ig');
+        return `${backendCaptchaUrl}/${appId}${originalUrl.href.replace(regEx, '')}`;
+    }
+    getThirdPartyXhrUrl(context, prefix) {
+        const originalUrl = context.requestData.url;
+        const { backendCollectorUrl } = this.config;
+        return `${backendCollectorUrl}${originalUrl.pathname.replace(prefix, '')}${originalUrl.search}`;
+    }
+}

package/lib/products/bot_defender/first_party/FirstPartySuffix.d.ts

@@ -0,0 +1,5 @@
+export declare enum FirstPartySuffix {
+    SENSOR = "/init.js",
+    CAPTCHA = "/captcha",
+    XHR = "/xhr"
+}

package/lib/products/bot_defender/first_party/FirstPartySuffix.js

@@ -0,0 +1,6 @@
+export var FirstPartySuffix;
+(function (FirstPartySuffix) {
+    FirstPartySuffix["SENSOR"] = "/init.js";
+    FirstPartySuffix["CAPTCHA"] = "/captcha";
+    FirstPartySuffix["XHR"] = "/xhr";
+})(FirstPartySuffix || (FirstPartySuffix = {}));

package/lib/{first_party → products/bot_defender/first_party}/constants.d.ts

@@ -1,9 +1,12 @@
-import { ContentType } from '../http';
-import { MinimalResponseOptions } from '../http';
+import { ContentType } from '../../../http';
+import { MinimalResponseOptions } from '../../../http';
 export declare const EMPTY_GIF: number[];
 export declare const X_PX_ENFORCER_TRUE_IP_HEADER_NAME = "x-px-enforcer-true-ip";
 export declare const FIRST_PARTY_HEADER_NAME = "x-px-first-party";
 export declare const FIRST_PARTY_HEADER_VALUE = "1";
+export declare const FIRST_PARTY_SENSOR_SUFFIX = "/init.js";
+export declare const FIRST_PARTY_CAPTCHA_SUFFIX = "/captcha";
+export declare const FIRST_PARTY_XHR_SUFFIX = "/xhr";
 export declare const DEFAULT_CLIENT_RESPONSE_OPTIONS: MinimalResponseOptions;
 export declare const DEFAULT_XHR_RESPONSE: {
     content: string;

package/lib/products/bot_defender/first_party/constants.js

@@ -0,0 +1,36 @@
+import { ContentType, CONTENT_TYPE_HEADER_NAME } from '../../../http';
+export const EMPTY_GIF = [
+    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x44, 0x01, 0x00, 0x3b,
+];
+export const X_PX_ENFORCER_TRUE_IP_HEADER_NAME = 'x-px-enforcer-true-ip';
+export const FIRST_PARTY_HEADER_NAME = 'x-px-first-party';
+export const FIRST_PARTY_HEADER_VALUE = '1';
+export const FIRST_PARTY_SENSOR_SUFFIX = '/init.js';
+export const FIRST_PARTY_CAPTCHA_SUFFIX = '/captcha';
+export const FIRST_PARTY_XHR_SUFFIX = '/xhr';
+export const DEFAULT_CLIENT_RESPONSE_OPTIONS = {
+    body: '',
+    status: 200,
+    headers: {
+        [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JAVASCRIPT],
+    },
+};
+export const DEFAULT_XHR_RESPONSE = {
+    content: '{}',
+    options: {
+        status: 200,
+        headers: {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JAVASCRIPT],
+        },
+    },
+};
+export const DEFAULT_GIF_RESPONSE = {
+    content: 'GIF89a\x01\x00\x01\x00\x80\x00\x00ÿÿÿ\x00\x00\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;',
+    options: {
+        status: 200,
+        headers: {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.IMAGE_GIF],
+        },
+    },
+};

package/lib/products/bot_defender/first_party/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DefaultBotDefenderFirstParty';
+export * from './utils';
+export * from './constants';
+export * from './FirstPartySuffix';

package/lib/products/bot_defender/first_party/index.js

@@ -0,0 +1,4 @@
+export * from './DefaultBotDefenderFirstParty';
+export * from './utils';
+export * from './constants';
+export * from './FirstPartySuffix';

package/lib/products/bot_defender/first_party/utils.d.ts

@@ -0,0 +1,11 @@
+import { IConfiguration } from '../../../config';
+import { FirstPartySuffix } from './FirstPartySuffix';
+export declare const getAllFirstPartyPaths: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>, suffix: FirstPartySuffix) => string[];
+export declare const getCustomEndpointFromFirstPartySuffix: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>, suffix: FirstPartySuffix) => string;
+export declare const getMostCustomizedFirstPartyPath: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>, suffix: FirstPartySuffix) => string;
+export declare const getFirstPartySensorScriptPaths: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>) => string[];
+export declare const getFirstPartyCaptchaScriptPathPrefixes: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>) => string[];
+export declare const getFirstPartyXhrPathPrefixes: <Req, Res>(config: IConfiguration<Req, Res, import("../../../config").ConfigurationParams<Req, Res>>) => string[];
+export declare const getDefaultFirstPartyPrefix: (appId: string) => string;
+export declare const getFirstPartyPath: (prefix: string, suffix: string) => string;
+export declare const addInitialSlashIfNeeded: (path: string) => string;