perimeterx-js-core 0.1.0

package/lib/http/request/HttpRequestBase.js

@@ -0,0 +1,77 @@
+"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.HttpRequestBase = void 0;
+var utils_1 = require("../utils");
+var HttpRequestBase = /** @class */ (function () {
+    function HttpRequestBase(url, options) {
+        this.url = url;
+        this.method = (options === null || options === void 0 ? void 0 : options.method) || utils_1.HttpMethod.GET;
+        this.headers = (options === null || options === void 0 ? void 0 : options.headers) instanceof utils_1.HttpHeaders ? options === null || options === void 0 ? void 0 : options.headers : new utils_1.HttpHeaders(options === null || options === void 0 ? void 0 : options.headers);
+        this.bodyReader = options === null || options === void 0 ? void 0 : options.bodyReader;
+    }
+    Object.defineProperty(HttpRequestBase.prototype, "body", {
+        get: function () {
+            var _a;
+            return (_a = this.bodyReader) === null || _a === void 0 ? void 0 : _a.body;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpRequestBase.prototype.readBody = function () {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (typeof this.httpBody !== 'undefined') {
+                            return [2 /*return*/, this.httpBody];
+                        }
+                        _c = this;
+                        return [4 /*yield*/, ((_a = this.bodyReader) === null || _a === void 0 ? void 0 : _a.readBody((_b = this.headers.get(utils_1.CONTENT_TYPE_HEADER_NAME)) === null || _b === void 0 ? void 0 : _b[0]))];
+                    case 1:
+                        _c.httpBody = _d.sent();
+                        return [2 /*return*/, this.httpBody];
+                }
+            });
+        });
+    };
+    return HttpRequestBase;
+}());
+exports.HttpRequestBase = HttpRequestBase;

package/lib/http/request/IHttpRequest.d.ts

@@ -0,0 +1,31 @@
+import { HttpMethod, HttpHeaders, HttpBody } from '../utils';
+export interface IHttpRequest<UnreadBodyType = unknown, Req = unknown> {
+    /**
+     * The full URL of the request, including scheme, path, and query parameters
+     * e.g., https://www.example.com/some/path?param1=value1&param2=value2
+     */
+    url: string;
+    /**
+     * The request method in all caps
+     * e.g., GET, POST
+     */
+    method: HttpMethod;
+    /**
+     * An object representing the HTTP headers. For more information, see the documentation for the HttpHeaders class.
+     */
+    headers: HttpHeaders;
+    /**
+     * A representation of the request body. If the request does not have a body, it should be undefined.
+     * This is called when the request body needs to be accessed or used to reconstruct a new request, but not read.
+     */
+    readonly body: UnreadBodyType | string;
+    /**
+     * The request body if it needs to be used in the enforcer. If read, the call to HttpRequest.body
+     * should return the saved value so as not to consume streams twice.
+     */
+    readBody(): Promise<HttpBody>;
+    /**
+     * The underlying, platform-specific implementation of the request object.
+     */
+    getUnderlyingRequest(): Req;
+}

package/lib/http/request/IHttpRequest.js

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

package/lib/http/response/DefaultHttpResponse.d.ts

@@ -0,0 +1,5 @@
+import { HttpResponseBase, HttpResponseOptions } from './HttpResponseBase';
+export declare class DefaultHttpResponse extends HttpResponseBase<string, DefaultHttpResponse> {
+    constructor(body?: string, options?: HttpResponseOptions);
+    getUnderlyingResponse(): DefaultHttpResponse;
+}

package/lib/http/response/DefaultHttpResponse.js

@@ -0,0 +1,32 @@
+"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.DefaultHttpResponse = void 0;
+var HttpResponseBase_1 = require("./HttpResponseBase");
+var StringBodyReader_1 = require("../body_reader/StringBodyReader");
+var DefaultHttpResponse = /** @class */ (function (_super) {
+    __extends(DefaultHttpResponse, _super);
+    function DefaultHttpResponse(body, options) {
+        if (body === void 0) { body = ''; }
+        return _super.call(this, new StringBodyReader_1.StringBodyReader(body), options) || this;
+    }
+    DefaultHttpResponse.prototype.getUnderlyingResponse = function () {
+        return this;
+    };
+    return DefaultHttpResponse;
+}(HttpResponseBase_1.HttpResponseBase));
+exports.DefaultHttpResponse = DefaultHttpResponse;

