perimeterx-js-core 0.6.1 → 0.6.2

package/README.md

@@ -122,6 +122,7 @@ are provided:
 
 `IHashUtils` - Represents a hashing utility that is required by Credential Intelligence. The following implementations are provided:
 * `CryptoHashUtils`, which relies on the native NodeJS `crypto` package.
+* `CryptoJSHashUtils`, which uses the `crypto-js` dependency.
 * `SubtleCryptoHashUtils`, which relies on an object implementing the `SubtleCrypto` interface. By default, it is assumed that the global `crypto.subtle` implements this interface.
 
 

package/lib/action/ProductAction.d.ts

@@ -0,0 +1,5 @@
+import { ActionData } from './ActionData';
+import { ProductName } from '../products';
+export declare type ProductAction = ActionData & {
+    productName: ProductName;
+};

package/lib/action/ProductAction.js

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

package/lib/action/index.d.ts

@@ -2,3 +2,5 @@ export * from './Action';
 export * from './ActionData';
 export * from './ActionPriorityOrder';
 export * from './Decision';
+export * from './ProductAction';
+export * from './utils';

package/lib/action/index.js

@@ -2,3 +2,5 @@ export * from './Action';
 export * from './ActionData';
 export * from './ActionPriorityOrder';
 export * from './Decision';
+export * from './ProductAction';
+export * from './utils';

package/lib/action/utils.d.ts

@@ -0,0 +1,6 @@
+import { Decision } from './Decision';
+import { IContext } from '../context';
+import { ProductAction } from './ProductAction';
+export declare const getDecisionFromContext: <Req, Res>(context: IContext<Req, Res>) => Decision;
+export declare const getProductActions: <Req, Res>(context: IContext<Req, Res>) => ProductAction[];
+export declare const getDecisionFromActions: (productActions: ProductAction[]) => Decision;

package/lib/action/utils.js

@@ -0,0 +1,34 @@
+import { Action } from './Action';
+import { ACTION_PRIORITY_ORDER } from './ActionPriorityOrder';
+export const getDecisionFromContext = (context) => {
+    return getDecisionFromActions(getProductActions(context));
+};
+export const getProductActions = (context) => {
+    return Object.entries(context.productData)
+        .filter(([_, data]) => (data === null || data === void 0 ? void 0 : data.action) != null && (data === null || data === void 0 ? void 0 : data.reason) != null)
+        .map(([productName, data]) => ({
+        action: data.action,
+        reason: data.reason,
+        productName: productName,
+    }));
+};
+export const getDecisionFromActions = (productActions) => {
+    return createDecision(reduce(productActions));
+};
+const reduce = (actions) => {
+    return actions.reduce((tally, { action, reason, productName }) => {
+        if (!tally[action]) {
+            tally[action] = {};
+        }
+        tally[action][productName] = reason;
+        return tally;
+    }, {});
+};
+const createDecision = (tally) => {
+    for (const action of ACTION_PRIORITY_ORDER) {
+        if (tally[action]) {
+            return { action, reasons: tally[action] };
+        }
+    }
+    return { action: Action.PASS_REQUEST };
+};

package/lib/activities/HttpActivityClient.js

@@ -62,9 +62,9 @@ export class HttpActivityClient {
             };
             const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
             this.config.logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
-            const req = new OutgoingRequestImpl({ url: url, method: method, headers: headers, body: body });
-            const status = yield this.httpClient.send(req).then((resp) => resp.status);
-            return status === 200;
+            const req = new OutgoingRequestImpl({ url, method, headers, body });
+            const res = yield this.httpClient.send(req);
+            return (res === null || res === void 0 ? void 0 : res.status) === 200;
         });
     }
 }

package/lib/activities/IActivityClient.d.ts

@@ -1,8 +1,9 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
 export interface IActivityClient<Req, Res> {
     /**
      * @param context - The request context.
      * @returns Promise<boolean> - Whether sending the activities was successful or not.
      */
-    sendActivities(context: ReadonlyContext<Req, Res>): Promise<boolean>;
+    sendActivities(context: ReadonlyContext<Req, Res>): AsyncOrSync<boolean>;
 }

package/lib/additional_activity_handler/AdditionalActivityHandler.d.ts

@@ -1,3 +1,3 @@
 import { ConfigurationParams } from '../config';
 import { ReadonlyContext } from '../context';
