@yielded/crypto 0.0.0-stage → 0.1.0-beta.19

package/dist/internal/argon2-core.mjs

@@ -0,0 +1,293 @@
+import { rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from "./word64.mjs";
+import { Blake2b } from "./blake2b.mjs";
+//#region src/internal/argon2-core.ts
+/**
+* Adapted from noble-hashes, Copyright (c) 2022 Paul Miller.
+* MIT; source revision 8060cc83bbab6681d23c9eed071db3f3a6b442da.
+* See ../../THIRD_PARTY_NOTICES.md for source mapping and license.
+*/
+const ARGON2_SYNC_POINTS = 4;
+function mul(a, b) {
+	const aL = a & 65535;
+	const aH = a >>> 16;
+	const bL = b & 65535;
+	const bH = b >>> 16;
+	const ll = Math.imul(aL, bL);
+	const hl = Math.imul(aH, bL);
+	const lh = Math.imul(aL, bH);
+	const hh = Math.imul(aH, bH);
+	const carry = (ll >>> 16) + (hl & 65535) + lh;
+	return {
+		h: hh + (hl >>> 16) + (carry >>> 16) | 0,
+		l: carry << 16 | ll & 65535
+	};
+}
+function mulHi(a, b) {
+	const aL = a & 65535, aH = a >>> 16, bL = b & 65535, bH = b >>> 16;
+	const carry = (Math.imul(aL, bL) >>> 16) + (Math.imul(aH, bL) & 65535) + Math.imul(aL, bH);
+	return Math.imul(aH, bH) + (Math.imul(aH, bL) >>> 16) + (carry >>> 16) | 0;
+}
+function G(A2_BUF, a, b, c, d) {
+	let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1];
+	let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1];
+	let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1];
+	let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1];
+	let ml = 0, mh = 0, rl = 0, xh = 0, xl = 0;
+	ml = Math.imul(Al, Bl);
+	mh = mulHi(Al, Bl);
+	rl = (Al >>> 0) + (Bl >>> 0) + (ml << 1 >>> 0);
+	Ah = Ah + Bh + (mh << 1 | ml >>> 31) + (rl / 4294967296 | 0) | 0;
+	Al = rl | 0;
+	xh = Dh ^ Ah;
+	xl = Dl ^ Al;
+	Dh = rotr32H(xh, xl);
+	Dl = rotr32L(xh, xl);
+	ml = Math.imul(Cl, Dl);
+	mh = mulHi(Cl, Dl);
+	rl = (Cl >>> 0) + (Dl >>> 0) + (ml << 1 >>> 0);
+	Ch = Ch + Dh + (mh << 1 | ml >>> 31) + (rl / 4294967296 | 0) | 0;
+	Cl = rl | 0;
+	xh = Bh ^ Ch;
+	xl = Bl ^ Cl;
+	Bh = rotrSH(xh, xl, 24);
+	Bl = rotrSL(xh, xl, 24);
+	ml = Math.imul(Al, Bl);
+	mh = mulHi(Al, Bl);
+	rl = (Al >>> 0) + (Bl >>> 0) + (ml << 1 >>> 0);
+	Ah = Ah + Bh + (mh << 1 | ml >>> 31) + (rl / 4294967296 | 0) | 0;
+	Al = rl | 0;
+	xh = Dh ^ Ah;
+	xl = Dl ^ Al;
+	Dh = rotrSH(xh, xl, 16);
+	Dl = rotrSL(xh, xl, 16);
+	ml = Math.imul(Cl, Dl);
+	mh = mulHi(Cl, Dl);
+	rl = (Cl >>> 0) + (Dl >>> 0) + (ml << 1 >>> 0);
+	Ch = Ch + Dh + (mh << 1 | ml >>> 31) + (rl / 4294967296 | 0) | 0;
+	Cl = rl | 0;
+	xh = Bh ^ Ch;
+	xl = Bl ^ Cl;
+	Bh = rotrBH(xh, xl, 63);
+	Bl = rotrBL(xh, xl, 63);
+	A2_BUF[2 * a] = Al;
+	A2_BUF[2 * a + 1] = Ah;
+	A2_BUF[2 * b] = Bl;
+	A2_BUF[2 * b + 1] = Bh;
+	A2_BUF[2 * c] = Cl;
+	A2_BUF[2 * c + 1] = Ch;
+	A2_BUF[2 * d] = Dl;
+	A2_BUF[2 * d + 1] = Dh;
+}
+function P(A2_BUF, v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {
+	G(A2_BUF, v00, v04, v08, v12);
+	G(A2_BUF, v01, v05, v09, v13);
+	G(A2_BUF, v02, v06, v10, v14);
+	G(A2_BUF, v03, v07, v11, v15);
+	G(A2_BUF, v00, v05, v10, v15);
+	G(A2_BUF, v01, v06, v11, v12);
+	G(A2_BUF, v02, v07, v08, v13);
+	G(A2_BUF, v03, v04, v09, v14);
+}
+function block(A2_BUF, x, xPos, yPos, outPos, needXor) {
+	for (let i = 0; i < 256; i++) A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
+	for (let i = 0; i < 128; i += 16) P(A2_BUF, i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);
+	for (let i = 0; i < 16; i += 2) P(A2_BUF, i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);
+	if (needXor) for (let i = 0; i < 256; i++) x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+	else for (let i = 0; i < 256; i++) x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+	A2_BUF.fill(0);
+}
+function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
+	let area;
+	if (r === 0) {
+		if (s === 0) area = index - 1;
+		else if (sameLane) area = s * segmentLen + index - 1;
+		else area = s * segmentLen + (index === 0 ? -1 : 0);
+	} else if (sameLane) area = laneLen - segmentLen + index - 1;
+	else area = laneLen - segmentLen + (index === 0 ? -1 : 0);
+	return ((r !== 0 && s !== 3 ? (s + 1) * segmentLen : 0) + (area - 1 - mul(area, mul(randL, randL).h).h)) % laneLen;
+}
+const bytesOfWords = (words) => {
+	const bytes = new Uint8Array(words.length * 4);
+	const view = new DataView(bytes.buffer);
+	for (let i = 0; i < words.length; i++) view.setUint32(i * 4, words[i], true);
+	return bytes;
+};
+const hash = (data, length = 64) => {
+	const state = new Blake2b(length);
+	try {
+		return state.update(data).digest();
+	} finally {
+		state.destroy();
+	}
+};
+function variableHash(words, length) {
+	const data = bytesOfWords(words);
+	const prefix = /* @__PURE__ */ new Uint8Array(4);
+	new DataView(prefix.buffer).setUint32(0, length, true);
+	const state = new Blake2b(Math.min(length, 64));
+	let previous;
+	let out;
+	try {
+		previous = state.update(prefix).update(data).digest();
+		if (length <= 64) {
+			const result = previous;
+			previous = void 0;
+			return result;
+		}
+		out = new Uint8Array(length);
+		out.set(previous.subarray(0, 32));
+		let position = 32;
+		for (; length - position > 64; position += 32) {
+			const next = hash(previous);
+			previous.fill(0);
+			previous = next;
+			out.set(previous.subarray(0, 32), position);
+		}
+		const last = hash(previous, length - position);
+		out.set(last, position);
+		last.fill(0);
+		return out;
+	} catch (error) {
+		out?.fill(0);
+		throw error;
+	} finally {
+		state.destroy();
+		previous?.fill(0);
+		prefix.fill(0);
+		data.fill(0);
+	}
+}
+const allocate = (input) => {
+	const blocks = 4 * input.parallelism * Math.floor(input.memoryKiB / (4 * input.parallelism));
+	const laneLength = blocks / input.parallelism;
+	return {
+		memory: new Uint32Array(blocks * 256),
+		scratch: /* @__PURE__ */ new Uint32Array(256),
+		address: /* @__PURE__ */ new Uint32Array(768),
+		initial: /* @__PURE__ */ new Uint32Array(18),
+		final: /* @__PURE__ */ new Uint32Array(256),
+		blocks,
+		laneLength,
+		segmentLength: laneLength / 4
+	};
+};
+const destroy = (state) => {
+	state.memory.fill(0);
+	state.scratch.fill(0);
+	state.address.fill(0);
+	state.initial.fill(0);
+	state.final.fill(0);
+};
+const initialize = (state, input) => {
+	const h = new Blake2b();
+	const scalar = /* @__PURE__ */ new Uint8Array(4);
+	const view = new DataView(scalar.buffer);
+	const number = (value) => {
+		view.setUint32(0, value, true);
+		h.update(scalar);
+	};
+	try {
+		for (const value of [
+			input.parallelism,
+			input.length,
+			input.memoryKiB,
+			input.passes,
+			19,
+			2
+		]) number(value);
+		for (const data of [
+			input.password,
+			input.salt,
+			input.secret ?? /* @__PURE__ */ new Uint8Array(),
+			input.associatedData
+		]) {
+			number(data.length);
+			h.update(data);
+		}
+		const initial = h.digest();
+		try {
+			const hashView = new DataView(initial.buffer, initial.byteOffset, initial.byteLength);
+			for (let i = 0; i < 16; i++) state.initial[i] = hashView.getUint32(i * 4, true);
+		} finally {
+			initial.fill(0);
+		}
+		for (let lane = 0; lane < input.parallelism; lane++) {
+			state.initial[17] = lane;
+			for (let first = 0; first < 2; first++) {
+				state.initial[16] = first;
+				const expanded = variableHash(state.initial, 1024);
+				try {
+					const expandedView = new DataView(expanded.buffer, expanded.byteOffset, expanded.byteLength);
+					const offset = (lane * state.laneLength + first) * 256;
+					for (let i = 0; i < 256; i++) state.memory[offset + i] = expandedView.getUint32(i * 4, true);
+				} finally {
+					expanded.fill(0);
+				}
+			}
+		}
+	} finally {
+		h.destroy();
+		scalar.fill(0);
+		state.initial.fill(0);
+	}
+};
+/** Yield block boundaries to the Effect driver; all scratch belongs to this derivation. */
+function* fill(state, input) {
+	const { memory: B, scratch, address, laneLength: laneLen, segmentLength: segmentLen } = state;
+	const p = input.parallelism;
+	address[262] = state.blocks;
+	address[264] = input.passes;
+	address[266] = 2;
+	for (let r = 0; r < input.passes; r++) {
+		const needXor = r !== 0;
+		address[256] = r;
+		for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+			address[260] = s;
+			const dataIndependent = r === 0 && s < 2;
+			for (let lane = 0; lane < p; lane++) {
+				address[258] = lane;
+				address[268] = 0;
+				const start = r === 0 && s === 0 ? 2 : 0;
+				if (start === 2 && dataIndependent) {
+					address[268]++;
+					block(scratch, address, 256, 512, 0, false);
+					block(scratch, address, 0, 512, 0, false);
+				}
+				let offset = lane * laneLen + s * segmentLen + start;
+				for (let index = start; index < segmentLen; index++, offset++) {
+					const prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+					let randL;
+					let randH;
+					if (dataIndependent) {
+						const addressIndex = index % 128;
+						if (addressIndex === 0) {
+							address[268]++;
+							block(scratch, address, 256, 512, 0, false);
+							block(scratch, address, 0, 512, 0, false);
+						}
+						randL = address[2 * addressIndex];
+						randH = address[2 * addressIndex + 1];
+					} else {
+						randL = B[256 * prev];
+						randH = B[256 * prev + 1];
+					}
+					const refLane = r === 0 && s === 0 ? lane : randH % p;
+					const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane === lane);
+					block(scratch, B, 256 * prev, 256 * (laneLen * refLane + refPos), offset * 256, needXor);
+					yield;
+				}
+			}
+		}
+	}
+}
+const output = (state, input) => {
+	for (let lane = 0; lane < input.parallelism; lane++) {
+		const offset = 256 * (state.laneLength * lane + state.laneLength - 1);
+		for (let word = 0; word < 256; word++) state.final[word] ^= state.memory[offset + word];
+	}
+	return variableHash(state.final, input.length);
+};
+//#endregion
+export { allocate, destroy, fill, initialize, output };
+
+//# sourceMappingURL=argon2-core.mjs.map

