perimeterx-js-core 0.7.0 → 0.8.0

package/lib/enforcer/EnforcerBase.js

@@ -1,22 +1,20 @@
-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 { EnforceFlow, FilterFlow, PostEnforceFlow } from '../phase';
+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 {
+    config;
+    filterFlow;
+    enforceFlow;
+    postEnforceFlow;
+    endEnforcerFlow;
+    activityClient;
     /**
      * The EnforcerBase constructor.
      * @param config - The enforcer configuration.
@@ -30,26 +28,25 @@ export class EnforcerBase {
         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}`);
+    async enforce(...args) {
+        try {
+            if (!this.config.moduleEnabled) {
+                this.config.logger.debug('module is disabled, will not enforce');
                 return null;
             }
-        });
+            return await 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.
@@ -57,17 +54,20 @@ export class EnforcerBase {
      * @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) {
-                return result.response ? this.convertToRes(result.response) : null;
-            }
-            this.preserveContext(context, ...args);
-            result = yield this.enforceFlow.execute(context);
-            return result.response ? this.convertToRes(result.response) : null;
-        });
+    async doEnforce(...args) {
+        const context = await this.constructContext(...args);
+        let result = await this.filterFlow.execute(context);
+        if (result.done) {
+            await this.endEnforcerFlow.execute(context);
+            return result.response ? this.convertToRes(result.response, ...args) : null;
+        }
+        this.preserveContext(context, ...args);
+        result = await this.enforceFlow.execute(context);
+        if (result.done) {
+            await this.endEnforcerFlow.execute(context);
+            return result.response ? this.convertToRes(result.response, ...args) : null;
+        }
+        return null;
     }
     /**
      * Performs all required functionality after an origin response has been received.
@@ -75,27 +75,24 @@ export class EnforcerBase {
      * @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);
-                }
-            }
-            catch (e) {
-                this.config.logger.error(`caught error in post enforce - ${e}`);
-            }
-        });
-    }
-    sendAdditionalS2SActivity(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async postEnforce(...args) {
+        try {
             const context = this.retrieveContext(...args);
             if (context) {
-                yield this.activityClient.sendActivities(context);
+                context.response = await this.convertToOutgoingResponse(...args);
+                await this.postEnforceFlow.execute(context);
+                await this.endEnforcerFlow.execute(context);
             }
-        });
+        }
+        catch (e) {
+            this.config.logger.error(`caught error in post enforce - ${e}`);
+        }
+    }
+    async sendAdditionalS2SActivity(...args) {
+        const context = this.retrieveContext(...args);
+        if (context) {
+            await this.activityClient.sendActivities(context);
+        }
     }
     /**
      * Returns the components needed to initialize the enforcer according to the provided options. If no
@@ -124,6 +121,7 @@ export class EnforcerBase {
             (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,
@@ -137,22 +135,23 @@ export class EnforcerBase {
             tokenParser,
             riskApiClient,
             activityClient,
+            logServiceClient,
         };
         const products = this.initializeProducts(config, options.products, base64Utils, hashUtils, ipRangeChecker);
-        return Object.assign({ products }, allOptions);
+        return { 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 botDefender = products?.bd || new BotDefender(config, { base64Utils, ipRangeChecker });
+        const accountDefender = products?.ad || new AccountDefender(config, { base64Utils });
         const credentialIntelligence = config.ciEnabled
-            ? (products === null || products === void 0 ? void 0 : products.ci) || new CredentialIntelligence(config, hashUtils)
+            ? 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.CODE_DEFENDER]: products?.cd,
             [ProductName.CREDENTIAL_INTELLIGENCE]: credentialIntelligence,
-            [ProductName.HYPE_SALE_CHALLENGE]: products === null || products === void 0 ? void 0 : products.hsc,
+            [ProductName.HYPE_SALE_CHALLENGE]: products?.hsc,
         };
     }
 }

package/lib/enforcer/options/EnforcerBaseOptions.d.ts

@@ -8,6 +8,7 @@ import { IRiskApiClient } from '../../risk_api';
 import { IActivityClient } from '../../activities';
 import { Products } from '../../products';
 import { IGraphQLParser } from '../../graphql';
+import { ILogServiceClient } from '../../logger';
 export type EnforcerBaseOptions<Req, Res> = {
     httpClient: IHttpClient;
     base64Utils: IBase64Utils;
@@ -22,4 +23,5 @@ export type EnforcerBaseOptions<Req, Res> = {
     telemetry?: ITelemetry<Req, Res>;
     riskApiClient?: IRiskApiClient<Req, Res>;
     activityClient?: IActivityClient<Req, Res>;
+    logServiceClient?: ILogServiceClient<Req, Res>;
 };

package/lib/graphql/DefaultGraphQLParser.js

@@ -1,16 +1,11 @@
-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 {
+    config;
+    graphqlRoutes;
+    sensitiveOperationTypes;
+    sensitiveOperationNames;
     constructor(config) {
         this.config = config;
         this.graphqlRoutes = config.graphqlRoutes;
@@ -20,42 +15,38 @@ export class DefaultGraphQLParser {
     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;
+    async parseGraphQLRequest({ requestData }) {
+        try {
+            const graphQLOperations = await this.getGraphQLOperationsFromBody(requestData);
+            if (!graphQLOperations) {
+                this.config.logger.debug('unable to get graphql operations from request body');
+                return null;
             }
-            catch (e) {
-                this.config.logger.debug(`unable to parse graphql request: ${e}`);
+            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}`);
+    async getGraphQLOperationsFromBody({ request, }) {
+        try {
+            let body = await 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);

package/lib/http/index.d.ts

@@ -1,3 +1,2 @@
 export * from './utils';
 export * from './interfaces';
-export * from './impl';

package/lib/http/index.js

@@ -1,3 +1,2 @@
 export * from './utils';
 export * from './interfaces';
-export * from './impl';

package/lib/http/interfaces/IBody.d.ts

@@ -1,5 +1,6 @@
 import { AsyncOrSync } from 'ts-essentials';
 import { IFormData } from './IFormData';
+import { IURLSearchParams } from './IURLSearchParams';
 export interface IBody {
     /**
      * the unread body.
@@ -18,7 +19,7 @@ export interface IBody {
      */
     text(): AsyncOrSync<string>;
     /**
-     * Converts the body to URLSearchParams (application/x-www-form-urlencoded)
+     * Converts the body to a URL search params-like object (application/x-www-form-urlencoded)
      */
-    formUrlEncoded(): AsyncOrSync<URLSearchParams>;
+    formUrlEncoded(): AsyncOrSync<IURLSearchParams>;
 }

