perimeterx-js-core 0.7.1 → 0.9.0

package/lib/cjs/http/utils/OutgoingRequestImpl.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutgoingRequestImpl = void 0;
+var index_1 = require("../index");
+var OutgoingRequestImpl = /** @class */ (function () {
+    function OutgoingRequestImpl(options) {
+        this.url = options.url;
+        this.method = options.method || index_1.HttpMethod.GET;
+        this.headers = options.headers || {};
+        this.body = options.body;
+    }
+    return OutgoingRequestImpl;
+}());
+exports.OutgoingRequestImpl = OutgoingRequestImpl;

package/lib/cjs/http/utils/URLUtils.js

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

package/lib/cjs/http/utils/UrlImpl.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlImpl = void 0;
+var utils_1 = require("../../utils");
+var URLUtils_1 = require("./URLUtils");
+var UrlImpl = /** @class */ (function () {
+    function UrlImpl(rawUrl) {
+        var match = rawUrl.match(utils_1.URL_REGEX);
+        if (!match) {
+            throw new Error("Invalid UrlImpl: ".concat(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] || '';
+    }
+    Object.defineProperty(UrlImpl.prototype, "href", {
+        get: function () {
+            return "".concat(this.origin).concat(this.pathname).concat(this.search).concat(this.hash);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UrlImpl.prototype, "origin", {
+        get: function () {
+            return "".concat(this.protocol, "//").concat(this.host);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UrlImpl.prototype, "host", {
+        get: function () {
+            return "".concat(this.hostname).concat(this.port ? ":".concat(this.port) : '');
+        },
+        set: function (newHost) {
+            var _a = newHost.split(':'), host = _a[0], port = _a[1];
+            this.hostname = host;
+            this.port = port;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UrlImpl.prototype, "port", {
+        get: function () {
+            return this._port;
+        },
+        set: function (port) {
+            if (port) {
+                this._port = this.isDefaultPort(port) ? '' : port;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UrlImpl.prototype, "searchParams", {
+        get: function () {
+            return URLUtils_1.URLUtils.parseSearchParams(this.search);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    UrlImpl.prototype.isDefaultPort = function (port) {
+        var PROTOCOL_TO_DEFAULT_PORT = {
+            'https:': '443',
+            'http:': '80',
+        };
+        return PROTOCOL_TO_DEFAULT_PORT[this.protocol] === port;
+    };
+    return UrlImpl;
+}());
+exports.UrlImpl = UrlImpl;

package/lib/cjs/http/utils/UrlSearchParamsImpl.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlSearchParamsImpl = void 0;
+// This file is based on the implementation found here:
+// https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/80.implement-your-own-URLSearchParams.md
+var URLUtils_1 = require("./URLUtils");
+var UrlSearchParamsImpl = /** @class */ (function () {
+    function UrlSearchParamsImpl(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);
+            }
+        }
+    }
+    UrlSearchParamsImpl.prototype.append = function (name, value) {
+        name = String(name);
+        value = String(value);
+        this._saveParam(name, value);
+    };
+    UrlSearchParamsImpl.prototype.delete = function (name) {
+        name = String(name);
+        this._searchParamsMap.delete(name);
+        this._searchParamsArray = this._searchParamsArray.filter(function (param) { return param[0] !== name; });
+    };
+    UrlSearchParamsImpl.prototype.forEach = function (callback) {
+        var _this = this;
+        this._searchParamsArray.forEach(function (param) {
+            callback(param[1], param[0], _this);
+        });
+    };
+    UrlSearchParamsImpl.prototype.get = function (name) {
+        name = String(name);
+        var value = this._searchParamsMap.get(name);
+        return value ? value[0] : null;
+    };
+    UrlSearchParamsImpl.prototype.getAll = function (name) {
+        name = String(name);
+        var value = this._searchParamsMap.get(name);
+        return value ? value : [];
+    };
+    UrlSearchParamsImpl.prototype.has = function (name) {
+        name = String(name);
+        return this._searchParamsMap.has(name);
+    };
+    UrlSearchParamsImpl.prototype.set = function (name, value) {
+        name = String(name);
+        value = String(value);
+        if (!this.has(name)) {
+            this.append(name, value);
+            return;
+        }
+        name = URLUtils_1.URLUtils.decodeUriComponent(name);
+        value = URLUtils_1.URLUtils.decodeUriComponent(value);
+        this._searchParamsMap.set(name, [value]);
+        var searchParamIdx = this._searchParamsArray.findIndex(function (param) { return param[0] === name; });
+        this._searchParamsArray[searchParamIdx][1] = value;
+        this._searchParamsArray = this._searchParamsArray.filter(function (param, idx) { return param[0] !== name || idx === searchParamIdx; });
+    };
+    UrlSearchParamsImpl.prototype.toString = function () {
+        return this._searchParamsArray
+            .map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return "".concat(URLUtils_1.URLUtils.encodeUriComponent(key), "=").concat(URLUtils_1.URLUtils.encodeUriComponent(value));
+        })
+            .join('&');
+    };
+    UrlSearchParamsImpl.prototype._constructSearchParamsFromString = function (init) {
+        var _this = this;
+        var searchParams = String(init);
+        if (searchParams.startsWith('?')) {
+            searchParams = searchParams.slice(1);
+        }
+        searchParams.split('&').forEach(function (param) {
+            var _a = param.split('='), key = _a[0], value = _a[1];
+            if (!value) {
+                value = '';
+            }
+            _this._saveParam(key, value);
+        });
+    };
+    UrlSearchParamsImpl.prototype._constructSearchParamsFromArray = function (init) {
+        for (var _i = 0, init_1 = init; _i < init_1.length; _i++) {
+            var param = init_1[_i];
+            if (!Array.isArray(param || param.length !== 2)) {
+                throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+            }
+            var key = String(param[0]);
+            var value = String(param[1]);
+            this._saveParam(key, value);
+        }
+    };
+    UrlSearchParamsImpl.prototype._constructSearchParamsFromObject = function (init) {
+        if (init instanceof Set) {
+            throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+        }
+        for (var _i = 0, _a = Object.keys(init); _i < _a.length; _i++) {
+            var key = _a[_i];
+            var value = String(init[key]);
+            this._saveParam(key, value);
+        }
+    };
+    UrlSearchParamsImpl.prototype._saveParam = function (key, value) {
+        key = URLUtils_1.URLUtils.decodeUriComponent(key);
+        value = URLUtils_1.URLUtils.decodeUriComponent(value);
+        this._searchParamsArray.push([key, value]);
+        this._storeParamInSearchParamsMap(key, value);
+    };
+    UrlSearchParamsImpl.prototype._storeParamInSearchParamsMap = function (key, value) {
+        var values = this._searchParamsMap.get(key);
+        if (!values) {
+            values = [];
+            this._searchParamsMap.set(key, values);
+        }
+        values.push(value);
+    };
+    return UrlSearchParamsImpl;
+}());
+exports.UrlSearchParamsImpl = UrlSearchParamsImpl;

package/lib/cjs/http/utils/constants.js

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

package/lib/cjs/http/utils/index.js

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

package/lib/cjs/impl/base64/AtobBase64Utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtobBase64Utils = void 0;
+var AtobBase64Utils = /** @class */ (function () {
+    function AtobBase64Utils() {
+    }
+    AtobBase64Utils.prototype.base64Decode = function (stringToDecode) {
+        return atob(stringToDecode);
+    };
+    AtobBase64Utils.prototype.base64Encode = function (stringToEncode) {
+        return btoa(stringToEncode);
+    };
+    return AtobBase64Utils;
+}());
+exports.AtobBase64Utils = AtobBase64Utils;

package/lib/cjs/impl/base64/BufferBase64Utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferBase64Utils = void 0;
+var BufferBase64Utils = exports.BufferBase64Utils = /** @class */ (function () {
+    function BufferBase64Utils() {
+    }
+    BufferBase64Utils.prototype.base64Decode = function (stringToDecode) {
+        var buffer = Buffer.from(stringToDecode, BufferBase64Utils.BASE_64_ENCODING);
+        return buffer.toString('utf8');
+    };
+    BufferBase64Utils.prototype.base64Encode = function (stringToEncode) {
+        var buffer = Buffer.from(stringToEncode, 'utf8');
+        return buffer.toString(BufferBase64Utils.BASE_64_ENCODING);
+    };
+    BufferBase64Utils.BASE_64_ENCODING = 'base64';
+    return BufferBase64Utils;
+}());

package/lib/cjs/impl/base64/JSBase64Base64Utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSBase64Base64Utils = void 0;
+var js_base64_1 = require("js-base64");
+var JSBase64Base64Utils = /** @class */ (function () {
+    function JSBase64Base64Utils() {
+    }
+    JSBase64Base64Utils.prototype.base64Encode = function (stringToEncode) {
+        return (0, js_base64_1.encode)(stringToEncode);
+    };
+    JSBase64Base64Utils.prototype.base64Decode = function (stringToDecode) {
+        return (0, js_base64_1.decode)(stringToDecode);
+    };
+    return JSBase64Base64Utils;
+}());
+exports.JSBase64Base64Utils = JSBase64Base64Utils;

package/lib/cjs/impl/cipher/CryptoCipherUtils.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoCipherUtils = void 0;
+var crypto = __importStar(require("crypto"));
+var CryptoCipherUtils = /** @class */ (function () {
+    function CryptoCipherUtils(cryptoModule) {
+        if (cryptoModule === void 0) { cryptoModule = crypto; }
+        this.crypto = cryptoModule;
+    }
+    CryptoCipherUtils.prototype.pbkdf2Decrypt = function (secret, encryptedString, iterations, salt, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keylen, ivlen, derivation, key, iv, cipher, decrypted;
+            return __generator(this, function (_a) {
+                keylen = (options === null || options === void 0 ? void 0 : options.keylen) || 32;
+                ivlen = (options === null || options === void 0 ? void 0 : options.ivlen) || 16;
+                derivation = this.crypto.pbkdf2Sync(secret, Buffer.from(salt, 'base64'), iterations, keylen + ivlen, 'sha256');
+                key = derivation.subarray(0, keylen);
+                iv = derivation.subarray(keylen);
+                cipher = this.crypto.createDecipheriv('aes-256-cbc', key, iv);
+                decrypted = cipher.update(encryptedString, 'base64', 'utf8');
+                decrypted += cipher.final('utf8');
+                return [2 /*return*/, decrypted];
+            });
+        });
+    };
+    return CryptoCipherUtils;
+}());
+exports.CryptoCipherUtils = CryptoCipherUtils;

package/lib/cjs/impl/cipher/SubtleCryptoCipherUtils.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubtleCryptoCipherUtils = void 0;
+var SubtleCryptoCipherUtils = /** @class */ (function () {
+    function SubtleCryptoCipherUtils(base64Utils, subtleCrypto) {
+        if (subtleCrypto === void 0) { subtleCrypto = crypto.subtle; }
+        this.subtleCrypto = subtleCrypto;
+        this.base64Utils = base64Utils;
+    }
+    SubtleCryptoCipherUtils.prototype.pbkdf2Decrypt = function (secret, encryptedString, iterations, salt, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ivlen, keylen, bitsLength, encodedPassword, encodedSalt, importedKey, params, derivation, derivedKey, iv, cookieBuffer, importedDecryptionKey, decrypted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ivlen = (options === null || options === void 0 ? void 0 : options.ivlen) || 16;
+                        keylen = (options === null || options === void 0 ? void 0 : options.keylen) || 32;
+                        bitsLength = (ivlen + keylen) * 8;
+                        encodedPassword = new TextEncoder().encode(secret);
+                        encodedSalt = this.base64ToArrayBuffer(salt);
+                        return [4 /*yield*/, this.subtleCrypto.importKey('raw', encodedPassword, 'PBKDF2', false, ['deriveBits'])];
+                    case 1:
+                        importedKey = _a.sent();
+                        params = { name: 'PBKDF2', hash: 'SHA-256', salt: encodedSalt, iterations: iterations };
+                        return [4 /*yield*/, this.subtleCrypto.deriveBits(params, importedKey, bitsLength)];
+                    case 2:
+                        derivation = _a.sent();
+                        derivedKey = derivation.slice(0, keylen);
+                        iv = derivation.slice(keylen);
+                        cookieBuffer = this.base64ToArrayBuffer(encryptedString);
+                        return [4 /*yield*/, this.subtleCrypto.importKey('raw', derivedKey, { name: 'AES-CBC' }, false, [
+                                'decrypt',
+                            ])];
+                    case 3:
+                        importedDecryptionKey = _a.sent();
+                        return [4 /*yield*/, this.subtleCrypto.decrypt({
+                                name: 'AES-CBC',
+                                iv: iv,
+                            }, importedDecryptionKey, cookieBuffer)];
+                    case 4:
+                        decrypted = _a.sent();
+                        return [2 /*return*/, new TextDecoder('utf-8').decode(decrypted)];
+                }
+            });
+        });
+    };
+    SubtleCryptoCipherUtils.prototype.base64ToArrayBuffer = function (base64String) {
+        var binaryString = this.base64Utils.base64Decode(base64String);
+        var length = binaryString.length;
+        var bytes = new Uint8Array(length);
+        binaryString.split('').forEach(function (char, index) {
+            bytes[index] = char.charCodeAt(0);
+        });
+        return bytes.buffer;
+    };
+    return SubtleCryptoCipherUtils;
+}());
+exports.SubtleCryptoCipherUtils = SubtleCryptoCipherUtils;

package/lib/cjs/impl/hash/CryptoHashUtils.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoHashUtils = void 0;
+var crypto = __importStar(require("crypto"));
+var CryptoHashUtils = /** @class */ (function () {
+    function CryptoHashUtils(cryptoModule) {
+        if (cryptoModule === void 0) { cryptoModule = crypto; }
+        this.crypto = cryptoModule;
+    }
+    CryptoHashUtils.prototype.hashString = function (text, algo) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.crypto.createHash(algo).update(text).digest('hex')];
+            });
+        });
+    };
+    return CryptoHashUtils;
+}());
+exports.CryptoHashUtils = CryptoHashUtils;

package/lib/cjs/impl/hash/CryptoJSHashUtils.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoJSHashUtils = void 0;
+var crypto_js_1 = __importDefault(require("crypto-js"));
+var utils_1 = require("../../utils");
+var CryptoJSHashUtils = /** @class */ (function () {
+    function CryptoJSHashUtils() {
+    }
+    CryptoJSHashUtils.prototype.hashString = function (text, algo) {
+        switch (algo) {
+            case utils_1.Algorithm.SHA256:
+                return crypto_js_1.default.SHA256(text).toString(crypto_js_1.default.enc.Hex);
+            default:
+                return null;
+        }
+    };
+    return CryptoJSHashUtils;
+}());
+exports.CryptoJSHashUtils = CryptoJSHashUtils;