@intlayer/backend 7.0.9-canary.0 → 7.0.9-canary.2

package/dist/cjs/node_modules/node-rsa/src/NodeRSA.cjs

@@ -0,0 +1,341 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_utils$1 = require('./utils.cjs');
+const require_schemes$1 = require('./schemes/schemes.cjs');
+const require_rsa$1 = require('./libs/rsa.cjs');
+const require_index = require('../../asn1/lib/index.cjs');
+const require_formats$1 = require('./formats/formats.cjs');
+
+//#region ../../node_modules/node-rsa/src/NodeRSA.js
+var require_NodeRSA = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/NodeRSA.js": ((exports, module) => {
+	/*!
+	* RSA library for Node.js
+	*
+	* Author: rzcoder
+	* License MIT
+	*/
+	var constants = require("constants");
+	var rsa = require_rsa$1.default;
+	require("crypto");
+	require_index.default.Ber;
+	var _ = require_utils$1.default._;
+	var utils = require_utils$1.default;
+	var schemes = require_schemes$1.default;
+	var formats = require_formats$1.default;
+	if (typeof constants.RSA_NO_PADDING === "undefined") constants.RSA_NO_PADDING = 3;
+	module.exports = (function() {
+		var SUPPORTED_HASH_ALGORITHMS = {
+			node10: [
+				"md4",
+				"md5",
+				"ripemd160",
+				"sha1",
+				"sha224",
+				"sha256",
+				"sha384",
+				"sha512"
+			],
+			node: [
+				"md4",
+				"md5",
+				"ripemd160",
+				"sha1",
+				"sha224",
+				"sha256",
+				"sha384",
+				"sha512"
+			],
+			iojs: [
+				"md4",
+				"md5",
+				"ripemd160",
+				"sha1",
+				"sha224",
+				"sha256",
+				"sha384",
+				"sha512"
+			],
+			browser: [
+				"md5",
+				"ripemd160",
+				"sha1",
+				"sha256",
+				"sha512"
+			]
+		};
+		var DEFAULT_ENCRYPTION_SCHEME = "pkcs1_oaep";
+		var DEFAULT_SIGNING_SCHEME = "pkcs1";
+		var DEFAULT_EXPORT_FORMAT = "private";
+		var EXPORT_FORMAT_ALIASES = {
+			"private": "pkcs1-private-pem",
+			"private-der": "pkcs1-private-der",
+			"public": "pkcs8-public-pem",
+			"public-der": "pkcs8-public-der"
+		};
+		/**
+		* @param key {string|buffer|object} Key in PEM format, or data for generate key {b: bits, e: exponent}
+		* @constructor
+		*/
+		function NodeRSA(key, format, options) {
+			if (!(this instanceof NodeRSA)) return new NodeRSA(key, format, options);
+			if (_.isObject(format)) {
+				options = format;
+				format = void 0;
+			}
+			this.$options = {
+				signingScheme: DEFAULT_SIGNING_SCHEME,
+				signingSchemeOptions: {
+					hash: "sha256",
+					saltLength: null
+				},
+				encryptionScheme: DEFAULT_ENCRYPTION_SCHEME,
+				encryptionSchemeOptions: {
+					hash: "sha1",
+					label: null
+				},
+				environment: utils.detectEnvironment(),
+				rsaUtils: this
+			};
+			this.keyPair = new rsa.Key();
+			this.$cache = {};
+			if (Buffer.isBuffer(key) || _.isString(key)) this.importKey(key, format);
+			else if (_.isObject(key)) this.generateKeyPair(key.b, key.e);
+			this.setOptions(options);
+		}
+		/**
+		* Set and validate options for key instance
+		* @param options
+		*/
+		NodeRSA.prototype.setOptions = function(options) {
+			options = options || {};
+			if (options.environment) this.$options.environment = options.environment;
+			if (options.signingScheme) {
+				if (_.isString(options.signingScheme)) {
+					var signingScheme = options.signingScheme.toLowerCase().split("-");
+					if (signingScheme.length == 1) if (SUPPORTED_HASH_ALGORITHMS.node.indexOf(signingScheme[0]) > -1) {
+						this.$options.signingSchemeOptions = { hash: signingScheme[0] };
+						this.$options.signingScheme = DEFAULT_SIGNING_SCHEME;
+					} else {
+						this.$options.signingScheme = signingScheme[0];
+						this.$options.signingSchemeOptions = { hash: null };
+					}
+					else {
+						this.$options.signingSchemeOptions = { hash: signingScheme[1] };
+						this.$options.signingScheme = signingScheme[0];
+					}
+				} else if (_.isObject(options.signingScheme)) {
+					this.$options.signingScheme = options.signingScheme.scheme || DEFAULT_SIGNING_SCHEME;
+					this.$options.signingSchemeOptions = _.omit(options.signingScheme, "scheme");
+				}
+				if (!schemes.isSignature(this.$options.signingScheme)) throw Error("Unsupported signing scheme");
+				if (this.$options.signingSchemeOptions.hash && SUPPORTED_HASH_ALGORITHMS[this.$options.environment].indexOf(this.$options.signingSchemeOptions.hash) === -1) throw Error("Unsupported hashing algorithm for " + this.$options.environment + " environment");
+			}
+			if (options.encryptionScheme) {
+				if (_.isString(options.encryptionScheme)) {
+					this.$options.encryptionScheme = options.encryptionScheme.toLowerCase();
+					this.$options.encryptionSchemeOptions = {};
+				} else if (_.isObject(options.encryptionScheme)) {
+					this.$options.encryptionScheme = options.encryptionScheme.scheme || DEFAULT_ENCRYPTION_SCHEME;
+					this.$options.encryptionSchemeOptions = _.omit(options.encryptionScheme, "scheme");
+				}
+				if (!schemes.isEncryption(this.$options.encryptionScheme)) throw Error("Unsupported encryption scheme");
+				if (this.$options.encryptionSchemeOptions.hash && SUPPORTED_HASH_ALGORITHMS[this.$options.environment].indexOf(this.$options.encryptionSchemeOptions.hash) === -1) throw Error("Unsupported hashing algorithm for " + this.$options.environment + " environment");
+			}
+			this.keyPair.setOptions(this.$options);
+		};
+		/**
+		* Generate private/public keys pair
+		*
+		* @param bits {int} length key in bits. Default 2048.
+		* @param exp {int} public exponent. Default 65537.
+		* @returns {NodeRSA}
+		*/
+		NodeRSA.prototype.generateKeyPair = function(bits, exp) {
+			bits = bits || 2048;
+			exp = exp || 65537;
+			if (bits % 8 !== 0) throw Error("Key size must be a multiple of 8.");
+			this.keyPair.generate(bits, exp.toString(16));
+			this.$cache = {};
+			return this;
+		};
+		/**
+		* Importing key
+		* @param keyData {string|buffer|Object}
+		* @param format {string}
+		*/
+		NodeRSA.prototype.importKey = function(keyData, format) {
+			if (!keyData) throw Error("Empty key given");
+			if (format) format = EXPORT_FORMAT_ALIASES[format] || format;
+			if (!formats.detectAndImport(this.keyPair, keyData, format) && format === void 0) throw Error("Key format must be specified");
+			this.$cache = {};
+			return this;
+		};
+		/**
+		* Exporting key
+		* @param [format] {string}
+		*/
+		NodeRSA.prototype.exportKey = function(format) {
+			format = format || DEFAULT_EXPORT_FORMAT;
+			format = EXPORT_FORMAT_ALIASES[format] || format;
+			if (!this.$cache[format]) this.$cache[format] = formats.detectAndExport(this.keyPair, format);
+			return this.$cache[format];
+		};
+		/**
+		* Check if key pair contains private key
+		*/
+		NodeRSA.prototype.isPrivate = function() {
+			return this.keyPair.isPrivate();
+		};
+		/**
+		* Check if key pair contains public key
+		* @param [strict] {boolean} - public key only, return false if have private exponent
+		*/
+		NodeRSA.prototype.isPublic = function(strict) {
+			return this.keyPair.isPublic(strict);
+		};
+		/**
+		* Check if key pair doesn't contains any data
+		*/
+		NodeRSA.prototype.isEmpty = function(strict) {
+			return !(this.keyPair.n || this.keyPair.e || this.keyPair.d);
+		};
+		/**
+		* Encrypting data method with public key
+		*
+		* @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.
+		* @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+		* @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+		* @returns {string|Buffer}
+		*/
+		NodeRSA.prototype.encrypt = function(buffer, encoding, source_encoding) {
+			return this.$$encryptKey(false, buffer, encoding, source_encoding);
+		};
+		/**
+		* Decrypting data method with private key
+		*
+		* @param buffer {Buffer} - buffer for decrypting
+		* @param encoding - encoding for result string, can also take 'json' or 'buffer' for the automatic conversion of this type
+		* @returns {Buffer|object|string}
+		*/
+		NodeRSA.prototype.decrypt = function(buffer, encoding) {
+			return this.$$decryptKey(false, buffer, encoding);
+		};
+		/**
+		* Encrypting data method with private key
+		*
+		* Parameters same as `encrypt` method
+		*/
+		NodeRSA.prototype.encryptPrivate = function(buffer, encoding, source_encoding) {
+			return this.$$encryptKey(true, buffer, encoding, source_encoding);
+		};
+		/**
+		* Decrypting data method with public key
+		*
+		* Parameters same as `decrypt` method
+		*/
+		NodeRSA.prototype.decryptPublic = function(buffer, encoding) {
+			return this.$$decryptKey(true, buffer, encoding);
+		};
+		/**
+		* Encrypting data method with custom key
+		*/
+		NodeRSA.prototype.$$encryptKey = function(usePrivate, buffer, encoding, source_encoding) {
+			try {
+				var res = this.keyPair.encrypt(this.$getDataForEncrypt(buffer, source_encoding), usePrivate);
+				if (encoding == "buffer" || !encoding) return res;
+				else return res.toString(encoding);
+			} catch (e) {
+				throw Error("Error during encryption. Original error: " + e);
+			}
+		};
+		/**
+		* Decrypting data method with custom key
+		*/
+		NodeRSA.prototype.$$decryptKey = function(usePublic, buffer, encoding) {
+			try {
+				buffer = _.isString(buffer) ? Buffer.from(buffer, "base64") : buffer;
+				var res = this.keyPair.decrypt(buffer, usePublic);
+				if (res === null) throw Error("Key decrypt method returns null.");
+				return this.$getDecryptedData(res, encoding);
+			} catch (e) {
+				throw Error("Error during decryption (probably incorrect key). Original error: " + e);
+			}
+		};
+		/**
+		*  Signing data
+		*
+		* @param buffer {string|number|object|array|Buffer} - data for signing. Object and array will convert to JSON string.
+		* @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+		* @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+		* @returns {string|Buffer}
+		*/
+		NodeRSA.prototype.sign = function(buffer, encoding, source_encoding) {
+			if (!this.isPrivate()) throw Error("This is not private key");
+			var res = this.keyPair.sign(this.$getDataForEncrypt(buffer, source_encoding));
+			if (encoding && encoding != "buffer") res = res.toString(encoding);
+			return res;
+		};
+		/**
+		*  Verifying signed data
+		*
+		* @param buffer - signed data
+		* @param signature
+		* @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+		* @param signature_encoding - optional. Encoding of given signature. May be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+		* @returns {*}
+		*/
+		NodeRSA.prototype.verify = function(buffer, signature, source_encoding, signature_encoding) {
+			if (!this.isPublic()) throw Error("This is not public key");
+			signature_encoding = !signature_encoding || signature_encoding == "buffer" ? null : signature_encoding;
+			return this.keyPair.verify(this.$getDataForEncrypt(buffer, source_encoding), signature, signature_encoding);
+		};
+		/**
+		* Returns key size in bits
+		* @returns {int}
+		*/
+		NodeRSA.prototype.getKeySize = function() {
+			return this.keyPair.keySize;
+		};
+		/**
+		* Returns max message length in bytes (for 1 chunk) depending on current encryption scheme
+		* @returns {int}
+		*/
+		NodeRSA.prototype.getMaxMessageSize = function() {
+			return this.keyPair.maxMessageLength;
+		};
+		/**
+		* Preparing given data for encrypting/signing. Just make new/return Buffer object.
+		*
+		* @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.
+		* @param encoding {string} - optional. Encoding for given string. Default utf8.
+		* @returns {Buffer}
+		*/
+		NodeRSA.prototype.$getDataForEncrypt = function(buffer, encoding) {
+			if (_.isString(buffer) || _.isNumber(buffer)) return Buffer.from("" + buffer, encoding || "utf8");
+			else if (Buffer.isBuffer(buffer)) return buffer;
+			else if (_.isObject(buffer)) return Buffer.from(JSON.stringify(buffer));
+			else throw Error("Unexpected data type");
+		};
+		/**
+		*
+		* @param buffer {Buffer} - decrypted data.
+		* @param encoding - optional. Encoding for result output. May be 'buffer', 'json' or any of Node.js Buffer supported encoding.
+		* @returns {*}
+		*/
+		NodeRSA.prototype.$getDecryptedData = function(buffer, encoding) {
+			encoding = encoding || "buffer";
+			if (encoding == "buffer") return buffer;
+			else if (encoding == "json") return JSON.parse(buffer.toString());
+			else return buffer.toString(encoding);
+		};
+		return NodeRSA;
+	})();
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_NodeRSA();
+  }
+});
+//# sourceMappingURL=NodeRSA.cjs.map

