@backblaze-labs/b2-sdk 0.2.0 → 0.4.0

package/dist/util/md5.cjs

@@ -0,0 +1,211 @@
+//#region src/util/md5.ts
+/**
+* Encodes raw bytes as base64 in an isomorphic way (Node Buffer fallback to btoa).
+*
+* @param bytes - The raw bytes to encode.
+*
+* @returns The base64-encoded string.
+*/
+function bytesToBase64(bytes) {
+	const g = globalThis;
+	if (g.Buffer) return g.Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+var loadNodeCrypto = () => import("node:crypto");
+function syncNodeCreateHash() {
+	const crypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+	if (!crypto || typeof crypto !== "object") return null;
+	const { createHash } = crypto;
+	return typeof createHash === "function" ? createHash : null;
+}
+/**
+* Computes the MD5 digest of the given bytes as a base64 string. Prefers
+* `node:crypto` for native speed when available; falls back to a pure-JS
+* implementation in browser / edge runtimes because WebCrypto's
+* `crypto.subtle.digest` deliberately does not support MD5.
+*
+* MD5 is used only for wire-protocol integrity checks, not as a security
+* boundary.
+*
+* @param bytes - The bytes to digest.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+async function md5Base64(bytes) {
+	return md5Base64WithCryptoLoader(bytes, loadNodeCrypto);
+}
+/**
+* Computes the MD5 digest with an injected async crypto loader.
+*
+* @param bytes - The bytes to digest.
+* @param loadCrypto - Crypto module loader used by runtime fallback tests.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+async function md5Base64WithCryptoLoader(bytes, loadCrypto) {
+	try {
+		const { createHash } = await loadCrypto();
+		if (typeof createHash !== "function") throw new Error("createHash unavailable");
+		return createHash("md5").update(bytes).digest("base64");
+	} catch {
+		return md5Base64Sync(bytes);
+	}
+}
+/**
+* Computes the MD5 digest of the given bytes as a base64 string without
+* dynamic imports.
+*
+* @param bytes - The bytes to digest.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+function md5Base64Sync(bytes) {
+	const createHash = syncNodeCreateHash();
+	if (createHash) return createHash("md5").update(bytes).digest("base64");
+	return bytesToBase64(md5Bytes(bytes));
+}
+/**
+* Pure-JS MD5 implementation per RFC 1321. Returns the 16-byte digest of the
+* input. Used as a browser fallback for SSE-C key MD5 computation; not
+* intended for security-sensitive purposes (MD5 is broken cryptographically).
+*
+* @param data - The bytes to hash.
+*
+* @returns The 16-byte MD5 digest.
+*/
+function md5Bytes(data) {
+	const originalBitLength = data.length * 8;
+	const paddedLength = data.length + 1 + 8 + 63 & -64;
+	const msg = new Uint8Array(paddedLength);
+	msg.set(data);
+	msg[data.length] = 128;
+	const view = new DataView(msg.buffer);
+	view.setUint32(paddedLength - 8, originalBitLength >>> 0, true);
+	view.setUint32(paddedLength - 4, Math.floor(originalBitLength / 4294967296), true);
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	const s = [
+		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 k = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296));
+	const leftRotate = (x, c) => x << c | x >>> 32 - c;
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		const m = Array.from({ length: 16 }, (_, i) => view.getUint32(offset + i * 4, true));
+		for (let i = 0; i < 64; 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) % 16;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % 16;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % 16;
+			}
+			const temp = d;
+			d = c;
+			c = b;
+			b = b + leftRotate(a + f + k[i] + m[g] >>> 0, s[i]) >>> 0;
+			a = temp;
+		}
+		a0 = a0 + a >>> 0;
+		b0 = b0 + b >>> 0;
+		c0 = c0 + c >>> 0;
+		d0 = d0 + d >>> 0;
+	}
+	const out = /* @__PURE__ */ new Uint8Array(16);
+	const outView = new DataView(out.buffer);
+	outView.setUint32(0, a0, true);
+	outView.setUint32(4, b0, true);
+	outView.setUint32(8, c0, true);
+	outView.setUint32(12, d0, true);
+	return out;
+}
+//#endregion
+exports.md5Base64 = md5Base64;
+exports.md5Base64Sync = md5Base64Sync;
+exports.md5Base64WithCryptoLoader = md5Base64WithCryptoLoader;
+
+//# sourceMappingURL=md5.cjs.map