-export declare type AdditionalActivityHandler = <Req, Res>(config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>) => void | Promise<void>;
+export declare type AdditionalActivityHandler = <Req, Res>(config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>, request: Req) => void | Promise<void>;

package/lib/additional_activity_handler/AdditionalActivityHandlerUtils.js

@@ -12,7 +12,7 @@ export var AdditionalActivityHandlerUtils;
     AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler = (config, context) => __awaiter(this, void 0, void 0, function* () {
         if (config.additionalActivityHandler && typeof config.additionalActivityHandler === 'function') {
             try {
-                yield config.additionalActivityHandler(config.toParams(), context);
+                yield config.additionalActivityHandler(config.toParams(), context, context.requestData.request.getUnderlyingRequest());
             }
             catch (e) {
                 config.logger.error(`caught additional activity handler error - ${e}`);

package/lib/cors/ICors.d.ts

@@ -1,6 +1,6 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
-import { IMinimalResponse } from '../http';
-import { ReadonlyHeaders } from '../http';
+import { IMinimalResponse, ReadonlyHeaders } from '../http';
 export interface ICors<Req, Res> {
     /**
      * @param context
@@ -11,7 +11,7 @@ export interface ICors<Req, Res> {
      * @param context- The request context.
      * @returns IMinimalResponse- The response that return to client for preflight request.
      */
-    runPreflightCustomHandler(context: ReadonlyContext<Req, Res>): Promise<IMinimalResponse> | null;
+    runPreflightCustomHandler(context: ReadonlyContext<Req, Res>): AsyncOrSync<IMinimalResponse> | null;
     /**
      * @param context- The request context.
      * @returns boolean - Whether the request is CORS.
@@ -22,5 +22,5 @@ export interface ICors<Req, Res> {
      * @param context - The request context.
      * @returns ReadOnlyHeaders - headers to be added to the block response.
      */
-    getCorsBlockHeaders(context: ReadonlyContext<Req, Res>): Promise<ReadonlyHeaders>;
+    getCorsBlockHeaders(context: ReadonlyContext<Req, Res>): AsyncOrSync<ReadonlyHeaders>;
 }

package/lib/filter/FilterReason.d.ts

@@ -5,5 +5,6 @@ export declare enum FilterReason {
     HTTP_METHOD = "http_method",
     USER_AGENT = "user_agent",
     IP = "ip",
-    TELEMETRY_REQUEST = "telemetry_request"
+    TELEMETRY_REQUEST = "telemetry_request",
+    CORS_PREFLIGHT_REQUEST = "cors_preflight_request"
 }

package/lib/filter/FilterReason.js

@@ -7,4 +7,5 @@ export var FilterReason;
     FilterReason["USER_AGENT"] = "user_agent";
     FilterReason["IP"] = "ip";
     FilterReason["TELEMETRY_REQUEST"] = "telemetry_request";
+    FilterReason["CORS_PREFLIGHT_REQUEST"] = "cors_preflight_request";
 })(FilterReason || (FilterReason = {}));

package/lib/first_party/IFirstParty.d.ts

@@ -1,3 +1,4 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
 import { FirstPartyData } from './FirstPartyData';
 export interface IFirstParty<Req, Res> {
@@ -5,5 +6,5 @@ export interface IFirstParty<Req, Res> {
      * @param context - The request context
      * @returns Promise<FirstPartyData | null> - If the request is not a first party request, it will return null.
      */
-    handleFirstPartyRequest(context: ReadonlyContext<Req, Res>): Promise<FirstPartyData | null>;
+    handleFirstPartyRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<FirstPartyData | null>;
 }

package/lib/graphql/IGraphQLParser.d.ts

@@ -1,6 +1,7 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
 import { GraphQLData } from './model';
 export interface IGraphQLParser<Req, Res> {
     isGraphQLRequest(context: ReadonlyContext<Req, Res>): boolean;
-    parseGraphQLRequest(context: ReadonlyContext<Req, Res>): Promise<GraphQLData[]>;
+    parseGraphQLRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<GraphQLData[]>;
 }

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

@@ -1,8 +1,9 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { IOutgoingRequest } from './IOutgoingRequest';
 import { IIncomingResponse } from './IIncomingResponse';
 export declare type HttpSendOptions = {
     timeoutMs?: number;
 };
 export interface IHttpClient {
-    send(request: IOutgoingRequest, options?: HttpSendOptions): Promise<IIncomingResponse>;
+    send(request: IOutgoingRequest, options?: HttpSendOptions): AsyncOrSync<IIncomingResponse>;
 }

package/lib/phase/IPhase.d.ts

@@ -1,5 +1,6 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { IContext } from '../context';
 import { PhaseResult } from './PhaseResult';
 export interface IPhase<Req, Res> {
-    execute(context: IContext<Req, Res>): Promise<PhaseResult>;
+    execute(context: IContext<Req, Res>): AsyncOrSync<PhaseResult>;
 }

package/lib/phase/impl/DecideActionPhase.d.ts

@@ -1,19 +1,10 @@
 import { IConfiguration } from '../../config';
 import { IContext } from '../../context';
-import { ProductName } from '../../products';
-import { Action, ActionData, Decision } from '../../action';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
-declare type ProductAction = ActionData & {
-    productName: ProductName;
-};
 export declare abstract class DecideActionPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly config: IConfiguration<Req, Res>;
     protected constructor(config: IConfiguration<Req, Res>);
     abstract execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected updateContextDecision(context: IContext<Req, Res>): Promise<void>;
-    protected getProductActions(context: IContext<Req, Res>): ProductAction[];
-    protected reduce(actions: ProductAction[]): Partial<Record<Action, Partial<Record<ProductName, string>>>>;
-    protected createDecision(tally: Partial<Record<Action, Partial<Record<ProductName, string>>>>): Decision;
 }
-export {};

package/lib/phase/impl/DecideActionPhase.js

@@ -7,16 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Action, ACTION_PRIORITY_ORDER } from '../../action';
 import { LoggerSeverity } from '../../logger';
+import { getDecisionFromContext } from '../../action';
 export class DecideActionPhase {
     constructor(config) {
         this.config = config;
     }
     updateContextDecision(context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const actions = this.getProductActions(context);
-            const { action, reasons } = this.createDecision(this.reduce(actions));
+            const { action, reasons } = getDecisionFromContext(context);
             if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
                 const productReasons = Object.entries(reasons)
                     .map(([prod, reason]) => `${prod} -> ${reason}`)
@@ -27,30 +26,4 @@ export class DecideActionPhase {
             context.reasons = reasons;
         });
     }
-    getProductActions(context) {
-        return Object.entries(context.productData)
-            .filter(([_, data]) => (data === null || data === void 0 ? void 0 : data.action) != null && (data === null || data === void 0 ? void 0 : data.reason) != null)
-            .map(([productName, data]) => ({
-            action: data.action,
-            reason: data.reason,
-            productName: productName,
-        }));
-    }
-    reduce(actions) {
-        return actions.reduce((tally, { action, reason, productName }) => {
-            if (!tally[action]) {
-                tally[action] = {};
-            }
-            tally[action][productName] = reason;
-            return tally;
-        }, {});
-    }
-    createDecision(tally) {
-        for (const action of ACTION_PRIORITY_ORDER) {
-            if (tally[action]) {
-                return { action, reasons: tally[action] };
-            }
-        }
-        return { action: Action.PASS_REQUEST };
-    }
 }