package/lib/http/response/HttpResponseBase.d.ts

@@ -0,0 +1,17 @@
+import { HttpHeaders, HttpHeadersInit, HttpBody } from '../utils';
+import { IBodyReader } from '../body_reader/IBodyReader';
+import { IHttpResponse } from './IHttpResponse';
+export declare type HttpResponseOptions = {
+    status?: number;
+    headers?: HttpHeaders | HttpHeadersInit;
+};
+export declare abstract class HttpResponseBase<UnreadBodyType, Res> implements IHttpResponse<UnreadBodyType, Res> {
+    headers: HttpHeaders;
+    status: number;
+    protected httpBody: HttpBody;
+    protected readonly bodyReader: IBodyReader<UnreadBodyType>;
+    abstract getUnderlyingResponse(): Res;
+    protected constructor(bodyReader: IBodyReader<UnreadBodyType>, options?: HttpResponseOptions);
+    get body(): UnreadBodyType | string;
+    readBody(): Promise<HttpBody>;
+}

package/lib/http/response/HttpResponseBase.js

@@ -0,0 +1,75 @@
+"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.HttpResponseBase = void 0;
+var utils_1 = require("../utils");
+var HttpResponseBase = /** @class */ (function () {
+    function HttpResponseBase(bodyReader, options) {
+        this.bodyReader = bodyReader;
+        this.status = (options === null || options === void 0 ? void 0 : options.status) || 200;
+        this.headers = (options === null || options === void 0 ? void 0 : options.headers) instanceof utils_1.HttpHeaders ? options === null || options === void 0 ? void 0 : options.headers : new utils_1.HttpHeaders(options === null || options === void 0 ? void 0 : options.headers);
+    }
+    Object.defineProperty(HttpResponseBase.prototype, "body", {
+        get: function () {
+            return this.bodyReader.body;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpResponseBase.prototype.readBody = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (typeof this.httpBody !== 'undefined') {
+                            return [2 /*return*/, this.httpBody];
+                        }
+                        _b = this;
+                        return [4 /*yield*/, this.bodyReader.readBody((_a = this.headers.get(utils_1.CONTENT_TYPE_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0])];
+                    case 1:
+                        _b.httpBody = _c.sent();
+                        return [2 /*return*/, this.httpBody];
+                }
+            });
+        });
+    };
+    return HttpResponseBase;
+}());
+exports.HttpResponseBase = HttpResponseBase;

package/lib/http/response/IHttpResponse.d.ts

@@ -0,0 +1,26 @@
+import { HttpHeaders, HttpBody } from '../utils';
+export interface IHttpResponse<UnreadBodyType = unknown, Res = unknown> {
+    /**
+     * The numerical status code of the response
+     * e.g., 200, 404, etc.
+     */
+    status: number;
+    /**
+     * An object representing the HTTP headers. For more information, see the documentation for the HttpHeaders class.
+     */
+    headers: HttpHeaders;
+    /**
+     * A representation of the response body. If the response does not have a body, it should be undefined.
+     * This is called when the response body needs to be accessed or used to reconstruct a new response, but not read.
+     */
+    readonly body: UnreadBodyType | string;
+    /**
+     * A string or object representation of the response body if it needs to be used in the enforcer. If read, the call to
+     * HttpResponse.body should return the saved string value so as not to consume the same ReadableStream twice.
+     */
+    readBody(): Promise<HttpBody>;
+    /**
+     * The underlying, platform-specific implementation of the response object.
+     */
+    getUnderlyingResponse(): Res;
+}

package/lib/http/response/IHttpResponse.js

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

package/lib/http/utils/ContentType.d.ts

