perimeterx-js-core 0.7.1 → 0.9.0

package/lib/context/DefaultContext.d.ts

@@ -1,49 +0,0 @@
-import { IConfiguration } from '../config';
-import { BlockAction } from '../blocker';
-import { CustomParameters } from '../custom_parameters';
-import { PXDE } from '../pxde';
-import { PXHD } from '../pxhd';
-import { TokenOrigin } from '../risk_token';
-import { IIncomingRequest, IOutgoingResponse, ReadonlyHeaders } from '../http';
-import { ICookieParser, IRequestIdGenerator, VidSource } from '../utils';
-import { IContext, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
-import { ProductData, ProductName } from '../products';
-import { Action } from '../action';
-import { IURLParser } from '../utils/url_parser';
-export type DefaultContextOptions = {
-    cookieParser?: ICookieParser;
-    requestIdGenerator: IRequestIdGenerator;
-    urlParser?: IURLParser;
-};
-export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
-    readonly requestId: string;
-    readonly tokenOrigin: TokenOrigin;
-    readonly requestData: RequestData<Req>;
-    readonly tokenData: TokenData<Req, Res>;
-    readonly riskApiData: RiskApiData;
-    readonly tlsData: TlsData;
-    readonly serverData: ServerData;
-    readonly productData: ProductData;
-    uuid: string;
-    vid?: string;
-    vidSource?: VidSource;
-    action: Action;
-    reasons?: Partial<Record<ProductName, string>>;
-    score?: number;
-    blockAction?: BlockAction;
-    pxhd?: PXHD;
-    pxde?: PXDE;
-    pxdeVerified?: boolean;
-    customParameters?: CustomParameters;
-    response?: IOutgoingResponse<Res>;
-    protected readonly config: IConfiguration<Req, Res>;
-    protected readonly urlParser: IURLParser;
-    constructor(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
-    get isMobile(): boolean;
-    protected createRequestData(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;
-    protected static getCookies(cookieParser: ICookieParser, ...cookieHeaderValues: string[]): Record<string, string>;
-    protected extractUserAgentFromHeader(config: IConfiguration<Req, Res>, headers: ReadonlyHeaders): string;
-    protected extractIpFromHeader(config: IConfiguration<Req, Res>, headers: ReadonlyHeaders): string;
-    protected getTokenOrigin(request: IIncomingRequest<Req>): TokenOrigin;
-    protected setCookiesOnContext(): void;
-}

package/lib/context/DefaultContext.js

@@ -1,85 +0,0 @@
-import { BlockAction } from '../blocker';
-import { PXHDSource } from '../pxhd';
-import { TokenOrigin, TokenParseResult } from '../risk_token';
-import { RiskApiCallResult } from '../risk_api';
-import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '../http';
-import { StringSplitCookieParser, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
-import { DefaultUrlParser } from '../utils/url_parser';
-export class DefaultContext {
-    constructor(config, request, options) {
-        this.config = config;
-        this.urlParser = options.urlParser || new DefaultUrlParser();
-        this.tokenData = {
-            tokenParseResult: TokenParseResult.NONE,
-        };
-        this.riskApiData = {
-            riskApiCallResult: RiskApiCallResult.NONE,
-        };
-        this.tlsData = {};
-        this.serverData = {};
-        this.productData = {};
-        this.requestId = options.requestIdGenerator.generateRequestId();
-        this.blockAction = BlockAction.CAPTCHA;
-        this.pxdeVerified = false;
-        this.requestData = this.createRequestData(config, request, options.cookieParser);
-        this.tokenOrigin = this.getTokenOrigin(request);
-        if (!this.isMobile) {
-            this.setCookiesOnContext();
-        }
-    }
-    get isMobile() {
-        return this.tokenOrigin === TokenOrigin.HEADER;
-    }
-    createRequestData(config, request, cookieParser = new StringSplitCookieParser()) {
-        const rawUrl = request.url;
-        const url = this.urlParser.parse(rawUrl);
-        const method = request.method;
-        const headers = request.headers;
-        const cookies = DefaultContext.getCookies(cookieParser, request.headers.get(COOKIE_HEADER_NAME), request.headers.get(config.customCookieHeader));
-        const requestCookieNames = Object.keys(cookies);
-        const readOnlyHeaders = toReadonlyHeaders(headers);
-        const userAgent = this.extractUserAgentFromHeader(config, readOnlyHeaders);
-        const ip = this.extractIpFromHeader(config, readOnlyHeaders) || request.clientIP;
-        return { url, rawUrl, method, headers: readOnlyHeaders, cookies, ip, userAgent, requestCookieNames, request };
-    }
-    static getCookies(cookieParser, ...cookieHeaderValues) {
-        const cookies = {};
-        cookieHeaderValues.forEach((value) => {
-            Object.assign(cookies, value ? cookieParser.parseCookies(value) : null);
-        });
-        return cookies;
-    }
-    extractUserAgentFromHeader(config, headers) {
-        var _a;
-        let userAgent = ((_a = headers[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;
-    }
-    extractIpFromHeader(config, headers) {
-        let ip;
-        config.ipHeaders.some((ipHeader) => {
-            var _a;
-            const headerValue = (_a = headers[ipHeader]) === null || _a === void 0 ? void 0 : _a[0];
-            if (headerValue) {
-                ip = headerValue;
-                return true;
-            }
-        });
-        return ip;
-    }
-    getTokenOrigin(request) {
-        return request.headers.get(X_PX_AUTHORIZATION_HEADER_NAME) ? TokenOrigin.HEADER : TokenOrigin.COOKIE;
-    }
-    setCookiesOnContext() {
-        this.vid = this.requestData.cookies[PXVID_COOKIE_NAME] || '';
-        const pxhdCookie = this.requestData.cookies[PXHD_COOKIE_NAME] || '';
-        if (pxhdCookie) {
-            this.pxhd = {
-                value: pxhdCookie,
-                source: PXHDSource.COOKIE,
-            };
-        }
-    }
-}

package/lib/context/interfaces/RiskApiData.d.ts

@@ -1,27 +0,0 @@
-import { IRiskResponse, S2SErrorReason, RiskApiCallResult } from '../../risk_api';
-export type RiskApiData = {
-    /**
-     * The result of the risk API call.
-     */
-    riskApiCallResult: RiskApiCallResult;
-    /**
-     * An interface representing the risk API response.
-     */
-    riskResponse?: IRiskResponse;
-    /**
-     * The risk API round trip time in milliseconds.
-     */
-    riskRtt?: number;
-    /**
-     * The reason for the error during the risk API call if an error occurred.
-     */
-    errorReason?: S2SErrorReason;
-    /**
-     * The HTTP response status that was received for the risk API call if an error occurred.
-     */
-    errorHttpStatus?: number;
-    /**
-     * An error message that contains more details about the risk API error if an error occurred.
-     */
-    errorMessage?: string;
-};

package/lib/cors/DefaultCors.js

@@ -1,59 +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 { ACCESS_CONTROL_REQUEST_METHOD_HEADER, ORIGIN_HEADER } from './constants';
-import { HttpMethod } from '../http';
-export class DefaultCors {
-    constructor(config) {
-        this.customBlockResponseHeaders = config.corsCreateCustomBlockResponseHeaders;
-        this.customPreflightHandler = config.corsCustomPreflightHandler;
-        this.logger = config.logger;
-    }
-    isPreflightRequest(context) {
-        const { requestData } = context;
-        return !!(requestData.method.toUpperCase() === HttpMethod.OPTIONS &&
-            requestData.headers[ORIGIN_HEADER] &&
-            requestData.headers[ACCESS_CONTROL_REQUEST_METHOD_HEADER]);
-    }
-    runPreflightCustomHandler(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.customPreflightHandler && typeof this.customPreflightHandler === 'function') {
-                try {
-                    return yield this.customPreflightHandler(context.requestData.request.getUnderlyingRequest());
-                }
-                catch (e) {
-                    this.logger.debug(`Exception occurred while executing custom preflight handler: ${e}`);
-                }
-            }
-            return null;
-        });
-    }
-    isCorsRequest(context) {
-        return !!context.requestData.headers[ORIGIN_HEADER];
-    }
-    getCorsBlockHeaders(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.customBlockResponseHeaders && typeof this.customBlockResponseHeaders === 'function') {
-                try {
-                    return yield this.customBlockResponseHeaders(context.requestData.request.getUnderlyingRequest());
-                }
-                catch (e) {
-                    this.logger.debug(`Exception occurred in px_cors_create_custom_block_response_headers custom function: ${e}`);
-                }
-            }
-            return this.getDefaultCorsHeaders(context);
-        });
-    }
-    getDefaultCorsHeaders(context) {
-        return {
-            'Access-Control-Allow-Origin': context.requestData.headers[ORIGIN_HEADER],
-            'Access-Control-Allow-Credentials': ['true'],
-        };
-    }
-}

