perimeterx-js-core 0.7.1 → 0.8.0

package/lib/products/account_defender/AccountDefender.js

@@ -1,48 +1,30 @@
-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 { getPropertyFromObject } from '../../utils';
 import { CROSS_TAB_SESSION_COOKIE_NAME } from './constants';
 export class AccountDefender {
+    config;
+    base64Utils;
     constructor(config, options) {
         this.config = config;
         this.base64Utils = options.base64Utils;
     }
-    enrichContextFromRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const crossTabSession = context.requestData.cookies[CROSS_TAB_SESSION_COOKIE_NAME];
-            const jwtData = this.getJwtData(context.requestData);
-            return Object.assign({ crossTabSession }, jwtData);
-        });
+    async enrichContextFromRequest(context) {
+        const crossTabSession = context.requestData.cookies[CROSS_TAB_SESSION_COOKIE_NAME];
+        const jwtData = this.getJwtData(context.requestData);
+        return { crossTabSession, ...jwtData };
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async enrichContextFromRiskApi(context) {
+        return;
     }
-    enrichContextFromResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async enrichContextFromResponse(context) {
+        return;
     }
-    modifyIncomingRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async modifyIncomingRequest(context) {
+        return;
     }
-    modifyOutgoingResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async modifyOutgoingResponse(context) {
+        return;
     }
     getJwtData(requestData) {
-        var _a;
         let jwtToken;
         let userIdFieldName;
         let additionalFieldNames;
@@ -54,7 +36,7 @@ export class AccountDefender {
             }
         }
         if (!jwtToken && this.config.jwtHeaderName) {
-            jwtToken = (_a = requestData.headers[this.config.jwtHeaderName]) === null || _a === void 0 ? void 0 : _a[0];
+            jwtToken = requestData.headers[this.config.jwtHeaderName]?.[0];
             if (jwtToken) {
                 userIdFieldName = this.config.jwtHeaderUserIdFieldName;
                 additionalFieldNames = this.config.jwtHeaderAdditionalFieldNames;
@@ -84,9 +66,8 @@ export class AccountDefender {
         return null;
     }
     getDecodedJwt(jwt) {
-        var _a;
         try {
-            const encodedPayload = (_a = jwt.split('.')) === null || _a === void 0 ? void 0 : _a[1];
+            const encodedPayload = jwt.split('.')?.[1];
             const base64 = encodedPayload.replace('-', '+').replace('_', '/');
             return JSON.parse(this.base64Utils.base64Decode(base64));
         }

package/lib/products/bot_defender/BotDefender.js

@@ -1,12 +1,3 @@
-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 { Action } from '../../action';
 import { TokenParseResult } from '../../risk_token';
 import { RiskApiCallResult } from '../../risk_api';
@@ -18,30 +9,31 @@ import { BotDefenderBlockReason, BotDefenderPassReason, BotDefenderS2SCallReason
 import { BotDefenderUtils } from './BotDefenderUtils';
 import { DefaultBotDefenderBlocker } from './block';
 export class BotDefender {
+    config;
+    firstParty;
+    filter;
+    blocker;
     constructor(config, options) {
-        var _a, _b, _c;
         this.config = config;
-        this.firstParty = (_a = options.firstParty) !== null && _a !== void 0 ? _a : new DefaultBotDefenderFirstParty(config);
-        this.filter = (_b = options.filter) !== null && _b !== void 0 ? _b : new DefaultBotDefenderFilter(config, options.ipRangeChecker);
-        this.blocker = (_c = options.blocker) !== null && _c !== void 0 ? _c : new DefaultBotDefenderBlocker(config, options.base64Utils);
+        this.firstParty = options.firstParty ?? new DefaultBotDefenderFirstParty(config);
+        this.filter = options.filter ?? new DefaultBotDefenderFilter(config, options.ipRangeChecker);
+        this.blocker = options.blocker ?? new DefaultBotDefenderBlocker(config, options.base64Utils);
     }
-    handleFirstPartyRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.firstParty.handleFirstPartyRequest(context);
-        });
+    async handleFirstPartyRequest(context) {
+        return this.firstParty.handleFirstPartyRequest(context);
     }
     shouldFilter(context) {
         return this.filter.shouldFilter(context);
     }
-    enrichContextFromRequest(context) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const isMonitoredRequest = this.isMonitoredRoute(context);
-            const isSensitiveRequest = this.isSensitiveRequest(context) || ((_a = context.graphqlData) === null || _a === void 0 ? void 0 : _a.some((operation) => operation.sensitive));
-            const actionData = yield this.getTokenAction(context, isMonitoredRequest, isSensitiveRequest);
-            return Object.assign(Object.assign({}, actionData), { isMonitoredRequest,
-                isSensitiveRequest });
-        });
+    async enrichContextFromRequest(context) {
+        const isMonitoredRequest = this.isMonitoredRoute(context);
+        const isSensitiveRequest = this.isSensitiveRequest(context) || context.graphqlData?.some((operation) => operation.sensitive);
+        const actionData = await this.getTokenAction(context, isMonitoredRequest, isSensitiveRequest);
+        return {
+            ...actionData,
+            isMonitoredRequest,
+            isSensitiveRequest,
+        };
     }
     isMonitoredRoute(context) {
         return isMonitoredRequest(this.config, context);
@@ -50,28 +42,23 @@ export class BotDefender {
         // TODO: Include custom sensitive request function
         return isRouteInPatterns(url.pathname, this.config.sensitiveRoutes);
     }
-    enrichContextFromResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    getTokenAction(context, isMonitoredRequest, isSensitiveRequest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (context.tokenData.tokenParseResult) {
-                case TokenParseResult.NONE:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, this.getNoTokenS2SCallReason(context));
-                case TokenParseResult.DECRYPTION_FAILED:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_DECRYPTION_FAILED);
-                case TokenParseResult.VALIDATION_FAILED:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_VALIDATION_FAILED);
-                case TokenParseResult.SUCCESSFUL:
-                    return this.getActionForSuccessfulTokenParse(context, isMonitoredRequest, isSensitiveRequest);
-            }
-        });
+    async enrichContextFromResponse(context) {
+        return;
+    }
+    async getTokenAction(context, isMonitoredRequest, isSensitiveRequest) {
+        switch (context.tokenData.tokenParseResult) {
+            case TokenParseResult.NONE:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, this.getNoTokenS2SCallReason(context));
+            case TokenParseResult.DECRYPTION_FAILED:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_DECRYPTION_FAILED);
+            case TokenParseResult.VALIDATION_FAILED:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_VALIDATION_FAILED);
+            case TokenParseResult.SUCCESSFUL:
+                return this.getActionForSuccessfulTokenParse(context, isMonitoredRequest, isSensitiveRequest);
+        }
     }
     getNoTokenS2SCallReason({ pxhd, isMobile, tokenData, }) {
-        var _a;
-        if (isMobile && ((_a = tokenData.mobileData) === null || _a === void 0 ? void 0 : _a.mobileError)) {
+        if (isMobile && tokenData.mobileData?.mobileError) {
             return BotDefenderUtils.getS2SCallReasonFromMobileError(tokenData.mobileData.mobileError);
         }
         if (pxhd) {
@@ -91,24 +78,20 @@ export class BotDefender {
         }
         return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.COOKIE);
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getRiskApiActionData(context);
-        });
-    }
-    getRiskApiActionData({ riskApiData, productData: { bd }, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (riskApiData.riskApiCallResult) {
-                case RiskApiCallResult.NONE:
-                    throw new EnforcerError('risk api call result should not be none!');
-                case RiskApiCallResult.ERROR:
-                    return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_ERROR);
-                case RiskApiCallResult.TIMEOUT:
-                    return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_TIMEOUT);
-                case RiskApiCallResult.SUCCESSFUL:
-                    return this.getSuccessfulRiskApiAction(riskApiData.riskResponse, bd.isMonitoredRequest);
-            }
-        });
+    async enrichContextFromRiskApi(context) {
+        return await this.getRiskApiActionData(context);
+    }
+    async getRiskApiActionData({ riskApiData, productData: { bd }, }) {
+        switch (riskApiData.riskApiCallResult) {
+            case RiskApiCallResult.NONE:
+                throw new EnforcerError('risk api call result should not be none!');
+            case RiskApiCallResult.ERROR:
+                return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_ERROR);
+            case RiskApiCallResult.TIMEOUT:
+                return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_TIMEOUT);
+            case RiskApiCallResult.SUCCESSFUL:
+                return this.getSuccessfulRiskApiAction(riskApiData.riskResponse, bd.isMonitoredRequest);
+        }
     }
     getSuccessfulRiskApiAction(riskResponse, isMonitored) {
         if (riskResponse.score >= this.config.blockingScore) {
@@ -122,14 +105,10 @@ export class BotDefender {
     createBlockResponse(context) {
         return this.blocker.createBlockResponse(context);
     }
-    modifyIncomingRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // intentionally left blank
-        });
+    async modifyIncomingRequest(context) {
+        // intentionally left blank
     }
-    modifyOutgoingResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // intentionally left blank
-        });
+    async modifyOutgoingResponse(context) {
+        // intentionally left blank
     }
 }