package/dist/cjs/node_modules/node-rsa/src/NodeRSA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeRSA.cjs","names":[],"sources":["../../../../../../../node_modules/node-rsa/src/NodeRSA.js"],"sourcesContent":["/*!\n * RSA library for Node.js\n *\n * Author: rzcoder\n * License MIT\n */\n\nvar constants = require('constants');\nvar rsa = require('./libs/rsa.js');\nvar crypt = require('crypto');\nvar ber = require('asn1').Ber;\nvar _ = require('./utils')._;\nvar utils = require('./utils');\nvar schemes = require('./schemes/schemes.js');\nvar formats = require('./formats/formats.js');\n\nif (typeof constants.RSA_NO_PADDING === \"undefined\") {\n    //patch for node v0.10.x, constants do not defined\n    constants.RSA_NO_PADDING = 3;\n}\n\nmodule.exports = (function () {\n    var SUPPORTED_HASH_ALGORITHMS = {\n        node10: ['md4', 'md5', 'ripemd160', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'],\n        node: ['md4', 'md5', 'ripemd160', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'],\n        iojs: ['md4', 'md5', 'ripemd160', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'],\n        browser: ['md5', 'ripemd160', 'sha1', 'sha256', 'sha512']\n    };\n\n    var DEFAULT_ENCRYPTION_SCHEME = 'pkcs1_oaep';\n    var DEFAULT_SIGNING_SCHEME = 'pkcs1';\n\n    var DEFAULT_EXPORT_FORMAT = 'private';\n    var EXPORT_FORMAT_ALIASES = {\n        'private': 'pkcs1-private-pem',\n        'private-der': 'pkcs1-private-der',\n        'public': 'pkcs8-public-pem',\n        'public-der': 'pkcs8-public-der',\n    };\n\n    /**\n     * @param key {string|buffer|object} Key in PEM format, or data for generate key {b: bits, e: exponent}\n     * @constructor\n     */\n    function NodeRSA(key, format, options) {\n        if (!(this instanceof NodeRSA)) {\n            return new NodeRSA(key, format, options);\n        }\n\n        if (_.isObject(format)) {\n            options = format;\n            format = undefined;\n        }\n\n        this.$options = {\n            signingScheme: DEFAULT_SIGNING_SCHEME,\n            signingSchemeOptions: {\n                hash: 'sha256',\n                saltLength: null\n            },\n            encryptionScheme: DEFAULT_ENCRYPTION_SCHEME,\n            encryptionSchemeOptions: {\n                hash: 'sha1',\n                label: null\n            },\n            environment: utils.detectEnvironment(),\n            rsaUtils: this\n        };\n        this.keyPair = new rsa.Key();\n        this.$cache = {};\n\n        if (Buffer.isBuffer(key) || _.isString(key)) {\n            this.importKey(key, format);\n        } else if (_.isObject(key)) {\n            this.generateKeyPair(key.b, key.e);\n        }\n\n        this.setOptions(options);\n    }\n\n    /**\n     * Set and validate options for key instance\n     * @param options\n     */\n    NodeRSA.prototype.setOptions = function (options) {\n        options = options || {};\n        if (options.environment) {\n            this.$options.environment = options.environment;\n        }\n\n        if (options.signingScheme) {\n            if (_.isString(options.signingScheme)) {\n                var signingScheme = options.signingScheme.toLowerCase().split('-');\n                if (signingScheme.length == 1) {\n                    if (SUPPORTED_HASH_ALGORITHMS.node.indexOf(signingScheme[0]) > -1) {\n                        this.$options.signingSchemeOptions = {\n                            hash: signingScheme[0]\n                        };\n                        this.$options.signingScheme = DEFAULT_SIGNING_SCHEME;\n                    } else {\n                        this.$options.signingScheme = signingScheme[0];\n                        this.$options.signingSchemeOptions = {\n                            hash: null\n                        };\n                    }\n                } else {\n                    this.$options.signingSchemeOptions = {\n                        hash: signingScheme[1]\n                    };\n                    this.$options.signingScheme = signingScheme[0];\n                }\n            } else if (_.isObject(options.signingScheme)) {\n                this.$options.signingScheme = options.signingScheme.scheme || DEFAULT_SIGNING_SCHEME;\n                this.$options.signingSchemeOptions = _.omit(options.signingScheme, 'scheme');\n            }\n\n            if (!schemes.isSignature(this.$options.signingScheme)) {\n                throw Error('Unsupported signing scheme');\n            }\n\n            if (this.$options.signingSchemeOptions.hash &&\n                SUPPORTED_HASH_ALGORITHMS[this.$options.environment].indexOf(this.$options.signingSchemeOptions.hash) === -1) {\n                throw Error('Unsupported hashing algorithm for ' + this.$options.environment + ' environment');\n            }\n        }\n\n        if (options.encryptionScheme) {\n            if (_.isString(options.encryptionScheme)) {\n                this.$options.encryptionScheme = options.encryptionScheme.toLowerCase();\n                this.$options.encryptionSchemeOptions = {};\n            } else if (_.isObject(options.encryptionScheme)) {\n                this.$options.encryptionScheme = options.encryptionScheme.scheme || DEFAULT_ENCRYPTION_SCHEME;\n                this.$options.encryptionSchemeOptions = _.omit(options.encryptionScheme, 'scheme');\n            }\n\n            if (!schemes.isEncryption(this.$options.encryptionScheme)) {\n                throw Error('Unsupported encryption scheme');\n            }\n\n            if (this.$options.encryptionSchemeOptions.hash &&\n                SUPPORTED_HASH_ALGORITHMS[this.$options.environment].indexOf(this.$options.encryptionSchemeOptions.hash) === -1) {\n                throw Error('Unsupported hashing algorithm for ' + this.$options.environment + ' environment');\n            }\n        }\n\n        this.keyPair.setOptions(this.$options);\n    };\n\n    /**\n     * Generate private/public keys pair\n     *\n     * @param bits {int} length key in bits. Default 2048.\n     * @param exp {int} public exponent. Default 65537.\n     * @returns {NodeRSA}\n     */\n    NodeRSA.prototype.generateKeyPair = function (bits, exp) {\n        bits = bits || 2048;\n        exp = exp || 65537;\n\n        if (bits % 8 !== 0) {\n            throw Error('Key size must be a multiple of 8.');\n        }\n\n        this.keyPair.generate(bits, exp.toString(16));\n        this.$cache = {};\n        return this;\n    };\n\n    /**\n     * Importing key\n     * @param keyData {string|buffer|Object}\n     * @param format {string}\n     */\n    NodeRSA.prototype.importKey = function (keyData, format) {\n        if (!keyData) {\n            throw Error(\"Empty key given\");\n        }\n\n        if (format) {\n            format = EXPORT_FORMAT_ALIASES[format] || format;\n        }\n\n        if (!formats.detectAndImport(this.keyPair, keyData, format) && format === undefined) {\n            throw Error(\"Key format must be specified\");\n        }\n        \n        this.$cache = {};\n        \n        return this;\n    };\n\n    /**\n     * Exporting key\n     * @param [format] {string}\n     */\n    NodeRSA.prototype.exportKey = function (format) {\n        format = format || DEFAULT_EXPORT_FORMAT;\n        format = EXPORT_FORMAT_ALIASES[format] || format;\n\n        if (!this.$cache[format]) {\n            this.$cache[format] = formats.detectAndExport(this.keyPair, format);\n        }\n\n        return this.$cache[format];\n    };\n\n    /**\n     * Check if key pair contains private key\n     */\n    NodeRSA.prototype.isPrivate = function () {\n        return this.keyPair.isPrivate();\n    };\n\n    /**\n     * Check if key pair contains public key\n     * @param [strict] {boolean} - public key only, return false if have private exponent\n     */\n    NodeRSA.prototype.isPublic = function (strict) {\n        return this.keyPair.isPublic(strict);\n    };\n\n    /**\n     * Check if key pair doesn't contains any data\n     */\n    NodeRSA.prototype.isEmpty = function (strict) {\n        return !(this.keyPair.n || this.keyPair.e || this.keyPair.d);\n    };\n\n    /**\n     * Encrypting data method with public key\n     *\n     * @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.\n     * @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.\n     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.\n     * @returns {string|Buffer}\n     */\n    NodeRSA.prototype.encrypt = function (buffer, encoding, source_encoding) {\n        return this.$$encryptKey(false, buffer, encoding, source_encoding);\n    };\n\n    /**\n     * Decrypting data method with private key\n     *\n     * @param buffer {Buffer} - buffer for decrypting\n     * @param encoding - encoding for result string, can also take 'json' or 'buffer' for the automatic conversion of this type\n     * @returns {Buffer|object|string}\n     */\n    NodeRSA.prototype.decrypt = function (buffer, encoding) {\n        return this.$$decryptKey(false, buffer, encoding);\n    };\n\n    /**\n     * Encrypting data method with private key\n     *\n     * Parameters same as `encrypt` method\n     */\n    NodeRSA.prototype.encryptPrivate = function (buffer, encoding, source_encoding) {\n        return this.$$encryptKey(true, buffer, encoding, source_encoding);\n    };\n\n    /**\n     * Decrypting data method with public key\n     *\n     * Parameters same as `decrypt` method\n     */\n    NodeRSA.prototype.decryptPublic = function (buffer, encoding) {\n        return this.$$decryptKey(true, buffer, encoding);\n    };\n\n    /**\n     * Encrypting data method with custom key\n     */\n    NodeRSA.prototype.$$encryptKey = function (usePrivate, buffer, encoding, source_encoding) {\n        try {\n            var res = this.keyPair.encrypt(this.$getDataForEncrypt(buffer, source_encoding), usePrivate);\n\n            if (encoding == 'buffer' || !encoding) {\n                return res;\n            } else {\n                return res.toString(encoding);\n            }\n        } catch (e) {\n            throw Error('Error during encryption. Original error: ' + e);\n        }\n    };\n\n    /**\n     * Decrypting data method with custom key\n     */\n    NodeRSA.prototype.$$decryptKey = function (usePublic, buffer, encoding) {\n        try {\n            buffer = _.isString(buffer) ? Buffer.from(buffer, 'base64') : buffer;\n            var res = this.keyPair.decrypt(buffer, usePublic);\n\n            if (res === null) {\n                throw Error('Key decrypt method returns null.');\n            }\n\n            return this.$getDecryptedData(res, encoding);\n        } catch (e) {\n            throw Error('Error during decryption (probably incorrect key). Original error: ' + e);\n        }\n    };\n\n    /**\n     *  Signing data\n     *\n     * @param buffer {string|number|object|array|Buffer} - data for signing. Object and array will convert to JSON string.\n     * @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.\n     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.\n     * @returns {string|Buffer}\n     */\n    NodeRSA.prototype.sign = function (buffer, encoding, source_encoding) {\n        if (!this.isPrivate()) {\n            throw Error(\"This is not private key\");\n        }\n\n        var res = this.keyPair.sign(this.$getDataForEncrypt(buffer, source_encoding));\n\n        if (encoding && encoding != 'buffer') {\n            res = res.toString(encoding);\n        }\n\n        return res;\n    };\n\n    /**\n     *  Verifying signed data\n     *\n     * @param buffer - signed data\n     * @param signature\n     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.\n     * @param signature_encoding - optional. Encoding of given signature. May be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.\n     * @returns {*}\n     */\n    NodeRSA.prototype.verify = function (buffer, signature, source_encoding, signature_encoding) {\n        if (!this.isPublic()) {\n            throw Error(\"This is not public key\");\n        }\n        signature_encoding = (!signature_encoding || signature_encoding == 'buffer' ? null : signature_encoding);\n        return this.keyPair.verify(this.$getDataForEncrypt(buffer, source_encoding), signature, signature_encoding);\n    };\n\n    /**\n     * Returns key size in bits\n     * @returns {int}\n     */\n    NodeRSA.prototype.getKeySize = function () {\n        return this.keyPair.keySize;\n    };\n\n    /**\n     * Returns max message length in bytes (for 1 chunk) depending on current encryption scheme\n     * @returns {int}\n     */\n    NodeRSA.prototype.getMaxMessageSize = function () {\n        return this.keyPair.maxMessageLength;\n    };\n\n    /**\n     * Preparing given data for encrypting/signing. Just make new/return Buffer object.\n     *\n     * @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.\n     * @param encoding {string} - optional. Encoding for given string. Default utf8.\n     * @returns {Buffer}\n     */\n    NodeRSA.prototype.$getDataForEncrypt = function (buffer, encoding) {\n        if (_.isString(buffer) || _.isNumber(buffer)) {\n            return Buffer.from('' + buffer, encoding || 'utf8');\n        } else if (Buffer.isBuffer(buffer)) {\n            return buffer;\n        } else if (_.isObject(buffer)) {\n            return Buffer.from(JSON.stringify(buffer));\n        } else {\n            throw Error(\"Unexpected data type\");\n        }\n    };\n\n    /**\n     *\n     * @param buffer {Buffer} - decrypted data.\n     * @param encoding - optional. Encoding for result output. May be 'buffer', 'json' or any of Node.js Buffer supported encoding.\n     * @returns {*}\n     */\n    NodeRSA.prototype.$getDecryptedData = function (buffer, encoding) {\n        encoding = encoding || 'buffer';\n\n        if (encoding == 'buffer') {\n            return buffer;\n        } else if (encoding == 'json') {\n            return JSON.parse(buffer.toString());\n        } else {\n            return buffer.toString(encoding);\n        }\n    };\n\n    return NodeRSA;\n})();\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/encryptEngines.cjs

@@ -0,0 +1,26 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_js$1 = require('./js.cjs');
+const require_io$1 = require('./io.cjs');
+const require_node12$1 = require('./node12.cjs');
+
+//#region ../../node_modules/node-rsa/src/encryptEngines/encryptEngines.js
+var require_encryptEngines = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/encryptEngines/encryptEngines.js": ((exports, module) => {
+	var crypt = require("crypto");
+	module.exports = { getEngine: function(keyPair, options) {
+		var engine = require_js$1.default;
+		if (options.environment === "node") {
+			if (typeof crypt.publicEncrypt === "function" && typeof crypt.privateDecrypt === "function") if (typeof crypt.privateEncrypt === "function" && typeof crypt.publicDecrypt === "function") engine = require_io$1.default;
+			else engine = require_node12$1.default;
+		}
+		return engine(keyPair, options);
+	} };
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_encryptEngines();
+  }
+});
+//# sourceMappingURL=encryptEngines.cjs.map

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/encryptEngines.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryptEngines.cjs","names":[],"sources":["../../../../../../../../node_modules/node-rsa/src/encryptEngines/encryptEngines.js"],"sourcesContent":["var crypt = require('crypto');\r\n\r\nmodule.exports = {\r\n    getEngine: function (keyPair, options) {\r\n        var engine = require('./js.js');\r\n        if (options.environment === 'node') {\r\n            if (typeof crypt.publicEncrypt === 'function' && typeof crypt.privateDecrypt === 'function') {\r\n                if (typeof crypt.privateEncrypt === 'function' && typeof crypt.publicDecrypt === 'function') {\r\n                    engine = require('./io.js');\r\n                } else {\r\n                    engine = require('./node12.js');\r\n                }\r\n            }\r\n        }\r\n        return engine(keyPair, options);\r\n    }\r\n};"],"x_google_ignoreList":[0],"mappings":";;;;;;;CAAA,IAAI,QAAQ,QAAQ,SAAS;AAE7B,QAAO,UAAU,EACb,WAAW,SAAU,SAAS,SAAS;EACnC,IAAI;AACJ,MAAI,QAAQ,gBAAgB,QACxB;OAAI,OAAO,MAAM,kBAAkB,cAAc,OAAO,MAAM,mBAAmB,WAC7E,KAAI,OAAO,MAAM,mBAAmB,cAAc,OAAO,MAAM,kBAAkB,WAC7E;OAEA;;AAIZ,SAAO,OAAO,SAAS,QAAQ;IAEtC"}

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/io.cjs