@@ -0,0 +1,9 @@
+export declare enum ContentType {
+    APPLICATION_X_WWW_FORM_URL_ENCODED = "application/x-www-form-urlencoded",
+    APPLICATION_JSON = "application/json",
+    APPLICATION_JAVASCRIPT = "application/javascript",
+    TEXT_PLAIN = "text/plain",
+    TEXT_HTML = "text/html",
+    MULTIPART_FORM_DATA = "multipart/form-data",
+    IMAGE_GIF = "image/gif"
+}

package/lib/http/utils/ContentType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["APPLICATION_X_WWW_FORM_URL_ENCODED"] = "application/x-www-form-urlencoded";
+    ContentType["APPLICATION_JSON"] = "application/json";
+    ContentType["APPLICATION_JAVASCRIPT"] = "application/javascript";
+    ContentType["TEXT_PLAIN"] = "text/plain";
+    ContentType["TEXT_HTML"] = "text/html";
+    ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
+    ContentType["IMAGE_GIF"] = "image/gif";
+})(ContentType = exports.ContentType || (exports.ContentType = {}));

package/lib/http/utils/HttpBody.d.ts

@@ -0,0 +1,4 @@
+declare type JsonObject = Record<string, unknown>;
+declare type JsonArray = unknown[];
+export declare type HttpBody = string | JsonObject | JsonArray | undefined;
+export {};

package/lib/http/utils/HttpBody.js

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

package/lib/http/utils/HttpHeaders.d.ts

@@ -0,0 +1,51 @@
+export declare type HttpHeadersInit = Record<string, string[]>;
+export declare class HttpHeaders {
+    private readonly headers;
+    /**
+     * Constructs a new instance of the HttpHeaders class.
+     * @param init - Optional header names and values with which to initialize the HttpHeaders instance.
+     */
+    constructor(init?: HttpHeadersInit);
+    /**
+     * Retrieves the values associated with the provided header name. If no header exists, it returns undefined.
+     * @param name - The case-insensitive header name.
+     * @returns values - An array of strings representing the header values associated with the provided header name.
+     */
+    get(name: string): readonly string[] | undefined;
+    /**
+     * Sets a header with the provided name and value(s). If no header by that name exists, one will be added.
+     * If the header name already exists, the provided values will override all pre-existing values.
+     * @param name - The case-insensitive header name.
+     * @param values - The header values to be associated with the provided header name.
+     */
+    set(name: string, ...values: readonly string[]): void;
+    /**
+     * Adds the value(s) to the header with the given name. If no header by that name exists, one will be added.
+     * If the header name already exists, the provided values will be added to the end of the list of existing values.
+     * @param name - The case-insensitive header name.
+     * @param values - The header values to be associated with the provided header name.
+     */
+    append(name: string, ...values: readonly string[]): void;
+    /**
+     * Deletes a header and all its associated values. If no header by that name exists, no action is taken.
+     * @param name - The case-insensitive header name.
+     */
+    delete(name: string): void;
+    /**
+     * Returns a deep copy of the current HttpHeaders instance.
+     * @returns HttpHeaders - A new instance of the HttpHeaders class with the same header names and values as the original.
+     */
+    copy(): HttpHeaders;
+    /**
+     * Returns an object representation of the HttpHeaders instance.
+     * @returns object - An object representing the current state of the HttpHeaders instance. The keys are the header
+     * names (all lowercase), and the values are arrays of all the associated header values.
+     */
+    toObject(): Record<string, string[]>;
+    /**
+     * Iterates through all headers and applies a callback function to each one.
+     * @param callbackFn - The callback function to be applied on every header.
+     */
+    forEach(callbackFn: (values: readonly string[], name: string) => void): void;
+    private toKey;
+}

package/lib/http/utils/HttpHeaders.js