package/lib/products/bot_defender/BotDefenderActionData.js

@@ -1,4 +1,6 @@
 export class BotDefenderActionData {
+    action;
+    reason;
     constructor(action, reason) {
         this.action = action;
         this.reason = reason;

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

@@ -1,14 +1,14 @@
 import { ReadonlyContext } from '../../../context';
 import { IConfiguration } from '../../../config';
 import { IBase64Utils } from '../../../utils';
-import { IConditionalBlocker } from '../../../blocker';
+import { IBlocker, IConditionalBlocker } from '../../../blocker';
 import { IMinimalResponse } from '../../../http';
 export declare class DefaultBotDefenderBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
-    private readonly config;
-    private readonly captchaResponseGenerator;
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly captchaBlocker: IBlocker<Req, Res>;
     constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
     shouldBlock({ action, reasons, productData }: ReadonlyContext<Req, Res>): boolean;
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
-    private createRateLimitResponse;
+    protected createRateLimitResponse(): IMinimalResponse;
     private createCaptchaResponse;
 }

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

@@ -5,12 +5,14 @@ import { ProductName } from '../../utils';
 import { CaptchaBlocker } from './captcha';
 import { RATE_LIMIT_TEMPLATE } from './templates';
 export class DefaultBotDefenderBlocker {
+    config;
+    captchaBlocker;
     constructor(config, base64Utils) {
         this.config = config;
-        this.captchaResponseGenerator = new CaptchaBlocker(config, base64Utils);
+        this.captchaBlocker = new CaptchaBlocker(config, base64Utils);
     }
     shouldBlock({ action, reasons, productData }) {
-        return action === Action.BLOCK && !!(reasons === null || reasons === void 0 ? void 0 : reasons[ProductName.BOT_DEFENDER]);
+        return action === Action.BLOCK && !!reasons?.[ProductName.BOT_DEFENDER];
     }
     createBlockResponse(context) {
         switch (context.blockAction) {
@@ -34,6 +36,6 @@ export class DefaultBotDefenderBlocker {
         });
     }
     createCaptchaResponse(context) {
-        return this.captchaResponseGenerator.createBlockResponse(context);
+        return this.captchaBlocker.createBlockResponse(context);
     }
 }

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

@@ -3,11 +3,14 @@ import { ReadonlyContext } from '../../../../context';
 import { IBase64Utils } from '../../../../utils';
 import { IBlocker } from '../../../../blocker';
 import { IMinimalResponse } from '../../../../http';
+import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
+import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
+import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
 export declare class CaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
-    private readonly config;
-    private readonly jsonCaptchaGenerator;
-    private readonly mobileCaptchaGenerator;
-    private readonly htmlCaptchaGenerator;
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly jsonCaptchaBlocker: JsonCaptchaBlocker<Req, Res>;
+    protected readonly mobileCaptchaBlocker: MobileCaptchaBlocker<Req, Res>;
+    protected readonly htmlCaptchaBlocker: HtmlCaptchaBlocker<Req, Res>;
     constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }

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