@@ -0,0 +1,65 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_schemes$1 = require('../schemes/schemes.cjs');
+
+//#region ../../node_modules/node-rsa/src/encryptEngines/io.js
+var require_io = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/encryptEngines/io.js": ((exports, module) => {
+	var crypto = require("crypto");
+	var constants = require("constants");
+	var schemes = require_schemes$1.default;
+	module.exports = function(keyPair, options) {
+		var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);
+		return {
+			encrypt: function(buffer, usePrivate) {
+				var padding;
+				if (usePrivate) {
+					padding = constants.RSA_PKCS1_PADDING;
+					if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+					return crypto.privateEncrypt({
+						key: options.rsaUtils.exportKey("private"),
+						padding
+					}, buffer);
+				} else {
+					padding = constants.RSA_PKCS1_OAEP_PADDING;
+					if (options.encryptionScheme === "pkcs1") padding = constants.RSA_PKCS1_PADDING;
+					if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+					var data = buffer;
+					if (padding === constants.RSA_NO_PADDING) data = pkcs1Scheme.pkcs0pad(buffer);
+					return crypto.publicEncrypt({
+						key: options.rsaUtils.exportKey("public"),
+						padding
+					}, data);
+				}
+			},
+			decrypt: function(buffer, usePublic) {
+				var padding;
+				if (usePublic) {
+					padding = constants.RSA_PKCS1_PADDING;
+					if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+					return crypto.publicDecrypt({
+						key: options.rsaUtils.exportKey("public"),
+						padding
+					}, buffer);
+				} else {
+					padding = constants.RSA_PKCS1_OAEP_PADDING;
+					if (options.encryptionScheme === "pkcs1") padding = constants.RSA_PKCS1_PADDING;
+					if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+					var res = crypto.privateDecrypt({
+						key: options.rsaUtils.exportKey("private"),
+						padding
+					}, buffer);
+					if (padding === constants.RSA_NO_PADDING) return pkcs1Scheme.pkcs0unpad(res);
+					return res;
+				}
+			}
+		};
+	};
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_io();
+  }
+});
+//# sourceMappingURL=io.cjs.map

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/io.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.cjs","names":[],"sources":["../../../../../../../../node_modules/node-rsa/src/encryptEngines/io.js"],"sourcesContent":["var crypto = require('crypto');\nvar constants = require('constants');\nvar schemes = require('../schemes/schemes.js');\n\nmodule.exports = function (keyPair, options) {\n    var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);\n\n    return {\n        encrypt: function (buffer, usePrivate) {\n            var padding;\n            if (usePrivate) {\n                padding = constants.RSA_PKCS1_PADDING;\n                if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                    padding = options.encryptionSchemeOptions.padding;\n                }\n                return crypto.privateEncrypt({\n                    key: options.rsaUtils.exportKey('private'),\n                    padding: padding\n                }, buffer);\n            } else {\n                padding = constants.RSA_PKCS1_OAEP_PADDING;\n                if (options.encryptionScheme === 'pkcs1') {\n                    padding = constants.RSA_PKCS1_PADDING;\n                }\n                if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                    padding = options.encryptionSchemeOptions.padding;\n                }\n\n                var data = buffer;\n                if (padding === constants.RSA_NO_PADDING) {\n                    data = pkcs1Scheme.pkcs0pad(buffer);\n                }\n\n                return crypto.publicEncrypt({\n                    key: options.rsaUtils.exportKey('public'),\n                    padding: padding\n                }, data);\n            }\n        },\n\n        decrypt: function (buffer, usePublic) {\n            var padding;\n            if (usePublic) {\n                padding = constants.RSA_PKCS1_PADDING;\n                if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                    padding = options.encryptionSchemeOptions.padding;\n                }\n                return crypto.publicDecrypt({\n                    key: options.rsaUtils.exportKey('public'),\n                    padding: padding\n                }, buffer);\n            } else {\n                padding = constants.RSA_PKCS1_OAEP_PADDING;\n                if (options.encryptionScheme === 'pkcs1') {\n                    padding = constants.RSA_PKCS1_PADDING;\n                }\n                if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                    padding = options.encryptionSchemeOptions.padding;\n                }\n                var res = crypto.privateDecrypt({\n                    key: options.rsaUtils.exportKey('private'),\n                    padding: padding\n                }, buffer);\n\n                if (padding === constants.RSA_NO_PADDING) {\n                    return pkcs1Scheme.pkcs0unpad(res);\n                }\n                return res;\n            }\n        }\n    };\n};"],"x_google_ignoreList":[0],"mappings":";;;;;CAAA,IAAI,SAAS,QAAQ,SAAS;CAC9B,IAAI,YAAY,QAAQ,YAAY;CACpC,IAAI;AAEJ,QAAO,UAAU,SAAU,SAAS,SAAS;EACzC,IAAI,cAAc,QAAQ,MAAM,WAAW,SAAS,QAAQ;AAE5D,SAAO;GACH,SAAS,SAAU,QAAQ,YAAY;IACnC,IAAI;AACJ,QAAI,YAAY;AACZ,eAAU,UAAU;AACpB,SAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;AAE9C,YAAO,OAAO,eAAe;MACzB,KAAK,QAAQ,SAAS,UAAU,UAAU;MACjC;MACZ,EAAE,OAAO;WACP;AACH,eAAU,UAAU;AACpB,SAAI,QAAQ,qBAAqB,QAC7B,WAAU,UAAU;AAExB,SAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;KAG9C,IAAI,OAAO;AACX,SAAI,YAAY,UAAU,eACtB,QAAO,YAAY,SAAS,OAAO;AAGvC,YAAO,OAAO,cAAc;MACxB,KAAK,QAAQ,SAAS,UAAU,SAAS;MAChC;MACZ,EAAE,KAAK;;;GAIhB,SAAS,SAAU,QAAQ,WAAW;IAClC,IAAI;AACJ,QAAI,WAAW;AACX,eAAU,UAAU;AACpB,SAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;AAE9C,YAAO,OAAO,cAAc;MACxB,KAAK,QAAQ,SAAS,UAAU,SAAS;MAChC;MACZ,EAAE,OAAO;WACP;AACH,eAAU,UAAU;AACpB,SAAI,QAAQ,qBAAqB,QAC7B,WAAU,UAAU;AAExB,SAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;KAE9C,IAAI,MAAM,OAAO,eAAe;MAC5B,KAAK,QAAQ,SAAS,UAAU,UAAU;MACjC;MACZ,EAAE,OAAO;AAEV,SAAI,YAAY,UAAU,eACtB,QAAO,YAAY,WAAW,IAAI;AAEtC,YAAO;;;GAGlB"}

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/js.cjs