package/dist/util/md5.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.cjs","names":[],"sources":["../../src/util/md5.ts"],"sourcesContent":["/**\n * Encodes raw bytes as base64 in an isomorphic way (Node Buffer fallback to btoa).\n *\n * @param bytes - The raw bytes to encode.\n *\n * @returns The base64-encoded string.\n */\nfunction bytesToBase64(bytes: Uint8Array): string {\n  const g = globalThis as {\n    Buffer?: { from(b: Uint8Array): { toString(encoding: string): string } }\n  }\n  if (g.Buffer) return g.Buffer.from(bytes).toString('base64')\n\n  let binary = ''\n  for (const byte of bytes) binary += String.fromCharCode(byte)\n  return btoa(binary)\n}\n\ntype SyncNodeHash = {\n  update(bytes: Uint8Array): SyncNodeHash\n  digest(encoding: 'base64'): string\n}\n\ntype AsyncNodeCryptoLoader = () => Promise<{ createHash?: unknown }>\n\nconst loadNodeCrypto: AsyncNodeCryptoLoader = () => import('node:crypto')\n\nfunction syncNodeCreateHash(): ((algorithm: string) => SyncNodeHash) | null {\n  const g = globalThis as {\n    process?: {\n      getBuiltinModule?: (name: string) => unknown\n    }\n  }\n  const crypto = g.process?.getBuiltinModule?.('node:crypto')\n  if (!crypto || typeof crypto !== 'object') return null\n  const { createHash } = crypto as { createHash?: unknown }\n  return typeof createHash === 'function'\n    ? (createHash as (algorithm: string) => SyncNodeHash)\n    : null\n}\n\n/**\n * Computes the MD5 digest of the given bytes as a base64 string. Prefers\n * `node:crypto` for native speed when available; falls back to a pure-JS\n * implementation in browser / edge runtimes because WebCrypto's\n * `crypto.subtle.digest` deliberately does not support MD5.\n *\n * MD5 is used only for wire-protocol integrity checks, not as a security\n * boundary.\n *\n * @param bytes - The bytes to digest.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport async function md5Base64(bytes: Uint8Array): Promise<string> {\n  return md5Base64WithCryptoLoader(bytes, loadNodeCrypto)\n}\n\n/**\n * Computes the MD5 digest with an injected async crypto loader.\n *\n * @param bytes - The bytes to digest.\n * @param loadCrypto - Crypto module loader used by runtime fallback tests.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport async function md5Base64WithCryptoLoader(\n  bytes: Uint8Array,\n  loadCrypto: AsyncNodeCryptoLoader,\n): Promise<string> {\n  try {\n    const { createHash } = await loadCrypto()\n    // Vite's browser shim resolves the import but does not implement\n    // `createHash`. Probe explicitly so we fall through to the pure-JS path.\n    if (typeof createHash !== 'function') throw new Error('createHash unavailable')\n    return createHash('md5').update(bytes).digest('base64')\n  } catch {\n    return md5Base64Sync(bytes)\n  }\n}\n\n/**\n * Computes the MD5 digest of the given bytes as a base64 string without\n * dynamic imports.\n *\n * @param bytes - The bytes to digest.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport function md5Base64Sync(bytes: Uint8Array): string {\n  const createHash = syncNodeCreateHash()\n  if (createHash) return createHash('md5').update(bytes).digest('base64')\n\n  return bytesToBase64(md5Bytes(bytes))\n}\n\n/**\n * Pure-JS MD5 implementation per RFC 1321. Returns the 16-byte digest of the\n * input. Used as a browser fallback for SSE-C key MD5 computation; not\n * intended for security-sensitive purposes (MD5 is broken cryptographically).\n *\n * @param data - The bytes to hash.\n *\n * @returns The 16-byte MD5 digest.\n */\nfunction md5Bytes(data: Uint8Array): Uint8Array {\n  const originalBitLength = data.length * 8\n  const withOne = data.length + 1\n  const paddedLength = (withOne + 8 + 63) & ~63\n  const msg = new Uint8Array(paddedLength)\n  msg.set(data)\n  msg[data.length] = 0x80\n  const view = new DataView(msg.buffer)\n  view.setUint32(paddedLength - 8, originalBitLength >>> 0, true)\n  view.setUint32(paddedLength - 4, Math.floor(originalBitLength / 0x1_0000_0000), true)\n\n  let a0 = 0x67452301\n  let b0 = 0xefcdab89\n  let c0 = 0x98badcfe\n  let d0 = 0x10325476\n\n  const s = [\n    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,\n    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,\n    6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,\n  ]\n  const k = Array.from({ length: 64 }, (_, i) =>\n    Math.floor(Math.abs(Math.sin(i + 1)) * 0x1_0000_0000),\n  )\n\n  const leftRotate = (x: number, c: number) => (x << c) | (x >>> (32 - c))\n\n  for (let offset = 0; offset < paddedLength; offset += 64) {\n    let a = a0\n    let b = b0\n    let c = c0\n    let d = d0\n\n    const m = Array.from({ length: 16 }, (_, i) => view.getUint32(offset + i * 4, true))\n\n    for (let i = 0; i < 64; i++) {\n      let f: number\n      let g: number\n      if (i < 16) {\n        f = (b & c) | (~b & d)\n        g = i\n      } else if (i < 32) {\n        f = (d & b) | (~d & c)\n        g = (5 * i + 1) % 16\n      } else if (i < 48) {\n        f = b ^ c ^ d\n        g = (3 * i + 5) % 16\n      } else {\n        f = c ^ (b | ~d)\n        g = (7 * i) % 16\n      }\n\n      const temp = d\n      d = c\n      c = b\n      b =\n        (b + leftRotate((a + f + (k[i] as number) + (m[g] as number)) >>> 0, s[i] as number)) >>> 0\n      a = temp\n    }\n\n    a0 = (a0 + a) >>> 0\n    b0 = (b0 + b) >>> 0\n    c0 = (c0 + c) >>> 0\n    d0 = (d0 + d) >>> 0\n  }\n\n  const out = new Uint8Array(16)\n  const outView = new DataView(out.buffer)\n  outView.setUint32(0, a0, true)\n  outView.setUint32(4, b0, true)\n  outView.setUint32(8, c0, true)\n  outView.setUint32(12, d0, true)\n  return out\n}\n"],"mappings":"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"}