@@ -0,0 +1,106 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHeaders = void 0;
+var HttpHeaders = /** @class */ (function () {
+    /**
+     * Constructs a new instance of the HttpHeaders class.
+     * @param init - Optional header names and values with which to initialize the HttpHeaders instance.
+     */
+    function HttpHeaders(init) {
+        var _this = this;
+        this.headers = init ? new Map(Object.keys(init).map(function (name) { return [_this.toKey(name), init[name]]; })) : new Map();
+    }
+    /**
+     * Retrieves the values associated with the provided header name. If no header exists, it returns undefined.
+     * @param name - The case-insensitive header name.
+     * @returns values - An array of strings representing the header values associated with the provided header name.
+     */
+    HttpHeaders.prototype.get = function (name) {
+        return this.headers.get(this.toKey(name));
+    };
+    /**
+     * Sets a header with the provided name and value(s). If no header by that name exists, one will be added.
+     * If the header name already exists, the provided values will override all pre-existing values.
+     * @param name - The case-insensitive header name.
+     * @param values - The header values to be associated with the provided header name.
+     */
+    HttpHeaders.prototype.set = function (name) {
+        var values = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            values[_i - 1] = arguments[_i];
+        }
+        if ((values === null || values === void 0 ? void 0 : values.length) > 0) {
+            this.headers.set(this.toKey(name), values);
+        }
+    };
+    /**
+     * Adds the value(s) to the header with the given name. If no header by that name exists, one will be added.
+     * If the header name already exists, the provided values will be added to the end of the list of existing values.
+     * @param name - The case-insensitive header name.
+     * @param values - The header values to be associated with the provided header name.
+     */
+    HttpHeaders.prototype.append = function (name) {
+        var values = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            values[_i - 1] = arguments[_i];
+        }
+        var existingValues = this.get(name);
+        if (existingValues) {
+            this.set.apply(this, __spreadArray([name], existingValues.concat(values), false));
+        }
+        else {
+            this.set.apply(this, __spreadArray([name], values, false));
+        }
+    };
+    /**
+     * Deletes a header and all its associated values. If no header by that name exists, no action is taken.
+     * @param name - The case-insensitive header name.
+     */
+    HttpHeaders.prototype.delete = function (name) {
+        this.headers.delete(this.toKey(name));
+    };
+    /**
+     * Returns a deep copy of the current HttpHeaders instance.
+     * @returns HttpHeaders - A new instance of the HttpHeaders class with the same header names and values as the original.
+     */
+    HttpHeaders.prototype.copy = function () {
+        var copy = new HttpHeaders();
+        this.forEach(function (values, name) {
+            copy.set.apply(copy, __spreadArray([name], values, false));
+        });
+        return copy;
+    };
+    /**
+     * Returns an object representation of the HttpHeaders instance.
+     * @returns object - An object representing the current state of the HttpHeaders instance. The keys are the header
+     * names (all lowercase), and the values are arrays of all the associated header values.
+     */
+    HttpHeaders.prototype.toObject = function () {
+        var obj = {};
+        this.forEach(function (values, name) {
+            obj[name] = __spreadArray([], values, true);
+        });
+        return obj;
+    };
+    /**
+     * Iterates through all headers and applies a callback function to each one.
+     * @param callbackFn - The callback function to be applied on every header.
+     */
+    HttpHeaders.prototype.forEach = function (callbackFn) {
+        this.headers.forEach(function (values, name) { return callbackFn(values, name); });
+    };
+    HttpHeaders.prototype.toKey = function (name) {
+        return name.toLowerCase();
+    };
+    return HttpHeaders;
+}());
+exports.HttpHeaders = HttpHeaders;

package/lib/http/utils/HttpMethod.d.ts

@@ -0,0 +1,11 @@
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    HEAD = "HEAD",
+    DELETE = "DELETE",
+    OPTIONS = "OPTIONS",
+    CONNECT = "CONNECT",
+    TRACE = "TRACE",
+    PATCH = "PATCH"
+}

package/lib/http/utils/HttpMethod.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["CONNECT"] = "CONNECT";
+    HttpMethod["TRACE"] = "TRACE";
+    HttpMethod["PATCH"] = "PATCH";
+})(HttpMethod = exports.HttpMethod || (exports.HttpMethod = {}));