package/dist/internal/argon2-core.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"argon2-core.mjs","names":[],"sources":["../../src/internal/argon2-core.ts"],"sourcesContent":["import { Blake2b } from \"./blake2b\";\nimport type { Argon2Parameters } from \"./kdf\";\n/**\n * Adapted from noble-hashes, Copyright (c) 2022 Paul Miller.\n * MIT; source revision 8060cc83bbab6681d23c9eed071db3f3a6b442da.\n * See ../../THIRD_PARTY_NOTICES.md for source mapping and license.\n */\nimport { rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from \"./word64\";\n\nconst ARGON2_SYNC_POINTS = 4;\n\n// Unsigned `u32 * u32 = { h, l }`, returned as split 64-bit halves.\nfunction mul(a: number, b: number) {\n  // Split into 16-bit limbs so each partial product stays exact under `Math.imul`.\n  const aL = a & 0xffff;\n  const aH = a >>> 16;\n  const bL = b & 0xffff;\n  const bH = b >>> 16;\n  const ll = Math.imul(aL, bL);\n  const hl = Math.imul(aH, bL);\n  const lh = Math.imul(aL, bH);\n  const hh = Math.imul(aH, bH);\n  const carry = (ll >>> 16) + (hl & 0xffff) + lh;\n  const high = (hh + (hl >>> 16) + (carry >>> 16)) | 0;\n  const low = (carry << 16) | (ll & 0xffff);\n\n  return { h: high, l: low };\n}\n\n// High 32 bits of unsigned u32 multiply, via the same 16-bit limb split as `mul`.\nfunction mulHi(a: number, b: number): number {\n  const aL = a & 0xffff,\n    aH = a >>> 16,\n    bL = b & 0xffff,\n    bH = b >>> 16;\n\n  const carry = (Math.imul(aL, bL) >>> 16) + (Math.imul(aH, bL) & 0xffff) + Math.imul(aL, bH);\n\n  return (Math.imul(aH, bH) + (Math.imul(aH, bL) >>> 16) + (carry >>> 16)) | 0;\n}\n\n// 1024-byte block: 256 u32 = 128 interleaved low/high halves = RFC's\n// 8x8 matrix of 16-byte registers.\n\n// Quarter-round over 64-bit word indices into `A2_BUF`; each index maps to adjacent low/high u32s.\n// Each BlaMka step `X = X + Y + 2 * trunc(X) * trunc(Y)` (trunc = low 32 bits) is three lines:\n// `Math.imul` is the low product half, `mulHi` the high half, then a split 64-bit add with the\n// doubling folded in. RFC 9106 Figure 19 GB rotates by 32, 24, 16, and 63 bits after each XOR.\nfunction G(A2_BUF: Uint32Array, a: number, b: number, c: number, d: number) {\n  let Al = A2_BUF[2 * a],\n    Ah = A2_BUF[2 * a + 1];\n\n  let Bl = A2_BUF[2 * b],\n    Bh = A2_BUF[2 * b + 1];\n\n  let Cl = A2_BUF[2 * c],\n    Ch = A2_BUF[2 * c + 1];\n\n  let Dl = A2_BUF[2 * d],\n    Dh = A2_BUF[2 * d + 1];\n\n  let ml = 0,\n    mh = 0,\n    rl = 0,\n    xh = 0,\n    xl = 0;\n\n  // A = blamka(A, B); D = rotr64(D ^ A, 32)\n  ml = Math.imul(Al, Bl);\n  mh = mulHi(Al, Bl);\n  rl = (Al >>> 0) + (Bl >>> 0) + ((ml << 1) >>> 0);\n  Ah = (Ah + Bh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n  Al = rl | 0;\n  xh = Dh ^ Ah;\n  xl = Dl ^ Al;\n  Dh = rotr32H(xh, xl);\n  Dl = rotr32L(xh, xl);\n\n  // C = blamka(C, D); B = rotr64(B ^ C, 24)\n  ml = Math.imul(Cl, Dl);\n  mh = mulHi(Cl, Dl);\n  rl = (Cl >>> 0) + (Dl >>> 0) + ((ml << 1) >>> 0);\n  Ch = (Ch + Dh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n  Cl = rl | 0;\n  xh = Bh ^ Ch;\n  xl = Bl ^ Cl;\n  Bh = rotrSH(xh, xl, 24);\n  Bl = rotrSL(xh, xl, 24);\n\n  // A = blamka(A, B); D = rotr64(D ^ A, 16)\n  ml = Math.imul(Al, Bl);\n  mh = mulHi(Al, Bl);\n  rl = (Al >>> 0) + (Bl >>> 0) + ((ml << 1) >>> 0);\n  Ah = (Ah + Bh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n  Al = rl | 0;\n  xh = Dh ^ Ah;\n  xl = Dl ^ Al;\n  Dh = rotrSH(xh, xl, 16);\n  Dl = rotrSL(xh, xl, 16);\n\n  // C = blamka(C, D); B = rotr64(B ^ C, 63)\n  ml = Math.imul(Cl, Dl);\n  mh = mulHi(Cl, Dl);\n  rl = (Cl >>> 0) + (Dl >>> 0) + ((ml << 1) >>> 0);\n  Ch = (Ch + Dh + ((mh << 1) | (ml >>> 31)) + ((rl / 0x100000000) | 0)) | 0;\n  Cl = rl | 0;\n  xh = Bh ^ Ch;\n  xl = Bl ^ Cl;\n  Bh = rotrBH(xh, xl, 63);\n  Bl = rotrBL(xh, xl, 63);\n\n  A2_BUF[2 * a] = Al;\n  A2_BUF[2 * a + 1] = Ah;\n  A2_BUF[2 * b] = Bl;\n  A2_BUF[2 * b + 1] = Bh;\n  A2_BUF[2 * c] = Cl;\n  A2_BUF[2 * c + 1] = Ch;\n  A2_BUF[2 * d] = Dl;\n  A2_BUF[2 * d + 1] = Dh;\n}\n\n// Argon2 permutation over 16 register indices into `A2_BUF`, not the register values themselves.\n// RFC 9106 Figure 17: these arguments are the 16 `v0..v15` 64-bit word\n// indices inside eight 16-byte inputs, not copied word values.\nfunction P(\n  A2_BUF: Uint32Array,\n  v00: number,\n  v01: number,\n  v02: number,\n  v03: number,\n  v04: number,\n  v05: number,\n  v06: number,\n  v07: number,\n  v08: number,\n  v09: number,\n  v10: number,\n  v11: number,\n  v12: number,\n  v13: number,\n  v14: number,\n  v15: number,\n) {\n  // RFC 9106 Figure 18: first apply GB across rows, then across columns of the 8x8 register matrix.\n  G(A2_BUF, v00, v04, v08, v12);\n  G(A2_BUF, v01, v05, v09, v13);\n  G(A2_BUF, v02, v06, v10, v14);\n  G(A2_BUF, v03, v07, v11, v15);\n  G(A2_BUF, v00, v05, v10, v15);\n  G(A2_BUF, v01, v06, v11, v12);\n  G(A2_BUF, v02, v07, v08, v13);\n  G(A2_BUF, v03, v04, v09, v14);\n}\n\nfunction block(\n  A2_BUF: Uint32Array,\n  x: Uint32Array,\n  xPos: number,\n  yPos: number,\n  outPos: number,\n  needXor: boolean,\n) {\n  for (let i = 0; i < 256; i++) A2_BUF[i] = x[xPos + i] ^ x[yPos + i];\n  // rows (8 consecutive 16-register groups)\n  for (let i = 0; i < 128; i += 16) {\n    P(\n      A2_BUF,\n      i,\n      i + 1,\n      i + 2,\n      i + 3,\n      i + 4,\n      i + 5,\n      i + 6,\n      i + 7,\n      i + 8,\n      i + 9,\n      i + 10,\n      i + 11,\n      i + 12,\n      i + 13,\n      i + 14,\n      i + 15,\n    );\n  }\n  // columns (8 strided 16-register groups)\n  for (let i = 0; i < 16; i += 2) {\n    P(\n      A2_BUF,\n      i,\n      i + 1,\n      i + 16,\n      i + 17,\n      i + 32,\n      i + 33,\n      i + 48,\n      i + 49,\n      i + 64,\n      i + 65,\n      i + 80,\n      i + 81,\n      i + 96,\n      i + 97,\n      i + 112,\n      i + 113,\n    );\n  }\n\n  // RFC 9106 step 6: passes after the first XOR the old destination block into the new G(X, Y).\n  if (needXor) for (let i = 0; i < 256; i++) x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];\n  else for (let i = 0; i < 256; i++) x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];\n  A2_BUF.fill(0);\n}\n\n// Used only inside argon2Blocks!\nfunction indexAlpha(\n  r: number,\n  s: number,\n  laneLen: number,\n  segmentLen: number,\n  index: number,\n  randL: number,\n  sameLane: boolean = false,\n) {\n  // RFC 9106 §3.4.2 Figures 12-13: map `J1` / `J2` into the current lane's reference area `W`.\n  let area: number;\n\n  if (r === 0) {\n    if (s === 0) area = index - 1;\n    else if (sameLane) area = s * segmentLen + index - 1;\n    else area = s * segmentLen + (index === 0 ? -1 : 0);\n  } else if (sameLane) area = laneLen - segmentLen + index - 1;\n  else area = laneLen - segmentLen + (index === 0 ? -1 : 0);\n  const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;\n  // RFC 9106 Figure 13: `mul(randL, randL).h` is `floor(J_1^2 / 2^32)`, and the outer high-half\n  // multiply computes `floor(|W| * x / 2^32)` without floating-point math.\n  const rel = area - 1 - mul(area, mul(randL, randL).h).h;\n\n  return (startPos + rel) % laneLen;\n}\n\nconst bytesOfWords = (words: Uint32Array): Uint8Array => {\n  const bytes = new Uint8Array(words.length * 4);\n  const view = new DataView(bytes.buffer);\n\n  for (let i = 0; i < words.length; i++) view.setUint32(i * 4, words[i], true);\n\n  return bytes;\n};\n\nconst hash = (data: Uint8Array, length = 64) => {\n  const state = new Blake2b(length);\n\n  try {\n    return state.update(data).digest();\n  } finally {\n    state.destroy();\n  }\n};\n\n// RFC 9106 H': preserve byte tails, including output lengths not divisible by four.\nfunction variableHash(words: Uint32Array, length: number): Uint8Array {\n  const data = bytesOfWords(words);\n  const prefix = new Uint8Array(4);\n\n  new DataView(prefix.buffer).setUint32(0, length, true);\n  const state = new Blake2b(Math.min(length, 64));\n  let previous: Uint8Array | undefined;\n  let out: Uint8Array | undefined;\n\n  try {\n    previous = state.update(prefix).update(data).digest();\n    if (length <= 64) {\n      const result = previous;\n\n      previous = undefined;\n\n      return result;\n    }\n    out = new Uint8Array(length);\n    out.set(previous.subarray(0, 32));\n    let position = 32;\n\n    for (; length - position > 64; position += 32) {\n      const next = hash(previous);\n\n      previous.fill(0);\n      previous = next;\n      out.set(previous.subarray(0, 32), position);\n    }\n    const last = hash(previous, length - position);\n\n    out.set(last, position);\n    last.fill(0);\n\n    return out;\n  } catch (error) {\n    out?.fill(0);\n    throw error;\n  } finally {\n    state.destroy();\n    previous?.fill(0);\n    prefix.fill(0);\n    data.fill(0);\n  }\n}\n\nexport interface State {\n  readonly memory: Uint32Array;\n  readonly scratch: Uint32Array;\n  readonly address: Uint32Array;\n  readonly initial: Uint32Array;\n  readonly final: Uint32Array;\n  readonly blocks: number;\n  readonly laneLength: number;\n  readonly segmentLength: number;\n}\n\n// Allocate before absorbing secrets. Kdf has already applied Schema/resource limits.\nexport const allocate = (input: Argon2Parameters): State => {\n  const blocks = 4 * input.parallelism * Math.floor(input.memoryKiB / (4 * input.parallelism));\n  const laneLength = blocks / input.parallelism;\n\n  return {\n    memory: new Uint32Array(blocks * 256),\n    scratch: new Uint32Array(256),\n    address: new Uint32Array(3 * 256),\n    initial: new Uint32Array(18),\n    final: new Uint32Array(256),\n    blocks,\n    laneLength,\n    segmentLength: laneLength / 4,\n  };\n};\n\nexport const destroy = (state: State): void => {\n  state.memory.fill(0);\n  state.scratch.fill(0);\n  state.address.fill(0);\n  state.initial.fill(0);\n  state.final.fill(0);\n};\n\nexport const initialize = (state: State, input: Argon2Parameters): void => {\n  const h = new Blake2b();\n  const scalar = new Uint8Array(4);\n  const view = new DataView(scalar.buffer);\n\n  const number = (value: number) => {\n    view.setUint32(0, value, true);\n    h.update(scalar);\n  };\n\n  try {\n    for (const value of [input.parallelism, input.length, input.memoryKiB, input.passes, 19, 2])\n      number(value);\n    for (const data of [\n      input.password,\n      input.salt,\n      input.secret ?? new Uint8Array(),\n      input.associatedData,\n    ]) {\n      number(data.length);\n      h.update(data);\n    }\n    const initial = h.digest();\n\n    try {\n      const hashView = new DataView(initial.buffer, initial.byteOffset, initial.byteLength);\n\n      for (let i = 0; i < 16; i++) state.initial[i] = hashView.getUint32(i * 4, true);\n    } finally {\n      initial.fill(0);\n    }\n    for (let lane = 0; lane < input.parallelism; lane++) {\n      state.initial[17] = lane;\n      for (let first = 0; first < 2; first++) {\n        state.initial[16] = first;\n        const expanded = variableHash(state.initial, 1024);\n\n        try {\n          const expandedView = new DataView(\n            expanded.buffer,\n            expanded.byteOffset,\n            expanded.byteLength,\n          );\n\n          const offset = (lane * state.laneLength + first) * 256;\n\n          for (let i = 0; i < 256; i++)\n            state.memory[offset + i] = expandedView.getUint32(i * 4, true);\n        } finally {\n          expanded.fill(0);\n        }\n      }\n    }\n  } finally {\n    h.destroy();\n    scalar.fill(0);\n    state.initial.fill(0);\n  }\n};\n\n/** Yield block boundaries to the Effect driver; all scratch belongs to this derivation. */\nexport function* fill(state: State, input: Argon2Parameters): Generator<void, void> {\n  const { memory: B, scratch, address, laneLength: laneLen, segmentLength: segmentLen } = state;\n  const p = input.parallelism;\n\n  address[256 + 6] = state.blocks;\n  address[256 + 8] = input.passes;\n  address[256 + 10] = 2;\n  for (let r = 0; r < input.passes; r++) {\n    const needXor = r !== 0;\n\n    address[256] = r;\n    for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {\n      address[256 + 4] = s;\n      const dataIndependent = r === 0 && s < 2;\n\n      for (let lane = 0; lane < p; lane++) {\n        address[256 + 2] = lane;\n        address[256 + 12] = 0;\n        const start = r === 0 && s === 0 ? 2 : 0;\n\n        if (start === 2 && dataIndependent) {\n          address[256 + 12]++;\n          block(scratch, address, 256, 512, 0, false);\n          block(scratch, address, 0, 512, 0, false);\n        }\n        let offset = lane * laneLen + s * segmentLen + start;\n\n        for (let index = start; index < segmentLen; index++, offset++) {\n          const prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;\n          let randL: number;\n          let randH: number;\n\n          if (dataIndependent) {\n            const addressIndex = index % 128;\n\n            if (addressIndex === 0) {\n              address[256 + 12]++;\n              block(scratch, address, 256, 512, 0, false);\n              block(scratch, address, 0, 512, 0, false);\n            }\n            randL = address[2 * addressIndex];\n            randH = address[2 * addressIndex + 1];\n          } else {\n            randL = B[256 * prev];\n            randH = B[256 * prev + 1];\n          }\n          const refLane = r === 0 && s === 0 ? lane : randH % p;\n          const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane === lane);\n\n          block(scratch, B, 256 * prev, 256 * (laneLen * refLane + refPos), offset * 256, needXor);\n          yield;\n        }\n      }\n    }\n  }\n}\n\nexport const output = (state: State, input: Argon2Parameters): Uint8Array => {\n  for (let lane = 0; lane < input.parallelism; lane++) {\n    const offset = 256 * (state.laneLength * lane + state.laneLength - 1);\n\n    for (let word = 0; word < 256; word++) state.final[word] ^= state.memory[offset + word];\n  }\n\n  return variableHash(state.final, input.length);\n};\n"],"mappings":";;;;;;;;AASA,MAAM,qBAAqB;AAG3B,SAAS,IAAI,GAAW,GAAW;CAEjC,MAAM,KAAK,IAAI;CACf,MAAM,KAAK,MAAM;CACjB,MAAM,KAAK,IAAI;CACf,MAAM,KAAK,MAAM;CACjB,MAAM,KAAK,KAAK,KAAK,IAAI,EAAE;CAC3B,MAAM,KAAK,KAAK,KAAK,IAAI,EAAE;CAC3B,MAAM,KAAK,KAAK,KAAK,IAAI,EAAE;CAC3B,MAAM,KAAK,KAAK,KAAK,IAAI,EAAE;CAC3B,MAAM,SAAS,OAAO,OAAO,KAAK,SAAU;CAI5C,OAAO;EAAE,GAHK,MAAM,OAAO,OAAO,UAAU,MAAO;EAGjC,GAFL,SAAS,KAAO,KAAK;CAET;AAC3B;AAGA,SAAS,MAAM,GAAW,GAAmB;CAC3C,MAAM,KAAK,IAAI,OACb,KAAK,MAAM,IACX,KAAK,IAAI,OACT,KAAK,MAAM;CAEb,MAAM,SAAS,KAAK,KAAK,IAAI,EAAE,MAAM,OAAO,KAAK,KAAK,IAAI,EAAE,IAAI,SAAU,KAAK,KAAK,IAAI,EAAE;CAE1F,OAAQ,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK,KAAK,IAAI,EAAE,MAAM,OAAO,UAAU,MAAO;AAC7E;AASA,SAAS,EAAE,QAAqB,GAAW,GAAW,GAAW,GAAW;CAC1E,IAAI,KAAK,OAAO,IAAI,IAClB,KAAK,OAAO,IAAI,IAAI;CAEtB,IAAI,KAAK,OAAO,IAAI,IAClB,KAAK,OAAO,IAAI,IAAI;CAEtB,IAAI,KAAK,OAAO,IAAI,IAClB,KAAK,OAAO,IAAI,IAAI;CAEtB,IAAI,KAAK,OAAO,IAAI,IAClB,KAAK,OAAO,IAAI,IAAI;CAEtB,IAAI,KAAK,GACP,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK;CAGP,KAAK,KAAK,KAAK,IAAI,EAAE;CACrB,KAAK,MAAM,IAAI,EAAE;CACjB,MAAM,OAAO,MAAM,OAAO,MAAO,MAAM,MAAO;CAC9C,KAAM,KAAK,MAAO,MAAM,IAAM,OAAO,OAAS,KAAK,aAAe,KAAM;CACxE,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,QAAQ,IAAI,EAAE;CACnB,KAAK,QAAQ,IAAI,EAAE;CAGnB,KAAK,KAAK,KAAK,IAAI,EAAE;CACrB,KAAK,MAAM,IAAI,EAAE;CACjB,MAAM,OAAO,MAAM,OAAO,MAAO,MAAM,MAAO;CAC9C,KAAM,KAAK,MAAO,MAAM,IAAM,OAAO,OAAS,KAAK,aAAe,KAAM;CACxE,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,OAAO,IAAI,IAAI,EAAE;CACtB,KAAK,OAAO,IAAI,IAAI,EAAE;CAGtB,KAAK,KAAK,KAAK,IAAI,EAAE;CACrB,KAAK,MAAM,IAAI,EAAE;CACjB,MAAM,OAAO,MAAM,OAAO,MAAO,MAAM,MAAO;CAC9C,KAAM,KAAK,MAAO,MAAM,IAAM,OAAO,OAAS,KAAK,aAAe,KAAM;CACxE,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,OAAO,IAAI,IAAI,EAAE;CACtB,KAAK,OAAO,IAAI,IAAI,EAAE;CAGtB,KAAK,KAAK,KAAK,IAAI,EAAE;CACrB,KAAK,MAAM,IAAI,EAAE;CACjB,MAAM,OAAO,MAAM,OAAO,MAAO,MAAM,MAAO;CAC9C,KAAM,KAAK,MAAO,MAAM,IAAM,OAAO,OAAS,KAAK,aAAe,KAAM;CACxE,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,KAAK;CACV,KAAK,OAAO,IAAI,IAAI,EAAE;CACtB,KAAK,OAAO,IAAI,IAAI,EAAE;CAEtB,OAAO,IAAI,KAAK;CAChB,OAAO,IAAI,IAAI,KAAK;CACpB,OAAO,IAAI,KAAK;CAChB,OAAO,IAAI,IAAI,KAAK;CACpB,OAAO,IAAI,KAAK;CAChB,OAAO,IAAI,IAAI,KAAK;CACpB,OAAO,IAAI,KAAK;CAChB,OAAO,IAAI,IAAI,KAAK;AACtB;AAKA,SAAS,EACP,QACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA;CAEA,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;CAC5B,EAAE,QAAQ,KAAK,KAAK,KAAK,GAAG;AAC9B;AAEA,SAAS,MACP,QACA,GACA,MACA,MACA,QACA,SACA;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,OAAO;CAEjE,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,IAC5B,EACE,QACA,GACA,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,EACN;CAGF,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,GAC3B,EACE,QACA,GACA,IAAI,GACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,KACJ,IAAI,GACN;CAIF,IAAI,SAAS,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,EAAE,SAAS,MAAM,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,OAAO;MAC1F,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,EAAE,SAAS,KAAK,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,OAAO;CACtF,OAAO,KAAK,CAAC;AACf;AAGA,SAAS,WACP,GACA,GACA,SACA,YACA,OACA,OACA,WAAoB,OACpB;CAEA,IAAI;CAEJ,IAAI,MAAM,GAAG;EACX,IAAI,MAAM,GAAG,OAAO,QAAQ;OACvB,IAAI,UAAU,OAAO,IAAI,aAAa,QAAQ;OAC9C,OAAO,IAAI,cAAc,UAAU,IAAI,KAAK;CACnD,OAAO,IAAI,UAAU,OAAO,UAAU,aAAa,QAAQ;MACtD,OAAO,UAAU,cAAc,UAAU,IAAI,KAAK;CAMvD,SALiB,MAAM,KAAK,MAAM,KAA0B,IAAI,KAAK,aAAa,MAGtE,OAAO,IAAI,IAAI,MAAM,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAE5B;AAC5B;AAEA,MAAM,gBAAgB,UAAmC;CACvD,MAAM,QAAQ,IAAI,WAAW,MAAM,SAAS,CAAC;CAC7C,MAAM,OAAO,IAAI,SAAS,MAAM,MAAM;CAEtC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,KAAK,UAAU,IAAI,GAAG,MAAM,IAAI,IAAI;CAE3E,OAAO;AACT;AAEA,MAAM,QAAQ,MAAkB,SAAS,OAAO;CAC9C,MAAM,QAAQ,IAAI,QAAQ,MAAM;CAEhC,IAAI;EACF,OAAO,MAAM,OAAO,IAAI,CAAC,CAAC,OAAO;CACnC,UAAU;EACR,MAAM,QAAQ;CAChB;AACF;AAGA,SAAS,aAAa,OAAoB,QAA4B;CACpE,MAAM,OAAO,aAAa,KAAK;CAC/B,MAAM,yBAAS,IAAI,WAAW,CAAC;CAE/B,IAAI,SAAS,OAAO,MAAM,CAAC,CAAC,UAAU,GAAG,QAAQ,IAAI;CACrD,MAAM,QAAQ,IAAI,QAAQ,KAAK,IAAI,QAAQ,EAAE,CAAC;CAC9C,IAAI;CACJ,IAAI;CAEJ,IAAI;EACF,WAAW,MAAM,OAAO,MAAM,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO;EACpD,IAAI,UAAU,IAAI;GAChB,MAAM,SAAS;GAEf,WAAW,KAAA;GAEX,OAAO;EACT;EACA,MAAM,IAAI,WAAW,MAAM;EAC3B,IAAI,IAAI,SAAS,SAAS,GAAG,EAAE,CAAC;EAChC,IAAI,WAAW;EAEf,OAAO,SAAS,WAAW,IAAI,YAAY,IAAI;GAC7C,MAAM,OAAO,KAAK,QAAQ;GAE1B,SAAS,KAAK,CAAC;GACf,WAAW;GACX,IAAI,IAAI,SAAS,SAAS,GAAG,EAAE,GAAG,QAAQ;EAC5C;EACA,MAAM,OAAO,KAAK,UAAU,SAAS,QAAQ;EAE7C,IAAI,IAAI,MAAM,QAAQ;EACtB,KAAK,KAAK,CAAC;EAEX,OAAO;CACT,SAAS,OAAO;EACd,KAAK,KAAK,CAAC;EACX,MAAM;CACR,UAAU;EACR,MAAM,QAAQ;EACd,UAAU,KAAK,CAAC;EAChB,OAAO,KAAK,CAAC;EACb,KAAK,KAAK,CAAC;CACb;AACF;AAcA,MAAa,YAAY,UAAmC;CAC1D,MAAM,SAAS,IAAI,MAAM,cAAc,KAAK,MAAM,MAAM,aAAa,IAAI,MAAM,YAAY;CAC3F,MAAM,aAAa,SAAS,MAAM;CAElC,OAAO;EACL,QAAQ,IAAI,YAAY,SAAS,GAAG;EACpC,yBAAS,IAAI,YAAY,GAAG;EAC5B,yBAAS,IAAI,YAAY,GAAO;EAChC,yBAAS,IAAI,YAAY,EAAE;EAC3B,uBAAO,IAAI,YAAY,GAAG;EAC1B;EACA;EACA,eAAe,aAAa;CAC9B;AACF;AAEA,MAAa,WAAW,UAAuB;CAC7C,MAAM,OAAO,KAAK,CAAC;CACnB,MAAM,QAAQ,KAAK,CAAC;CACpB,MAAM,QAAQ,KAAK,CAAC;CACpB,MAAM,QAAQ,KAAK,CAAC;CACpB,MAAM,MAAM,KAAK,CAAC;AACpB;AAEA,MAAa,cAAc,OAAc,UAAkC;CACzE,MAAM,IAAI,IAAI,QAAQ;CACtB,MAAM,yBAAS,IAAI,WAAW,CAAC;CAC/B,MAAM,OAAO,IAAI,SAAS,OAAO,MAAM;CAEvC,MAAM,UAAU,UAAkB;EAChC,KAAK,UAAU,GAAG,OAAO,IAAI;EAC7B,EAAE,OAAO,MAAM;CACjB;CAEA,IAAI;EACF,KAAK,MAAM,SAAS;GAAC,MAAM;GAAa,MAAM;GAAQ,MAAM;GAAW,MAAM;GAAQ;GAAI;EAAC,GACxF,OAAO,KAAK;EACd,KAAK,MAAM,QAAQ;GACjB,MAAM;GACN,MAAM;GACN,MAAM,0BAAU,IAAI,WAAW;GAC/B,MAAM;EACR,GAAG;GACD,OAAO,KAAK,MAAM;GAClB,EAAE,OAAO,IAAI;EACf;EACA,MAAM,UAAU,EAAE,OAAO;EAEzB,IAAI;GACF,MAAM,WAAW,IAAI,SAAS,QAAQ,QAAQ,QAAQ,YAAY,QAAQ,UAAU;GAEpF,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,MAAM,QAAQ,KAAK,SAAS,UAAU,IAAI,GAAG,IAAI;EAChF,UAAU;GACR,QAAQ,KAAK,CAAC;EAChB;EACA,KAAK,IAAI,OAAO,GAAG,OAAO,MAAM,aAAa,QAAQ;GACnD,MAAM,QAAQ,MAAM;GACpB,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS;IACtC,MAAM,QAAQ,MAAM;IACpB,MAAM,WAAW,aAAa,MAAM,SAAS,IAAI;IAEjD,IAAI;KACF,MAAM,eAAe,IAAI,SACvB,SAAS,QACT,SAAS,YACT,SAAS,UACX;KAEA,MAAM,UAAU,OAAO,MAAM,aAAa,SAAS;KAEnD,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KACvB,MAAM,OAAO,SAAS,KAAK,aAAa,UAAU,IAAI,GAAG,IAAI;IACjE,UAAU;KACR,SAAS,KAAK,CAAC;IACjB;GACF;EACF;CACF,UAAU;EACR,EAAE,QAAQ;EACV,OAAO,KAAK,CAAC;EACb,MAAM,QAAQ,KAAK,CAAC;CACtB;AACF;;AAGA,UAAiB,KAAK,OAAc,OAAgD;CAClF,MAAM,EAAE,QAAQ,GAAG,SAAS,SAAS,YAAY,SAAS,eAAe,eAAe;CACxF,MAAM,IAAI,MAAM;CAEhB,QAAQ,OAAW,MAAM;CACzB,QAAQ,OAAW,MAAM;CACzB,QAAQ,OAAY;CACpB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,UAAU,MAAM;EAEtB,QAAQ,OAAO;EACf,KAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,KAAK;GAC3C,QAAQ,OAAW;GACnB,MAAM,kBAAkB,MAAM,KAAK,IAAI;GAEvC,KAAK,IAAI,OAAO,GAAG,OAAO,GAAG,QAAQ;IACnC,QAAQ,OAAW;IACnB,QAAQ,OAAY;IACpB,MAAM,QAAQ,MAAM,KAAK,MAAM,IAAI,IAAI;IAEvC,IAAI,UAAU,KAAK,iBAAiB;KAClC,QAAQ,IAAS;KACjB,MAAM,SAAS,SAAS,KAAK,KAAK,GAAG,KAAK;KAC1C,MAAM,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;IAC1C;IACA,IAAI,SAAS,OAAO,UAAU,IAAI,aAAa;IAE/C,KAAK,IAAI,QAAQ,OAAO,QAAQ,YAAY,SAAS,UAAU;KAC7D,MAAM,OAAO,SAAS,UAAU,SAAS,IAAI,SAAS,UAAU;KAChE,IAAI;KACJ,IAAI;KAEJ,IAAI,iBAAiB;MACnB,MAAM,eAAe,QAAQ;MAE7B,IAAI,iBAAiB,GAAG;OACtB,QAAQ,IAAS;OACjB,MAAM,SAAS,SAAS,KAAK,KAAK,GAAG,KAAK;OAC1C,MAAM,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;MAC1C;MACA,QAAQ,QAAQ,IAAI;MACpB,QAAQ,QAAQ,IAAI,eAAe;KACrC,OAAO;MACL,QAAQ,EAAE,MAAM;MAChB,QAAQ,EAAE,MAAM,OAAO;KACzB;KACA,MAAM,UAAU,MAAM,KAAK,MAAM,IAAI,OAAO,QAAQ;KACpD,MAAM,SAAS,WAAW,GAAG,GAAG,SAAS,YAAY,OAAO,OAAO,YAAY,IAAI;KAEnF,MAAM,SAAS,GAAG,MAAM,MAAM,OAAO,UAAU,UAAU,SAAS,SAAS,KAAK,OAAO;KACvF;IACF;GACF;EACF;CACF;AACF;AAEA,MAAa,UAAU,OAAc,UAAwC;CAC3E,KAAK,IAAI,OAAO,GAAG,OAAO,MAAM,aAAa,QAAQ;EACnD,MAAM,SAAS,OAAO,MAAM,aAAa,OAAO,MAAM,aAAa;EAEnE,KAAK,IAAI,OAAO,GAAG,OAAO,KAAK,QAAQ,MAAM,MAAM,SAAS,MAAM,OAAO,SAAS;CACpF;CAEA,OAAO,aAAa,MAAM,OAAO,MAAM,MAAM;AAC/C"}