package/dist/util/md5.d.cts

@@ -0,0 +1,43 @@
+type AsyncNodeCryptoLoader = () => Promise<{
+    createHash?: unknown;
+}>;
+/**
+ * Computes the MD5 digest of the given bytes as a base64 string. Prefers
+ * `node:crypto` for native speed when available; falls back to a pure-JS
+ * implementation in browser / edge runtimes because WebCrypto's
+ * `crypto.subtle.digest` deliberately does not support MD5.
+ *
+ * MD5 is used only for wire-protocol integrity checks, not as a security
+ * boundary.
+ *
+ * @param bytes - The bytes to digest.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64(bytes: Uint8Array): Promise<string>;
+/**
+ * Computes the MD5 digest with an injected async crypto loader.
+ *
+ * @param bytes - The bytes to digest.
+ * @param loadCrypto - Crypto module loader used by runtime fallback tests.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64WithCryptoLoader(bytes: Uint8Array, loadCrypto: AsyncNodeCryptoLoader): Promise<string>;
+/**
+ * Computes the MD5 digest of the given bytes as a base64 string without
+ * dynamic imports.
+ *
+ * @param bytes - The bytes to digest.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64Sync(bytes: Uint8Array): string;
+export {};
+//# sourceMappingURL=md5.d.ts.map

package/dist/util/md5.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.d.ts","sourceRoot":"","sources":["../../src/util/md5.js"],"names":[],"mappings":"AAuBA,KAAK,qBAAqB,GAAG,MAAM,OAAO,CAAC;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAkBpE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAElE;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,qBAAqB,GAChC,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD"}

package/dist/util/md5.d.ts

@@ -0,0 +1,43 @@
+type AsyncNodeCryptoLoader = () => Promise<{
+    createHash?: unknown;
+}>;
+/**
+ * Computes the MD5 digest of the given bytes as a base64 string. Prefers
+ * `node:crypto` for native speed when available; falls back to a pure-JS
+ * implementation in browser / edge runtimes because WebCrypto's
+ * `crypto.subtle.digest` deliberately does not support MD5.
+ *
+ * MD5 is used only for wire-protocol integrity checks, not as a security
+ * boundary.
+ *
+ * @param bytes - The bytes to digest.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64(bytes: Uint8Array): Promise<string>;
+/**
+ * Computes the MD5 digest with an injected async crypto loader.
+ *
+ * @param bytes - The bytes to digest.
+ * @param loadCrypto - Crypto module loader used by runtime fallback tests.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64WithCryptoLoader(bytes: Uint8Array, loadCrypto: AsyncNodeCryptoLoader): Promise<string>;
+/**
+ * Computes the MD5 digest of the given bytes as a base64 string without
+ * dynamic imports.
+ *
+ * @param bytes - The bytes to digest.
+ *
+ * @returns The base64-encoded MD5 digest.
+ *
+ * @internal
+ */
+export declare function md5Base64Sync(bytes: Uint8Array): string;
+export {};
+//# sourceMappingURL=md5.d.ts.map

package/dist/util/md5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.d.ts","sourceRoot":"","sources":["../../src/util/md5.js"],"names":[],"mappings":"AAuBA,KAAK,qBAAqB,GAAG,MAAM,OAAO,CAAC;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAkBpE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAElE;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,qBAAqB,GAChC,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD"}

