import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
import { require_forge } from "./forge.mjs";
import { require_util } from "./util.mjs";

//#region ../../node_modules/node-forge/lib/cipher.js
var require_cipher = /* @__PURE__ */ __commonJS({ "../../node_modules/node-forge/lib/cipher.js": ((exports, module) => {
	/**
	* Cipher base API.
	*
	* @author Dave Longley
	*
	* Copyright (c) 2010-2014 Digital Bazaar, Inc.
	*/
	var forge = require_forge();
	require_util();
	module.exports = forge.cipher = forge.cipher || {};
	forge.cipher.algorithms = forge.cipher.algorithms || {};
	/**
	* Creates a cipher object that can be used to encrypt data using the given
	* algorithm and key. The algorithm may be provided as a string value for a
	* previously registered algorithm or it may be given as a cipher algorithm
	* API object.
	*
	* @param algorithm the algorithm to use, either a string or an algorithm API
	*          object.
	* @param key the key to use, as a binary-encoded string of bytes or a
	*          byte buffer.
	*
	* @return the cipher.
	*/
	forge.cipher.createCipher = function(algorithm, key) {
		var api = algorithm;
		if (typeof api === "string") {
			api = forge.cipher.getAlgorithm(api);
			if (api) api = api();
		}
		if (!api) throw new Error("Unsupported algorithm: " + algorithm);
		return new forge.cipher.BlockCipher({
			algorithm: api,
			key,
			decrypt: false
		});
	};
	/**
	* Creates a decipher object that can be used to decrypt data using the given
	* algorithm and key. The algorithm may be provided as a string value for a
	* previously registered algorithm or it may be given as a cipher algorithm
	* API object.
	*
	* @param algorithm the algorithm to use, either a string or an algorithm API
	*          object.
	* @param key the key to use, as a binary-encoded string of bytes or a
	*          byte buffer.
	*
	* @return the cipher.
	*/
	forge.cipher.createDecipher = function(algorithm, key) {
		var api = algorithm;
		if (typeof api === "string") {
			api = forge.cipher.getAlgorithm(api);
			if (api) api = api();
		}
		if (!api) throw new Error("Unsupported algorithm: " + algorithm);
		return new forge.cipher.BlockCipher({
			algorithm: api,
			key,
			decrypt: true
		});
	};
	/**
	* Registers an algorithm by name. If the name was already registered, the
	* algorithm API object will be overwritten.
	*
	* @param name the name of the algorithm.
	* @param algorithm the algorithm API object.
	*/
	forge.cipher.registerAlgorithm = function(name, algorithm) {
		name = name.toUpperCase();
		forge.cipher.algorithms[name] = algorithm;
	};
	/**
	* Gets a registered algorithm by name.
	*
	* @param name the name of the algorithm.
	*
	* @return the algorithm, if found, null if not.
	*/
	forge.cipher.getAlgorithm = function(name) {
		name = name.toUpperCase();
		if (name in forge.cipher.algorithms) return forge.cipher.algorithms[name];
		return null;
	};
	var BlockCipher = forge.cipher.BlockCipher = function(options) {
		this.algorithm = options.algorithm;
		this.mode = this.algorithm.mode;
		this.blockSize = this.mode.blockSize;
		this._finish = false;
		this._input = null;
		this.output = null;
		this._op = options.decrypt ? this.mode.decrypt : this.mode.encrypt;
		this._decrypt = options.decrypt;
		this.algorithm.initialize(options);
	};
	/**
	* Starts or restarts the encryption or decryption process, whichever
	* was previously configured.
	*
	* For non-GCM mode, the IV may be a binary-encoded string of bytes, an array
	* of bytes, a byte buffer, or an array of 32-bit integers. If the IV is in
	* bytes, then it must be Nb (16) bytes in length. If the IV is given in as
	* 32-bit integers, then it must be 4 integers long.
	*
	* Note: an IV is not required or used in ECB mode.
	*
	* For GCM-mode, the IV must be given as a binary-encoded string of bytes or
	* a byte buffer. The number of bytes should be 12 (96 bits) as recommended
	* by NIST SP-800-38D but another length may be given.
	*
	* @param options the options to use:
	*          iv the initialization vector to use as a binary-encoded string of
	*            bytes, null to reuse the last ciphered block from a previous
	*            update() (this "residue" method is for legacy support only).
	*          additionalData additional authentication data as a binary-encoded
	*            string of bytes, for 'GCM' mode, (default: none).
	*          tagLength desired length of authentication tag, in bits, for
	*            'GCM' mode (0-128, default: 128).
	*          tag the authentication tag to check if decrypting, as a
	*             binary-encoded string of bytes.
	*          output the output the buffer to write to, null to create one.
	*/
	BlockCipher.prototype.start = function(options) {
		options = options || {};
		var opts = {};
		for (var key in options) opts[key] = options[key];
		opts.decrypt = this._decrypt;
		this._finish = false;
		this._input = forge.util.createBuffer();
		this.output = options.output || forge.util.createBuffer();
		this.mode.start(opts);
	};
	/**
	* Updates the next block according to the cipher mode.
	*
	* @param input the buffer to read from.
	*/
	BlockCipher.prototype.update = function(input) {
		if (input) this._input.putBuffer(input);
		while (!this._op.call(this.mode, this._input, this.output, this._finish) && !this._finish);
		this._input.compact();
	};
	/**
	* Finishes encrypting or decrypting.
	*
	* @param pad a padding function to use in CBC mode, null for default,
	*          signature(blockSize, buffer, decrypt).
	*
	* @return true if successful, false on error.
	*/
	BlockCipher.prototype.finish = function(pad) {
		if (pad && (this.mode.name === "ECB" || this.mode.name === "CBC")) {
			this.mode.pad = function(input) {
				return pad(this.blockSize, input, false);
			};
			this.mode.unpad = function(output) {
				return pad(this.blockSize, output, true);
			};
		}
		var options = {};
		options.decrypt = this._decrypt;
		options.overflow = this._input.length() % this.blockSize;
		if (!this._decrypt && this.mode.pad) {
			if (!this.mode.pad(this._input, options)) return false;
		}
		this._finish = true;
		this.update();
		if (this._decrypt && this.mode.unpad) {
			if (!this.mode.unpad(this.output, options)) return false;
		}
		if (this.mode.afterFinish) {
			if (!this.mode.afterFinish(this.output, options)) return false;
		}
		return true;
	};
}) });

//#endregion
export default require_cipher();

export { require_cipher };
//# sourceMappingURL=cipher.mjs.map