package/lib/http/interfaces/IIncomingRequest.d.ts

@@ -21,6 +21,10 @@ export interface IIncomingRequest<Req> extends IBody {
      * Return the client IP provided by the environment or null.
      */
     readonly clientIP: string | null;
+    /**
+     * Http version provided by the environment if supported.
+     */
+    readonly httpVersion?: string;
     /**
      * Returns the platform-specific request implementation of the request.
      */

package/lib/http/interfaces/IURL.d.ts

@@ -1,6 +1,9 @@
+import { IURLSearchParams } from './IURLSearchParams';
 export interface IURL {
     href: string;
     search: string;
     origin: string;
+    host: string;
     pathname: string;
+    searchParams: IURLSearchParams;
 }

package/lib/http/interfaces/IURLSearchParams.d.ts

@@ -0,0 +1,9 @@
+export interface IURLSearchParams {
+    get(name: string): string;
+    getAll(name: string): string[];
+    set(name: string, value: string): void;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    has(name: string): boolean;
+    forEach(callback: (value: string, key: string, params?: IURLSearchParams, thisArg?: any) => void): void;
+}

package/lib/http/interfaces/IURLSearchParams.js

@@ -0,0 +1 @@
+export {};

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

@@ -9,3 +9,4 @@ export * from './IHeaders';
 export * from './IFormData';
 export * from './ReadonlyHeaders';
 export * from './IURL';
+export * from './IURLSearchParams';

package/lib/http/interfaces/index.js

@@ -9,3 +9,4 @@ export * from './IHeaders';
 export * from './IFormData';
 export * from './ReadonlyHeaders';
 export * from './IURL';
+export * from './IURLSearchParams';

package/lib/http/{impl → utils}/FormDataImpl.js

@@ -1,6 +1,7 @@
 export class FormDataImpl {
+    data;
     constructor(data) {
-        this.data = data !== null && data !== void 0 ? data : {};
+        this.data = data ?? {};
     }
     append(name, value, fileName) {
         this.data[name] = (this.data[name] || []).concat(value);
@@ -10,14 +11,13 @@ export class FormDataImpl {
     }
     forEach(callbackfn, thisArg) {
         Object.entries(this.data).forEach(([key, values]) => {
-            values === null || values === void 0 ? void 0 : values.forEach((val) => {
+            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;
+        return this.data[name]?.[0] || null;
     }
     getAll(name) {
         return this.data[name] || [];

package/lib/http/{impl → utils}/MinimalResponseImpl.js

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

package/lib/http/utils/MinimalResponseUtils.js

@@ -1,4 +1,4 @@
-import { MinimalResponseImpl } from '../impl';
+import { MinimalResponseImpl } from '../utils';
 export var MinimalResponseUtils;
 (function (MinimalResponseUtils) {
     MinimalResponseUtils.appendHeader = (response, name, value) => {
@@ -10,7 +10,7 @@ export var MinimalResponseUtils;
         const body = response.body;
         const statusCode = response.status;
         const responseHeaders = response.headers;
-        const newHeaders = Object.assign({}, responseHeaders);
+        const newHeaders = { ...responseHeaders };
         Object.entries(headers).forEach(([name, values]) => {
             newHeaders[name] = (newHeaders[name] || []).concat(values);
         });
@@ -22,11 +22,9 @@ export var MinimalResponseUtils;
     };
     MinimalResponseUtils.from = (response) => {
         return new (class {
-            constructor() {
-                this.body = response.body;
-                this.headers = response.headers;
-                this.status = response.status;
-            }
+            body = response.body;
+            headers = response.headers;
+            status = response.status;
         })();
     };
 })(MinimalResponseUtils || (MinimalResponseUtils = {}));

package/lib/http/utils/MultipartFormDataUtils.js

@@ -1,4 +1,4 @@
-import { FormDataImpl } from '../impl';
+import { FormDataImpl } from './FormDataImpl';
 export var MultipartFormDataUtils;
 (function (MultipartFormDataUtils) {
     MultipartFormDataUtils.createFormDataWithoutFiles = (rawBody, contentType) => {
@@ -19,22 +19,21 @@ export var MultipartFormDataUtils;
         return boundary.slice(BOUNDARY_PREFIX.length).trim();
     };
     MultipartFormDataUtils.parseMultipartBodyWithoutFiles = (boundary, rawBody) => {
-        var _a, _b, _c, _d, _e, _f;
         if (!rawBody || !boundary) {
             return null;
         }
         const body = {};
         const entries = rawBody.split(boundary);
         for (const item of entries) {
-            const filename = (_b = (_a = item.match(/filename="(.+?)"/)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.trim();
+            const filename = item.match(/filename="(.+?)"/)?.[1]?.trim();
             if (filename) {
                 continue;
             }
-            const name = (_d = (_c = item.match(/name="(.+?)"/)) === null || _c === void 0 ? void 0 : _c[1]) === null || _d === void 0 ? void 0 : _d.trim();
+            const name = item.match(/name="(.+?)"/)?.[1]?.trim();
             if (!name) {
                 continue;
             }
-            const value = (_f = (_e = item.match(/\r\n\r\n([^\r\n\v]*)\r\n--$/)) === null || _e === void 0 ? void 0 : _e[1]) === null || _f === void 0 ? void 0 : _f.trim();
+            const value = item.match(/\r\n\r\n([^\r\n\v]*)\r\n--$/)?.[1]?.trim();
             if (!value) {
                 continue;
             }

package/lib/http/{impl → utils}/OutgoingRequestImpl.d.ts

@@ -1,4 +1,4 @@
-import { ReadonlyHeaders, HttpMethod, IOutgoingRequest } from '..';
+import { ReadonlyHeaders, HttpMethod, IOutgoingRequest } from '../index';
 export type OutGoingRequestImplOptions = {
     url: string;
     method?: HttpMethod | string;

package/lib/http/{impl → utils}/OutgoingRequestImpl.js

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

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

@@ -0,0 +1,7 @@
+import { IURL, IURLSearchParams } from '../interfaces';
+export declare namespace URLUtils {
+    const parseURL: (rawUrl: string) => IURL;
+    const parseSearchParams: (search: string) => IURLSearchParams;
+    const decodeUriComponent: (input: string) => string;
+    const encodeUriComponent: (input: string) => string;
+}

package/lib/http/utils/URLUtils.js

@@ -0,0 +1,62 @@
+import { UrlImpl } from './UrlImpl';
+import { UrlSearchParamsImpl } from './UrlSearchParamsImpl';
+export var URLUtils;
+(function (URLUtils) {
+    URLUtils.parseURL = (rawUrl) => {
+        return global?.URL ? new URL(rawUrl) : new UrlImpl(rawUrl);
+    };
+    URLUtils.parseSearchParams = (search) => {
+        return global?.URLSearchParams ? new URLSearchParams(search) : new UrlSearchParamsImpl(search);
+    };
+    URLUtils.decodeUriComponent = (input) => {
+        return global?.decodeURIComponent ? decodeURIComponent(input) : decodeUriComponentPolyfill(input);
+    };
+    URLUtils.encodeUriComponent = (input) => {
+        return global?.encodeURIComponent ? encodeURIComponent(input) : encodeUriComponentPolyfill(input);
+    };
+    const decodeUriComponentPolyfill = (input) => {
+        // https://www.npmjs.com/package/as-uri-encode-decode
+        // Note: Does not work well with multibyte characters
+        let result = '';
+        for (let i = 0; i < input.length; i++) {
+            if (input.charAt(i) === '+') {
+                result += ' ';
+                continue;
+            }
+            if (input.charAt(i) === '%' && input.charAt(i + 1) !== '%' && input.charAt(i + 2) !== '%') {
+                const charCode = parseInt(input.charAt(i + 1) + input.charAt(i + 2), 16);
+                const char = String.fromCharCode(charCode);
+                result += char;
+                i += 2;
+                continue;
+            }
+            result += input.charAt(i);
+        }
+        return result;
+    };
+    const encodeUriComponentPolyfill = (input) => {
+        // https://www.npmjs.com/package/as-uri-encode-decode
+        // Note: Does not work well with multibyte characters
+        let result = '';
+        for (let i = 0; i < input.length; i++) {
+            const c = input.charAt(i);
+            if (isSafe(c)) {
+                result += c;
+            }
+            else {
+                result += '%' + c.charCodeAt(0).toString(16).toUpperCase();
+            }
+        }
+        return result;
+    };
+    const isSafe = (c) => {
+        return ((c >= 'a' && c <= 'z') ||
+            (c >= 'A' && c <= 'Z') ||
+            (c >= '0' && c <= '9') ||
+            c == '-' ||
+            c == '_' ||
+            c == '.' ||
+            c == '*' ||
+            c == '!');
+    };
+})(URLUtils || (URLUtils = {}));

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

@@ -0,0 +1,18 @@
+import { IURL, IURLSearchParams } from '../interfaces';
+export declare class UrlImpl implements IURL {
+    protocol: string;
+    hostname: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    protected _port: string;
+    constructor(rawUrl: string);
+    get href(): string;
+    get origin(): string;
+    get host(): string;
+    set host(newHost: string);
+    get port(): string;
+    set port(port: string);
+    get searchParams(): IURLSearchParams;
+    private isDefaultPort;
+}

package/lib/http/utils/UrlImpl.js

@@ -0,0 +1,54 @@
+import { URL_REGEX } from '../../utils';
+import { URLUtils } from './URLUtils';
+export class UrlImpl {
+    protocol;
+    hostname;
+    pathname;
+    search;
+    hash;
+    _port;
+    constructor(rawUrl) {
+        const match = rawUrl.match(URL_REGEX);
+        if (!match) {
+            throw new Error(`Invalid UrlImpl: ${rawUrl}`);
+        }
+        this.protocol = match[1];
+        this.hostname = match[3];
+        this.port = match[4] || '';
+        this.pathname = match[5] || '/';
+        this.search = match[6] || '';
+        this.hash = match[7] || '';
+    }
+    get href() {
+        return `${this.origin}${this.pathname}${this.search}${this.hash}`;
+    }
+    get origin() {
+        return `${this.protocol}//${this.host}`;
+    }
+    get host() {
+        return `${this.hostname}${this.port ? `:${this.port}` : ''}`;
+    }
+    set host(newHost) {
+        const [host, port] = newHost.split(':');
+        this.hostname = host;
+        this.port = port;
+    }
+    get port() {
+        return this._port;
+    }
+    set port(port) {
+        if (port) {
+            this._port = this.isDefaultPort(port) ? '' : port;
+        }
+    }
+    get searchParams() {
+        return URLUtils.parseSearchParams(this.search);
+    }
+    isDefaultPort(port) {
+        const PROTOCOL_TO_DEFAULT_PORT = {
+            'https:': '443',
+            'http:': '80',
+        };
+        return PROTOCOL_TO_DEFAULT_PORT[this.protocol] === port;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { IURLSearchParams } from '../interfaces';
+export declare class UrlSearchParamsImpl implements IURLSearchParams {
+    private _searchParamsArray;
+    private _searchParamsMap;
+    constructor(init?: string | Record<string, string | string[]> | [string, string][]);
+    append(name: string, value: any): void;
+    delete(name: string): void;
+    forEach(callback: (value: string, key: string, params?: IURLSearchParams, thisArg?: any) => void): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string): boolean;
+    set(name: string, value: any): void;
+    toString(): string;
+    private _constructSearchParamsFromString;
+    private _constructSearchParamsFromArray;
+    private _constructSearchParamsFromObject;
+    private _saveParam;
+    private _storeParamInSearchParamsMap;
+}