package/lib/custom_parameters/CustomParametersUtils.js

@@ -1,36 +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 var CustomParametersUtils;
-(function (CustomParametersUtils) {
-    CustomParametersUtils.createCustomParameters = (config, context) => __awaiter(this, void 0, void 0, function* () {
-        if (config.enrichCustomParameters && typeof config.enrichCustomParameters === 'function') {
-            try {
-                const parameters = yield config.enrichCustomParameters(config.toParams(), context.requestData.request.getUnderlyingRequest());
-                return CustomParametersUtils.normalizeCustomParams(parameters);
-            }
-            catch (e) {
-                config.logger.error(`unable to enrich custom params: ${e}`);
-            }
-        }
-        return null;
-    });
-    CustomParametersUtils.normalizeCustomParams = (customParameters) => {
-        const normalizedParams = {};
-        if (customParameters && typeof customParameters === 'object') {
-            const paramKeyRegex = /^custom_param([1-9]|10)$/;
-            Object.entries(customParameters).forEach(([param, value]) => {
-                if (param.match(paramKeyRegex) && value !== '') {
-                    normalizedParams[param] = value;
-                }
-            });
-        }
-        return Object.keys(normalizedParams).length === 0 ? null : normalizedParams;
-    };
-})(CustomParametersUtils || (CustomParametersUtils = {}));