package/dist/util/md5.js

@@ -0,0 +1,209 @@
+//#region src/util/md5.ts
+/**
+* Encodes raw bytes as base64 in an isomorphic way (Node Buffer fallback to btoa).
+*
+* @param bytes - The raw bytes to encode.
+*
+* @returns The base64-encoded string.
+*/
+function bytesToBase64(bytes) {
+	const g = globalThis;
+	if (g.Buffer) return g.Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+var loadNodeCrypto = () => import("node:crypto");
+function syncNodeCreateHash() {
+	const crypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+	if (!crypto || typeof crypto !== "object") return null;
+	const { createHash } = crypto;
+	return typeof createHash === "function" ? createHash : null;
+}
+/**
+* Computes the MD5 digest of the given bytes as a base64 string. Prefers
+* `node:crypto` for native speed when available; falls back to a pure-JS
+* implementation in browser / edge runtimes because WebCrypto's
+* `crypto.subtle.digest` deliberately does not support MD5.
+*
+* MD5 is used only for wire-protocol integrity checks, not as a security
+* boundary.
+*
+* @param bytes - The bytes to digest.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+async function md5Base64(bytes) {
+	return md5Base64WithCryptoLoader(bytes, loadNodeCrypto);
+}
+/**
+* Computes the MD5 digest with an injected async crypto loader.
+*
+* @param bytes - The bytes to digest.
+* @param loadCrypto - Crypto module loader used by runtime fallback tests.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+async function md5Base64WithCryptoLoader(bytes, loadCrypto) {
+	try {
+		const { createHash } = await loadCrypto();
+		if (typeof createHash !== "function") throw new Error("createHash unavailable");
+		return createHash("md5").update(bytes).digest("base64");
+	} catch {
+		return md5Base64Sync(bytes);
+	}
+}
+/**
+* Computes the MD5 digest of the given bytes as a base64 string without
+* dynamic imports.
+*
+* @param bytes - The bytes to digest.
+*
+* @returns The base64-encoded MD5 digest.
+*
+* @internal
+*/
+function md5Base64Sync(bytes) {
+	const createHash = syncNodeCreateHash();
+	if (createHash) return createHash("md5").update(bytes).digest("base64");
+	return bytesToBase64(md5Bytes(bytes));
+}
+/**
+* Pure-JS MD5 implementation per RFC 1321. Returns the 16-byte digest of the
+* input. Used as a browser fallback for SSE-C key MD5 computation; not
+* intended for security-sensitive purposes (MD5 is broken cryptographically).
+*
+* @param data - The bytes to hash.
+*
+* @returns The 16-byte MD5 digest.
+*/
+function md5Bytes(data) {
+	const originalBitLength = data.length * 8;
+	const paddedLength = data.length + 1 + 8 + 63 & -64;
+	const msg = new Uint8Array(paddedLength);
+	msg.set(data);
+	msg[data.length] = 128;
+	const view = new DataView(msg.buffer);
+	view.setUint32(paddedLength - 8, originalBitLength >>> 0, true);
+	view.setUint32(paddedLength - 4, Math.floor(originalBitLength / 4294967296), true);
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	const s = [
+		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 k = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296));
+	const leftRotate = (x, c) => x << c | x >>> 32 - c;
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		const m = Array.from({ length: 16 }, (_, i) => view.getUint32(offset + i * 4, true));
+		for (let i = 0; i < 64; 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) % 16;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % 16;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % 16;
+			}
+			const temp = d;
+			d = c;
+			c = b;
+			b = b + leftRotate(a + f + k[i] + m[g] >>> 0, s[i]) >>> 0;
+			a = temp;
+		}
+		a0 = a0 + a >>> 0;
+		b0 = b0 + b >>> 0;
+		c0 = c0 + c >>> 0;
+		d0 = d0 + d >>> 0;
+	}
+	const out = /* @__PURE__ */ new Uint8Array(16);
+	const outView = new DataView(out.buffer);
+	outView.setUint32(0, a0, true);
+	outView.setUint32(4, b0, true);
+	outView.setUint32(8, c0, true);
+	outView.setUint32(12, d0, true);
+	return out;
+}
+//#endregion
+export { md5Base64, md5Base64Sync, md5Base64WithCryptoLoader };
+
+//# sourceMappingURL=md5.js.map

