perimeterx-js-core 0.1.0

package/lib/context/ContextBase.js

@@ -0,0 +1,206 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextBase = void 0;
+var block_handler_1 = require("../block_handler");
+var custom_parameters_1 = require("../custom_parameters");
+var http_1 = require("../http");
+var risk_token_1 = require("../risk_token");
+var utils_1 = require("../utils");
+var ContextBase = /** @class */ (function () {
+    function ContextBase(config, request, options) {
+        this.config = config;
+        this.mobileData = {};
+        this.riskApiData = {};
+        this.tlsData = {};
+        this.responseData = {};
+        this.serverData = {};
+        this.requestId = ((options === null || options === void 0 ? void 0 : options.uuidGenerator) || new utils_1.DefaultUuidGenerator()).generateUuidV4();
+        this.tokenOrigin = risk_token_1.TokenOrigin.COOKIE;
+        this.blockAction = block_handler_1.BlockAction.CAPTCHA;
+        this.pxdeVerified = false;
+        this.requestData = this.createRequestData(config, request, options === null || options === void 0 ? void 0 : options.cookieParser);
+        this.isMonitoredRequest = this.isMonitored(config, this.requestData);
+        this.isSensitiveRequest = this.isSensitive(config, this.requestData);
+        this.setRiskTokenOnContext(config, options);
+        if (!this.isMobile) {
+            this.setCookiesOnContext();
+        }
+    }
+    ContextBase.prototype.createRequestData = function (config, request, cookieParser) {
+        var _a;
+        if (cookieParser === void 0) { cookieParser = new utils_1.DefaultCookieParser(); }
+        var url = (0, utils_1.getDecodedUrl)(request.url);
+        var method = request.method;
+        var headers = request.headers;
+        var cookieHeaderValue = ((_a = request.headers.get(config.customCookieHeader || http_1.COOKIE_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        var cookies = cookieHeaderValue ? cookieParser.parseCookies(cookieHeaderValue) : {};
+        var requestCookieNames = Object.keys(cookies);
+        var userAgent = this.extractUserAgentFromHeader(config, headers);
+        var ip = this.extractIpFromHeader(config, headers);
+        return { url: url, method: method, headers: headers, cookies: cookies, ip: ip, userAgent: userAgent, requestCookieNames: requestCookieNames, request: request };
+    };
+    ContextBase.prototype.extractUserAgentFromHeader = function (config, headers) {
+        var _a;
+        var userAgent = ((_a = headers === null || headers === void 0 ? void 0 : headers.get(http_1.USER_AGENT_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        if (userAgent.length > config.userAgentMaxLength) {
+            userAgent = userAgent.substring(0, config.userAgentMaxLength);
+        }
+        return userAgent;
+    };
+    ContextBase.prototype.extractIpFromHeader = function (config, headers) {
+        var ip;
+        config.ipHeaders.some(function (ipHeader) {
+            var _a;
+            var headerValue = (_a = headers.get(ipHeader)) === null || _a === void 0 ? void 0 : _a[0];
+            if (headerValue) {
+                ip = headerValue;
+                return true;
+            }
+        });
+        return ip;
+    };
+    ContextBase.prototype.isMonitored = function (config, requestData) {
+        var pathname = requestData.url.pathname;
+        var enforcedRoute = (0, utils_1.isRouteInPatterns)(pathname, config.enforcedRoutes);
+        var monitoredRoute = !enforcedRoute && (0, utils_1.isRouteInPatterns)(pathname, config.monitoredRoutes);
+        var monitorMode = config.moduleMode === utils_1.ModuleMode.MONITOR && !enforcedRoute;
+        return (monitorMode || monitoredRoute) && !this.isAllowedToBypassMonitor(config, requestData);
+    };
+    ContextBase.prototype.isSensitive = function (config, _a) {
+        var url = _a.url;
+        return (0, utils_1.isRouteInPatterns)(url.pathname, config.sensitiveRoutes);
+    };
+    ContextBase.prototype.isAllowedToBypassMonitor = function (config, requestData) {
+        var _a;
+        return (config.bypassMonitorHeader &&
+            ((_a = requestData.headers.get(config.bypassMonitorHeader)) === null || _a === void 0 ? void 0 : _a[0]) === utils_1.BYPASS_MONITOR_HEADER_VALUE);
+    };
+    ContextBase.prototype.completeInitialization = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.handleCustomParameters(this.config, this.requestData.request)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ContextBase.prototype.setRiskTokenOnContext = function (config, options) {
+        var _a;
+        var mobileToken = (_a = this.requestData.headers.get(utils_1.X_PX_AUTHORIZATION_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0];
+        if (mobileToken) {
+            this.setMobileTokenOnContext(config, mobileToken, options);
+        }
+        else {
+            this.setWebTokenOnContext(config, options);
+        }
+    };
+    ContextBase.prototype.setMobileTokenOnContext = function (config, mobileToken, options) {
+        var _a, _b;
+        this.tokenOrigin = risk_token_1.TokenOrigin.HEADER;
+        this.riskToken = this.getMobileToken(config, mobileToken, options);
+        this.mobileData.originalToken = this.getMobileToken(config, (_a = this.requestData.headers.get(utils_1.X_PX_ORIGINAL_TOKEN_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0], options);
+        this.mobileData.bypassReason = ((_b = this.requestData.headers.get(utils_1.X_PX_BYPASS_REASON_HEADER_NAME)) === null || _b === void 0 ? void 0 : _b[0]) || '';
+        if (!this.riskToken && /^\d+$/.test(mobileToken)) {
+            this.mobileData.mobileError = mobileToken;
+        }
+    };
+    ContextBase.prototype.setWebTokenOnContext = function (config, options) {
+        this.tokenOrigin = risk_token_1.TokenOrigin.COOKIE;
+        this.riskToken = this.createRiskToken(config, this.requestData.cookies, options);
+    };
+    ContextBase.prototype.setCookiesOnContext = function () {
+        this.vid = this.requestData.cookies[utils_1.PXVID_COOKIE_NAME] || '';
+        this.pxhd = this.requestData.cookies[utils_1.PXHD_COOKIE_NAME] || '';
+    };
+    ContextBase.prototype.getMobileToken = function (config, mobileToken, options) {
+        var _a;
+        try {
+            if (!mobileToken || (mobileToken === null || mobileToken === void 0 ? void 0 : mobileToken.indexOf(risk_token_1.COOKIE_SPLIT_DELIMITER)) === -1) {
+                return null;
+            }
+            var _b = mobileToken.split(risk_token_1.COOKIE_SPLIT_DELIMITER), tokenVersion = _b[0], cookieString = _b.slice(1);
+            var cookieName = (0, risk_token_1.convertMobileTokenVersionToCookieName)(tokenVersion);
+            if (!cookieName) {
+                return null;
+            }
+            return this.createRiskToken(config, (_a = {}, _a[cookieName] = cookieString.join(risk_token_1.COOKIE_SPLIT_DELIMITER), _a), options);
+        }
+        catch (e) {
+            config.logger.debug("error extracting mobile token - ".concat(e, ", token: ").concat(mobileToken));
+            return null;
+        }
+    };
+    ContextBase.prototype.handleCustomParameters = function (config, request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, e_1;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!(config.enrichCustomParameters && typeof config.enrichCustomParameters === 'function')) return [3 /*break*/, 4];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        _a = this;
+                        _c = (_b = custom_parameters_1.CustomParametersUtils).normalizeCustomParams;
+                        return [4 /*yield*/, config.enrichCustomParameters(config.toParams(), request)];
+                    case 2:
+                        _a.customParameters = _c.apply(_b, [_d.sent()]);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _d.sent();
+                        config.logger.error("unable to enrich custom params: ".concat(e_1));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(ContextBase.prototype, "isMobile", {
+        get: function () {
+            return this.tokenOrigin === risk_token_1.TokenOrigin.HEADER;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ContextBase;
+}());
+exports.ContextBase = ContextBase;

package/lib/context/DefaultTokenV2Context.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration } from '../config';
+import { IHttpRequest } from '../http';
+import { IBotDefenderToken } from '../risk_token';
+import { IBase64Utils, IHashUtils } from '../utils';
+import { ContextBase, ContextBaseOptions } from './ContextBase';
+export declare type DefaultTokenV2ContextOptions = {
+    base64Utils?: IBase64Utils;
+    hashUtils?: IHashUtils;
+} & ContextBaseOptions;
+export declare class DefaultTokenV2Context extends ContextBase<DefaultTokenV2ContextOptions> {
+    constructor(config: IConfiguration, httpRequest: IHttpRequest, options?: DefaultTokenV2ContextOptions);
+    protected createRiskToken(config: IConfiguration, cookies: Record<string, string>, options: DefaultTokenV2ContextOptions): IBotDefenderToken;
+}

package/lib/context/DefaultTokenV2Context.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTokenV2Context = void 0;
+var risk_token_1 = require("../risk_token");
+var utils_1 = require("../utils");
+var ContextBase_1 = require("./ContextBase");
+var DefaultTokenV2Context = /** @class */ (function (_super) {
+    __extends(DefaultTokenV2Context, _super);
+    function DefaultTokenV2Context(config, httpRequest, options) {
+        return _super.call(this, config, httpRequest, options) || this;
+    }
+    DefaultTokenV2Context.prototype.createRiskToken = function (config, cookies, options) {
+        if (cookies[risk_token_1.COOKIE_V2_NAME]) {
+            return new risk_token_1.DefaultBotDefenderTokenV2(config, cookies[risk_token_1.COOKIE_V2_NAME], (options === null || options === void 0 ? void 0 : options.base64Utils) || new utils_1.DefaultBase64Utils(), (options === null || options === void 0 ? void 0 : options.hashUtils) || new utils_1.DefaultHashUtils());
+        }
+        return null;
+    };
+    return DefaultTokenV2Context;
+}(ContextBase_1.ContextBase));
+exports.DefaultTokenV2Context = DefaultTokenV2Context;

package/lib/context/DefaultTokenV3Context.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration } from '../config';
+import { IHttpRequest } from '../http';
+import { IBotDefenderToken } from '../risk_token';
+import { IHashUtils, ICipherUtils } from '../utils';
+import { ContextBase, ContextBaseOptions } from './ContextBase';
+export declare type DefaultTokenV3ContextOptions = {
+    cipherUtils: ICipherUtils;
+    hashUtils?: IHashUtils;
+} & ContextBaseOptions;
+export declare class DefaultTokenV3Context extends ContextBase<DefaultTokenV3ContextOptions> {
+    constructor(config: IConfiguration, httpRequest: IHttpRequest, options: DefaultTokenV3ContextOptions);
+    protected createRiskToken(config: IConfiguration, cookies: Record<string, string>, options: DefaultTokenV3ContextOptions): IBotDefenderToken;
+}

package/lib/context/DefaultTokenV3Context.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTokenV3Context = void 0;
+var risk_token_1 = require("../risk_token");
+var utils_1 = require("../utils");
+var ContextBase_1 = require("./ContextBase");
+var DefaultTokenV3Context = /** @class */ (function (_super) {
+    __extends(DefaultTokenV3Context, _super);
+    function DefaultTokenV3Context(config, httpRequest, options) {
+        return _super.call(this, config, httpRequest, options) || this;
+    }
+    DefaultTokenV3Context.prototype.createRiskToken = function (config, cookies, options) {
+        if (cookies[risk_token_1.COOKIE_V3_NAME]) {
+            return new risk_token_1.DefaultBotDefenderTokenV3(config, cookies[risk_token_1.COOKIE_V3_NAME], options.cipherUtils, options.hashUtils || new utils_1.DefaultHashUtils());
+        }
+        return null;
+    };
+    return DefaultTokenV3Context;
+}(ContextBase_1.ContextBase));
+exports.DefaultTokenV3Context = DefaultTokenV3Context;

package/lib/context/IContext.d.ts

@@ -0,0 +1,256 @@
+import { TokenOrigin, MobileError, IBotDefenderToken } from '../risk_token';
+import { FilterReason } from '../filter';
+import { S2SCallReason, S2SErrorReason } from '../risk_api';
+import { PassReason, VidSource } from '../utils';
+import { BlockAction, BlockReason } from '../block_handler';
+import { HttpHeaders, HttpMethod, IHttpRequest } from '../http';
+import { CustomParameters } from '../custom_parameters';
+import { PXDE } from '../pxde';
+export declare type RequestData = {
+    /**
+     * The request URL.
+     */
+    url: URL;
+    /**
+     * The request method, capitalized.
+     */
+    method: HttpMethod;
+    /**
+     * An object representing the request headers. The keys are the header names (all lowercase) and the values
+     * are arrays of strings, with each string representing one value associated with the header name.
+     */
+    headers: HttpHeaders;
+    /**
+     * An object representing the request cookies. The keys are the cookie
+     * names and the values are the cookie values.
+     */
+    cookies: Record<string, string>;
+    /**
+     * An array of the cookie names present on the request.
+     */
+    requestCookieNames: string[];
+    /**
+     * The user agent header on the request.
+     */
+    userAgent: string;
+    /**
+     * The IP of the request.
+     */
+    ip: string;
+    /**
+     * An interface representing the original HTTP request.
+     */
+    request: IHttpRequest;
+    /**
+     * The HTTP version used for the request (e.g., 0.9, 1.0, 1.1, 2.0).
+     */
+    httpVersion?: string;
+};
+export declare type ResponseData = {
+    /**
+     * The HTTP status code from the response to the original request.
+     */
+    status?: number;
+};
+export interface TlsData {
+    /**
+     * The TLS version used for the HTTPS request (e.g., 1.2, 1.3).
+     */
+    tlsProtocol?: string;
+    /**
+     * The Server Name Indication (SNI) the client sent in the TLS Client Hello packet of the HTTPS request.
+     */
+    tlsServer?: string;
+    /**
+     * The name of the TLS cipher used to encrypt the HTTPS request.
+     */
+    tlsCipher?: string;
+    /**
+     * The hash used to encrypt the HTTPS request.
+     */
+    tlsCiphersSha?: string;
+    /**
+     * The hash of the TLS extension identifiers sent from the client as part of the TLS handshake
+     */
+    tlsExtensionSha?: string;
+    /**
+     * The client's preferred TLS ciphers for the HTTPS request.
+     */
+    tlsPreferredCiphers?: string;
+    /**
+     * The JA3 fingerprint computed from the TLS Client Hello packet of th HTTPS request.
+     */
+    tlsJa3Fingerprint?: string;
+}
+export interface MobileData {
+    /**
+     * The mobile error sent on the X-PX-Authorization header for mobile requests.
+     */
+    mobileError?: MobileError;
+    /**
+     * An interface representing the original token sent on the X-PX-Original-Token header for mobile requests.
+     */
+    originalToken?: IBotDefenderToken;
+    /**
+     * The bypass reason from the X-PX-Bypass-Reason header for mobile requests.
+     */
+    bypassReason?: string;
+    /**
+     * The reason the original token could not be verified (e.g., cookie_decryption_failed, cookie_validation_failed).
+     */
+    originalTokenError?: string;
+    /**
+     * The JSON string of the original token if one was sent on the mobile request.
+     */
+    decodedOriginalToken?: string;
+}
+export interface RiskApiData {
+    /**
+     * The risk API round trip time in milliseconds.
+     */
+    riskRtt?: number;
+    /**
+     * Whether the enforcer completed the risk API call.
+     */
+    madeApiCall?: boolean;
+    /**
+     * The reason for the risk API call.
+     */
+    s2sCallReason?: S2SCallReason;
+    /**
+     * The reason for the error during the risk API call if an error occurred.
+     */
+    s2sErrorReason?: S2SErrorReason;
+    /**
+     * The HTTP response status that was received for the risk API call if an error occurred.
+     */
+    s2sErrorHttpStatus?: number;
+    /**
+     * An error message that contains more details about the risk API error if an error occurred.
+     */
+    errorMessage?: string;
+}
+export interface ServerData {
+    /**
+     * The operating system platform.
+     */
+    osName?: string;
+    /**
+     * The CDN PoP/data center region the request hit.
+     */
+    region?: string;
+    /**
+     * The host name of the operating system.
+     */
+    nodeName?: string;
+}
+export interface IContext {
+    /**
+     * A UUID v4 generated in the enforcer unique to each HTTP request.
+     */
+    readonly requestId: string;
+    /**
+     * Whether the request is from a mobile device.
+     */
+    readonly isMobile: boolean;
+    /**
+     * An object containing details about the original HTTP request.
+     */
+    readonly requestData: RequestData;
+    /**
+     * An object containing details about the HTTP response.
+     */
+    readonly responseData: ResponseData;
+    /**
+     * An object containing details about the mobile data if the request was made from a mobile device.
+     */
+    readonly mobileData: MobileData;
+    /**
+     * An object containing details about the risk API data.
+     */
+    readonly riskApiData: RiskApiData;
+    /**
+     * An object containing details about the TLS metadata of the HTTP request.
+     */
+    readonly tlsData: TlsData;
+    /**
+     * An object containing details about the server on which the enforcer is running.
+     */
+    readonly serverData: ServerData;
+    /**
+     * The client UUID.
+     */
+    uuid: string;
+    /**
+     * The visitor ID, unique to the end-user.
+     */
+    vid?: string;
+    /**
+     * A string representing where the visitor ID was obtained.
+     */
+    vidSource?: VidSource;
+    /**
+     * The risk score retrieved from either the risk cookie or risk API request. This should be a value
+     * between 0 and 100 (inclusive), with 100 representing a bot.
+     */
+    score?: number;
+    /**
+     * Whether the request should go through the enforcement flow in monitor mode.
+     * This depends on various configurations including the module mode, monitored routes, enforced
+     * routes, and the bypass monitor header.
+     */
+    isMonitoredRequest: boolean;
+    /**
+     * Whether the request should trigger a Risk API call regardless of the risk cookie it carries.
+     */
+    isSensitiveRequest: boolean;
+    /**
+     * The reason to pass the request, if it should be passed.
+     */
+    passReason?: PassReason;
+    /**
+     * The reason to block the request, if it should be blocked.
+     */
+    blockReason?: BlockReason;
+    /**
+     * The action to take in the event of a block.
+     */
+    blockAction?: BlockAction;
+    /**
+     * The reason the request was filtered, if it was filtered.
+     */
+    filterReason?: FilterReason;
+    /**
+     * The origin of the risk token, indicating whether the request originates from
+     * a web browser ('cookie') or from the mobile SDK ('header').
+     */
+    tokenOrigin?: TokenOrigin;
+    /**
+     * An interface representing the risk token.
+     */
+    riskToken?: IBotDefenderToken;
+    /**
+     * The PXHD (PerimeterX Hashed Data) cookie value, if it exists on the request.
+     */
+    pxhd?: string;
+    /**
+     * The PXDE (PerimeterX Data Enrichment) object, if it was parsed from
+     * the PXDE cookie or received on the risk response.
+     */
+    pxde?: PXDE;
+    /**
+     * Whether the HMAC on the PXDE cookie has been validated. If the PXDE object
+     * was received on the risk response, this value will be true.
+     */
+    pxdeVerified?: boolean;
+    /**
+     * An object with 10 custom parameters that the customer can set and define. These
+     * custom parameters will be added to the activities sent to the collector.
+     */
+    customParameters?: CustomParameters;
+    /**
+     * A function that completes context initialization. Should be called only if
+     * the request should not be filtered and is not first-party.
+     */
+    completeInitialization(): Promise<void>;
+}

package/lib/context/IContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/context/index.d.ts

@@ -0,0 +1,4 @@
+export { IContext } from './IContext';
+export { ContextBase, ContextBaseOptions } from './ContextBase';
+export { DefaultTokenV2Context, DefaultTokenV2ContextOptions } from './DefaultTokenV2Context';
+export { DefaultTokenV3Context, DefaultTokenV3ContextOptions } from './DefaultTokenV3Context';

package/lib/context/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTokenV3Context = exports.DefaultTokenV2Context = exports.ContextBase = void 0;
+var ContextBase_1 = require("./ContextBase");
+Object.defineProperty(exports, "ContextBase", { enumerable: true, get: function () { return ContextBase_1.ContextBase; } });
+var DefaultTokenV2Context_1 = require("./DefaultTokenV2Context");
+Object.defineProperty(exports, "DefaultTokenV2Context", { enumerable: true, get: function () { return DefaultTokenV2Context_1.DefaultTokenV2Context; } });
+var DefaultTokenV3Context_1 = require("./DefaultTokenV3Context");
+Object.defineProperty(exports, "DefaultTokenV3Context", { enumerable: true, get: function () { return DefaultTokenV3Context_1.DefaultTokenV3Context; } });

package/lib/custom_parameters/CustomParameters.d.ts

@@ -0,0 +1,12 @@
+export declare type CustomParameters = {
+    custom_param1?: any;
+    custom_param2?: any;
+    custom_param3?: any;
+    custom_param4?: any;
+    custom_param5?: any;
+    custom_param6?: any;
+    custom_param7?: any;
+    custom_param8?: any;
+    custom_param9?: any;
+    custom_param10?: any;
+};

package/lib/custom_parameters/CustomParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/custom_parameters/CustomParametersFunction.d.ts

@@ -0,0 +1,4 @@
+import { IHttpRequest } from '../http';
+import { ConfigurationParams } from '../config';
+import { CustomParameters } from './CustomParameters';
+export declare type CustomParametersFunction = (config: ConfigurationParams, httpRequest: IHttpRequest) => CustomParameters | Promise<CustomParameters>;

package/lib/custom_parameters/CustomParametersFunction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/custom_parameters/CustomParametersUtils.d.ts

@@ -0,0 +1,4 @@
+import { CustomParameters } from './CustomParameters';
+export declare namespace CustomParametersUtils {
+    const normalizeCustomParams: (customParameters: Record<string, any>) => CustomParameters;
+}

package/lib/custom_parameters/CustomParametersUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomParametersUtils = void 0;
+var CustomParametersUtils;
+(function (CustomParametersUtils) {
+    CustomParametersUtils.normalizeCustomParams = function (customParameters) {
+        var normalizedParams = {};
+        if (customParameters && typeof customParameters === 'object') {
+            var paramKeyRegex_1 = /^custom_param([1-9]|10)$/;
+            Object.entries(customParameters).forEach(function (_a) {
+                var param = _a[0], value = _a[1];
+                if (param.match(paramKeyRegex_1) && value !== '') {
+                    normalizedParams[param] = value;
+                }
+            });
+        }
+        return Object.keys(normalizedParams).length === 0 ? null : normalizedParams;
+    };
+})(CustomParametersUtils = exports.CustomParametersUtils || (exports.CustomParametersUtils = {}));

package/lib/custom_parameters/index.d.ts

@@ -0,0 +1,3 @@
+export { CustomParameters } from './CustomParameters';
+export { CustomParametersUtils } from './CustomParametersUtils';
+export { CustomParametersFunction } from './CustomParametersFunction';

package/lib/custom_parameters/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomParametersUtils = void 0;
+var CustomParametersUtils_1 = require("./CustomParametersUtils");
+Object.defineProperty(exports, "CustomParametersUtils", { enumerable: true, get: function () { return CustomParametersUtils_1.CustomParametersUtils; } });