package/lib/enforcer/EnforcerBase.js

@@ -1,168 +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 { DefaultDataEnrichment } from '../pxde';
-import { DefaultTelemetry } from '../telemetry';
-import { DefaultTokenV2Parser, DefaultTokenV3Parser, TokenVersion } from '../risk_token';
-import { DefaultCors } from '../cors';
-import { PostRiskApiClientV2, PostRiskApiClientV3 } from '../risk_api';
-import { EndEnforcerFlow, EnforceFlow, FilterFlow, PostEnforceFlow } from '../phase';
-import { AccountDefender, BotDefender, CredentialIntelligence, ProductName } from '../products';
-import { HttpActivityClient, HttpBatchedActivityClient } from '../activities';
-import { DefaultGraphQLParser } from '../graphql';
-import { HttpLogServiceClient } from '../logger';
-export class EnforcerBase {
-    /**
-     * The EnforcerBase constructor.
-     * @param config - The enforcer configuration.
-     * @param options - An EnforcerOptions object that allows for overriding any functional building blocks in the enforcer.
-     * @protected
-     */
-    constructor(config, options) {
-        this.config = config;
-        const initializationBlock = this.getInitializationBlock(config, options);
-        this.activityClient = initializationBlock.activityClient;
-        this.filterFlow = new FilterFlow(config, initializationBlock);
-        this.enforceFlow = new EnforceFlow(config, initializationBlock);
-        this.postEnforceFlow = new PostEnforceFlow(config, initializationBlock);
-        this.endEnforcerFlow = new EndEnforcerFlow(config, initializationBlock);
-    }
-    /**
-     * The central function that triggers enforcement on the incoming request.
-     * @param args - The EnforceArgs required to enforce the incoming request.
-     * @returns Promise<Res|null> - A Promise resolving to a Res or null depending on the action that should be taken.
-     */
-    enforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.config.moduleEnabled) {
-                    this.config.logger.debug('module is disabled, will not enforce');
-                    return null;
-                }
-                return yield this.doEnforce(...args);
-            }
-            catch (e) {
-                this.config.logger.error(`caught error in enforce - ${e}`);
-                return null;
-            }
-        });
-    }
-    /**
-     * Performs all enforcer functionality on the incoming request context.
-     * @param args - The EnforceArgs required to enforce the incoming request.
-     * @returns Promise<Res|null> -  A Promise resolving to a Res or null depending on the action that should be taken.
-     * @protected
-     */
-    doEnforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const context = yield this.constructContext(...args);
-            let result = yield this.filterFlow.execute(context);
-            if (result.done) {
-                yield this.endEnforcerFlow.execute(context);
-                return result.response ? this.convertToRes(result.response, ...args) : null;
-            }
-            this.preserveContext(context, ...args);
-            result = yield this.enforceFlow.execute(context);
-            if (result.response) {
-                yield this.endEnforcerFlow.execute(context);
-                return this.convertToRes(result.response, ...args);
-            }
-            return null;
-        });
-    }
-    /**
-     * Performs all required functionality after an origin response has been received.
-     * @param args - The PostEnforce args required to enforce the incoming request.
-     * @returns Promise<void> - The response parameter will be modified as needed
-     * @protected
-     */
-    postEnforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = this.retrieveContext(...args);
-                if (context) {
-                    context.response = yield this.convertToOutgoingResponse(...args);
-                    yield this.postEnforceFlow.execute(context);
-                }
-                yield this.endEnforcerFlow.execute(context);
-            }
-            catch (e) {
-                this.config.logger.error(`caught error in post enforce - ${e}`);
-            }
-        });
-    }
-    sendAdditionalS2SActivity(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const context = this.retrieveContext(...args);
-            if (context) {
-                yield this.activityClient.sendActivities(context);
-            }
-        });
-    }
-    /**
-     * Returns the components needed to initialize the enforcer according to the provided options. If no
-     * component is provided in the options, a default one is generated and returned.
-     * @param config
-     * @param options
-     * @returns Required<EnforcerBaseOptions>
-     * @protected
-     */
-    getInitializationBlock(config, options) {
-        const { tokenVersion, httpClient, base64Utils, hmacUtils, hashUtils, ipRangeChecker } = options;
-        const cipherUtils = tokenVersion === TokenVersion.V2 ? null : options.cipherUtils;
-        const cors = options.cors || new DefaultCors(config);
-        const telemetry = options.telemetry || new DefaultTelemetry(config, httpClient, base64Utils, hmacUtils);
-        const dataEnrichment = options.dataEnrichment || new DefaultDataEnrichment(config, base64Utils, hmacUtils);
-        const graphQLParser = options.graphQLParser || new DefaultGraphQLParser(config);
-        const tokenParser = options.tokenParser ||
-            (tokenVersion === TokenVersion.V2
-                ? new DefaultTokenV2Parser(config, { base64Utils, hmacUtils })
-                : new DefaultTokenV3Parser(config, { cipherUtils, hmacUtils }));
-        const riskApiClient = options.riskApiClient ||
-            (tokenVersion === TokenVersion.V2
-                ? new PostRiskApiClientV2(config, httpClient)
-                : new PostRiskApiClientV3(config, httpClient));
-        const activityClient = options.activityClient ||
-            (config.maxActivityBatchSize > 1
-                ? new HttpBatchedActivityClient(config, httpClient)
-                : new HttpActivityClient(config, httpClient));
-        const logServiceClient = options.logServiceClient || (config.loggerAuthToken ? new HttpLogServiceClient(config, httpClient) : null);
-        const allOptions = {
-            httpClient,
-            base64Utils,
-            hmacUtils,
-            hashUtils,
-            ipRangeChecker,
-            cors,
-            telemetry,
-            dataEnrichment,
-            graphQLParser,
-            tokenParser,
-            riskApiClient,
-            activityClient,
-            logServiceClient,
-        };
-        const products = this.initializeProducts(config, options.products, base64Utils, hashUtils, ipRangeChecker);
-        return Object.assign({ products }, allOptions);
-    }
-    initializeProducts(config, products, base64Utils, hashUtils, ipRangeChecker) {
-        const botDefender = (products === null || products === void 0 ? void 0 : products.bd) || new BotDefender(config, { base64Utils, ipRangeChecker });
-        const accountDefender = (products === null || products === void 0 ? void 0 : products.ad) || new AccountDefender(config, { base64Utils });
-        const credentialIntelligence = config.ciEnabled
-            ? (products === null || products === void 0 ? void 0 : products.ci) || new CredentialIntelligence(config, hashUtils)
-            : null;
-        return {
-            [ProductName.BOT_DEFENDER]: botDefender,
-            [ProductName.ACCOUNT_DEFENDER]: accountDefender,
-            [ProductName.CODE_DEFENDER]: products === null || products === void 0 ? void 0 : products.cd,
-            [ProductName.CREDENTIAL_INTELLIGENCE]: credentialIntelligence,
-            [ProductName.HYPE_SALE_CHALLENGE]: products === null || products === void 0 ? void 0 : products.hsc,
-        };
-    }
-}