package/dist/util/md5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.js","names":[],"sources":["../../src/util/md5.ts"],"sourcesContent":["/**\n * Encodes raw bytes as base64 in an isomorphic way (Node Buffer fallback to btoa).\n *\n * @param bytes - The raw bytes to encode.\n *\n * @returns The base64-encoded string.\n */\nfunction bytesToBase64(bytes: Uint8Array): string {\n  const g = globalThis as {\n    Buffer?: { from(b: Uint8Array): { toString(encoding: string): string } }\n  }\n  if (g.Buffer) return g.Buffer.from(bytes).toString('base64')\n\n  let binary = ''\n  for (const byte of bytes) binary += String.fromCharCode(byte)\n  return btoa(binary)\n}\n\ntype SyncNodeHash = {\n  update(bytes: Uint8Array): SyncNodeHash\n  digest(encoding: 'base64'): string\n}\n\ntype AsyncNodeCryptoLoader = () => Promise<{ createHash?: unknown }>\n\nconst loadNodeCrypto: AsyncNodeCryptoLoader = () => import('node:crypto')\n\nfunction syncNodeCreateHash(): ((algorithm: string) => SyncNodeHash) | null {\n  const g = globalThis as {\n    process?: {\n      getBuiltinModule?: (name: string) => unknown\n    }\n  }\n  const crypto = g.process?.getBuiltinModule?.('node:crypto')\n  if (!crypto || typeof crypto !== 'object') return null\n  const { createHash } = crypto as { createHash?: unknown }\n  return typeof createHash === 'function'\n    ? (createHash as (algorithm: string) => SyncNodeHash)\n    : null\n}\n\n/**\n * Computes the MD5 digest of the given bytes as a base64 string. Prefers\n * `node:crypto` for native speed when available; falls back to a pure-JS\n * implementation in browser / edge runtimes because WebCrypto's\n * `crypto.subtle.digest` deliberately does not support MD5.\n *\n * MD5 is used only for wire-protocol integrity checks, not as a security\n * boundary.\n *\n * @param bytes - The bytes to digest.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport async function md5Base64(bytes: Uint8Array): Promise<string> {\n  return md5Base64WithCryptoLoader(bytes, loadNodeCrypto)\n}\n\n/**\n * Computes the MD5 digest with an injected async crypto loader.\n *\n * @param bytes - The bytes to digest.\n * @param loadCrypto - Crypto module loader used by runtime fallback tests.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport async function md5Base64WithCryptoLoader(\n  bytes: Uint8Array,\n  loadCrypto: AsyncNodeCryptoLoader,\n): Promise<string> {\n  try {\n    const { createHash } = await loadCrypto()\n    // Vite's browser shim resolves the import but does not implement\n    // `createHash`. Probe explicitly so we fall through to the pure-JS path.\n    if (typeof createHash !== 'function') throw new Error('createHash unavailable')\n    return createHash('md5').update(bytes).digest('base64')\n  } catch {\n    return md5Base64Sync(bytes)\n  }\n}\n\n/**\n * Computes the MD5 digest of the given bytes as a base64 string without\n * dynamic imports.\n *\n * @param bytes - The bytes to digest.\n *\n * @returns The base64-encoded MD5 digest.\n *\n * @internal\n */\nexport function md5Base64Sync(bytes: Uint8Array): string {\n  const createHash = syncNodeCreateHash()\n  if (createHash) return createHash('md5').update(bytes).digest('base64')\n\n  return bytesToBase64(md5Bytes(bytes))\n}\n\n/**\n * Pure-JS MD5 implementation per RFC 1321. Returns the 16-byte digest of the\n * input. Used as a browser fallback for SSE-C key MD5 computation; not\n * intended for security-sensitive purposes (MD5 is broken cryptographically).\n *\n * @param data - The bytes to hash.\n *\n * @returns The 16-byte MD5 digest.\n */\nfunction md5Bytes(data: Uint8Array): Uint8Array {\n  const originalBitLength = data.length * 8\n  const withOne = data.length + 1\n  const paddedLength = (withOne + 8 + 63) & ~63\n  const msg = new Uint8Array(paddedLength)\n  msg.set(data)\n  msg[data.length] = 0x80\n  const view = new DataView(msg.buffer)\n  view.setUint32(paddedLength - 8, originalBitLength >>> 0, true)\n  view.setUint32(paddedLength - 4, Math.floor(originalBitLength / 0x1_0000_0000), true)\n\n  let a0 = 0x67452301\n  let b0 = 0xefcdab89\n  let c0 = 0x98badcfe\n  let d0 = 0x10325476\n\n  const s = [\n    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,\n    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,\n    6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,\n  ]\n  const k = Array.from({ length: 64 }, (_, i) =>\n    Math.floor(Math.abs(Math.sin(i + 1)) * 0x1_0000_0000),\n  )\n\n  const leftRotate = (x: number, c: number) => (x << c) | (x >>> (32 - c))\n\n  for (let offset = 0; offset < paddedLength; offset += 64) {\n    let a = a0\n    let b = b0\n    let c = c0\n    let d = d0\n\n    const m = Array.from({ length: 16 }, (_, i) => view.getUint32(offset + i * 4, true))\n\n    for (let i = 0; i < 64; i++) {\n      let f: number\n      let g: number\n      if (i < 16) {\n        f = (b & c) | (~b & d)\n        g = i\n      } else if (i < 32) {\n        f = (d & b) | (~d & c)\n        g = (5 * i + 1) % 16\n      } else if (i < 48) {\n        f = b ^ c ^ d\n        g = (3 * i + 5) % 16\n      } else {\n        f = c ^ (b | ~d)\n        g = (7 * i) % 16\n      }\n\n      const temp = d\n      d = c\n      c = b\n      b =\n        (b + leftRotate((a + f + (k[i] as number) + (m[g] as number)) >>> 0, s[i] as number)) >>> 0\n      a = temp\n    }\n\n    a0 = (a0 + a) >>> 0\n    b0 = (b0 + b) >>> 0\n    c0 = (c0 + c) >>> 0\n    d0 = (d0 + d) >>> 0\n  }\n\n  const out = new Uint8Array(16)\n  const outView = new DataView(out.buffer)\n  outView.setUint32(0, a0, true)\n  outView.setUint32(4, b0, true)\n  outView.setUint32(8, c0, true)\n  outView.setUint32(12, d0, true)\n  return out\n}\n"],"mappings":"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"}