package/lib/products/credential_intelligence/endpoint/ICredentialEndpoint.d.ts

@@ -1,9 +1,9 @@
-import { DeepReadonly } from 'ts-essentials';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import { IIncomingRequest, IOutgoingResponse } from '../../../http';
 import { RequestData } from '../../../context';
 import { CredentialData } from '../model';
 export interface ICredentialEndpoint<Req, Res> {
     matches(requestData: DeepReadonly<RequestData<Req>>): boolean;
-    getCredentialData(request: DeepReadonly<IIncomingRequest<Req>>): Promise<CredentialData>;
-    isLoginSuccessful(response: DeepReadonly<IOutgoingResponse<Res>>): Promise<boolean>;
+    getCredentialData(request: DeepReadonly<IIncomingRequest<Req>>): AsyncOrSync<CredentialData>;
+    isLoginSuccessful(response: DeepReadonly<IOutgoingResponse<Res>>): AsyncOrSync<boolean>;
 }

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

@@ -6,5 +6,5 @@ export declare class HeaderCredentialExtractor<Req> implements ICredentialExtrac
     protected readonly userField: string;
     protected readonly passField: string;
     constructor(userField: string, passField: string);
-    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): Promise<Credentials | null>;
+    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): Credentials | null;
 }

package/lib/products/credential_intelligence/endpoint/extractor/HeaderCredentialExtractor.js

