internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/deriveKeysFromPassword-DJRWZ8Rw.mjs

@@ -0,0 +1,735 @@
+import { AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, CONTEXT_DERIVE } from "./constants.mjs";
+import { d as hexToUint8Array, l as UTF8ToUint8, p as uint8ArrayToHex } from "./genID-3Er5IowC.mjs";
+import { s as importSymmetricCryptoKey } from "./aes-DSDxP8uF.mjs";
+import { blake3 } from "@noble/hashes/blake3.js";
+
+//#region src/derive-key/deriveKeysFromKey.ts
+/**
+* Derives a symmetric key from the base key and context string
+*
+* @param context - The context string.
+* The context string should be hardcoded, globally unique, and application-specific.
+* @param baseKey - The base key (NOT PASSWORD!)
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromContext(context, baseKey) {
+	return blake3(baseKey, { context: UTF8ToUint8(context) });
+}
+/**
+* Derives a symmetric CryptoKey from the base key and context string
+*
+* @param context - The context string.
+* The context string should be hardcoded, globally unique, and application-specific.
+* @param baseKey - The base key (NOT PASSWORD!)
+* @returns The derived secret CryptoKey
+*/
+async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
+	try {
+		if (baseKey.length != AES_KEY_BIT_LENGTH / 8) throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
+		if (!context) throw new Error("Context is empry");
+		return await importSymmetricCryptoKey(deriveSymmetricKeyFromContext(context, baseKey));
+	} catch (error) {
+		throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
+	}
+}
+/**
+* Derives a symmetric key from two keys
+*
+* @param key1 - The 32-bytes key
+* @param key2 - The 32-bytes key
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromTwoKeys(key1, key2) {
+	return deriveSymmetricKeyFromTwoKeysAndContext(key1, key2, CONTEXT_DERIVE);
+}
+/**
+* Derives a symmetric CryptoKey from two keys
+*
+* @param key1 - The 32-bytes key
+* @param key2 - The 32-bytes key
+* @returns The derived secret CryptoKey
+*/
+async function deriveSymmetricCryptoKeyFromTwoKeys(key1, key2) {
+	try {
+		return await importSymmetricCryptoKey(deriveSymmetricKeyFromTwoKeys(key1, key2));
+	} catch (error) {
+		throw new Error("Failed to derive symmetric CryptoKey from two keys", { cause: error });
+	}
+}
+/**
+* Derives a symmetric key from two keys and context
+*
+* @param key1 - The 32-bytes key
+* @param key2 - The 32-bytes key
+* @param context - The context string
+* @returns The derived symmetric key
+*/
+function deriveSymmetricKeyFromTwoKeysAndContext(key1, key2, context) {
+	try {
+		if (key2.length != AES_KEY_BIT_LENGTH / 8 || key1.length != AES_KEY_BIT_LENGTH / 8) throw new Error(`Input key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
+		return blake3(blake3(key1, { key: key2 }), { context: UTF8ToUint8(context) });
+	} catch (error) {
+		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
+	}
+}
+
+//#endregion
+//#region node_modules/hash-wasm/dist/index.esm.js
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function __awaiter(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 Mutex = class {
+	constructor() {
+		this.mutex = Promise.resolve();
+	}
+	lock() {
+		let begin = () => {};
+		this.mutex = this.mutex.then(() => new Promise(begin));
+		return new Promise((res) => {
+			begin = res;
+		});
+	}
+	dispatch(fn) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const unlock = yield this.lock();
+			try {
+				return yield Promise.resolve(fn());
+			} finally {
+				unlock();
+			}
+		});
+	}
+};
+var _a;
+function getGlobal() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	return global;
+}
+const globalObject = getGlobal();
+const nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
+const textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
+function hexCharCodesToInt(a, b) {
+	return (a & 15) + (a >> 6 | a >> 3 & 8) << 4 | (b & 15) + (b >> 6 | b >> 3 & 8);
+}
+function writeHexToUInt8(buf, str) {
+	const size = str.length >> 1;
+	for (let i = 0; i < size; i++) {
+		const index = i << 1;
+		buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+	}
+}
+function hexStringEqualsUInt8(str, buf) {
+	if (str.length !== buf.length * 2) return false;
+	for (let i = 0; i < buf.length; i++) {
+		const strIndex = i << 1;
+		if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) return false;
+	}
+	return true;
+}
+const alpha = "a".charCodeAt(0) - 10;
+const digit = "0".charCodeAt(0);
+function getDigestHex(tmpBuffer, input, hashLength) {
+	let p = 0;
+	for (let i = 0; i < hashLength; i++) {
+		let nibble = input[i] >>> 4;
+		tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+		nibble = input[i] & 15;
+		tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+	}
+	return String.fromCharCode.apply(null, tmpBuffer);
+}
+const getUInt8Buffer = nodeBuffer !== null ? (data) => {
+	if (typeof data === "string") {
+		const buf = nodeBuffer.from(data, "utf8");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+	}
+	if (nodeBuffer.isBuffer(data)) return new Uint8Array(data.buffer, data.byteOffset, data.length);
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	throw new Error("Invalid data type!");
+} : (data) => {
+	if (typeof data === "string") return textEncoder.encode(data);
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	throw new Error("Invalid data type!");
+};
+const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const base64Lookup = new Uint8Array(256);
+for (let i = 0; i < 64; i++) base64Lookup[base64Chars.charCodeAt(i)] = i;
+function encodeBase64(data, pad = true) {
+	const len = data.length;
+	const extraBytes = len % 3;
+	const parts = [];
+	const len2 = len - extraBytes;
+	for (let i = 0; i < len2; i += 3) {
+		const tmp = (data[i] << 16 & 16711680) + (data[i + 1] << 8 & 65280) + (data[i + 2] & 255);
+		const triplet = base64Chars.charAt(tmp >> 18 & 63) + base64Chars.charAt(tmp >> 12 & 63) + base64Chars.charAt(tmp >> 6 & 63) + base64Chars.charAt(tmp & 63);
+		parts.push(triplet);
+	}
+	if (extraBytes === 1) {
+		const tmp = data[len - 1];
+		const a = base64Chars.charAt(tmp >> 2);
+		const b = base64Chars.charAt(tmp << 4 & 63);
+		parts.push(`${a}${b}`);
+		if (pad) parts.push("==");
+	} else if (extraBytes === 2) {
+		const tmp = (data[len - 2] << 8) + data[len - 1];
+		const a = base64Chars.charAt(tmp >> 10);
+		const b = base64Chars.charAt(tmp >> 4 & 63);
+		const c = base64Chars.charAt(tmp << 2 & 63);
+		parts.push(`${a}${b}${c}`);
+		if (pad) parts.push("=");
+	}
+	return parts.join("");
+}
+function getDecodeBase64Length(data) {
+	let bufferLength = Math.floor(data.length * .75);
+	const len = data.length;
+	if (data[len - 1] === "=") {
+		bufferLength -= 1;
+		if (data[len - 2] === "=") bufferLength -= 1;
+	}
+	return bufferLength;
+}
+function decodeBase64(data) {
+	const bufferLength = getDecodeBase64Length(data);
+	const len = data.length;
+	const bytes = new Uint8Array(bufferLength);
+	let p = 0;
+	for (let i = 0; i < len; i += 4) {
+		const encoded1 = base64Lookup[data.charCodeAt(i)];
+		const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+		const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+		const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+		bytes[p] = encoded1 << 2 | encoded2 >> 4;
+		p += 1;
+		bytes[p] = (encoded2 & 15) << 4 | encoded3 >> 2;
+		p += 1;
+		bytes[p] = (encoded3 & 3) << 6 | encoded4 & 63;
+		p += 1;
+	}
+	return bytes;
+}
+const MAX_HEAP = 16 * 1024;
+const WASM_FUNC_HASH_LENGTH = 4;
+const wasmMutex = new Mutex();
+const wasmModuleCache = /* @__PURE__ */ new Map();
+function WASMInterface(binary, hashLength) {
+	return __awaiter(this, void 0, void 0, function* () {
+		let wasmInstance = null;
+		let memoryView = null;
+		let initialized = false;
+		if (typeof WebAssembly === "undefined") throw new Error("WebAssembly is not supported in this environment!");
+		const writeMemory = (data, offset = 0) => {
+			memoryView.set(data, offset);
+		};
+		const getMemory = () => memoryView;
+		const getExports = () => wasmInstance.exports;
+		const setMemorySize = (totalSize) => {
+			wasmInstance.exports.Hash_SetMemorySize(totalSize);
+			const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+			const memoryBuffer = wasmInstance.exports.memory.buffer;
+			memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+		};
+		const getStateSize = () => {
+			return new DataView(wasmInstance.exports.memory.buffer).getUint32(wasmInstance.exports.STATE_SIZE, true);
+		};
+		const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
+			if (!wasmModuleCache.has(binary.name)) {
+				const asm = decodeBase64(binary.data);
+				const promise = WebAssembly.compile(asm);
+				wasmModuleCache.set(binary.name, promise);
+			}
+			const module = yield wasmModuleCache.get(binary.name);
+			wasmInstance = yield WebAssembly.instantiate(module, {});
+		}));
+		const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
+			if (!wasmInstance) yield loadWASMPromise;
+			const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+			const memoryBuffer = wasmInstance.exports.memory.buffer;
+			memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+		});
+		const init = (bits = null) => {
+			initialized = true;
+			wasmInstance.exports.Hash_Init(bits);
+		};
+		const updateUInt8Array = (data) => {
+			let read = 0;
+			while (read < data.length) {
+				const chunk = data.subarray(read, read + MAX_HEAP);
+				read += chunk.length;
+				memoryView.set(chunk);
+				wasmInstance.exports.Hash_Update(chunk.length);
+			}
+		};
+		const update = (data) => {
+			if (!initialized) throw new Error("update() called before init()");
+			updateUInt8Array(getUInt8Buffer(data));
+		};
+		const digestChars = new Uint8Array(hashLength * 2);
+		const digest = (outputType, padding = null) => {
+			if (!initialized) throw new Error("digest() called before init()");
+			initialized = false;
+			wasmInstance.exports.Hash_Final(padding);
+			if (outputType === "binary") return memoryView.slice(0, hashLength);
+			return getDigestHex(digestChars, memoryView, hashLength);
+		};
+		const save = () => {
+			if (!initialized) throw new Error("save() can only be called after init() and before digest()");
+			const stateOffset = wasmInstance.exports.Hash_GetState();
+			const stateLength = getStateSize();
+			const memoryBuffer = wasmInstance.exports.memory.buffer;
+			const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+			const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+			writeHexToUInt8(prefixedState, binary.hash);
+			prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+			return prefixedState;
+		};
+		const load = (state) => {
+			if (!(state instanceof Uint8Array)) throw new Error("load() expects an Uint8Array generated by save()");
+			const stateOffset = wasmInstance.exports.Hash_GetState();
+			const stateLength = getStateSize();
+			const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
+			const memoryBuffer = wasmInstance.exports.memory.buffer;
+			if (state.length !== overallLength) throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+			if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) throw new Error("This state was written by an incompatible hash implementation");
+			const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+			new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+			initialized = true;
+		};
+		const isDataShort = (data) => {
+			if (typeof data === "string") return data.length < MAX_HEAP / 4;
+			return data.byteLength < MAX_HEAP;
+		};
+		let canSimplify = isDataShort;
+		switch (binary.name) {
+			case "argon2":
+			case "scrypt":
+				canSimplify = () => true;
+				break;
+			case "blake2b":
+			case "blake2s":
+				canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
+				break;
+			case "blake3":
+				canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+				break;
+			case "xxhash64":
+			case "xxhash3":
+			case "xxhash128":
+			case "crc64":
+				canSimplify = () => false;
+				break;
+		}
+		const calculate = (data, initParam = null, digestParam = null) => {
+			if (!canSimplify(data, initParam)) {
+				init(initParam);
+				update(data);
+				return digest("hex", digestParam);
+			}
+			const buffer = getUInt8Buffer(data);
+			memoryView.set(buffer);
+			wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
+			return getDigestHex(digestChars, memoryView, hashLength);
+		};
+		yield setupInterface();
+		return {
+			getMemory,
+			writeMemory,
+			getExports,
+			setMemorySize,
+			init,
+			update,
+			digest,
+			save,
+			load,
+			calculate,
+			hashLength
+		};
+	});
+}
+const mutex$l = new Mutex();
+var wasmJson$k = {
+	name: "argon2",
+	data: "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",
+	hash: "e4cdc523"
+};
+var wasmJson$j = {
+	name: "blake2b",
+	data: "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",
+	hash: "c6f286e6"
+};
+const mutex$k = new Mutex();
+function validateBits$4(bits) {
+	if (!Number.isInteger(bits) || bits < 8 || bits > 512 || bits % 8 !== 0) return /* @__PURE__ */ new Error("Invalid variant! Valid values: 8, 16, ..., 512");
+	return null;
+}
+function getInitParam$1(outputBits, keyBits) {
+	return outputBits | keyBits << 16;
+}
+/**
+* Creates a new BLAKE2b hash instance
+* @param bits Number of output bits, which has to be a number
+*             divisible by 8, between 8 and 512. Defaults to 512.
+* @param key Optional key (string, Buffer or TypedArray). Maximum length is 64 bytes.
+*/
+function createBLAKE2b(bits = 512, key = null) {
+	if (validateBits$4(bits)) return Promise.reject(validateBits$4(bits));
+	let keyBuffer = null;
+	let initParam = bits;
+	if (key !== null) {
+		keyBuffer = getUInt8Buffer(key);
+		if (keyBuffer.length > 64) return Promise.reject(/* @__PURE__ */ new Error("Max key length is 64 bytes"));
+		initParam = getInitParam$1(bits, keyBuffer.length);
+	}
+	const outputSize = bits / 8;
+	return WASMInterface(wasmJson$j, outputSize).then((wasm) => {
+		if (initParam > 512) wasm.writeMemory(keyBuffer);
+		wasm.init(initParam);
+		const obj = {
+			init: initParam > 512 ? () => {
+				wasm.writeMemory(keyBuffer);
+				wasm.init(initParam);
+				return obj;
+			} : () => {
+				wasm.init(initParam);
+				return obj;
+			},
+			update: (data) => {
+				wasm.update(data);
+				return obj;
+			},
+			digest: (outputType) => wasm.digest(outputType),
+			save: () => wasm.save(),
+			load: (data) => {
+				wasm.load(data);
+				return obj;
+			},
+			blockSize: 128,
+			digestSize: outputSize
+		};
+		return obj;
+	});
+}
+function encodeResult(salt, options, res) {
+	const parameters = [
+		`m=${options.memorySize}`,
+		`t=${options.iterations}`,
+		`p=${options.parallelism}`
+	].join(",");
+	return `$argon2${options.hashType}$v=19$${parameters}$${encodeBase64(salt, false)}$${encodeBase64(res, false)}`;
+}
+const uint32View = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+function int32LE(x) {
+	uint32View.setInt32(0, x, true);
+	return new Uint8Array(uint32View.buffer);
+}
+function hashFunc(blake512, buf, len) {
+	return __awaiter(this, void 0, void 0, function* () {
+		if (len <= 64) {
+			const blake = yield createBLAKE2b(len * 8);
+			blake.update(int32LE(len));
+			blake.update(buf);
+			return blake.digest("binary");
+		}
+		const r = Math.ceil(len / 32) - 2;
+		const ret = new Uint8Array(len);
+		blake512.init();
+		blake512.update(int32LE(len));
+		blake512.update(buf);
+		let vp = blake512.digest("binary");
+		ret.set(vp.subarray(0, 32), 0);
+		for (let i = 1; i < r; i++) {
+			blake512.init();
+			blake512.update(vp);
+			vp = blake512.digest("binary");
+			ret.set(vp.subarray(0, 32), i * 32);
+		}
+		const partialBytesNeeded = len - 32 * r;
+		let blakeSmall;
+		if (partialBytesNeeded === 64) {
+			blakeSmall = blake512;
+			blakeSmall.init();
+		} else blakeSmall = yield createBLAKE2b(partialBytesNeeded * 8);
+		blakeSmall.update(vp);
+		vp = blakeSmall.digest("binary");
+		ret.set(vp.subarray(0, partialBytesNeeded), r * 32);
+		return ret;
+	});
+}
+function getHashType(type) {
+	switch (type) {
+		case "d": return 0;
+		case "i": return 1;
+		default: return 2;
+	}
+}
+function argon2Internal(options) {
+	return __awaiter(this, void 0, void 0, function* () {
+		var _a;
+		const { parallelism, iterations, hashLength } = options;
+		const password = getUInt8Buffer(options.password);
+		const salt = getUInt8Buffer(options.salt);
+		const version = 19;
+		const hashType = getHashType(options.hashType);
+		const { memorySize } = options;
+		const secret = getUInt8Buffer((_a = options.secret) !== null && _a !== void 0 ? _a : "");
+		const [argon2Interface, blake512] = yield Promise.all([WASMInterface(wasmJson$k, 1024), createBLAKE2b(512)]);
+		argon2Interface.setMemorySize(memorySize * 1024 + 1024);
+		const initVector = new Uint8Array(24);
+		const initVectorView = new DataView(initVector.buffer);
+		initVectorView.setInt32(0, parallelism, true);
+		initVectorView.setInt32(4, hashLength, true);
+		initVectorView.setInt32(8, memorySize, true);
+		initVectorView.setInt32(12, iterations, true);
+		initVectorView.setInt32(16, version, true);
+		initVectorView.setInt32(20, hashType, true);
+		argon2Interface.writeMemory(initVector, memorySize * 1024);
+		blake512.init();
+		blake512.update(initVector);
+		blake512.update(int32LE(password.length));
+		blake512.update(password);
+		blake512.update(int32LE(salt.length));
+		blake512.update(salt);
+		blake512.update(int32LE(secret.length));
+		blake512.update(secret);
+		blake512.update(int32LE(0));
+		const lanes = Math.floor(memorySize / (parallelism * 4)) * 4;
+		const param = new Uint8Array(72);
+		const H0 = blake512.digest("binary");
+		param.set(H0);
+		for (let lane = 0; lane < parallelism; lane++) {
+			param.set(int32LE(0), 64);
+			param.set(int32LE(lane), 68);
+			let position = lane * lanes;
+			let chunk = yield hashFunc(blake512, param, 1024);
+			argon2Interface.writeMemory(chunk, position * 1024);
+			position += 1;
+			param.set(int32LE(1), 64);
+			chunk = yield hashFunc(blake512, param, 1024);
+			argon2Interface.writeMemory(chunk, position * 1024);
+		}
+		const C = new Uint8Array(1024);
+		writeHexToUInt8(C, argon2Interface.calculate(new Uint8Array([]), memorySize));
+		const res = yield hashFunc(blake512, C, hashLength);
+		if (options.outputType === "hex") return getDigestHex(new Uint8Array(hashLength * 2), res, hashLength);
+		if (options.outputType === "encoded") return encodeResult(salt, options, res);
+		return res;
+	});
+}
+const validateOptions$3 = (options) => {
+	var _a;
+	if (!options || typeof options !== "object") throw new Error("Invalid options parameter. It requires an object.");
+	if (!options.password) throw new Error("Password must be specified");
+	options.password = getUInt8Buffer(options.password);
+	if (options.password.length < 1) throw new Error("Password must be specified");
+	if (!options.salt) throw new Error("Salt must be specified");
+	options.salt = getUInt8Buffer(options.salt);
+	if (options.salt.length < 8) throw new Error("Salt should be at least 8 bytes long");
+	options.secret = getUInt8Buffer((_a = options.secret) !== null && _a !== void 0 ? _a : "");
+	if (!Number.isInteger(options.iterations) || options.iterations < 1) throw new Error("Iterations should be a positive number");
+	if (!Number.isInteger(options.parallelism) || options.parallelism < 1) throw new Error("Parallelism should be a positive number");
+	if (!Number.isInteger(options.hashLength) || options.hashLength < 4) throw new Error("Hash length should be at least 4 bytes.");
+	if (!Number.isInteger(options.memorySize)) throw new Error("Memory size should be specified.");
+	if (options.memorySize < 8 * options.parallelism) throw new Error("Memory size should be at least 8 * parallelism.");
+	if (options.outputType === void 0) options.outputType = "hex";
+	if (![
+		"hex",
+		"binary",
+		"encoded"
+	].includes(options.outputType)) throw new Error(`Insupported output type ${options.outputType}. Valid values: ['hex', 'binary', 'encoded']`);
+};
+/**
+* Calculates hash using the argon2id password-hashing function
+* @returns Computed hash
+*/
+function argon2id(options) {
+	return __awaiter(this, void 0, void 0, function* () {
+		validateOptions$3(options);
+		return argon2Internal(Object.assign(Object.assign({}, options), { hashType: "id" }));
+	});
+}
+const mutex$j = new Mutex();
+const mutex$i = new Mutex();
+const mutex$h = new Mutex();
+const mutex$g = new Mutex();
+const polyBuffer = new Uint8Array(8);
+const mutex$f = new Mutex();
+const mutex$e = new Mutex();
+const mutex$d = new Mutex();
+const mutex$c = new Mutex();
+const mutex$b = new Mutex();
+const mutex$a = new Mutex();
+const mutex$9 = new Mutex();
+const mutex$8 = new Mutex();
+const mutex$7 = new Mutex();
+const mutex$6 = new Mutex();
+const mutex$5 = new Mutex();
+const seedBuffer$2 = new Uint8Array(8);
+const mutex$4 = new Mutex();
+const seedBuffer$1 = new Uint8Array(8);
+const mutex$3 = new Mutex();
+const seedBuffer = new Uint8Array(8);
+const mutex$2 = new Mutex();
+const mutex$1 = new Mutex();
+const mutex = new Mutex();
+
+//#endregion
+//#region src/derive-key/core.ts
+/**
+* Calculates hash using the argon2id password-hashing function
+*
+* @param password - The user's password
+* @param salt - The given salt
+* @param parallelism - The degree of parallelism
+* @param iterations - The number of iterations
+* @param memorySize - The memory size in KB
+* @param hashLength - The desired hash byte length
+* @returns The resulting hash
+*/
+async function argon2(password, salt, parallelism = ARGON2ID_PARALLELISM, iterations = ARGON2ID_ITERATIONS, memorySize = ARGON2ID_MEMORY_SIZE, hashLength = ARGON2ID_OUTPUT_BYTE_LENGTH) {
+	return argon2id({
+		password,
+		salt,
+		parallelism,
+		iterations,
+		memorySize,
+		hashLength,
+		outputType: "binary"
+	});
+}
+/**
+* Samples a salt
+*
+* @returns The salt
+*/
+function sampleSalt() {
+	try {
+		const salt = new Uint8Array(ARGON2ID_SALT_BYTE_LENGTH);
+		crypto.getRandomValues(salt);
+		return salt;
+	} catch (error) {
+		throw new Error("Failed to sample salt", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/derive-key/deriveKeysFromPassword.ts
+/**
+* Derives a symmetric key from a user's password with a randomly sampled salt
+*
+* @param password - The user's password
+* @returns The derived secret key and randomly sampled salt
+*/
+async function getKeyFromPassword(password) {
+	try {
+		if (!password) throw new Error("No password given");
+		const salt = sampleSalt();
+		return {
+			key: await argon2(password, salt),
+			salt
+		};
+	} catch (error) {
+		throw new Error("Failed to derive key from password", { cause: error });
+	}
+}
+/**
+* Derives a symmetric key from a user's password and salt
+*
+* @param password - The user's password
+* @param salt - The given salt
+* @returns The derived secret key
+*/
+async function getKeyFromPasswordAndSalt(password, salt) {
+	try {
+		if (!salt.length) throw new Error("No salt given");
+		if (!password) throw new Error("No password given");
+		return await argon2(password, salt);
+	} catch (error) {
+		throw new Error("Failed to derive key from password and salt", { cause: error });
+	}
+}
+/**
+* Derives a HEX symmetric key from a user's password with a randomly sampled salt
+*
+* @param password - The user's password
+* @returns The derived HEX secret key and randomly sampled HEX salt
+*/
+async function getKeyFromPasswordHex(password) {
+	try {
+		const { key, salt } = await getKeyFromPassword(password);
+		return {
+			keyHex: uint8ArrayToHex(key),
+			saltHex: uint8ArrayToHex(salt)
+		};
+	} catch (error) {
+		throw new Error("Failed to derive key from password", { cause: error });
+	}
+}
+/**
+* Derives a HEX symmetric key from a user's password and salt
+*
+* @param password - The user's password
+* @param saltHex - The given HEX salt
+* @returns The derived HEX secret key
+*/
+async function getKeyFromPasswordAndSaltHex(password, saltHex) {
+	try {
+		return uint8ArrayToHex(await getKeyFromPasswordAndSalt(password, hexToUint8Array(saltHex)));
+	} catch (error) {
+		throw new Error("Failed to derive key from password and salt", { cause: error });
+	}
+}
+/**
+* Verifies the derived key
+*
+* @param password - The user's password
+* @param saltHex - The given HEX salt
+* @param keyHex - The derived HEX key
+* @returns The result of the key verification
+*/
+async function verifyKeyFromPasswordHex(password, saltHex, keyHex) {
+	return keyHex === await getKeyFromPasswordAndSaltHex(password, saltHex);
+}
+
+//#endregion
+export { verifyKeyFromPasswordHex as a, deriveSymmetricKeyFromContext as c, getKeyFromPasswordHex as i, deriveSymmetricKeyFromTwoKeys as l, getKeyFromPasswordAndSalt as n, deriveSymmetricCryptoKeyFromContext as o, getKeyFromPasswordAndSaltHex as r, deriveSymmetricCryptoKeyFromTwoKeys as s, getKeyFromPassword as t, deriveSymmetricKeyFromTwoKeysAndContext as u };
+//# sourceMappingURL=deriveKeysFromPassword-DJRWZ8Rw.mjs.map