perimeterx-js-core 0.7.1 → 0.8.0

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;
+}

package/lib/http/utils/UrlSearchParamsImpl.js

@@ -0,0 +1,116 @@
+// This file is based on the implementation found here:
+// https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/80.implement-your-own-URLSearchParams.md
+import { URLUtils } from './URLUtils';
+export class UrlSearchParamsImpl {
+    _searchParamsArray;
+    _searchParamsMap;
+    constructor(init) {
+        this._searchParamsArray = [];
+        this._searchParamsMap = new Map();
+        if (init) {
+            if (typeof init !== 'object') {
+                this._constructSearchParamsFromString(init);
+            }
+            else if (Array.isArray(init)) {
+                this._constructSearchParamsFromArray(init);
+            }
+            else {
+                this._constructSearchParamsFromObject(init);
+            }
+        }
+    }
+    append(name, value) {
+        name = String(name);
+        value = String(value);
+        this._saveParam(name, value);
+    }
+    delete(name) {
+        name = String(name);
+        this._searchParamsMap.delete(name);
+        this._searchParamsArray = this._searchParamsArray.filter((param) => param[0] !== name);
+    }
+    forEach(callback) {
+        this._searchParamsArray.forEach((param) => {
+            callback(param[1], param[0], this);
+        });
+    }
+    get(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value[0] : null;
+    }
+    getAll(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value : [];
+    }
+    has(name) {
+        name = String(name);
+        return this._searchParamsMap.has(name);
+    }
+    set(name, value) {
+        name = String(name);
+        value = String(value);
+        if (!this.has(name)) {
+            this.append(name, value);
+            return;
+        }
+        name = URLUtils.decodeUriComponent(name);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsMap.set(name, [value]);
+        const searchParamIdx = this._searchParamsArray.findIndex((param) => param[0] === name);
+        this._searchParamsArray[searchParamIdx][1] = value;
+        this._searchParamsArray = this._searchParamsArray.filter((param, idx) => param[0] !== name || idx === searchParamIdx);
+    }
+    toString() {
+        return this._searchParamsArray
+            .map(([key, value]) => `${URLUtils.encodeUriComponent(key)}=${URLUtils.encodeUriComponent(value)}`)
+            .join('&');
+    }
+    _constructSearchParamsFromString(init) {
+        let searchParams = String(init);
+        if (searchParams.startsWith('?')) {
+            searchParams = searchParams.slice(1);
+        }
+        searchParams.split('&').forEach((param) => {
+            let [key, value] = param.split('=');
+            if (!value) {
+                value = '';
+            }
+            this._saveParam(key, value);
+        });
+    }
+    _constructSearchParamsFromArray(init) {
+        for (const param of init) {
+            if (!Array.isArray(param || param.length !== 2)) {
+                throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+            }
+            const key = String(param[0]);
+            const value = String(param[1]);
+            this._saveParam(key, value);
+        }
+    }
+    _constructSearchParamsFromObject(init) {
+        if (init instanceof Set) {
+            throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+        }
+        for (const key of Object.keys(init)) {
+            const value = String(init[key]);
+            this._saveParam(key, value);
+        }
+    }
+    _saveParam(key, value) {
+        key = URLUtils.decodeUriComponent(key);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsArray.push([key, value]);
+        this._storeParamInSearchParamsMap(key, value);
+    }
+    _storeParamInSearchParamsMap(key, value) {
+        let values = this._searchParamsMap.get(key);
+        if (!values) {
+            values = [];
+            this._searchParamsMap.set(key, values);
+        }
+        values.push(value);
+    }
+}

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

@@ -3,3 +3,9 @@ export * from './constants';
 export * from './HttpMethod';
 export * from './MinimalResponseUtils';
 export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/http/utils/index.js

@@ -3,3 +3,9 @@ export * from './constants';
 export * from './HttpMethod';
 export * from './MinimalResponseUtils';
 export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/{utils → impl}/base64/AtobBase64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class AtobBase64Utils implements IBase64Utils {
     base64Decode(stringToDecode: string): string;
     base64Encode(stringToEncode: string): string;

package/lib/{utils → impl}/base64/BufferBase64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class BufferBase64Utils implements IBase64Utils {
     static BASE_64_ENCODING: 'base64';
     base64Decode(stringToDecode: string): string;

package/lib/{utils → impl}/base64/BufferBase64Utils.js

@@ -1,4 +1,5 @@
 export class BufferBase64Utils {
+    static BASE_64_ENCODING = 'base64';
     base64Decode(stringToDecode) {
         const buffer = Buffer.from(stringToDecode, BufferBase64Utils.BASE_64_ENCODING);
         return buffer.toString('utf8');
@@ -8,4 +9,3 @@ export class BufferBase64Utils {
         return buffer.toString(BufferBase64Utils.BASE_64_ENCODING);
     }
 }
-BufferBase64Utils.BASE_64_ENCODING = 'base64';

package/lib/{utils → impl}/base64/JSBase64Base64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class JSBase64Base64Utils implements IBase64Utils {
     base64Encode(stringToEncode: string): string;
     base64Decode(stringToDecode: string): string;

package/lib/{utils → impl}/cipher/CryptoCipherUtils.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import * as crypto from 'crypto';
-import { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+import { ICipherUtils, Pbkdf2DecryptOptions } from '../../utils';
 declare type CryptoModule = typeof crypto;
 export declare class CryptoCipherUtils implements ICipherUtils {
     private crypto;

package/lib/impl/cipher/CryptoCipherUtils.js

@@ -0,0 +1,18 @@
+import * as crypto from 'crypto';
+export class CryptoCipherUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    async pbkdf2Decrypt(secret, encryptedString, iterations, salt, options) {
+        const keylen = options?.keylen || 32;
+        const ivlen = options?.ivlen || 16;
+        const derivation = this.crypto.pbkdf2Sync(secret, Buffer.from(salt, 'base64'), iterations, keylen + ivlen, 'sha256');
+        const key = derivation.subarray(0, keylen);
+        const iv = derivation.subarray(keylen);
+        const cipher = this.crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = cipher.update(encryptedString, 'base64', 'utf8');
+        decrypted += cipher.final('utf8');
+        return decrypted;
+    }
+}

package/lib/{utils → impl}/cipher/SubtleCryptoCipherUtils.d.ts

@@ -1,5 +1,4 @@
-import { IBase64Utils } from '../base64';
-import { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+import { ICipherUtils, IBase64Utils, Pbkdf2DecryptOptions } from '../../utils';
 export declare class SubtleCryptoCipherUtils implements ICipherUtils {
     private base64Utils;
     private subtleCrypto;