package/lib/graphql/DefaultGraphQLParser.js

@@ -1,126 +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 { isRouteInPatterns } from '../utils';
-import { HttpMethod } from '../http';
-import { GraphQLOperationType } from './model';
-export class DefaultGraphQLParser {
-    constructor(config) {
-        this.config = config;
-        this.graphqlRoutes = config.graphqlRoutes;
-        this.sensitiveOperationNames = config.sensitiveGraphqlOperationNames;
-        this.sensitiveOperationTypes = config.sensitiveGraphqlOperationTypes;
-    }
-    isGraphQLRequest({ requestData }) {
-        return (requestData.method === HttpMethod.POST && isRouteInPatterns(requestData.url.pathname, this.graphqlRoutes));
-    }
-    parseGraphQLRequest({ requestData }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const graphQLOperations = yield this.getGraphQLOperationsFromBody(requestData);
-                if (!graphQLOperations) {
-                    this.config.logger.debug('unable to get graphql operations from request body');
-                    return null;
-                }
-                const data = this.parseGraphQLOperations(graphQLOperations);
-                if (!data || data.length === 0) {
-                    this.config.logger.debug('unable to parse graphql operations');
-                    return null;
-                }
-                this.config.logger.debug(`${data.length} graphql operation${data.length === 1 ? '' : 's'} parsed successfully`);
-                return data;
-            }
-            catch (e) {
-                this.config.logger.debug(`unable to parse graphql request: ${e}`);
-                return null;
-            }
-        });
-    }
-    getGraphQLOperationsFromBody({ request, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let body = yield request.json();
-                if (!body) {
-                    return null;
-                }
-                return Array.isArray(body) ? body : [body];
-            }
-            catch (e) {
-                this.config.logger.debug(`unable to parse body to json: ${e}`);
-                return null;
-            }
-        });
-    }
-    parseGraphQLOperations(operations) {
-        return operations.map((operation) => this.parseGraphQlOperation(operation)).filter((x) => x);
-    }
-    parseGraphQlOperation(operation) {
-        if (!operation.query || typeof operation.query !== 'string') {
-            return null;
-        }
-        const operationNameToTypeMap = this.getOperationNameToTypeMap(operation.query);
-        if (!operationNameToTypeMap) {
-            return null;
-        }
-        return this.getGraphQLData(operationNameToTypeMap, operation);
-    }
-    getOperationNameToTypeMap(query) {
-        const operationTypesString = Object.values(GraphQLOperationType).join('|');
-        const pattern = new RegExp(`\\s*(${operationTypesString})\\s+(\\w+)`, 'gm');
-        let match;
-        const map = {};
-        while ((match = pattern.exec(query)) !== null) {
-            const operationType = match[1];
-            const operationName = match[2];
-            if (map[operationName]) {
-                // query contains two operations with the same name which is illegal
-                return null;
-            }
-            else {
-                map[operationName] = operationType;
-            }
-        }
-        return map;
-    }
-    getGraphQLData(operationNameToTypeMap, operation) {
-        let name = operation.operationName ||
-            (Object.keys(operationNameToTypeMap).length === 1 ? Object.keys(operationNameToTypeMap)[0] : undefined);
-        let type = operationNameToTypeMap[name];
-        if (!type && /^\s*{/.test(operation.query)) {
-            type = GraphQLOperationType.QUERY;
-        }
-        if (!type) {
-            return null;
-        }
-        const data = { name, type };
-        if (this.isSensitiveOperation(name, type)) {
-            data.sensitive = true;
-        }
-        if (operation.variables && typeof operation.variables === 'object') {
-            data.variables = this.extractGraphQLVariableNames(operation.variables);
-        }
-        return data;
-    }
-    isSensitiveOperation(operationName, operationType) {
-        return (this.sensitiveOperationTypes.some((type) => type === operationType) ||
-            this.sensitiveOperationNames.some((name) => name === operationName));
-    }
-    extractGraphQLVariableNames(variables) {
-        const processVariables = (variablesObj, prefix) => Object.entries(variablesObj).reduce((total, [key, value]) => {
-            if (!value || typeof value !== 'object' || Object.keys(value).length === 0) {
-                total.push(prefix + key);
-                return total;
-            }
-            else {
-                return total.concat(processVariables(value, `${prefix}${key}.`));
-            }
-        }, []);
-        return processVariables(variables, '');
-    }
-}