package/lib/http/utils/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const X_FORWARDED_FOR_HEADER_NAME = "x-forwarded-for";
+export declare const USER_AGENT_HEADER_NAME = "user-agent";
+export declare const CONTENT_TYPE_HEADER_NAME = "content-type";
+export declare const CONTENT_LENGTH_HEADER_NAME = "content-length";
+export declare const COOKIE_HEADER_NAME = "cookie";
+export declare const AUTHORIZATION_HEADER_NAME = "authorization";
+export declare const ACCEPT_HEADER_NAME = "accept";
+export declare const SET_COOKIE_HEADER_NAME = "set-cookie";
+export declare const HOST_HEADER_NAME = "host";

package/lib/http/utils/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOST_HEADER_NAME = exports.SET_COOKIE_HEADER_NAME = exports.ACCEPT_HEADER_NAME = exports.AUTHORIZATION_HEADER_NAME = exports.COOKIE_HEADER_NAME = exports.CONTENT_LENGTH_HEADER_NAME = exports.CONTENT_TYPE_HEADER_NAME = exports.USER_AGENT_HEADER_NAME = exports.X_FORWARDED_FOR_HEADER_NAME = void 0;
+exports.X_FORWARDED_FOR_HEADER_NAME = 'x-forwarded-for';
+exports.USER_AGENT_HEADER_NAME = 'user-agent';
+exports.CONTENT_TYPE_HEADER_NAME = 'content-type';
+exports.CONTENT_LENGTH_HEADER_NAME = 'content-length';
+exports.COOKIE_HEADER_NAME = 'cookie';
+exports.AUTHORIZATION_HEADER_NAME = 'authorization';
+exports.ACCEPT_HEADER_NAME = 'accept';
+exports.SET_COOKIE_HEADER_NAME = 'set-cookie';
+exports.HOST_HEADER_NAME = 'host';

package/lib/http/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { HttpMethod } from './HttpMethod';
+export { ContentType } from './ContentType';
+export { HttpHeaders, HttpHeadersInit } from './HttpHeaders';
+export { HttpBody } from './HttpBody';
+export * from './constants';

package/lib/http/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHeaders = exports.ContentType = exports.HttpMethod = void 0;
+var HttpMethod_1 = require("./HttpMethod");
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return HttpMethod_1.HttpMethod; } });
+var ContentType_1 = require("./ContentType");
+Object.defineProperty(exports, "ContentType", { enumerable: true, get: function () { return ContentType_1.ContentType; } });
+var HttpHeaders_1 = require("./HttpHeaders");
+Object.defineProperty(exports, "HttpHeaders", { enumerable: true, get: function () { return HttpHeaders_1.HttpHeaders; } });
+__exportStar(require("./constants"), exports);

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './additional_activity_handler';
+export * from './activities';
+export * from './block_handler';
+export * from './config';
+export * from './context';
+export * from './custom_parameters';
+export * from './enforcer';
+export * from './filter';
+export * from './first_party';
+export * from './http';
+export * from './logger';
+export * from './pxde';
+export * from './pxhd';
+export * from './risk_api';
+export * from './risk_token';
+export * from './telemetry';
+export * from './utils';

package/lib/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./additional_activity_handler"), exports);
+__exportStar(require("./activities"), exports);
+__exportStar(require("./block_handler"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./custom_parameters"), exports);
+__exportStar(require("./enforcer"), exports);
+__exportStar(require("./filter"), exports);
+__exportStar(require("./first_party"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./pxde"), exports);
+__exportStar(require("./pxhd"), exports);
+__exportStar(require("./risk_api"), exports);
+__exportStar(require("./risk_token"), exports);
+__exportStar(require("./telemetry"), exports);
+__exportStar(require("./utils"), exports);

package/lib/logger/DefaultLogger.d.ts

@@ -0,0 +1,7 @@
+import { LoggerSeverity } from './LoggerSeverity';
+import { LoggerBase } from './LoggerBase';
+import { ILogger } from './ILogger';
+export declare class DefaultLogger extends LoggerBase implements ILogger {
+    constructor(loggerSeverity: LoggerSeverity);
+    protected log(message: string): void;
+}