package/dist/util/normalize.cjs

@@ -36,7 +36,7 @@ function normalizeSha1(raw) {
 * substitution was needed, so callers paying for change detection
 * (e.g. React memo) see referential stability.
 *
-* @typeParam T - Any object with a `contentSha1: string | null` field.
+* @typeParam T - Any object with a `contentSha1?: string | null` field.
 *
 * @param fv - The wire-shape file-version object.
 *
@@ -50,11 +50,11 @@ function normalizeFileVersionSha1(fv) {
 }
 /**
 * Returns a new list-response object with `normalizeFileVersionSha1`
-* applied to every entry in `files`. Used at the `b2_list_file_names` /
-* `b2_list_file_versions` boundary so list output shares the same
-* SHA-1 semantics as the singular endpoints.
+* applied to every entry in `files`. Used at file-version and unfinished
+* large-file list boundaries so list output shares the same SHA-1 semantics
+* as the singular endpoints.
 *
-* @typeParam F - Any object with a `contentSha1: string | null` field.
+* @typeParam F - Any object with a `contentSha1?: string | null` field.
 * @typeParam R - The list-response shape (must have a `files` array of `F`).
 *
 * @param resp - The wire-shape list response.

package/dist/util/normalize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.cjs","names":[],"sources":["../../src/util/normalize.ts"],"sourcesContent":["/**\n * Wire-shape → SDK-shape normalization helpers.\n *\n * B2 occasionally uses sentinel strings on the wire where a missing\n * value would be more idiomatic in TypeScript. The biggest offender is\n * `contentSha1: 'none'` on files completed via `b2_finish_large_file`\n * (multipart-finished files don't have a whole-file SHA-1; B2 sends the\n * literal three-letter string). The SDK's `FileVersion.contentSha1` is\n * typed `string | null` to signal that absence — this module collapses\n * the wire sentinel to `null` so callers can write\n * `if (fv.contentSha1) { ... }` without an extra `=== 'none'` guard.\n *\n * Normalization happens at the RawClient boundary so every SDK consumer\n * (RawClient direct users, the high-level facade, the simulator-driven\n * tests, generated docs) sees the same `null` value.\n *\n * @packageDocumentation\n */\n\n/**\n * Collapses the B2 wire sentinel `'none'` (and `undefined`) to `null` for\n * SHA-1-shaped fields. Any other string passes through unchanged.\n *\n * @param raw - SHA-1 string from the wire, or `null`/`undefined`.\n *\n * @returns A hex SHA-1 string, or `null` when the wire said \"no hash\".\n */\nexport function normalizeSha1(raw: string | null | undefined): string | null {\n  if (raw === null || raw === undefined || raw === 'none') return null\n  return raw\n}\n\n/**\n * Returns a new file-version-shaped object with the `contentSha1: 'none'`\n * sentinel collapsed to `null`. Pass-through when the value is already\n * `null` or a real hash. The object reference is preserved if no\n * substitution was needed, so callers paying for change detection\n * (e.g. React memo) see referential stability.\n *\n * @typeParam T - Any object with a `contentSha1: string | null` field.\n *\n * @param fv - The wire-shape file-version object.\n *\n * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.\n */\nexport function normalizeFileVersionSha1<T extends { readonly contentSha1: string | null }>(\n  fv: T,\n): T {\n  return fv.contentSha1 === 'none' ? { ...fv, contentSha1: null } : fv\n}\n\n/**\n * Returns a new list-response object with `normalizeFileVersionSha1`\n * applied to every entry in `files`. Used at the `b2_list_file_names` /\n * `b2_list_file_versions` boundary so list output shares the same\n * SHA-1 semantics as the singular endpoints.\n *\n * @typeParam F - Any object with a `contentSha1: string | null` field.\n * @typeParam R - The list-response shape (must have a `files` array of `F`).\n *\n * @param resp - The wire-shape list response.\n *\n * @returns A response with normalized `files`. `resp.files` is a new array.\n */\nexport function normalizeFileVersionListSha1<\n  F extends { readonly contentSha1: string | null },\n  R extends { readonly files: readonly F[] },\n>(resp: R): R {\n  return { ...resp, files: resp.files.map(normalizeFileVersionSha1) }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,cAAc,KAA+C;CAC3E,IAAI,QAAQ,QAAQ,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO;CAChE,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,yBACd,IACG;CACH,OAAO,GAAG,gBAAgB,SAAS;EAAE,GAAG;EAAI,aAAa;CAAK,IAAI;AACpE;;;;;;;;;;;;;;AAeA,SAAgB,6BAGd,MAAY;CACZ,OAAO;EAAE,GAAG;EAAM,OAAO,KAAK,MAAM,IAAI,wBAAwB;CAAE;AACpE"}
+{"version":3,"file":"normalize.cjs","names":[],"sources":["../../src/util/normalize.ts"],"sourcesContent":["/**\n * Wire-shape → SDK-shape normalization helpers.\n *\n * B2 occasionally uses sentinel strings on the wire where a missing\n * value would be more idiomatic in TypeScript. The biggest offender is\n * `contentSha1: 'none'` on files completed via `b2_finish_large_file`\n * (multipart-finished files don't have a whole-file SHA-1; B2 sends the\n * literal three-letter string). The SDK's `FileVersion.contentSha1` is\n * typed `string | null` to signal that absence — this module collapses\n * the wire sentinel to `null` so callers can write\n * `if (fv.contentSha1) { ... }` without an extra `=== 'none'` guard.\n *\n * Normalization happens at the RawClient boundary so every SDK consumer\n * (RawClient direct users, the high-level facade, the simulator-driven\n * tests, generated docs) sees the same `null` value.\n *\n * @packageDocumentation\n */\n\n/**\n * Collapses the B2 wire sentinel `'none'` (and `undefined`) to `null` for\n * SHA-1-shaped fields. Any other string passes through unchanged.\n *\n * @param raw - SHA-1 string from the wire, or `null`/`undefined`.\n *\n * @returns A hex SHA-1 string, or `null` when the wire said \"no hash\".\n */\nexport function normalizeSha1(raw: string | null | undefined): string | null {\n  if (raw === null || raw === undefined || raw === 'none') return null\n  return raw\n}\n\n/**\n * Returns a new file-version-shaped object with the `contentSha1: 'none'`\n * sentinel collapsed to `null`. Pass-through when the value is already\n * `null` or a real hash. The object reference is preserved if no\n * substitution was needed, so callers paying for change detection\n * (e.g. React memo) see referential stability.\n *\n * @typeParam T - Any object with a `contentSha1?: string | null` field.\n *\n * @param fv - The wire-shape file-version object.\n *\n * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.\n */\nexport function normalizeFileVersionSha1<T extends { readonly contentSha1?: string | null }>(\n  fv: T,\n): T {\n  return fv.contentSha1 === 'none' ? { ...fv, contentSha1: null } : fv\n}\n\n/**\n * Returns a new list-response object with `normalizeFileVersionSha1`\n * applied to every entry in `files`. Used at file-version and unfinished\n * large-file list boundaries so list output shares the same SHA-1 semantics\n * as the singular endpoints.\n *\n * @typeParam F - Any object with a `contentSha1?: string | null` field.\n * @typeParam R - The list-response shape (must have a `files` array of `F`).\n *\n * @param resp - The wire-shape list response.\n *\n * @returns A response with normalized `files`. `resp.files` is a new array.\n */\nexport function normalizeFileVersionListSha1<\n  F extends { readonly contentSha1?: string | null },\n  R extends { readonly files: readonly F[] },\n>(resp: R): R {\n  return { ...resp, files: resp.files.map(normalizeFileVersionSha1) }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,cAAc,KAA+C;CAC3E,IAAI,QAAQ,QAAQ,QAAQ,KAAA,KAAa,QAAQ,QAAQ,OAAO;CAChE,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,yBACd,IACG;CACH,OAAO,GAAG,gBAAgB,SAAS;EAAE,GAAG;EAAI,aAAa;CAAK,IAAI;AACpE;;;;;;;;;;;;;;AAeA,SAAgB,6BAGd,MAAY;CACZ,OAAO;EAAE,GAAG;EAAM,OAAO,KAAK,MAAM,IAAI,wBAAwB;CAAE;AACpE"}

package/dist/util/normalize.d.cts

@@ -32,22 +32,22 @@ export declare function normalizeSha1(raw: string | null | undefined): string |
  * substitution was needed, so callers paying for change detection
  * (e.g. React memo) see referential stability.
  *
- * @typeParam T - Any object with a `contentSha1: string | null` field.
+ * @typeParam T - Any object with a `contentSha1?: string | null` field.
  *
  * @param fv - The wire-shape file-version object.
  *
  * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.
  */
 export declare function normalizeFileVersionSha1<T extends {
-    readonly contentSha1: string | null;
+    readonly contentSha1?: string | null;
 }>(fv: T): T;
 /**
  * Returns a new list-response object with `normalizeFileVersionSha1`
- * applied to every entry in `files`. Used at the `b2_list_file_names` /
- * `b2_list_file_versions` boundary so list output shares the same
- * SHA-1 semantics as the singular endpoints.
+ * applied to every entry in `files`. Used at file-version and unfinished
+ * large-file list boundaries so list output shares the same SHA-1 semantics
+ * as the singular endpoints.
  *
- * @typeParam F - Any object with a `contentSha1: string | null` field.
+ * @typeParam F - Any object with a `contentSha1?: string | null` field.
  * @typeParam R - The list-response shape (must have a `files` array of `F`).
  *
  * @param resp - The wire-shape list response.
@@ -55,7 +55,7 @@ export declare function normalizeFileVersionSha1<T extends {
  * @returns A response with normalized `files`. `resp.files` is a new array.
  */
 export declare function normalizeFileVersionListSha1<F extends {
-    readonly contentSha1: string | null;
+    readonly contentSha1?: string | null;
 }, R extends {
     readonly files: readonly F[];
 }>(resp: R): R;

package/dist/util/normalize.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/util/normalize.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACxF,EAAE,EAAE,CAAC,GACJ,CAAC,CAEH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACjD,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;CAAE,EAC1C,IAAI,EAAE,CAAC,GAAG,CAAC,CAEZ"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/util/normalize.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACzF,EAAE,EAAE,CAAC,GACJ,CAAC,CAEH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAClD,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;CAAE,EAC1C,IAAI,EAAE,CAAC,GAAG,CAAC,CAEZ"}

package/dist/util/normalize.d.ts

@@ -32,22 +32,22 @@ export declare function normalizeSha1(raw: string | null | undefined): string |
  * substitution was needed, so callers paying for change detection
  * (e.g. React memo) see referential stability.
  *
- * @typeParam T - Any object with a `contentSha1: string | null` field.
+ * @typeParam T - Any object with a `contentSha1?: string | null` field.
  *
  * @param fv - The wire-shape file-version object.
  *
  * @returns Either `fv` unchanged or a shallow copy with `contentSha1: null`.
  */
 export declare function normalizeFileVersionSha1<T extends {
-    readonly contentSha1: string | null;
+    readonly contentSha1?: string | null;
 }>(fv: T): T;
 /**
  * Returns a new list-response object with `normalizeFileVersionSha1`
- * applied to every entry in `files`. Used at the `b2_list_file_names` /
- * `b2_list_file_versions` boundary so list output shares the same
- * SHA-1 semantics as the singular endpoints.
+ * applied to every entry in `files`. Used at file-version and unfinished
+ * large-file list boundaries so list output shares the same SHA-1 semantics
+ * as the singular endpoints.
  *
- * @typeParam F - Any object with a `contentSha1: string | null` field.
+ * @typeParam F - Any object with a `contentSha1?: string | null` field.
  * @typeParam R - The list-response shape (must have a `files` array of `F`).
  *
  * @param resp - The wire-shape list response.
@@ -55,7 +55,7 @@ export declare function normalizeFileVersionSha1<T extends {
  * @returns A response with normalized `files`. `resp.files` is a new array.
  */
 export declare function normalizeFileVersionListSha1<F extends {
-    readonly contentSha1: string | null;
+    readonly contentSha1?: string | null;
 }, R extends {
     readonly files: readonly F[];
 }>(resp: R): R;