package/lib/http/impl/FormDataImpl.js

@@ -1,36 +0,0 @@
-export class FormDataImpl {
-    constructor(data) {
-        this.data = data !== null && data !== void 0 ? data : {};
-    }
-    append(name, value, fileName) {
-        this.data[name] = (this.data[name] || []).concat(value);
-    }
-    delete(name) {
-        delete this.data[name];
-    }
-    forEach(callbackfn, thisArg) {
-        Object.entries(this.data).forEach(([key, values]) => {
-            values === null || values === void 0 ? void 0 : values.forEach((val) => {
-                callbackfn(val, key, this);
-            });
-        });
-    }
-    get(name) {
-        var _a;
-        return ((_a = this.data[name]) === null || _a === void 0 ? void 0 : _a[0]) || null;
-    }
-    getAll(name) {
-        return this.data[name] || [];
-    }
-    has(name) {
-        return this.get(name) !== null;
-    }
-    set(name, value, filename) {
-        if (typeof value === 'string') {
-            this.data[name] = [value];
-        }
-        else if (File) {
-            this.data[name] = [new File([value], filename)];
-        }
-    }
-}

package/lib/http/impl/MinimalResponseImpl.js

@@ -1,7 +0,0 @@
-export class MinimalResponseImpl {
-    constructor(options) {
-        this.body = options.body;
-        this.headers = options.headers || {};
-        this.status = options.status || 200;
-    }
-}