@@ -1,22 +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());
-    });
-};
 export class HeaderCredentialExtractor {
     constructor(userField, passField) {
         this.userField = userField;
         this.passField = passField;
     }
     extractCredentials(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = request.headers.get(this.userField);
-            const pass = request.headers.get(this.passField);
-            return typeof user === 'string' || typeof pass === 'string' ? { user, pass } : null;
-        });
+        const user = request.headers.get(this.userField);
+        const pass = request.headers.get(this.passField);
+        return typeof user === 'string' || typeof pass === 'string' ? { user, pass } : null;
     }
 }

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

@@ -1,6 +1,6 @@
-import { DeepReadonly } from 'ts-essentials';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import { IIncomingRequest } from '../../../../http';
 import { Credentials } from '../../model';
 export interface ICredentialExtractor<Req> {
-    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): Promise<Credentials | null>;
+    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): AsyncOrSync<Credentials | null>;
 }

package/lib/products/credential_intelligence/endpoint/hash_protocol/ICredentialIntelligenceHashProtocol.d.ts

@@ -1,5 +1,5 @@
-import { CredentialData } from '../../model';
-import { Credentials } from '../../model/Credentials';
+import { AsyncOrSync } from 'ts-essentials';
+import { CredentialData, Credentials } from '../../model';
 export interface ICredentialIntelligenceHashProtocol {
-    hashCredentials(credentials: Credentials): Promise<CredentialData>;
+    hashCredentials(credentials: Credentials): AsyncOrSync<CredentialData>;
 }

package/lib/products/credential_intelligence/endpoint/login_successful/ILoginSuccessfulParser.d.ts

@@ -1,4 +1,5 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { IOutgoingResponse } from '../../../../http';
 export interface ILoginSuccessfulParser<Res> {
-    isLoginSuccessful(response: IOutgoingResponse<Res>): Promise<boolean>;
+    isLoginSuccessful(response: IOutgoingResponse<Res>): AsyncOrSync<boolean>;
 }

package/lib/products/interfaces/IProduct.d.ts

@@ -1,10 +1,11 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../../context';
 import { ProductName } from '../utils';
 import { ProductDataType } from './ProductDataType';
 export interface IProduct<Name extends ProductName, Req, Res> {
-    enrichContextFromRequest(context: ReadonlyContext<Req, Res>): Promise<ProductDataType<Name>>;
-    enrichContextFromRiskApi(context: ReadonlyContext<Req, Res>): Promise<Partial<ProductDataType<Name>>>;
-    modifyIncomingRequest(context: ReadonlyContext<Req, Res>): Promise<void>;
-    enrichContextFromResponse(context: ReadonlyContext<Req, Res>): Promise<Partial<ProductDataType<Name>>>;
-    modifyOutgoingResponse(context: ReadonlyContext<Req, Res>): Promise<void>;
+    enrichContextFromRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<ProductDataType<Name>>;
+    enrichContextFromRiskApi(context: ReadonlyContext<Req, Res>): AsyncOrSync<Partial<ProductDataType<Name>>>;
+    modifyIncomingRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
+    enrichContextFromResponse(context: ReadonlyContext<Req, Res>): AsyncOrSync<Partial<ProductDataType<Name>>>;
+    modifyOutgoingResponse(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
 }

package/lib/pxde/IDataEnrichment.d.ts

@@ -1,10 +1,11 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
-import { PxdeData } from './model/PxdeData';
+import { PxdeData } from './model';
 export interface IDataEnrichment<Req, Res> {
     /**
      * If the PXDE cookie is present on the request, parses it and enriches the context with its contents.
      * @param context - The request context.
      * @returns Promise<PxdeData|null>
      */
-    handlePxde(context: ReadonlyContext<Req, Res>): Promise<PxdeData | null>;
+    handlePxde(context: ReadonlyContext<Req, Res>): AsyncOrSync<PxdeData | null>;
 }

package/lib/risk_api/client/IRiskApiClient.d.ts

@@ -1,4 +1,5 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext, RiskApiData } from '../../context';
 export interface IRiskApiClient<Req, Res> {
-    executeRiskApi(context: ReadonlyContext<Req, Res>): Promise<RiskApiData>;
+    executeRiskApi(context: ReadonlyContext<Req, Res>): AsyncOrSync<RiskApiData>;
 }

