pdf-codec 1.4.2 → 1.6.0

package/dist/content-write.js

@@ -1,10 +1,12 @@
 import { o as encodeForShow } from "./afm-widths-Dxucrg7D.js";
 import { ByteWriter } from "./bytes/writer.js";
 import { pdfHexString } from "./objects.js";
-import { multiplyMatrices, rotationMatrix, scaleMatrix, translationMatrix } from "./matrix.js";
+import { BEZIER_KAPPA, multiplyMatrices, rotationMatrix, scaleMatrix, translationMatrix } from "./matrix.js";
+import { encodeForShowEmbedded } from "./embedded-font.js";
 import { formatNumber, writeObject } from "./serialize.js";
 //#region src/content-write.ts
-const BEZIER_KAPPA = .5522847498;
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
+const EMBEDDED_HORIZONTAL_SCALE_PERCENT = 100;
 function writeRgbOperator(writer, color, operator) {
 	writer.writeAscii(`${formatNumber(color.r)} ${formatNumber(color.g)} ${formatNumber(color.b)} ${operator}\n`);
 }
@@ -22,8 +24,7 @@ function anchorMatrix(xPt, yPt, rotationDeg) {
 		yPt
 	];
 }
-function writeUnderline(writer, item, widthPt, measurer) {
-	const underline = measurer.underlineAtSize(item.font, item.sizePt);
+function writeUnderline(writer, item, widthPt, underline) {
 	writer.writeAscii("q\n");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "cm");
 	writeRgbOperator(writer, item.color, "rg");
@@ -31,23 +32,39 @@ function writeUnderline(writer, item, widthPt, measurer) {
 	writer.writeAscii("f\n");
 	writer.writeAscii("Q\n");
 }
-function writeText(writer, item, context, substitutions) {
-	const font = context.resolveFont(item.font);
-	const encoded = encodeForShow(item.text, font.standardName);
-	substitutions.push(...encoded.substitutions);
-	const scalePercent = context.measurer.horizontalScaleFor(item.font) * 100;
+function writeShowTextBlock(writer, item, resourceName, scalePercent, codes) {
 	writer.writeAscii("BT\n");
-	writer.writeAscii(`/${font.resourceName} ${formatNumber(item.sizePt)} Tf\n`);
+	writer.writeAscii(`/${resourceName} ${formatNumber(item.sizePt)} Tf\n`);
 	writer.writeAscii(`${formatNumber(scalePercent)} Tz\n`);
 	writeRgbOperator(writer, item.color, "rg");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "Tm");
-	writeObject(writer, pdfHexString(encoded.codes));
+	writeObject(writer, pdfHexString(codes));
 	writer.writeAscii(" Tj\n");
 	writer.writeAscii("ET\n");
-	if (item.underline === true) {
-		const scale = context.measurer.horizontalScaleFor(item.font);
-		writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / 1e3 * item.sizePt * scale, context.measurer);
+}
+function writeStandardText(writer, item, standardName, resourceName, measurer, substitutions) {
+	const encoded = encodeForShow(item.text, standardName);
+	substitutions.push(...encoded.substitutions);
+	const scale = measurer.horizontalScaleFor(item.font);
+	writeShowTextBlock(writer, item, resourceName, scale * 100, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt * scale, measurer.underlineAtSize(item.font, item.sizePt));
+}
+function writeEmbeddedText(writer, item, face, resourceName, missingGlyphs) {
+	const encoded = encodeForShowEmbedded(item.text, face);
+	missingGlyphs.push(...encoded.substitutions);
+	writeShowTextBlock(writer, item, resourceName, EMBEDDED_HORIZONTAL_SCALE_PERCENT, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt, {
+		offsetPt: face.metrics.underlinePositionGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt,
+		thicknessPt: face.metrics.underlineThicknessGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt
+	});
+}
+function writeText(writer, item, context, substitutions, missingGlyphs) {
+	const font = context.resolveFont(item.font);
+	if (font.kind === "embedded") {
+		writeEmbeddedText(writer, item, font.face, font.resourceName, missingGlyphs);
+		return;
 	}
+	writeStandardText(writer, item, font.standardName, font.resourceName, context.measurer, substitutions);
 }
 function paintOperatorFor(fill, stroke, fillRule) {
 	const evenOdd = fillRule === "evenodd";
@@ -122,7 +139,8 @@ function writeImage(writer, item, context) {
 function writeContentStream(items, context) {
 	const writer = new ByteWriter();
 	const substitutions = [];
-	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions);
+	const missingGlyphs = [];
+	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
 	else if (item.kind === "image") writeImage(writer, item, context);
 	else if (item.kind === "rect") writeRect(writer, item);
 	else if (item.kind === "line") writeLine(writer, item);
@@ -130,7 +148,8 @@ function writeContentStream(items, context) {
 	else if (item.kind === "path") writePath(writer, item);
 	return {
 		bytes: writer.toBytes(),
-		substitutions
+		substitutions,
+		missingGlyphs
 	};
 }
 //#endregion

package/dist/crypto/aes.cjs

@@ -0,0 +1,166 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/aes.ts
+const AES_BLOCK_BYTES = 16;
+const WORDS_PER_BLOCK = 4;
+const GF_MODULUS = 283;
+const AFFINE_CONSTANT = 99;
+function xtime(a) {
+	const doubled = a << 1;
+	return (doubled & 256) !== 0 ? (doubled ^ GF_MODULUS) & 255 : doubled;
+}
+function gmul(a, b) {
+	let product = 0;
+	let left = a;
+	let right = b;
+	while (right !== 0) {
+		if ((right & 1) !== 0) product ^= left;
+		left = xtime(left);
+		right >>= 1;
+	}
+	return product & 255;
+}
+function rotl8(value, bits) {
+	return (value << bits | value >>> 8 - bits) & 255;
+}
+const { SBOX, INV_SBOX } = (() => {
+	const inverse = /* @__PURE__ */ new Uint8Array(256);
+	for (let a = 1; a < 256; a++) for (let b = 1; b < 256; b++) if (gmul(a, b) === 1) {
+		inverse[a] = b;
+		break;
+	}
+	const sbox = /* @__PURE__ */ new Uint8Array(256);
+	const invSbox = /* @__PURE__ */ new Uint8Array(256);
+	for (let i = 0; i < 256; i++) {
+		const b = inverse[i];
+		const s = (b ^ rotl8(b, 1) ^ rotl8(b, 2) ^ rotl8(b, 3) ^ rotl8(b, 4) ^ AFFINE_CONSTANT) & 255;
+		sbox[i] = s;
+		invSbox[s] = i;
+	}
+	return {
+		SBOX: sbox,
+		INV_SBOX: invSbox
+	};
+})();
+function subWord(word) {
+	return (SBOX[word >>> 24 & 255] << 24 | SBOX[word >>> 16 & 255] << 16 | SBOX[word >>> 8 & 255] << 8 | SBOX[word & 255]) >>> 0;
+}
+function rotWord(word) {
+	return (word << 8 | word >>> 24) >>> 0;
+}
+function expandKey(key) {
+	if (key.length !== 16 && key.length !== 24 && key.length !== 32) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
+	const nk = key.length / 4;
+	const rounds = nk + 6;
+	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
+	for (let i = 0; i < nk; i++) words[i] = (key[4 * i] << 24 | key[4 * i + 1] << 16 | key[4 * i + 2] << 8 | key[4 * i + 3]) >>> 0;
+	let rcon = 1;
+	for (let i = nk; i < words.length; i++) {
+		let temp = words[i - 1];
+		if (i % nk === 0) {
+			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
+			rcon = xtime(rcon);
+		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
+		words[i] = (words[i - nk] ^ temp) >>> 0;
+	}
+	return {
+		words,
+		rounds
+	};
+}
+function addRoundKey(state, words, round) {
+	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
+		const word = words[round * WORDS_PER_BLOCK + c];
+		for (let r = 0; r < WORDS_PER_BLOCK; r++) state[4 * c + r] = state[4 * c + r] ^ word >>> 24 - r * 8 & 255;
+	}
+}
+function substituteBytes(state, table) {
+	for (let i = 0; i < 16; i++) state[i] = table[state[i]];
+}
+function shiftRows(state, direction) {
+	const source = Uint8Array.from(state);
+	for (let r = 1; r < WORDS_PER_BLOCK; r++) for (let c = 0; c < WORDS_PER_BLOCK; c++) state[r + 4 * c] = source[r + 4 * (((c + direction * r) % WORDS_PER_BLOCK + WORDS_PER_BLOCK) % WORDS_PER_BLOCK)];
+}
+function mixColumns(state, coefficients) {
+	const [k0, k1, k2, k3] = coefficients;
+	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
+		const a0 = state[4 * c];
+		const a1 = state[4 * c + 1];
+		const a2 = state[4 * c + 2];
+		const a3 = state[4 * c + 3];
+		state[4 * c] = gmul(a0, k0) ^ gmul(a1, k1) ^ gmul(a2, k2) ^ gmul(a3, k3);
+		state[4 * c + 1] = gmul(a0, k3) ^ gmul(a1, k0) ^ gmul(a2, k1) ^ gmul(a3, k2);
+		state[4 * c + 2] = gmul(a0, k2) ^ gmul(a1, k3) ^ gmul(a2, k0) ^ gmul(a3, k1);
+		state[4 * c + 3] = gmul(a0, k1) ^ gmul(a1, k2) ^ gmul(a2, k3) ^ gmul(a3, k0);
+	}
+}
+const FORWARD_MIX = [
+	2,
+	3,
+	1,
+	1
+];
+const INVERSE_MIX = [
+	14,
+	11,
+	13,
+	9
+];
+function encryptBlock(state, key) {
+	addRoundKey(state, key.words, 0);
+	for (let round = 1; round < key.rounds; round++) {
+		substituteBytes(state, SBOX);
+		shiftRows(state, 1);
+		mixColumns(state, FORWARD_MIX);
+		addRoundKey(state, key.words, round);
+	}
+	substituteBytes(state, SBOX);
+	shiftRows(state, 1);
+	addRoundKey(state, key.words, key.rounds);
+}
+function decryptBlock(state, key) {
+	addRoundKey(state, key.words, key.rounds);
+	for (let round = key.rounds - 1; round >= 1; round--) {
+		shiftRows(state, -1);
+		substituteBytes(state, INV_SBOX);
+		addRoundKey(state, key.words, round);
+		mixColumns(state, INVERSE_MIX);
+	}
+	shiftRows(state, -1);
+	substituteBytes(state, INV_SBOX);
+	addRoundKey(state, key.words, 0);
+}
+function wholeBlockCount(byteLength) {
+	return Math.floor(byteLength / 16);
+}
+function aesCbcDecrypt(key, iv, data) {
+	const expanded = expandKey(key);
+	const blocks = wholeBlockCount(data.length);
+	const out = new Uint8Array(blocks * 16);
+	const chain = Uint8Array.from(iv.subarray(0, 16));
+	for (let b = 0; b < blocks; b++) {
+		const cipherBlock = data.subarray(b * 16, (b + 1) * 16);
+		const state = Uint8Array.from(cipherBlock);
+		decryptBlock(state, expanded);
+		for (let i = 0; i < 16; i++) out[b * 16 + i] = state[i] ^ chain[i];
+		chain.set(cipherBlock);
+	}
+	return out;
+}
+function aesCbcEncrypt(key, iv, data) {
+	const expanded = expandKey(key);
+	const blocks = wholeBlockCount(data.length);
+	const out = new Uint8Array(blocks * 16);
+	const chain = Uint8Array.from(iv.subarray(0, 16));
+	for (let b = 0; b < blocks; b++) {
+		const state = /* @__PURE__ */ new Uint8Array(16);
+		for (let i = 0; i < 16; i++) state[i] = data[b * 16 + i] ^ chain[i];
+		encryptBlock(state, expanded);
+		out.set(state, b * 16);
+		chain.set(state);
+	}
+	return out;
+}
+//#endregion
+exports.AES_BLOCK_BYTES = AES_BLOCK_BYTES;
+exports.aesCbcDecrypt = aesCbcDecrypt;
+exports.aesCbcEncrypt = aesCbcEncrypt;

package/dist/crypto/aes.d.cts

@@ -0,0 +1,6 @@
+//#region src/crypto/aes.d.ts
+declare const AES_BLOCK_BYTES = 16;
+declare function aesCbcDecrypt(key: Uint8Array<ArrayBuffer>, iv: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function aesCbcEncrypt(key: Uint8Array<ArrayBuffer>, iv: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { AES_BLOCK_BYTES, aesCbcDecrypt, aesCbcEncrypt };

package/dist/crypto/aes.d.ts

@@ -0,0 +1,6 @@
+//#region src/crypto/aes.d.ts
+declare const AES_BLOCK_BYTES = 16;
+declare function aesCbcDecrypt(key: Uint8Array<ArrayBuffer>, iv: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function aesCbcEncrypt(key: Uint8Array<ArrayBuffer>, iv: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { AES_BLOCK_BYTES, aesCbcDecrypt, aesCbcEncrypt };

package/dist/crypto/aes.js

@@ -0,0 +1,163 @@
+//#region src/crypto/aes.ts
+const AES_BLOCK_BYTES = 16;
+const WORDS_PER_BLOCK = 4;
+const GF_MODULUS = 283;
+const AFFINE_CONSTANT = 99;
+function xtime(a) {
+	const doubled = a << 1;
+	return (doubled & 256) !== 0 ? (doubled ^ GF_MODULUS) & 255 : doubled;
+}
+function gmul(a, b) {
+	let product = 0;
+	let left = a;
+	let right = b;
+	while (right !== 0) {
+		if ((right & 1) !== 0) product ^= left;
+		left = xtime(left);
+		right >>= 1;
+	}
+	return product & 255;
+}
+function rotl8(value, bits) {
+	return (value << bits | value >>> 8 - bits) & 255;
+}
+const { SBOX, INV_SBOX } = (() => {
+	const inverse = /* @__PURE__ */ new Uint8Array(256);
+	for (let a = 1; a < 256; a++) for (let b = 1; b < 256; b++) if (gmul(a, b) === 1) {
+		inverse[a] = b;
+		break;
+	}
+	const sbox = /* @__PURE__ */ new Uint8Array(256);
+	const invSbox = /* @__PURE__ */ new Uint8Array(256);
+	for (let i = 0; i < 256; i++) {
+		const b = inverse[i];
+		const s = (b ^ rotl8(b, 1) ^ rotl8(b, 2) ^ rotl8(b, 3) ^ rotl8(b, 4) ^ AFFINE_CONSTANT) & 255;
+		sbox[i] = s;
+		invSbox[s] = i;
+	}
+	return {
+		SBOX: sbox,
+		INV_SBOX: invSbox
+	};
+})();
+function subWord(word) {
+	return (SBOX[word >>> 24 & 255] << 24 | SBOX[word >>> 16 & 255] << 16 | SBOX[word >>> 8 & 255] << 8 | SBOX[word & 255]) >>> 0;
+}
+function rotWord(word) {
+	return (word << 8 | word >>> 24) >>> 0;
+}
+function expandKey(key) {
+	if (key.length !== 16 && key.length !== 24 && key.length !== 32) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
+	const nk = key.length / 4;
+	const rounds = nk + 6;
+	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
+	for (let i = 0; i < nk; i++) words[i] = (key[4 * i] << 24 | key[4 * i + 1] << 16 | key[4 * i + 2] << 8 | key[4 * i + 3]) >>> 0;
+	let rcon = 1;
+	for (let i = nk; i < words.length; i++) {
+		let temp = words[i - 1];
+		if (i % nk === 0) {
+			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
+			rcon = xtime(rcon);
+		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
+		words[i] = (words[i - nk] ^ temp) >>> 0;
+	}
+	return {
+		words,
+		rounds
+	};
+}
+function addRoundKey(state, words, round) {
+	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
+		const word = words[round * WORDS_PER_BLOCK + c];
+		for (let r = 0; r < WORDS_PER_BLOCK; r++) state[4 * c + r] = state[4 * c + r] ^ word >>> 24 - r * 8 & 255;
+	}
+}
+function substituteBytes(state, table) {
+	for (let i = 0; i < 16; i++) state[i] = table[state[i]];
+}
+function shiftRows(state, direction) {
+	const source = Uint8Array.from(state);
+	for (let r = 1; r < WORDS_PER_BLOCK; r++) for (let c = 0; c < WORDS_PER_BLOCK; c++) state[r + 4 * c] = source[r + 4 * (((c + direction * r) % WORDS_PER_BLOCK + WORDS_PER_BLOCK) % WORDS_PER_BLOCK)];
+}
+function mixColumns(state, coefficients) {
+	const [k0, k1, k2, k3] = coefficients;
+	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
+		const a0 = state[4 * c];
+		const a1 = state[4 * c + 1];
+		const a2 = state[4 * c + 2];
+		const a3 = state[4 * c + 3];
+		state[4 * c] = gmul(a0, k0) ^ gmul(a1, k1) ^ gmul(a2, k2) ^ gmul(a3, k3);
+		state[4 * c + 1] = gmul(a0, k3) ^ gmul(a1, k0) ^ gmul(a2, k1) ^ gmul(a3, k2);
+		state[4 * c + 2] = gmul(a0, k2) ^ gmul(a1, k3) ^ gmul(a2, k0) ^ gmul(a3, k1);
+		state[4 * c + 3] = gmul(a0, k1) ^ gmul(a1, k2) ^ gmul(a2, k3) ^ gmul(a3, k0);
+	}
+}
+const FORWARD_MIX = [
+	2,
+	3,
+	1,
+	1
+];
+const INVERSE_MIX = [
+	14,
+	11,
+	13,
+	9
+];
+function encryptBlock(state, key) {
+	addRoundKey(state, key.words, 0);
+	for (let round = 1; round < key.rounds; round++) {
+		substituteBytes(state, SBOX);
+		shiftRows(state, 1);
+		mixColumns(state, FORWARD_MIX);
+		addRoundKey(state, key.words, round);
+	}
+	substituteBytes(state, SBOX);
+	shiftRows(state, 1);
+	addRoundKey(state, key.words, key.rounds);
+}
+function decryptBlock(state, key) {
+	addRoundKey(state, key.words, key.rounds);
+	for (let round = key.rounds - 1; round >= 1; round--) {
+		shiftRows(state, -1);
+		substituteBytes(state, INV_SBOX);
+		addRoundKey(state, key.words, round);
+		mixColumns(state, INVERSE_MIX);
+	}
+	shiftRows(state, -1);
+	substituteBytes(state, INV_SBOX);
+	addRoundKey(state, key.words, 0);
+}
+function wholeBlockCount(byteLength) {
+	return Math.floor(byteLength / 16);
+}
+function aesCbcDecrypt(key, iv, data) {
+	const expanded = expandKey(key);
+	const blocks = wholeBlockCount(data.length);
+	const out = new Uint8Array(blocks * 16);
+	const chain = Uint8Array.from(iv.subarray(0, 16));
+	for (let b = 0; b < blocks; b++) {
+		const cipherBlock = data.subarray(b * 16, (b + 1) * 16);
+		const state = Uint8Array.from(cipherBlock);
+		decryptBlock(state, expanded);
+		for (let i = 0; i < 16; i++) out[b * 16 + i] = state[i] ^ chain[i];
+		chain.set(cipherBlock);
+	}
+	return out;
+}
+function aesCbcEncrypt(key, iv, data) {
+	const expanded = expandKey(key);
+	const blocks = wholeBlockCount(data.length);
+	const out = new Uint8Array(blocks * 16);
+	const chain = Uint8Array.from(iv.subarray(0, 16));
+	for (let b = 0; b < blocks; b++) {
+		const state = /* @__PURE__ */ new Uint8Array(16);
+		for (let i = 0; i < 16; i++) state[i] = data[b * 16 + i] ^ chain[i];
+		encryptBlock(state, expanded);
+		out.set(state, b * 16);
+		chain.set(state);
+	}
+	return out;
+}
+//#endregion
+export { AES_BLOCK_BYTES, aesCbcDecrypt, aesCbcEncrypt };

package/dist/crypto/md5.cjs

@@ -0,0 +1,215 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/md5.ts
+const BLOCK_BYTES = 64;
+const DIGEST_BYTES = 16;
+const ROUNDS = 64;
+const WORDS_PER_BLOCK = 16;
+const T = new Uint32Array([
+	3614090360,
+	3905402710,
+	606105819,
+	3250441966,
+	4118548399,
+	1200080426,
+	2821735955,
+	4249261313,
+	1770035416,
+	2336552879,
+	4294925233,
+	2304563134,
+	1804603682,
+	4254626195,
+	2792965006,
+	1236535329,
+	4129170786,
+	3225465664,
+	643717713,
+	3921069994,
+	3593408605,
+	38016083,
+	3634488961,
+	3889429448,
+	568446438,
+	3275163606,
+	4107603335,
+	1163531501,
+	2850285829,
+	4243563512,
+	1735328473,
+	2368359562,
+	4294588738,
+	2272392833,
+	1839030562,
+	4259657740,
+	2763975236,
+	1272893353,
+	4139469664,
+	3200236656,
+	681279174,
+	3936430074,
+	3572445317,
+	76029189,
+	3654602809,
+	3873151461,
+	530742520,
+	3299628645,
+	4096336452,
+	1126891415,
+	2878612391,
+	4237533241,
+	1700485571,
+	2399980690,
+	4293915773,
+	2240044497,
+	1873313359,
+	4264355552,
+	2734768916,
+	1309151649,
+	4149444226,
+	3174756917,
+	718787259,
+	3951481745
+]);
+const SHIFT = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+const INITIAL_STATE = [
+	1732584193,
+	4023233417,
+	2562383102,
+	271733878
+];
+function rotl32(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function padMessage(bytes) {
+	const paddedLength = (Math.floor((bytes.length + 8) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const bitLength = bytes.length * 8;
+	let low = bitLength % 4294967296;
+	let high = Math.floor(bitLength / 4294967296);
+	for (let i = 0; i < 4; i++) {
+		padded[paddedLength - 8 + i] = low & 255;
+		low = Math.floor(low / 256);
+		padded[paddedLength - 4 + i] = high & 255;
+		high = Math.floor(high / 256);
+	}
+	return padded;
+}
+function md5(bytes) {
+	const padded = padMessage(bytes);
+	const state = Int32Array.from(INITIAL_STATE);
+	const block = new Uint32Array(WORDS_PER_BLOCK);
+	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) {
+		for (let i = 0; i < WORDS_PER_BLOCK; i++) {
+			const at = offset + i * 4;
+			block[i] = (padded[at] | padded[at + 1] << 8 | padded[at + 2] << 16 | padded[at + 3] << 24) >>> 0;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		for (let i = 0; i < ROUNDS; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				f = b & c | ~b & d;
+				g = i;
+			} else if (i < 32) {
+				f = d & b | ~d & c;
+				g = (5 * i + 1) % WORDS_PER_BLOCK;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % WORDS_PER_BLOCK;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % WORDS_PER_BLOCK;
+			}
+			const rotated = rotl32(a + (f >>> 0) + T[i] + block[g] >>> 0, SHIFT[i]);
+			a = d;
+			d = c;
+			c = b;
+			b = b + rotated >>> 0;
+		}
+		state[0] = state[0] + a | 0;
+		state[1] = state[1] + b | 0;
+		state[2] = state[2] + c | 0;
+		state[3] = state[3] + d | 0;
+	}
+	const digest = new Uint8Array(DIGEST_BYTES);
+	for (let i = 0; i < state.length; i++) {
+		const word = state[i];
+		digest[i * 4] = word & 255;
+		digest[i * 4 + 1] = word >>> 8 & 255;
+		digest[i * 4 + 2] = word >>> 16 & 255;
+		digest[i * 4 + 3] = word >>> 24 & 255;
+	}
+	return digest;
+}
+//#endregion
+exports.md5 = md5;

package/dist/crypto/md5.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/md5.d.ts
+declare function md5(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { md5 };

package/dist/crypto/md5.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/md5.d.ts
+declare function md5(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { md5 };