@@ -0,0 +1,44 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_jsbn$1 = require('../libs/jsbn.cjs');
+const require_schemes$1 = require('../schemes/schemes.cjs');
+
+//#region ../../node_modules/node-rsa/src/encryptEngines/js.js
+var require_js = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/encryptEngines/js.js": ((exports, module) => {
+	var BigInteger = require_jsbn$1.default;
+	var schemes = require_schemes$1.default;
+	module.exports = function(keyPair, options) {
+		var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);
+		return {
+			encrypt: function(buffer, usePrivate) {
+				var m, c;
+				if (usePrivate) {
+					m = new BigInteger(pkcs1Scheme.encPad(buffer, { type: 1 }));
+					c = keyPair.$doPrivate(m);
+				} else {
+					m = new BigInteger(keyPair.encryptionScheme.encPad(buffer));
+					c = keyPair.$doPublic(m);
+				}
+				return c.toBuffer(keyPair.encryptedDataLength);
+			},
+			decrypt: function(buffer, usePublic) {
+				var m, c = new BigInteger(buffer);
+				if (usePublic) {
+					m = keyPair.$doPublic(c);
+					return pkcs1Scheme.encUnPad(m.toBuffer(keyPair.encryptedDataLength), { type: 1 });
+				} else {
+					m = keyPair.$doPrivate(c);
+					return keyPair.encryptionScheme.encUnPad(m.toBuffer(keyPair.encryptedDataLength));
+				}
+			}
+		};
+	};
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_js();
+  }
+});
+//# sourceMappingURL=js.cjs.map

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/js.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"js.cjs","names":[],"sources":["../../../../../../../../node_modules/node-rsa/src/encryptEngines/js.js"],"sourcesContent":["var BigInteger = require('../libs/jsbn.js');\r\nvar schemes = require('../schemes/schemes.js');\r\n\r\nmodule.exports = function (keyPair, options) {\r\n    var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);\r\n\r\n    return {\r\n        encrypt: function (buffer, usePrivate) {\r\n            var m, c;\r\n            if (usePrivate) {\r\n                /* Type 1: zeros padding for private key encrypt */\r\n                m = new BigInteger(pkcs1Scheme.encPad(buffer, {type: 1}));\r\n                c = keyPair.$doPrivate(m);\r\n            } else {\r\n                m = new BigInteger(keyPair.encryptionScheme.encPad(buffer));\r\n                c = keyPair.$doPublic(m);\r\n            }\r\n            return c.toBuffer(keyPair.encryptedDataLength);\r\n        },\r\n\r\n        decrypt: function (buffer, usePublic) {\r\n            var m, c = new BigInteger(buffer);\r\n\r\n            if (usePublic) {\r\n                m = keyPair.$doPublic(c);\r\n                /* Type 1: zeros padding for private key decrypt */\r\n                return pkcs1Scheme.encUnPad(m.toBuffer(keyPair.encryptedDataLength), {type: 1});\r\n            } else {\r\n                m = keyPair.$doPrivate(c);\r\n                return keyPair.encryptionScheme.encUnPad(m.toBuffer(keyPair.encryptedDataLength));\r\n            }\r\n        }\r\n    };\r\n};"],"x_google_ignoreList":[0],"mappings":";;;;;;CAAA,IAAI;CACJ,IAAI;AAEJ,QAAO,UAAU,SAAU,SAAS,SAAS;EACzC,IAAI,cAAc,QAAQ,MAAM,WAAW,SAAS,QAAQ;AAE5D,SAAO;GACH,SAAS,SAAU,QAAQ,YAAY;IACnC,IAAI,GAAG;AACP,QAAI,YAAY;AAEZ,SAAI,IAAI,WAAW,YAAY,OAAO,QAAQ,EAAC,MAAM,GAAE,CAAC,CAAC;AACzD,SAAI,QAAQ,WAAW,EAAE;WACtB;AACH,SAAI,IAAI,WAAW,QAAQ,iBAAiB,OAAO,OAAO,CAAC;AAC3D,SAAI,QAAQ,UAAU,EAAE;;AAE5B,WAAO,EAAE,SAAS,QAAQ,oBAAoB;;GAGlD,SAAS,SAAU,QAAQ,WAAW;IAClC,IAAI,GAAG,IAAI,IAAI,WAAW,OAAO;AAEjC,QAAI,WAAW;AACX,SAAI,QAAQ,UAAU,EAAE;AAExB,YAAO,YAAY,SAAS,EAAE,SAAS,QAAQ,oBAAoB,EAAE,EAAC,MAAM,GAAE,CAAC;WAC5E;AACH,SAAI,QAAQ,WAAW,EAAE;AACzB,YAAO,QAAQ,iBAAiB,SAAS,EAAE,SAAS,QAAQ,oBAAoB,CAAC;;;GAG5F"}

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/node12.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_schemes$1 = require('../schemes/schemes.cjs');
+const require_js$1 = require('./js.cjs');
+
+//#region ../../node_modules/node-rsa/src/encryptEngines/node12.js
+var require_node12 = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/encryptEngines/node12.js": ((exports, module) => {
+	var crypto = require("crypto");
+	var constants = require("constants");
+	var schemes = require_schemes$1.default;
+	module.exports = function(keyPair, options) {
+		var jsEngine = require_js$1.default(keyPair, options);
+		var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);
+		return {
+			encrypt: function(buffer, usePrivate) {
+				if (usePrivate) return jsEngine.encrypt(buffer, usePrivate);
+				var padding = constants.RSA_PKCS1_OAEP_PADDING;
+				if (options.encryptionScheme === "pkcs1") padding = constants.RSA_PKCS1_PADDING;
+				if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+				var data = buffer;
+				if (padding === constants.RSA_NO_PADDING) data = pkcs1Scheme.pkcs0pad(buffer);
+				return crypto.publicEncrypt({
+					key: options.rsaUtils.exportKey("public"),
+					padding
+				}, data);
+			},
+			decrypt: function(buffer, usePublic) {
+				if (usePublic) return jsEngine.decrypt(buffer, usePublic);
+				var padding = constants.RSA_PKCS1_OAEP_PADDING;
+				if (options.encryptionScheme === "pkcs1") padding = constants.RSA_PKCS1_PADDING;
+				if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) padding = options.encryptionSchemeOptions.padding;
+				var res = crypto.privateDecrypt({
+					key: options.rsaUtils.exportKey("private"),
+					padding
+				}, buffer);
+				if (padding === constants.RSA_NO_PADDING) return pkcs1Scheme.pkcs0unpad(res);
+				return res;
+			}
+		};
+	};
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_node12();
+  }
+});
+//# sourceMappingURL=node12.cjs.map