package/lib/risk_api/model/RiskActivity.d.ts

@@ -40,7 +40,7 @@ export declare type RiskAdditionalData = {
     server_info_datacenter?: string;
     cross_tab_session?: string;
     app_user_id?: string;
-    jwt_additional_fields?: string[];
+    jwt_additional_fields?: Record<string, any>;
     graphql_operations?: GraphQLData[];
     user?: string;
     pass?: string;

package/lib/risk_token/parser/ITokenParser.d.ts

@@ -1,4 +1,5 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext, TokenData } from '../../context';
 export interface ITokenParser<Req, Res> {
-    parseToken(context: ReadonlyContext<Req, Res>): Promise<TokenData<Req, Res>>;
+    parseToken(context: ReadonlyContext<Req, Res>): AsyncOrSync<TokenData<Req, Res>>;
 }

package/lib/telemetry/ITelemetry.d.ts

@@ -1,13 +1,14 @@
+import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
 export interface ITelemetry<Req, Res> {
     /**
      * @param context - The request context.
      * @returns Promise<boolean> - A Promise resolving to a boolean that indicates whether the request is a valid telemetry request.
      */
-    isValidTelemetryRequest(context: ReadonlyContext<Req, Res>): Promise<boolean>;
+    isValidTelemetryRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<boolean>;
     /**
      * @param context - The request context.
      * @returns void
      */
-    sendTelemetry(context: ReadonlyContext<Req, Res>): Promise<void>;
+    sendTelemetry(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
 }

package/lib/utils/constants.d.ts

@@ -8,4 +8,4 @@ export declare const X_PX_AUTHORIZATION_HEADER_NAME = "x-px-authorization";
 export declare const X_PX_ORIGINAL_TOKEN_HEADER_NAME = "x-px-original-token";
 export declare const X_PX_BYPASS_REASON_HEADER_NAME = "x-px-bypass-reason";
 export declare const EMAIL_ADDRESS_REGEX: RegExp;
-export declare const CORE_MODULE_VERSION = "JS Core 0.6.1";
+export declare const CORE_MODULE_VERSION = "JS Core 0.6.2";

package/lib/utils/constants.js

@@ -8,4 +8,4 @@ export const X_PX_AUTHORIZATION_HEADER_NAME = 'x-px-authorization';
 export const X_PX_ORIGINAL_TOKEN_HEADER_NAME = 'x-px-original-token';
 export const X_PX_BYPASS_REASON_HEADER_NAME = 'x-px-bypass-reason';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.6.1';
+export const CORE_MODULE_VERSION = 'JS Core 0.6.2';

package/lib/utils/hash/CryptoJSHashUtils.d.ts

@@ -0,0 +1,5 @@
+import { IHashUtils } from './IHashUtils';
+import { Algorithm } from '../Algorithm';
+export declare class CryptoJSHashUtils implements IHashUtils {
+    hashString(text: string, algo: Algorithm): string;
+}

package/lib/utils/hash/CryptoJSHashUtils.js

@@ -0,0 +1,12 @@
+import cryptoJs from 'crypto-js';
+import { Algorithm } from '../Algorithm';
+export class CryptoJSHashUtils {
+    hashString(text, algo) {
+        switch (algo) {
+            case Algorithm.SHA256:
+                return cryptoJs.SHA256(text).toString(cryptoJs.enc.Hex);
+            default:
+                return null;
+        }
+    }
+}

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

@@ -1,3 +1,4 @@
 export * from './IHashUtils';
 export * from './SubtleCryptoHashUtils';
 export * from './CryptoHashUtils';
+export * from './CryptoJSHashUtils';

package/lib/utils/hash/index.js

@@ -1,3 +1,4 @@
 export * from './IHashUtils';
 export * from './SubtleCryptoHashUtils';
 export * from './CryptoHashUtils';
+export * from './CryptoJSHashUtils';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "",
   "main": "lib/index.js",
   "type": "module",
@@ -25,6 +25,7 @@
     "ip-range-check": "^0.2.0",
     "js-base64": "^3.7.2",
     "phin": "^3.7.0",
+    "ts-essentials": "^9.3.2",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
@@ -49,7 +50,6 @@
     "nyc": "^15.1.0",
     "prettier": "^2.7.1",
     "sinon": "^14.0.1",
-    "ts-essentials": "^9.3.2",
     "ts-loader": "^9.4.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.4.4"