package/lib/http/impl/OutgoingRequestImpl.d.ts

@@ -1,14 +0,0 @@
-import { ReadonlyHeaders, HttpMethod, IOutgoingRequest } from '..';
-export type OutGoingRequestImplOptions = {
-    url: string;
-    method?: HttpMethod | string;
-    headers?: ReadonlyHeaders;
-    body?: any;
-};
-export declare class OutgoingRequestImpl implements IOutgoingRequest {
-    readonly body: any;
-    readonly url: string;
-    readonly method: HttpMethod;
-    readonly headers: ReadonlyHeaders;
-    constructor(options: OutGoingRequestImplOptions);
-}

package/lib/http/impl/OutgoingRequestImpl.js

@@ -1,9 +0,0 @@
-import { HttpMethod } from '..';
-export class OutgoingRequestImpl {
-    constructor(options) {
-        this.url = options.url;
-        this.method = options.method || HttpMethod.GET;
-        this.headers = options.headers || {};
-        this.body = options.body;
-    }
-}

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

@@ -1,4 +0,0 @@
-export * from './MinimalResponseImpl';
-export * from './OutgoingRequestImpl';
-export * from './FormDataImpl';
-export * from './phin';

package/lib/http/impl/index.js

@@ -1,4 +0,0 @@
-export * from './MinimalResponseImpl';
-export * from './OutgoingRequestImpl';
-export * from './FormDataImpl';
-export * from './phin';

package/lib/http/impl/phin/PhinHttpClient.d.ts

@@ -1,6 +0,0 @@
-import { HttpSendOptions, IHttpClient, IIncomingResponse, IOutgoingRequest } from '../../interfaces';
-export declare class PhinHttpClient implements IHttpClient {
-    private readonly httpsKeepAliveAgent;
-    constructor();
-    send(request: IOutgoingRequest, options?: HttpSendOptions): Promise<IIncomingResponse>;
-}