package/dist/cjs/node_modules/node-rsa/src/encryptEngines/node12.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node12.cjs","names":[],"sources":["../../../../../../../../node_modules/node-rsa/src/encryptEngines/node12.js"],"sourcesContent":["var crypto = require('crypto');\nvar constants = require('constants');\nvar schemes = require('../schemes/schemes.js');\n\nmodule.exports = function (keyPair, options) {\n    var jsEngine = require('./js.js')(keyPair, options);\n    var pkcs1Scheme = schemes.pkcs1.makeScheme(keyPair, options);\n\n    return {\n        encrypt: function (buffer, usePrivate) {\n            if (usePrivate) {\n                return jsEngine.encrypt(buffer, usePrivate);\n            }\n            var padding = constants.RSA_PKCS1_OAEP_PADDING;\n            if (options.encryptionScheme === 'pkcs1') {\n                padding = constants.RSA_PKCS1_PADDING;\n            }\n            if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                padding = options.encryptionSchemeOptions.padding;\n            }\n\n            var data = buffer;\n            if (padding === constants.RSA_NO_PADDING) {\n                data = pkcs1Scheme.pkcs0pad(buffer);\n            }\n\n            return crypto.publicEncrypt({\n                key: options.rsaUtils.exportKey('public'),\n                padding: padding\n            }, data);\n        },\n\n        decrypt: function (buffer, usePublic) {\n            if (usePublic) {\n                return jsEngine.decrypt(buffer, usePublic);\n            }\n            var padding = constants.RSA_PKCS1_OAEP_PADDING;\n            if (options.encryptionScheme === 'pkcs1') {\n                padding = constants.RSA_PKCS1_PADDING;\n            }\n            if (options.encryptionSchemeOptions && options.encryptionSchemeOptions.padding) {\n                padding = options.encryptionSchemeOptions.padding;\n            }\n\n            var res = crypto.privateDecrypt({\n                key: options.rsaUtils.exportKey('private'),\n                padding: padding\n            }, buffer);\n\n            if (padding === constants.RSA_NO_PADDING) {\n                return pkcs1Scheme.pkcs0unpad(res);\n            }\n            return res;\n        }\n    };\n};"],"x_google_ignoreList":[0],"mappings":";;;;;;CAAA,IAAI,SAAS,QAAQ,SAAS;CAC9B,IAAI,YAAY,QAAQ,YAAY;CACpC,IAAI;AAEJ,QAAO,UAAU,SAAU,SAAS,SAAS;EACzC,IAAI,gCAA8B,SAAS,QAAQ;EACnD,IAAI,cAAc,QAAQ,MAAM,WAAW,SAAS,QAAQ;AAE5D,SAAO;GACH,SAAS,SAAU,QAAQ,YAAY;AACnC,QAAI,WACA,QAAO,SAAS,QAAQ,QAAQ,WAAW;IAE/C,IAAI,UAAU,UAAU;AACxB,QAAI,QAAQ,qBAAqB,QAC7B,WAAU,UAAU;AAExB,QAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;IAG9C,IAAI,OAAO;AACX,QAAI,YAAY,UAAU,eACtB,QAAO,YAAY,SAAS,OAAO;AAGvC,WAAO,OAAO,cAAc;KACxB,KAAK,QAAQ,SAAS,UAAU,SAAS;KAChC;KACZ,EAAE,KAAK;;GAGZ,SAAS,SAAU,QAAQ,WAAW;AAClC,QAAI,UACA,QAAO,SAAS,QAAQ,QAAQ,UAAU;IAE9C,IAAI,UAAU,UAAU;AACxB,QAAI,QAAQ,qBAAqB,QAC7B,WAAU,UAAU;AAExB,QAAI,QAAQ,2BAA2B,QAAQ,wBAAwB,QACnE,WAAU,QAAQ,wBAAwB;IAG9C,IAAI,MAAM,OAAO,eAAe;KAC5B,KAAK,QAAQ,SAAS,UAAU,UAAU;KACjC;KACZ,EAAE,OAAO;AAEV,QAAI,YAAY,UAAU,eACtB,QAAO,YAAY,WAAW,IAAI;AAEtC,WAAO;;GAEd"}

