@backblaze-labs/b2-sdk 0.2.0 → 0.3.0

package/dist/util/abort.cjs

@@ -0,0 +1,114 @@
+//#region src/util/abort.ts
+/**
+* Abort-signal and cancellation-error helpers shared across SDK operations.
+*
+* @packageDocumentation
+*/
+/**
+* Resolves the abort reason for a signal, defaulting to a standard `AbortError`.
+*
+* @param signal - The aborted signal whose reason should be resolved.
+*
+* @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.
+*/
+function abortReason(signal) {
+	return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+/**
+* Returns whether an error represents an abort.
+*
+* @param err - Unknown thrown value.
+*
+* @returns True for `Error` or `DOMException` instances named `AbortError`.
+*/
+function isAbortError(err) {
+	return isNamedError(err, "AbortError");
+}
+/**
+* Returns whether an error should be treated as the given signal's abort.
+*
+* @param signal - Controlling signal for the operation.
+* @param err - Unknown thrown value.
+*
+* @returns True when the signal is aborted and `err` is either the signal's
+* reason or a trusted `AbortError` instance.
+*/
+function isSignalAbortError(signal, err) {
+	if (signal?.aborted !== true) return false;
+	if (signal.reason !== void 0 && Object.is(err, signal.reason)) return true;
+	return isAbortError(err);
+}
+/**
+* Returns whether an error represents a timeout.
+*
+* @param err - Unknown thrown value.
+*
+* @returns True for `Error` or `DOMException` instances named `TimeoutError`.
+*/
+function isTimeoutError(err) {
+	return isNamedError(err, "TimeoutError");
+}
+/**
+* Throws the abort reason if the signal is already aborted; otherwise returns.
+*
+* @param signal - The signal to check, or undefined to skip the check.
+*
+* @throws The signal's abort reason when the signal is already aborted.
+*/
+function throwIfSignalAborted(signal) {
+	if (signal?.aborted === true) throw abortReason(signal);
+}
+/**
+* Races a promise against an abort signal. Rejects with the signal's abort
+* reason if the signal fires first, detaching the listener and suppressing the
+* losing promise's rejection so it never surfaces as an unhandled rejection.
+*
+* The underlying work must still receive the same signal so transports can
+* cancel their network activity. This helper only makes callers stop waiting
+* promptly even when a test double or custom transport ignores the signal.
+*
+* @param promise - The work to await.
+* @param signal - Abort signal, or undefined to await the promise directly.
+*
+* @returns The resolved value of `promise` when it settles before the signal aborts.
+*
+* @throws The abort reason if the signal aborts first, or the promise's rejection.
+*/
+async function raceWithAbort(promise, signal) {
+	if (signal === void 0) return promise;
+	if (signal.aborted) {
+		promise.catch(() => {});
+		throw abortReason(signal);
+	}
+	let removeAbortListener;
+	const aborted = new Promise((_, reject) => {
+		const onAbort = () => {
+			promise.catch(() => {});
+			reject(abortReason(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		if (signal.aborted) onAbort();
+	});
+	try {
+		return await Promise.race([promise, aborted]);
+	} finally {
+		removeAbortListener?.();
+	}
+}
+function isNamedError(err, name) {
+	try {
+		return (err instanceof DOMException || err instanceof Error) && err.name === name;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+exports.abortReason = abortReason;
+exports.isAbortError = isAbortError;
+exports.isSignalAbortError = isSignalAbortError;
+exports.isTimeoutError = isTimeoutError;
+exports.raceWithAbort = raceWithAbort;
+exports.throwIfSignalAborted = throwIfSignalAborted;
+
+//# sourceMappingURL=abort.cjs.map

package/dist/util/abort.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.cjs","names":[],"sources":["../../src/util/abort.ts"],"sourcesContent":["/**\n * Abort-signal and cancellation-error helpers shared across SDK operations.\n *\n * @packageDocumentation\n */\n\n/**\n * Resolves the abort reason for a signal, defaulting to a standard `AbortError`.\n *\n * @param signal - The aborted signal whose reason should be resolved.\n *\n * @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.\n */\nexport function abortReason(signal: AbortSignal): unknown {\n  return signal.reason ?? new DOMException('Aborted', 'AbortError')\n}\n\n/**\n * Returns whether an error represents an abort.\n *\n * @param err - Unknown thrown value.\n *\n * @returns True for `Error` or `DOMException` instances named `AbortError`.\n */\nexport function isAbortError(err: unknown): boolean {\n  return isNamedError(err, 'AbortError')\n}\n\n/**\n * Returns whether an error should be treated as the given signal's abort.\n *\n * @param signal - Controlling signal for the operation.\n * @param err - Unknown thrown value.\n *\n * @returns True when the signal is aborted and `err` is either the signal's\n * reason or a trusted `AbortError` instance.\n */\nexport function isSignalAbortError(signal: AbortSignal | undefined, err: unknown): boolean {\n  if (signal?.aborted !== true) return false\n  if (signal.reason !== undefined && Object.is(err, signal.reason)) return true\n  return isAbortError(err)\n}\n\n/**\n * Returns whether an error represents a timeout.\n *\n * @param err - Unknown thrown value.\n *\n * @returns True for `Error` or `DOMException` instances named `TimeoutError`.\n */\nexport function isTimeoutError(err: unknown): boolean {\n  return isNamedError(err, 'TimeoutError')\n}\n\n/**\n * Throws the abort reason if the signal is already aborted; otherwise returns.\n *\n * @param signal - The signal to check, or undefined to skip the check.\n *\n * @throws The signal's abort reason when the signal is already aborted.\n */\nexport function throwIfSignalAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted === true) {\n    throw abortReason(signal)\n  }\n}\n\n/**\n * Races a promise against an abort signal. Rejects with the signal's abort\n * reason if the signal fires first, detaching the listener and suppressing the\n * losing promise's rejection so it never surfaces as an unhandled rejection.\n *\n * The underlying work must still receive the same signal so transports can\n * cancel their network activity. This helper only makes callers stop waiting\n * promptly even when a test double or custom transport ignores the signal.\n *\n * @param promise - The work to await.\n * @param signal - Abort signal, or undefined to await the promise directly.\n *\n * @returns The resolved value of `promise` when it settles before the signal aborts.\n *\n * @throws The abort reason if the signal aborts first, or the promise's rejection.\n */\nexport async function raceWithAbort<T>(\n  promise: Promise<T>,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  if (signal === undefined) return promise\n  if (signal.aborted) {\n    void promise.catch(() => {})\n    throw abortReason(signal)\n  }\n\n  let removeAbortListener: (() => void) | undefined\n  const aborted = new Promise<never>((_, reject) => {\n    const onAbort = (): void => {\n      void promise.catch(() => {})\n      reject(abortReason(signal))\n    }\n    signal.addEventListener('abort', onAbort, { once: true })\n    removeAbortListener = () => signal.removeEventListener('abort', onAbort)\n    if (signal.aborted) onAbort()\n  })\n\n  try {\n    return await Promise.race([promise, aborted])\n  } finally {\n    removeAbortListener?.()\n  }\n}\n\nfunction isNamedError(err: unknown, name: string): boolean {\n  try {\n    return (\n      (err instanceof DOMException || err instanceof Error) &&\n      (err as { readonly name: string }).name === name\n    )\n  } catch {\n    return false\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,YAAY,QAA8B;CACxD,OAAO,OAAO,UAAU,IAAI,aAAa,WAAW,YAAY;AAClE;;;;;;;;AASA,SAAgB,aAAa,KAAuB;CAClD,OAAO,aAAa,KAAK,YAAY;AACvC;;;;;;;;;;AAWA,SAAgB,mBAAmB,QAAiC,KAAuB;CACzF,IAAI,QAAQ,YAAY,MAAM,OAAO;CACrC,IAAI,OAAO,WAAW,KAAA,KAAa,OAAO,GAAG,KAAK,OAAO,MAAM,GAAG,OAAO;CACzE,OAAO,aAAa,GAAG;AACzB;;;;;;;;AASA,SAAgB,eAAe,KAAuB;CACpD,OAAO,aAAa,KAAK,cAAc;AACzC;;;;;;;;AASA,SAAgB,qBAAqB,QAAuC;CAC1E,IAAI,QAAQ,YAAY,MACtB,MAAM,YAAY,MAAM;AAE5B;;;;;;;;;;;;;;;;;AAkBA,eAAsB,cACpB,SACA,QACY;CACZ,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,IAAI,OAAO,SAAS;EAClB,QAAa,YAAY,CAAC,CAAC;EAC3B,MAAM,YAAY,MAAM;CAC1B;CAEA,IAAI;CACJ,MAAM,UAAU,IAAI,SAAgB,GAAG,WAAW;EAChD,MAAM,gBAAsB;GAC1B,QAAa,YAAY,CAAC,CAAC;GAC3B,OAAO,YAAY,MAAM,CAAC;EAC5B;EACA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACxD,4BAA4B,OAAO,oBAAoB,SAAS,OAAO;EACvE,IAAI,OAAO,SAAS,QAAQ;CAC9B,CAAC;CAED,IAAI;EACF,OAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,OAAO,CAAC;CAC9C,UAAU;EACR,sBAAsB;CACxB;AACF;AAEA,SAAS,aAAa,KAAc,MAAuB;CACzD,IAAI;EACF,QACG,eAAe,gBAAgB,eAAe,UAC9C,IAAkC,SAAS;CAEhD,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/util/abort.d.cts

@@ -0,0 +1,65 @@
+/**
+ * Abort-signal and cancellation-error helpers shared across SDK operations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Resolves the abort reason for a signal, defaulting to a standard `AbortError`.
+ *
+ * @param signal - The aborted signal whose reason should be resolved.
+ *
+ * @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.
+ */
+export declare function abortReason(signal: AbortSignal): unknown;
+/**
+ * Returns whether an error represents an abort.
+ *
+ * @param err - Unknown thrown value.
+ *
+ * @returns True for `Error` or `DOMException` instances named `AbortError`.
+ */
+export declare function isAbortError(err: unknown): boolean;
+/**
+ * Returns whether an error should be treated as the given signal's abort.
+ *
+ * @param signal - Controlling signal for the operation.
+ * @param err - Unknown thrown value.
+ *
+ * @returns True when the signal is aborted and `err` is either the signal's
+ * reason or a trusted `AbortError` instance.
+ */
+export declare function isSignalAbortError(signal: AbortSignal | undefined, err: unknown): boolean;
+/**
+ * Returns whether an error represents a timeout.
+ *
+ * @param err - Unknown thrown value.
+ *
+ * @returns True for `Error` or `DOMException` instances named `TimeoutError`.
+ */
+export declare function isTimeoutError(err: unknown): boolean;
+/**
+ * Throws the abort reason if the signal is already aborted; otherwise returns.
+ *
+ * @param signal - The signal to check, or undefined to skip the check.
+ *
+ * @throws The signal's abort reason when the signal is already aborted.
+ */
+export declare function throwIfSignalAborted(signal: AbortSignal | undefined): void;
+/**
+ * Races a promise against an abort signal. Rejects with the signal's abort
+ * reason if the signal fires first, detaching the listener and suppressing the
+ * losing promise's rejection so it never surfaces as an unhandled rejection.
+ *
+ * The underlying work must still receive the same signal so transports can
+ * cancel their network activity. This helper only makes callers stop waiting
+ * promptly even when a test double or custom transport ignores the signal.
+ *
+ * @param promise - The work to await.
+ * @param signal - Abort signal, or undefined to await the promise directly.
+ *
+ * @returns The resolved value of `promise` when it settles before the signal aborts.
+ *
+ * @throws The abort reason if the signal aborts first, or the promise's rejection.
+ */
+export declare function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+//# sourceMappingURL=abort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../../src/util/abort.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAIzF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAI1E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/util/abort.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Abort-signal and cancellation-error helpers shared across SDK operations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Resolves the abort reason for a signal, defaulting to a standard `AbortError`.
+ *
+ * @param signal - The aborted signal whose reason should be resolved.
+ *
+ * @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.
+ */
+export declare function abortReason(signal: AbortSignal): unknown;
+/**
+ * Returns whether an error represents an abort.
+ *
+ * @param err - Unknown thrown value.
+ *
+ * @returns True for `Error` or `DOMException` instances named `AbortError`.
+ */
+export declare function isAbortError(err: unknown): boolean;
+/**
+ * Returns whether an error should be treated as the given signal's abort.
+ *
+ * @param signal - Controlling signal for the operation.
+ * @param err - Unknown thrown value.
+ *
+ * @returns True when the signal is aborted and `err` is either the signal's
+ * reason or a trusted `AbortError` instance.
+ */
+export declare function isSignalAbortError(signal: AbortSignal | undefined, err: unknown): boolean;
+/**
+ * Returns whether an error represents a timeout.
+ *
+ * @param err - Unknown thrown value.
+ *
+ * @returns True for `Error` or `DOMException` instances named `TimeoutError`.
+ */
+export declare function isTimeoutError(err: unknown): boolean;
+/**
+ * Throws the abort reason if the signal is already aborted; otherwise returns.
+ *
+ * @param signal - The signal to check, or undefined to skip the check.
+ *
+ * @throws The signal's abort reason when the signal is already aborted.
+ */
+export declare function throwIfSignalAborted(signal: AbortSignal | undefined): void;
+/**
+ * Races a promise against an abort signal. Rejects with the signal's abort
+ * reason if the signal fires first, detaching the listener and suppressing the
+ * losing promise's rejection so it never surfaces as an unhandled rejection.
+ *
+ * The underlying work must still receive the same signal so transports can
+ * cancel their network activity. This helper only makes callers stop waiting
+ * promptly even when a test double or custom transport ignores the signal.
+ *
+ * @param promise - The work to await.
+ * @param signal - Abort signal, or undefined to await the promise directly.
+ *
+ * @returns The resolved value of `promise` when it settles before the signal aborts.
+ *
+ * @throws The abort reason if the signal aborts first, or the promise's rejection.
+ */
+export declare function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+//# sourceMappingURL=abort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../../src/util/abort.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAIzF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAI1E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/util/abort.js

@@ -0,0 +1,109 @@
+//#region src/util/abort.ts
+/**
+* Abort-signal and cancellation-error helpers shared across SDK operations.
+*
+* @packageDocumentation
+*/
+/**
+* Resolves the abort reason for a signal, defaulting to a standard `AbortError`.
+*
+* @param signal - The aborted signal whose reason should be resolved.
+*
+* @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.
+*/
+function abortReason(signal) {
+	return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+/**
+* Returns whether an error represents an abort.
+*
+* @param err - Unknown thrown value.
+*
+* @returns True for `Error` or `DOMException` instances named `AbortError`.
+*/
+function isAbortError(err) {
+	return isNamedError(err, "AbortError");
+}
+/**
+* Returns whether an error should be treated as the given signal's abort.
+*
+* @param signal - Controlling signal for the operation.
+* @param err - Unknown thrown value.
+*
+* @returns True when the signal is aborted and `err` is either the signal's
+* reason or a trusted `AbortError` instance.
+*/
+function isSignalAbortError(signal, err) {
+	if (signal?.aborted !== true) return false;
+	if (signal.reason !== void 0 && Object.is(err, signal.reason)) return true;
+	return isAbortError(err);
+}
+/**
+* Returns whether an error represents a timeout.
+*
+* @param err - Unknown thrown value.
+*
+* @returns True for `Error` or `DOMException` instances named `TimeoutError`.
+*/
+function isTimeoutError(err) {
+	return isNamedError(err, "TimeoutError");
+}
+/**
+* Throws the abort reason if the signal is already aborted; otherwise returns.
+*
+* @param signal - The signal to check, or undefined to skip the check.
+*
+* @throws The signal's abort reason when the signal is already aborted.
+*/
+function throwIfSignalAborted(signal) {
+	if (signal?.aborted === true) throw abortReason(signal);
+}
+/**
+* Races a promise against an abort signal. Rejects with the signal's abort
+* reason if the signal fires first, detaching the listener and suppressing the
+* losing promise's rejection so it never surfaces as an unhandled rejection.
+*
+* The underlying work must still receive the same signal so transports can
+* cancel their network activity. This helper only makes callers stop waiting
+* promptly even when a test double or custom transport ignores the signal.
+*
+* @param promise - The work to await.
+* @param signal - Abort signal, or undefined to await the promise directly.
+*
+* @returns The resolved value of `promise` when it settles before the signal aborts.
+*
+* @throws The abort reason if the signal aborts first, or the promise's rejection.
+*/
+async function raceWithAbort(promise, signal) {
+	if (signal === void 0) return promise;
+	if (signal.aborted) {
+		promise.catch(() => {});
+		throw abortReason(signal);
+	}
+	let removeAbortListener;
+	const aborted = new Promise((_, reject) => {
+		const onAbort = () => {
+			promise.catch(() => {});
+			reject(abortReason(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		if (signal.aborted) onAbort();
+	});
+	try {
+		return await Promise.race([promise, aborted]);
+	} finally {
+		removeAbortListener?.();
+	}
+}
+function isNamedError(err, name) {
+	try {
+		return (err instanceof DOMException || err instanceof Error) && err.name === name;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { abortReason, isAbortError, isSignalAbortError, isTimeoutError, raceWithAbort, throwIfSignalAborted };
+
+//# sourceMappingURL=abort.js.map

package/dist/util/abort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.js","names":[],"sources":["../../src/util/abort.ts"],"sourcesContent":["/**\n * Abort-signal and cancellation-error helpers shared across SDK operations.\n *\n * @packageDocumentation\n */\n\n/**\n * Resolves the abort reason for a signal, defaulting to a standard `AbortError`.\n *\n * @param signal - The aborted signal whose reason should be resolved.\n *\n * @returns The signal's `reason`, or a fresh `AbortError` DOMException when unset.\n */\nexport function abortReason(signal: AbortSignal): unknown {\n  return signal.reason ?? new DOMException('Aborted', 'AbortError')\n}\n\n/**\n * Returns whether an error represents an abort.\n *\n * @param err - Unknown thrown value.\n *\n * @returns True for `Error` or `DOMException` instances named `AbortError`.\n */\nexport function isAbortError(err: unknown): boolean {\n  return isNamedError(err, 'AbortError')\n}\n\n/**\n * Returns whether an error should be treated as the given signal's abort.\n *\n * @param signal - Controlling signal for the operation.\n * @param err - Unknown thrown value.\n *\n * @returns True when the signal is aborted and `err` is either the signal's\n * reason or a trusted `AbortError` instance.\n */\nexport function isSignalAbortError(signal: AbortSignal | undefined, err: unknown): boolean {\n  if (signal?.aborted !== true) return false\n  if (signal.reason !== undefined && Object.is(err, signal.reason)) return true\n  return isAbortError(err)\n}\n\n/**\n * Returns whether an error represents a timeout.\n *\n * @param err - Unknown thrown value.\n *\n * @returns True for `Error` or `DOMException` instances named `TimeoutError`.\n */\nexport function isTimeoutError(err: unknown): boolean {\n  return isNamedError(err, 'TimeoutError')\n}\n\n/**\n * Throws the abort reason if the signal is already aborted; otherwise returns.\n *\n * @param signal - The signal to check, or undefined to skip the check.\n *\n * @throws The signal's abort reason when the signal is already aborted.\n */\nexport function throwIfSignalAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted === true) {\n    throw abortReason(signal)\n  }\n}\n\n/**\n * Races a promise against an abort signal. Rejects with the signal's abort\n * reason if the signal fires first, detaching the listener and suppressing the\n * losing promise's rejection so it never surfaces as an unhandled rejection.\n *\n * The underlying work must still receive the same signal so transports can\n * cancel their network activity. This helper only makes callers stop waiting\n * promptly even when a test double or custom transport ignores the signal.\n *\n * @param promise - The work to await.\n * @param signal - Abort signal, or undefined to await the promise directly.\n *\n * @returns The resolved value of `promise` when it settles before the signal aborts.\n *\n * @throws The abort reason if the signal aborts first, or the promise's rejection.\n */\nexport async function raceWithAbort<T>(\n  promise: Promise<T>,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  if (signal === undefined) return promise\n  if (signal.aborted) {\n    void promise.catch(() => {})\n    throw abortReason(signal)\n  }\n\n  let removeAbortListener: (() => void) | undefined\n  const aborted = new Promise<never>((_, reject) => {\n    const onAbort = (): void => {\n      void promise.catch(() => {})\n      reject(abortReason(signal))\n    }\n    signal.addEventListener('abort', onAbort, { once: true })\n    removeAbortListener = () => signal.removeEventListener('abort', onAbort)\n    if (signal.aborted) onAbort()\n  })\n\n  try {\n    return await Promise.race([promise, aborted])\n  } finally {\n    removeAbortListener?.()\n  }\n}\n\nfunction isNamedError(err: unknown, name: string): boolean {\n  try {\n    return (\n      (err instanceof DOMException || err instanceof Error) &&\n      (err as { readonly name: string }).name === name\n    )\n  } catch {\n    return false\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,YAAY,QAA8B;CACxD,OAAO,OAAO,UAAU,IAAI,aAAa,WAAW,YAAY;AAClE;;;;;;;;AASA,SAAgB,aAAa,KAAuB;CAClD,OAAO,aAAa,KAAK,YAAY;AACvC;;;;;;;;;;AAWA,SAAgB,mBAAmB,QAAiC,KAAuB;CACzF,IAAI,QAAQ,YAAY,MAAM,OAAO;CACrC,IAAI,OAAO,WAAW,KAAA,KAAa,OAAO,GAAG,KAAK,OAAO,MAAM,GAAG,OAAO;CACzE,OAAO,aAAa,GAAG;AACzB;;;;;;;;AASA,SAAgB,eAAe,KAAuB;CACpD,OAAO,aAAa,KAAK,cAAc;AACzC;;;;;;;;AASA,SAAgB,qBAAqB,QAAuC;CAC1E,IAAI,QAAQ,YAAY,MACtB,MAAM,YAAY,MAAM;AAE5B;;;;;;;;;;;;;;;;;AAkBA,eAAsB,cACpB,SACA,QACY;CACZ,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,IAAI,OAAO,SAAS;EAClB,QAAa,YAAY,CAAC,CAAC;EAC3B,MAAM,YAAY,MAAM;CAC1B;CAEA,IAAI;CACJ,MAAM,UAAU,IAAI,SAAgB,GAAG,WAAW;EAChD,MAAM,gBAAsB;GAC1B,QAAa,YAAY,CAAC,CAAC;GAC3B,OAAO,YAAY,MAAM,CAAC;EAC5B;EACA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACxD,4BAA4B,OAAO,oBAAoB,SAAS,OAAO;EACvE,IAAI,OAAO,SAAS,QAAQ;CAC9B,CAAC;CAED,IAAI;EACF,OAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,OAAO,CAAC;CAC9C,UAAU;EACR,sBAAsB;CACxB;AACF;AAEA,SAAS,aAAa,KAAc,MAAuB;CACzD,IAAI;EACF,QACG,eAAe,gBAAgB,eAAe,UAC9C,IAAkC,SAAS;CAEhD,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/util/defaults.cjs

@@ -1,4 +1,6 @@
 //#region src/util/defaults.ts
+/** Default byte size for each ranged request in a parallel download. */
+var DEFAULT_DOWNLOAD_RANGE_SIZE = 10485760;
 /**
 * Default `maxFileCount` for list-style endpoints
 * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2
@@ -22,6 +24,7 @@ var DEFAULT_PAGE_SIZE = 1e3;
 var DEFAULT_CONTENT_TYPE = "b2/x-auto";
 //#endregion
 exports.DEFAULT_CONTENT_TYPE = DEFAULT_CONTENT_TYPE;
+exports.DEFAULT_DOWNLOAD_RANGE_SIZE = DEFAULT_DOWNLOAD_RANGE_SIZE;
 exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
 
 //# sourceMappingURL=defaults.cjs.map

package/dist/util/defaults.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;;;;;;;;;;AA6CA,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}
+{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/** Default byte size for each ranged request in a parallel download. */\nexport const DEFAULT_DOWNLOAD_RANGE_SIZE = 10 * 1024 * 1024\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;AAwBA,IAAa,8BAA8B;;;;;;;;;;;AAwB3C,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}

package/dist/util/defaults.d.cts

@@ -19,6 +19,8 @@
  * via the `concurrency` option on every transfer method.
  */
 export declare const DEFAULT_TRANSFER_CONCURRENCY = 4;
+/** Default byte size for each ranged request in a parallel download. */
+export declare const DEFAULT_DOWNLOAD_RANGE_SIZE: number;
 /**
  * Default parallel-task count for **bulk metadata** operations:
  * `Bucket.deleteMany` (per-version delete calls), and the action loop in

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

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/util/defaults.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/util/defaults.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wEAAwE;AACxE,eAAO,MAAM,2BAA2B,QAAmB,CAAA;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA"}

package/dist/util/defaults.d.ts

@@ -19,6 +19,8 @@
  * via the `concurrency` option on every transfer method.
  */
 export declare const DEFAULT_TRANSFER_CONCURRENCY = 4;
+/** Default byte size for each ranged request in a parallel download. */
+export declare const DEFAULT_DOWNLOAD_RANGE_SIZE: number;
 /**
  * Default parallel-task count for **bulk metadata** operations:
  * `Bucket.deleteMany` (per-version delete calls), and the action loop in

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

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/util/defaults.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/util/defaults.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wEAAwE;AACxE,eAAO,MAAM,2BAA2B,QAAmB,CAAA;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA"}

package/dist/util/defaults.js

@@ -1,4 +1,6 @@
 //#region src/util/defaults.ts
+/** Default byte size for each ranged request in a parallel download. */
+var DEFAULT_DOWNLOAD_RANGE_SIZE = 10485760;
 /**
 * Default `maxFileCount` for list-style endpoints
 * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2
@@ -21,6 +23,6 @@ var DEFAULT_PAGE_SIZE = 1e3;
 */
 var DEFAULT_CONTENT_TYPE = "b2/x-auto";
 //#endregion
-export { DEFAULT_CONTENT_TYPE, DEFAULT_PAGE_SIZE };
+export { DEFAULT_CONTENT_TYPE, DEFAULT_DOWNLOAD_RANGE_SIZE, DEFAULT_PAGE_SIZE };
 
 //# sourceMappingURL=defaults.js.map

package/dist/util/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;;;;;;;;;;AA6CA,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../../src/util/defaults.ts"],"sourcesContent":["/**\n * Shared SDK-wide default values.\n *\n * Centralising defaults here makes the trade-offs visible and prevents the\n * drift that creeps in when each module hard-codes its own magic number.\n *\n * @packageDocumentation\n */\n\n/**\n * Default parallel-task count for **data-transfer** operations: uploads\n * (multipart parts), downloads (byte ranges), server-side copies (parts),\n * and sync (file-by-file). Each in-flight task occupies one transport\n * slot and at least one part-worth of memory, so we keep this\n * conservative.\n *\n * Empirically `4` saturates a typical home / office uplink without\n * starving the event loop or risking B2's per-account upload-URL\n * rate-limit. Callers that have measured their environment can override\n * via the `concurrency` option on every transfer method.\n */\nexport const DEFAULT_TRANSFER_CONCURRENCY = 4\n\n/** Default byte size for each ranged request in a parallel download. */\nexport const DEFAULT_DOWNLOAD_RANGE_SIZE = 10 * 1024 * 1024\n\n/**\n * Default parallel-task count for **bulk metadata** operations:\n * `Bucket.deleteMany` (per-version delete calls), and the action loop in\n * `synchronize` when it dispatches mixed actions in batches.\n *\n * Higher than the transfer default because each task is a tiny API\n * round-trip (no payload), so concurrency is bound by API latency rather\n * than bandwidth or local memory. `10` keeps a delete-of-thousands\n * snappy without overwhelming a single account's request budget.\n */\nexport const DEFAULT_BULK_CONCURRENCY = 10\n\n/**\n * Default `maxFileCount` for list-style endpoints\n * (`b2_list_file_names`, `b2_list_file_versions`, `b2_list_parts`). B2\n * caps `maxFileCount` at `10000` for these endpoints; the SDK requests\n * `1000` per page so a single network blip doesn't lose 10× the work and\n * so callers see results sooner.\n *\n * `b2_list_unfinished_large_files` is capped at `100` server-side and is\n * not affected by this constant.\n */\nexport const DEFAULT_PAGE_SIZE = 1000\n\n/**\n * Default MIME type for uploads when the caller omits `contentType`.\n * B2 documents `b2/x-auto` as the magic value that asks the service to\n * sniff the file's content and pick a sensible `Content-Type` itself.\n * Centralising the literal here keeps the upload, copy, and create-write\n * paths in sync.\n *\n * @see https://www.backblaze.com/apidocs/b2-upload-file\n */\nexport const DEFAULT_CONTENT_TYPE = 'b2/x-auto'\n"],"mappings":";;AAwBA,IAAa,8BAA8B;;;;;;;;;;;AAwB3C,IAAa,oBAAoB;;;;;;;;;;AAWjC,IAAa,uBAAuB"}