perimeterx-js-core 0.7.1 → 0.9.0

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

@@ -1,20 +0,0 @@
-import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
-import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
-import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
-export class CaptchaBlocker {
-    constructor(config, base64Utils) {
-        this.config = config;
-        this.jsonCaptchaGenerator = new JsonCaptchaBlocker(config);
-        this.mobileCaptchaGenerator = new MobileCaptchaBlocker(config, base64Utils);
-        this.htmlCaptchaGenerator = new HtmlCaptchaBlocker(config);
-    }
-    createBlockResponse(context) {
-        if (this.mobileCaptchaGenerator.shouldBlock(context)) {
-            return this.mobileCaptchaGenerator.createBlockResponse(context);
-        }
-        if (this.jsonCaptchaGenerator.shouldBlock(context)) {
-            return this.jsonCaptchaGenerator.createBlockResponse(context);
-        }
-        return this.htmlCaptchaGenerator.createBlockResponse(context);
-    }
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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

@@ -1,34 +0,0 @@
-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/utils.js

@@ -1,44 +0,0 @@
-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 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`;
-    let blockScript = `${config.backendCaptchaUrl}/${config.appId}${captchaScriptSuffix}${captchaParams}`;
-    let hostUrl = config.backendCollectorUrl;
-    if (config.firstPartyEnabled && !context.isMobile) {
-        jsClientSrc = getMostCustomizedFirstPartyPath(config, FirstPartySuffix.SENSOR);
-        blockScript = `${getMostCustomizedFirstPartyPath(config, FirstPartySuffix.CAPTCHA)}${config.customFirstPartyCaptchaEndpoint ? captchaParams : `${captchaScriptSuffix}${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}${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]) || '',
-        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.js

@@ -1,55 +0,0 @@
-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);
-        if (filterReason !== FilterReason.NONE) {
-            this.config.logger.debug(`filter request due to ${filterReason}`);
-            return true;
-        }
-        return false;
-    }
-    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/first_party/DefaultBotDefenderFirstParty.js

@@ -1,131 +0,0 @@
-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';
-import { FirstPartySuffix } from './FirstPartySuffix';
-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);
-            }
-            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 };
-        });
-    }
-    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 };
-        });
-    }
-    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) {
-        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 };
-        });
-    }
-    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) {
-        const originalUrl = context.requestData.url;
-        const { appId, backendCaptchaUrl } = this.config;
-        return `${backendCaptchaUrl}/${appId}${FirstPartySuffix.CAPTCHA}.js${originalUrl.search}`;
-    }
-    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/constants.d.ts

@@ -1,28 +0,0 @@
-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;
-    options: {
-        status: number;
-        headers: {
-            "content-type": ContentType[];
-        };
-    };
-};
-export declare const DEFAULT_GIF_RESPONSE: {
-    content: string;
-    options: {
-        status: number;
-        headers: {
-            "content-type": ContentType[];
-        };
-    };
-};

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

@@ -1,36 +0,0 @@
-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/credential_intelligence/CredentialIntelligence.js

@@ -1,96 +0,0 @@
-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 { ActivityType, createActivity, ACTIVITIES_ENDPOINT } from '../../activities';
-import { CredentialEndpoint, CredentialEndpointManager, CredentialExtractorFactory, CredentialIntelligenceEndpointMatcherFactory, CredentialIntelligenceHashProtocolFactory, LoginSuccessfulParserFactory, } from './endpoint';
-import { ADDITIONAL_S2S_ACTIVITY_HEADER_NAME, ADDITIONAL_S2S_URL_HEADER_NAME, COMPROMISED_CREDENTIALS_HEADER_VALUE, } from './constants';
-export class CredentialIntelligence {
-    constructor(config, hashUtils) {
-        this.config = config;
-        this.endpointManager = new CredentialEndpointManager(this.initializeCredentialIntelligenceEndpoints(config, hashUtils));
-    }
-    enrichContextFromRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const endpointIndex = this.endpointManager.getEndpointIndex(context);
-            if (endpointIndex === -1) {
-                return null;
-            }
-            const data = yield this.endpointManager.getCredentialsData(endpointIndex, context);
-            if (!data) {
-                return null;
-            }
-            return Object.assign(Object.assign({}, data), { endpointIndex, action: Action.TRIGGER_RISK_API, reason: 'sensitive_route' });
-        });
-    }
-    enrichContextFromRiskApi(context) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!context.productData.ci) {
-                return;
-            }
-            const isCompromised = !!((_b = (_a = context.riskApiData.riskResponse) === null || _a === void 0 ? void 0 : _a.dataEnrichment) === null || _b === void 0 ? void 0 : _b.breached_account);
-            return { action: undefined, reason: undefined, isCompromised };
-        });
-    }
-    modifyIncomingRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!context.productData.ci) {
-                return;
-            }
-            const { productData: { ci: { isCompromised }, }, requestData: { request }, } = context;
-            if (isCompromised) {
-                this.setCompromisedCredentialHeader(request);
-            }
-            if (this.shouldSetAdditionalS2SActivityHeaders()) {
-                this.setAdditionalS2SActivityHeaders(request, context);
-            }
-        });
-    }
-    enrichContextFromResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!context.productData.ci) {
-                return;
-            }
-            return { isLoginSuccessful: yield this.isLoginSuccessful(context) };
-        });
-    }
-    modifyOutgoingResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // intentionally left blank
-        });
-    }
-    isLoginSuccessful(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { endpointIndex } = context.productData.ci;
-            return yield this.endpointManager.isLoginSuccessful(endpointIndex, context);
-        });
-    }
-    setCompromisedCredentialHeader(request) {
-        request.headers.set(this.config.ciCompromisedCredentialsHeaderName, COMPROMISED_CREDENTIALS_HEADER_VALUE);
-    }
-    shouldSetAdditionalS2SActivityHeaders() {
-        return !this.config.ciAutomaticAdditionalS2SEnabled && this.config.ciAdditionalS2SHeaderEnabled;
-    }
-    setAdditionalS2SActivityHeaders(request, context) {
-        const activity = createActivity(ActivityType.ADDITIONAL_S2S, this.config, context);
-        request.headers.set(ADDITIONAL_S2S_ACTIVITY_HEADER_NAME, JSON.stringify(activity));
-        request.headers.set(ADDITIONAL_S2S_URL_HEADER_NAME, `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`);
-    }
-    initializeCredentialIntelligenceEndpoints(config, hashUtils) {
-        return config.ciEndpoints.map((endpointConfig) => {
-            var _a;
-            const matcher = CredentialIntelligenceEndpointMatcherFactory.create(endpointConfig);
-            const extractor = CredentialExtractorFactory.create(endpointConfig);
-            const protocol = CredentialIntelligenceHashProtocolFactory.create(((_a = endpointConfig.protocol) !== null && _a !== void 0 ? _a : config.ciDefaultVersion), hashUtils);
-            const loginSuccessfulParser = LoginSuccessfulParserFactory.create(config, endpointConfig);
-            return new CredentialEndpoint(config, matcher, extractor, protocol, loginSuccessfulParser);
-        });
-    }
-}

package/lib/products/credential_intelligence/endpoint/CredentialEndpoint.js

@@ -1,37 +0,0 @@
-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());
-    });
-};
-export class CredentialEndpoint {
-    constructor(config, matcher, extractor, protocol, loginSuccessfulParser) {
-        this.config = config;
-        this.matcher = matcher;
-        this.extractor = extractor;
-        this.protocol = protocol;
-        this.loginSuccessfulParser = loginSuccessfulParser;
-    }
-    matches(requestData) {
-        return this.matcher.matches(requestData);
-    }
-    getCredentialData(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const credentials = yield this.extractor.extractCredentials(request);
-            if (!(credentials === null || credentials === void 0 ? void 0 : credentials.user) && !(credentials === null || credentials === void 0 ? void 0 : credentials.pass)) {
-                this.config.logger.debug('unable to extract credentials');
-                return null;
-            }
-            this.config.logger.debug(`successfully extracted credentials`);
-            return yield this.protocol.hashCredentials(credentials);
-        });
-    }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.loginSuccessfulParser.isLoginSuccessful(response);
-        });
-    }
-}

package/lib/products/credential_intelligence/endpoint/CredentialEndpointManager.js

@@ -1,32 +0,0 @@
-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());
-    });
-};
-export class CredentialEndpointManager {
-    constructor(endpoints) {
-        this.endpoints = endpoints;
-    }
-    getEndpointIndex({ requestData }) {
-        return this.endpoints.findIndex((endpoint) => endpoint.matches(requestData));
-    }
-    getCredentialsData(endpointIndex, { requestData }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield ((_a = this.endpoints[endpointIndex]) === null || _a === void 0 ? void 0 : _a.getCredentialData(requestData.request));
-        });
-    }
-    isLoginSuccessful(endpointIndex, { response }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!response) {
-                return undefined;
-            }
-            return yield ((_a = this.endpoints[endpointIndex]) === null || _a === void 0 ? void 0 : _a.isLoginSuccessful(response));
-        });
-    }
-}

package/lib/products/credential_intelligence/endpoint/extractor/BodyCredentialExtractor.d.ts

@@ -1,15 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { IFormData, IIncomingRequest } from '../../../../http';
-import { Credentials } from '../../model';
-import { ICredentialExtractor } from './ICredentialExtractor';
-export declare class BodyCredentialExtractor implements ICredentialExtractor<unknown> {
-    private readonly userField;
-    private readonly passField;
-    constructor(userField: string, passField: string);
-    extractCredentials(request: DeepReadonly<IIncomingRequest<unknown>>): Promise<Credentials | null>;
-    protected extractFromBody(contentType: string, request: DeepReadonly<IIncomingRequest<unknown>>): Promise<Credentials>;
-    protected extractFromJson(json: any): Credentials;
-    protected extractFromUrlEncoded(params: URLSearchParams): Credentials;
-    protected extractFromMultipart(formData: IFormData): Credentials;
-    private formDataEntryValueToString;
-}