package/dist/cjs/node_modules/node-rsa/src/formats/components.cjs

@@ -0,0 +1,55 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_utils$1 = require('../utils.cjs');
+
+//#region ../../node_modules/node-rsa/src/formats/components.js
+var require_components = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/node-rsa/src/formats/components.js": ((exports, module) => {
+	require_utils$1.default._;
+	require_utils$1.default;
+	module.exports = {
+		privateExport: function(key, options) {
+			return {
+				n: key.n.toBuffer(),
+				e: key.e,
+				d: key.d.toBuffer(),
+				p: key.p.toBuffer(),
+				q: key.q.toBuffer(),
+				dmp1: key.dmp1.toBuffer(),
+				dmq1: key.dmq1.toBuffer(),
+				coeff: key.coeff.toBuffer()
+			};
+		},
+		privateImport: function(key, data, options) {
+			if (data.n && data.e && data.d && data.p && data.q && data.dmp1 && data.dmq1 && data.coeff) key.setPrivate(data.n, data.e, data.d, data.p, data.q, data.dmp1, data.dmq1, data.coeff);
+			else throw Error("Invalid key data");
+		},
+		publicExport: function(key, options) {
+			return {
+				n: key.n.toBuffer(),
+				e: key.e
+			};
+		},
+		publicImport: function(key, data, options) {
+			if (data.n && data.e) key.setPublic(data.n, data.e);
+			else throw Error("Invalid key data");
+		},
+		autoImport: function(key, data) {
+			if (data.n && data.e) if (data.d && data.p && data.q && data.dmp1 && data.dmq1 && data.coeff) {
+				module.exports.privateImport(key, data);
+				return true;
+			} else {
+				module.exports.publicImport(key, data);
+				return true;
+			}
+			return false;
+		}
+	};
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_components();
+  }
+});
+//# sourceMappingURL=components.cjs.map