package/dist/internal/argon2.mjs

@@ -0,0 +1,16 @@
+import { allocate, destroy, fill, initialize, output } from "./argon2-core.mjs";
+import { Effect } from "effect";
+//#region src/internal/argon2.ts
+/** Effect schedules bounded batches; admission remains held through buffer cleanup. */
+const argon2 = (input) => Effect.acquireUseRelease(Effect.sync(() => allocate(input)), (state) => Effect.gen(function* () {
+	initialize(state, input);
+	const blocks = fill(state, input);
+	for (;;) {
+		for (let batch = 0; batch < 256; batch++) if (blocks.next().done) return output(state, input);
+		yield* Effect.yieldNow;
+	}
+}), (state) => Effect.sync(() => destroy(state)));
+//#endregion
+export { argon2 };
+
+//# sourceMappingURL=argon2.mjs.map

package/dist/internal/argon2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"argon2.mjs","names":[],"sources":["../../src/internal/argon2.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { allocate, destroy, fill, initialize, output } from \"./argon2-core\";\nimport type { Argon2 } from \"./kdf\";\n\n/** Effect schedules bounded batches; admission remains held through buffer cleanup. */\nexport const argon2: Argon2 = (input) =>\n  Effect.acquireUseRelease(\n    Effect.sync(() => allocate(input)),\n    (state) =>\n      Effect.gen(function* () {\n        initialize(state, input);\n        const blocks = fill(state, input);\n\n        for (;;) {\n          for (let batch = 0; batch < 256; batch++) {\n            if (blocks.next().done) return output(state, input);\n          }\n          yield* Effect.yieldNow;\n        }\n      }),\n    (state) => Effect.sync(() => destroy(state)),\n  );\n"],"mappings":";;;;AAMA,MAAa,UAAkB,UAC7B,OAAO,kBACL,OAAO,WAAW,SAAS,KAAK,CAAC,IAChC,UACC,OAAO,IAAI,aAAa;CACtB,WAAW,OAAO,KAAK;CACvB,MAAM,SAAS,KAAK,OAAO,KAAK;CAEhC,SAAS;EACP,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,SAC/B,IAAI,OAAO,KAAK,CAAC,CAAC,MAAM,OAAO,OAAO,OAAO,KAAK;EAEpD,OAAO,OAAO;CAChB;AACF,CAAC,IACF,UAAU,OAAO,WAAW,QAAQ,KAAK,CAAC,CAC7C"}