@@ -2,19 +2,23 @@ import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
 import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
 import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
 export class CaptchaBlocker {
+    config;
+    jsonCaptchaBlocker;
+    mobileCaptchaBlocker;
+    htmlCaptchaBlocker;
     constructor(config, base64Utils) {
         this.config = config;
-        this.jsonCaptchaGenerator = new JsonCaptchaBlocker(config);
-        this.mobileCaptchaGenerator = new MobileCaptchaBlocker(config, base64Utils);
-        this.htmlCaptchaGenerator = new HtmlCaptchaBlocker(config);
+        this.jsonCaptchaBlocker = new JsonCaptchaBlocker(config);
+        this.mobileCaptchaBlocker = new MobileCaptchaBlocker(config, base64Utils);
+        this.htmlCaptchaBlocker = new HtmlCaptchaBlocker(config);
     }
     createBlockResponse(context) {
-        if (this.mobileCaptchaGenerator.shouldBlock(context)) {
-            return this.mobileCaptchaGenerator.createBlockResponse(context);
+        if (this.mobileCaptchaBlocker.shouldBlock(context)) {
+            return this.mobileCaptchaBlocker.createBlockResponse(context);
         }
-        if (this.jsonCaptchaGenerator.shouldBlock(context)) {
-            return this.jsonCaptchaGenerator.createBlockResponse(context);
+        if (this.jsonCaptchaBlocker.shouldBlock(context)) {
+            return this.jsonCaptchaBlocker.createBlockResponse(context);
         }
-        return this.htmlCaptchaGenerator.createBlockResponse(context);
+        return this.htmlCaptchaBlocker.createBlockResponse(context);
     }
 }

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

@@ -3,7 +3,7 @@ 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;
+    protected readonly config: IConfiguration<Req, Res>;
     constructor(config: IConfiguration<Req, Res>);
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }

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

@@ -2,6 +2,7 @@ import { ContentType, CONTENT_TYPE_HEADER_NAME, MinimalResponseImpl } from '../.
 import { createBlockData, renderHtml } from '../utils';
 import { CAPTCHA_TEMPLATE } from '../templates';
 export class HtmlCaptchaBlocker {
+    config;
     constructor(config) {
         this.config = config;
     }

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

@@ -3,7 +3,7 @@ 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;
+    protected readonly config: IConfiguration<Req, Res>;
     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

@@ -2,6 +2,7 @@ import { BlockAction } from '../../../../blocker';
 import { ContentType, CONTENT_TYPE_HEADER_NAME, ACCEPT_HEADER_NAME, MinimalResponseImpl, } from '../../../../http';
 import { createBlockData } from '../utils';
 export class JsonCaptchaBlocker {
+    config;
     constructor(config) {
         this.config = config;
     }
@@ -9,10 +10,10 @@ export class JsonCaptchaBlocker {
         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);
+        const acceptHeaderValue = context.requestData.request.headers.get(ACCEPT_HEADER_NAME) || '';
+        const acceptHeaderContainsJson = acceptHeaderValue
+            ?.split(',')
+            .some((value) => value.toLowerCase() === ContentType.APPLICATION_JSON);
         return !context.isMobile && context.blockAction !== BlockAction.RATE_LIMIT && acceptHeaderContainsJson;
     }
     createBlockResponse(context) {

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

@@ -4,8 +4,8 @@ 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;
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly base64Utils: IBase64Utils;
     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

@@ -3,6 +3,8 @@ import { ContentType, CONTENT_TYPE_HEADER_NAME, MinimalResponseImpl } from '../.
 import { createBlockData, renderHtml } from '../utils';
 import { CAPTCHA_TEMPLATE } from '../templates';
 export class MobileCaptchaBlocker {
+    config;
+    base64Utils;
     constructor(config, base64Utils) {
         this.config = config;
         this.base64Utils = base64Utils;

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

@@ -12,7 +12,6 @@ export const renderHtml = (htmlTemplate, blockData) => {
     return htmlTemplate;
 };
 export const createBlockData = (config, context) => {
-    var _a, _b;
     const captchaScriptSuffix = '/captcha.js';
     const captchaParams = `?a=${context.blockAction}&u=${context.uuid}&v=${context.vid || ''}&m=${context.isMobile ? '1' : '0'}`;
     let jsClientSrc = `${config.backendClientUrl}/${config.appId}/main.min.js`;
@@ -28,7 +27,7 @@ export const createBlockData = (config, context) => {
     const altBlockScript = `${config.altBackendCaptchaUrl}/${config.appId}${captchaScriptSuffix}${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]) || '',
+        vid: context.vid || context.requestData?.cookies?.[PXVID_COOKIE_NAME] || '',
         uuid: context.uuid || '',
         isMobile: context.isMobile,
         customLogo: config.customLogo || '',

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

@@ -2,6 +2,8 @@ import { HttpMethod } from '../../../http';
 import { FilterReason } from '../../../filter';
 import { getExtension, isRouteInPatterns } from '../../../utils';
 export class DefaultBotDefenderFilter {
+    config;
+    ipRangeChecker;
     constructor(config, ipRangeChecker) {
         this.config = config;
         this.ipRangeChecker = ipRangeChecker;

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

@@ -1,61 +1,47 @@
-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 { COOKIE_HEADER_NAME, HOST_HEADER_NAME, X_FORWARDED_FOR_HEADER_NAME, OutgoingRequestImpl, MinimalResponseImpl, toMutableHeaders, URLUtils, } 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';
 import { FirstPartySuffix } from './FirstPartySuffix';
 export class DefaultBotDefenderFirstParty {
+    config;
     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);
-            }
-            return null;
-        });
+    async handleFirstPartyRequest(context) {
+        const { pathname } = context.requestData.url;
+        if (getFirstPartySensorScriptPaths(this.config).includes(pathname)) {
+            return await this.proxySensorScriptRequest(context);
+        }
+        const xhrPrefix = getFirstPartyXhrPathPrefixes(this.config).find((prefix) => pathname.startsWith(prefix));
+        if (xhrPrefix) {
+            return await this.proxyXhrRequest(context, xhrPrefix);
+        }
+        const captchaPrefix = getFirstPartyCaptchaScriptPathPrefixes(this.config).find((prefix) => pathname.startsWith(prefix));
+        if (captchaPrefix) {
+            return await this.proxyCaptchaScriptRequest(context);
+        }
+        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);
-            this.config.logger.debug(`proxying sensor script ${context.requestData.url.pathname} to ${url}`);
-            return { request, defaultResponse };
-        });
+    async proxySensorScriptRequest(context) {
+        const defaultResponse = new MinimalResponseImpl(DEFAULT_CLIENT_RESPONSE_OPTIONS);
+        if (!this.config.firstPartyEnabled) {
+            return { defaultResponse };
+        }
+        const url = this.getThirdPartySensorScriptUrl();
+        const request = await this.getOutgoingRequest(url, context);
+        this.config.logger.debug(`proxying first party sensor script ${context.requestData.url.pathname} to ${url}`);
+        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);
-            this.config.logger.debug(`proxying XHR request ${context.requestData.url.pathname} to ${url}`);
-            return { request, defaultResponse };
-        });
+    async proxyXhrRequest(context, prefix) {
+        const defaultResponse = DefaultBotDefenderFirstParty.getDefaultXhrResponse(context.requestData.url.pathname);
+        if (!this.config.firstPartyEnabled) {
+            return { defaultResponse };
+        }
+        const url = this.getThirdPartyXhrUrl(context, prefix);
+        const request = await this.getOutgoingRequest(url, context);
+        this.config.logger.debug(`proxying first party XHR request ${context.requestData.url.pathname} to ${url}`);
+        return { request, defaultResponse };
     }
     static getDefaultXhrResponse(path) {
         const { content, options } = path.endsWith('.gif') ? DEFAULT_GIF_RESPONSE : DEFAULT_XHR_RESPONSE;
@@ -65,26 +51,22 @@ export class DefaultBotDefenderFirstParty {
             headers: options.headers,
         });
     }
-    proxyCaptchaScriptRequest(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.getThirdPartyCaptchaScriptUrl(context);
-            const request = yield this.getOutgoingRequest(url, context);
-            this.config.logger.debug(`proxying captcha script ${context.requestData.url.pathname} to ${url}`);
-            return { request, defaultResponse };
-        });
+    async proxyCaptchaScriptRequest(context) {
+        const defaultResponse = new MinimalResponseImpl(DEFAULT_CLIENT_RESPONSE_OPTIONS);
+        if (!this.config.firstPartyEnabled) {
+            return { defaultResponse };
+        }
+        const url = this.getThirdPartyCaptchaScriptUrl(context);
+        const request = await this.getOutgoingRequest(url, context);
+        this.config.logger.debug(`proxying first party captcha script ${context.requestData.url.pathname} to ${url}`);
+        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,
-            });
+    async getOutgoingRequest(url, { requestData, vid }) {
+        return new OutgoingRequestImpl({
+            url: url,
+            method: requestData.method,
+            headers: this.prepareFirstPartyHeaders(url, requestData, vid),
+            body: requestData.request.body,
         });
     }
     prepareFirstPartyHeaders(url, requestData, vid) {
@@ -105,7 +87,8 @@ export class DefaultBotDefenderFirstParty {
         return headers;
     }
     setHostHeader(headers, url) {
-        headers[HOST_HEADER_NAME] = [new URL(url).host];
+        const { host } = URLUtils.parseURL(url);
+        headers[HOST_HEADER_NAME] = [host];
     }
     setXffHeader(headers, ip) {
         const xffValue = headers[X_FORWARDED_FOR_HEADER_NAME] || [];

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

@@ -1,12 +1,8 @@
 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;