@backblaze-labs/b2-sdk 0.1.0

package/dist/util/paginator.d.cts

@@ -0,0 +1,120 @@
+/**
+ * Generic pagination helpers for B2 list endpoints.
+ *
+ * B2 returns paginated results as `{ items, nextCursor }` shapes that differ
+ * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,
+ * `nextApplicationKeyId`, etc.). These helpers let callers iterate without
+ * threading the cursor by hand.
+ *
+ * Two flavours:
+ *   - {@link paginatePages} yields each page as the server returned it.
+ *     Useful when the caller wants the per-page response object (e.g. for
+ *     access to per-page metadata or to control item-iteration order).
+ *   - {@link paginateItems} flattens pages and yields individual items.
+ *     Useful for the common "iterate everything" case.
+ *
+ * Both helpers honour an optional {@link AbortSignal} that aborts the
+ * iteration **between fetches**. They do NOT abort an in-flight network
+ * request: the underlying list call has its own `signal` parameter and
+ * each consumer must wire that through if mid-flight cancellation is
+ * required.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```ts
+ * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {
+ *   console.log(file.fileName, file.contentLength)
+ * }
+ * ```
+ *
+ */
+/**
+ * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.
+ */
+export interface PaginatorOptions {
+    /**
+     * Maximum items per page. Forwarded to the underlying list call's
+     * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this
+     * at endpoint-specific limits (typically 10000 for files, 100 for parts).
+     */
+    pageSize?: number;
+    /**
+     * Aborts the iteration between fetches. When already aborted at call time,
+     * the iterator throws immediately on its first `next()` call.
+     *
+     * Note: this does NOT abort an in-flight HTTP request mid-page. The
+     * iterator checks `signal.throwIfAborted()` only between fetches.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Function that fetches a single page given a cursor.
+ *
+ * The cursor is `undefined` for the first page, then takes the value of the
+ * previous page's `nextCursor` on subsequent calls. Iteration stops when
+ * `nextCursor` is `undefined` (or any other falsy value the caller maps to
+ * `undefined`).
+ *
+ * @typeParam Page - The per-page response shape returned by the B2 endpoint.
+ * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).
+ */
+export type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{
+    /** The page just fetched. */
+    page: Page;
+    /** Cursor for the next page, or `undefined` if there are no more pages. */
+    nextCursor: Cursor | undefined;
+}>;
+/**
+ * Async-iterates one page at a time. Stops when `fetcher` returns
+ * `nextCursor: undefined`.
+ *
+ * @typeParam Page - The per-page response shape.
+ * @typeParam Cursor - The cursor type used to request the next page.
+ *
+ * @param fetcher - Function that fetches one page given the current cursor.
+ * @param signal - Optional abort signal. Checked before each fetch.
+ *
+ * @returns An async iterable of pages.
+ *
+ * @throws DOMException When `signal` is aborted between fetches.
+ *
+ * @example
+ * ```ts
+ * for await (const page of paginatePages(
+ *   async (cursor) => {
+ *     const resp = await bucket.listFileNames({ startFileName: cursor })
+ *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }
+ *   },
+ *   abortSignal,
+ * )) {
+ *   for (const file of page.files) { ... }
+ * }
+ * ```
+ */
+export declare function paginatePages<Page, Cursor>(fetcher: PageFetcher<Page, Cursor>, signal: AbortSignal | undefined): AsyncIterableIterator<Page>;
+/**
+ * Async-iterates items by flattening pages. The `extractItems` function
+ * pulls the relevant array out of each page (e.g. `page.files`,
+ * `page.keys`, `page.parts`). Each item is yielded individually so the
+ * caller can `for await (const item of paginator)` rather than nest loops.
+ *
+ * Aborts between **pages**, not between items: if `signal` is aborted while
+ * the caller is processing the items of page N, the iterator will still
+ * yield all of page N's remaining items before checking the signal before
+ * fetching page N+1.
+ *
+ * @typeParam Page - The per-page response shape.
+ * @typeParam Cursor - The cursor type used to request the next page.
+ * @typeParam Item - The item type the caller wants to iterate.
+ *
+ * @param fetcher - Function that fetches one page given the current cursor.
+ * @param extractItems - Pulls the iterable items out of a page.
+ * @param signal - Optional abort signal. Checked before each fetch.
+ *
+ * @returns An async iterable of individual items.
+ *
+ * @throws DOMException When `signal` is aborted between fetches.
+ */
+export declare function paginateItems<Page, Cursor, Item>(fetcher: PageFetcher<Page, Cursor>, extractItems: (page: Page) => Iterable<Item>, signal: AbortSignal | undefined): AsyncIterableIterator<Item>;
+//# sourceMappingURL=paginator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAS7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}

package/dist/util/paginator.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Generic pagination helpers for B2 list endpoints.
+ *
+ * B2 returns paginated results as `{ items, nextCursor }` shapes that differ
+ * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,
+ * `nextApplicationKeyId`, etc.). These helpers let callers iterate without
+ * threading the cursor by hand.
+ *
+ * Two flavours:
+ *   - {@link paginatePages} yields each page as the server returned it.
+ *     Useful when the caller wants the per-page response object (e.g. for
+ *     access to per-page metadata or to control item-iteration order).
+ *   - {@link paginateItems} flattens pages and yields individual items.
+ *     Useful for the common "iterate everything" case.
+ *
+ * Both helpers honour an optional {@link AbortSignal} that aborts the
+ * iteration **between fetches**. They do NOT abort an in-flight network
+ * request: the underlying list call has its own `signal` parameter and
+ * each consumer must wire that through if mid-flight cancellation is
+ * required.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```ts
+ * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {
+ *   console.log(file.fileName, file.contentLength)
+ * }
+ * ```
+ *
+ */
+/**
+ * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.
+ */
+export interface PaginatorOptions {
+    /**
+     * Maximum items per page. Forwarded to the underlying list call's
+     * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this
+     * at endpoint-specific limits (typically 10000 for files, 100 for parts).
+     */
+    pageSize?: number;
+    /**
+     * Aborts the iteration between fetches. When already aborted at call time,
+     * the iterator throws immediately on its first `next()` call.
+     *
+     * Note: this does NOT abort an in-flight HTTP request mid-page. The
+     * iterator checks `signal.throwIfAborted()` only between fetches.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Function that fetches a single page given a cursor.
+ *
+ * The cursor is `undefined` for the first page, then takes the value of the
+ * previous page's `nextCursor` on subsequent calls. Iteration stops when
+ * `nextCursor` is `undefined` (or any other falsy value the caller maps to
+ * `undefined`).
+ *
+ * @typeParam Page - The per-page response shape returned by the B2 endpoint.
+ * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).
+ */
+export type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{
+    /** The page just fetched. */
+    page: Page;
+    /** Cursor for the next page, or `undefined` if there are no more pages. */
+    nextCursor: Cursor | undefined;
+}>;
+/**
+ * Async-iterates one page at a time. Stops when `fetcher` returns
+ * `nextCursor: undefined`.
+ *
+ * @typeParam Page - The per-page response shape.
+ * @typeParam Cursor - The cursor type used to request the next page.
+ *
+ * @param fetcher - Function that fetches one page given the current cursor.
+ * @param signal - Optional abort signal. Checked before each fetch.
+ *
+ * @returns An async iterable of pages.
+ *
+ * @throws DOMException When `signal` is aborted between fetches.
+ *
+ * @example
+ * ```ts
+ * for await (const page of paginatePages(
+ *   async (cursor) => {
+ *     const resp = await bucket.listFileNames({ startFileName: cursor })
+ *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }
+ *   },
+ *   abortSignal,
+ * )) {
+ *   for (const file of page.files) { ... }
+ * }
+ * ```
+ */
+export declare function paginatePages<Page, Cursor>(fetcher: PageFetcher<Page, Cursor>, signal: AbortSignal | undefined): AsyncIterableIterator<Page>;
+/**
+ * Async-iterates items by flattening pages. The `extractItems` function
+ * pulls the relevant array out of each page (e.g. `page.files`,
+ * `page.keys`, `page.parts`). Each item is yielded individually so the
+ * caller can `for await (const item of paginator)` rather than nest loops.
+ *
+ * Aborts between **pages**, not between items: if `signal` is aborted while
+ * the caller is processing the items of page N, the iterator will still
+ * yield all of page N's remaining items before checking the signal before
+ * fetching page N+1.
+ *
+ * @typeParam Page - The per-page response shape.
+ * @typeParam Cursor - The cursor type used to request the next page.
+ * @typeParam Item - The item type the caller wants to iterate.
+ *
+ * @param fetcher - Function that fetches one page given the current cursor.
+ * @param extractItems - Pulls the iterable items out of a page.
+ * @param signal - Optional abort signal. Checked before each fetch.
+ *
+ * @returns An async iterable of individual items.
+ *
+ * @throws DOMException When `signal` is aborted between fetches.
+ */
+export declare function paginateItems<Page, Cursor, Item>(fetcher: PageFetcher<Page, Cursor>, extractItems: (page: Page) => Iterable<Item>, signal: AbortSignal | undefined): AsyncIterableIterator<Item>;
+//# sourceMappingURL=paginator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/util/paginator.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAC9E,6BAA6B;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAS7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EACrD,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,EAClC,YAAY,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAC5C,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,qBAAqB,CAAC,IAAI,CAAC,CAI7B"}

package/dist/util/paginator.js

@@ -0,0 +1,20 @@
+async function* paginatePages(fetcher, signal) {
+  let cursor;
+  while (true) {
+    signal?.throwIfAborted();
+    const { page, nextCursor } = await fetcher(cursor);
+    yield page;
+    if (nextCursor === void 0) return;
+    cursor = nextCursor;
+  }
+}
+async function* paginateItems(fetcher, extractItems, signal) {
+  for await (const page of paginatePages(fetcher, signal)) {
+    yield* extractItems(page);
+  }
+}
+export {
+  paginateItems,
+  paginatePages
+};
+//# sourceMappingURL=paginator.js.map

package/dist/util/paginator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.js","sources":["../../src/util/paginator.ts"],"sourcesContent":["/**\n * Generic pagination helpers for B2 list endpoints.\n *\n * B2 returns paginated results as `{ items, nextCursor }` shapes that differ\n * per endpoint (`nextFileName`, `nextFileId`, `nextPartNumber`,\n * `nextApplicationKeyId`, etc.). These helpers let callers iterate without\n * threading the cursor by hand.\n *\n * Two flavours:\n *   - {@link paginatePages} yields each page as the server returned it.\n *     Useful when the caller wants the per-page response object (e.g. for\n *     access to per-page metadata or to control item-iteration order).\n *   - {@link paginateItems} flattens pages and yields individual items.\n *     Useful for the common \"iterate everything\" case.\n *\n * Both helpers honour an optional {@link AbortSignal} that aborts the\n * iteration **between fetches**. They do NOT abort an in-flight network\n * request: the underlying list call has its own `signal` parameter and\n * each consumer must wire that through if mid-flight cancellation is\n * required.\n *\n * @packageDocumentation\n *\n * @example\n * ```ts\n * for await (const file of bucket.paginateFileNames({ prefix: 'photos/' })) {\n *   console.log(file.fileName, file.contentLength)\n * }\n * ```\n *\n */\n\n/**\n * Options accepted by every `paginateX` method on `Bucket` and `B2Client`.\n */\nexport interface PaginatorOptions {\n  /**\n   * Maximum items per page. Forwarded to the underlying list call's\n   * `maxFileCount` / `maxKeyCount` / `maxPartCount` parameter. B2 caps this\n   * at endpoint-specific limits (typically 10000 for files, 100 for parts).\n   */\n  pageSize?: number\n  /**\n   * Aborts the iteration between fetches. When already aborted at call time,\n   * the iterator throws immediately on its first `next()` call.\n   *\n   * Note: this does NOT abort an in-flight HTTP request mid-page. The\n   * iterator checks `signal.throwIfAborted()` only between fetches.\n   */\n  signal?: AbortSignal\n}\n\n/**\n * Function that fetches a single page given a cursor.\n *\n * The cursor is `undefined` for the first page, then takes the value of the\n * previous page's `nextCursor` on subsequent calls. Iteration stops when\n * `nextCursor` is `undefined` (or any other falsy value the caller maps to\n * `undefined`).\n *\n * @typeParam Page - The per-page response shape returned by the B2 endpoint.\n * @typeParam Cursor - The cursor type (typically `string` or a `{name, id}` pair).\n */\nexport type PageFetcher<Page, Cursor> = (cursor: Cursor | undefined) => Promise<{\n  /** The page just fetched. */\n  page: Page\n  /** Cursor for the next page, or `undefined` if there are no more pages. */\n  nextCursor: Cursor | undefined\n}>\n\n/**\n * Async-iterates one page at a time. Stops when `fetcher` returns\n * `nextCursor: undefined`.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of pages.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n *\n * @example\n * ```ts\n * for await (const page of paginatePages(\n *   async (cursor) => {\n *     const resp = await bucket.listFileNames({ startFileName: cursor })\n *     return { page: resp, nextCursor: resp.nextFileName ?? undefined }\n *   },\n *   abortSignal,\n * )) {\n *   for (const file of page.files) { ... }\n * }\n * ```\n */\nexport async function* paginatePages<Page, Cursor>(\n  fetcher: PageFetcher<Page, Cursor>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Page> {\n  let cursor: Cursor | undefined\n  while (true) {\n    signal?.throwIfAborted()\n    const { page, nextCursor } = await fetcher(cursor)\n    yield page\n    if (nextCursor === undefined) return\n    cursor = nextCursor\n  }\n}\n\n/**\n * Async-iterates items by flattening pages. The `extractItems` function\n * pulls the relevant array out of each page (e.g. `page.files`,\n * `page.keys`, `page.parts`). Each item is yielded individually so the\n * caller can `for await (const item of paginator)` rather than nest loops.\n *\n * Aborts between **pages**, not between items: if `signal` is aborted while\n * the caller is processing the items of page N, the iterator will still\n * yield all of page N's remaining items before checking the signal before\n * fetching page N+1.\n *\n * @typeParam Page - The per-page response shape.\n * @typeParam Cursor - The cursor type used to request the next page.\n * @typeParam Item - The item type the caller wants to iterate.\n *\n * @param fetcher - Function that fetches one page given the current cursor.\n * @param extractItems - Pulls the iterable items out of a page.\n * @param signal - Optional abort signal. Checked before each fetch.\n *\n * @returns An async iterable of individual items.\n *\n * @throws DOMException When `signal` is aborted between fetches.\n */\nexport async function* paginateItems<Page, Cursor, Item>(\n  fetcher: PageFetcher<Page, Cursor>,\n  extractItems: (page: Page) => Iterable<Item>,\n  signal: AbortSignal | undefined,\n): AsyncIterableIterator<Item> {\n  for await (const page of paginatePages(fetcher, signal)) {\n    yield* extractItems(page)\n  }\n}\n"],"names":[],"mappings":"AAiGA,gBAAuB,cACrB,SACA,QAC6B;AAC7B,MAAI;AACJ,SAAO,MAAM;AACX,YAAQ,eAAA;AACR,UAAM,EAAE,MAAM,WAAA,IAAe,MAAM,QAAQ,MAAM;AACjD,UAAM;AACN,QAAI,eAAe,OAAW;AAC9B,aAAS;AAAA,EACX;AACF;AAyBA,gBAAuB,cACrB,SACA,cACA,QAC6B;AAC7B,mBAAiB,QAAQ,cAAc,SAAS,MAAM,GAAG;AACvD,WAAO,aAAa,IAAI;AAAA,EAC1B;AACF;"}

package/dist/util/plan-ranges.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function planRanges(totalSize, chunkSize) {
+  const plans = [];
+  let offset = 0;
+  let index = 0;
+  while (offset < totalSize) {
+    const length = Math.min(chunkSize, totalSize - offset);
+    const end = offset + length - 1;
+    plans.push({
+      partNumber: index + 1,
+      index,
+      offset,
+      length,
+      start: offset,
+      end
+    });
+    offset += length;
+    index++;
+  }
+  return plans;
+}
+function byteRangeHeader(start, end) {
+  return `bytes=${start}-${end}`;
+}
+exports.byteRangeHeader = byteRangeHeader;
+exports.planRanges = planRanges;
+//# sourceMappingURL=plan-ranges.cjs.map

package/dist/util/plan-ranges.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-ranges.cjs","sources":["../../src/util/plan-ranges.ts"],"sourcesContent":["/**\n * Inclusive byte range plan for a single chunk of a larger sequence.\n *\n * Carries every commonly-needed shape so the three call sites (multipart\n * upload, server-side multipart copy, parallel-ranged download) can\n * destructure the fields they want without re-deriving them:\n *\n * - `partNumber` is 1-based to match the B2 `b2_upload_part` /\n *   `b2_copy_part` wire format.\n * - `index` is 0-based for callers that key into a `Map` or array slot.\n * - `offset` + `length` are the upload-style framing (where in the\n *   source to read, how many bytes).\n * - `start` + `end` (both inclusive) are the HTTP `Range:` /\n *   `Content-Range:` framing.\n */\nexport interface RangePlan {\n  /** 1-based part number for B2 multipart endpoints. */\n  readonly partNumber: number\n  /** 0-based slot index for in-memory bookkeeping. */\n  readonly index: number\n  /** Inclusive byte offset where this range begins. */\n  readonly offset: number\n  /** Number of bytes in this range. */\n  readonly length: number\n  /** Alias for {@link offset} — convenient for `bytes=start-end` formatters. */\n  readonly start: number\n  /** Inclusive byte offset where this range ends (`offset + length - 1`). */\n  readonly end: number\n}\n\n/**\n * Lays out a sequence of contiguous, non-overlapping byte ranges over\n * `[0, totalSize)`. Every produced range is at most `chunkSize` bytes\n * long; the final range may be shorter if `totalSize` is not a multiple\n * of `chunkSize`.\n *\n * Replaces three near-identical hand-rolled loops in\n * `upload/large.ts`, `copy/large.ts`, and `download/parallel.ts`.\n *\n * @param totalSize - Total number of bytes to cover.\n * @param chunkSize - Target size of each range in bytes (last range may be smaller).\n *\n * @returns Ordered, non-overlapping range plans. Empty array when `totalSize === 0`.\n */\nexport function planRanges(totalSize: number, chunkSize: number): RangePlan[] {\n  const plans: RangePlan[] = []\n  let offset = 0\n  let index = 0\n  while (offset < totalSize) {\n    const length = Math.min(chunkSize, totalSize - offset)\n    const end = offset + length - 1\n    plans.push({\n      partNumber: index + 1,\n      index,\n      offset,\n      length,\n      start: offset,\n      end,\n    })\n    offset += length\n    index++\n  }\n  return plans\n}\n\n/**\n * Format an HTTP `Range:` request-header value covering the given\n * inclusive byte offsets. Centralises the `bytes=<start>-<end>` template\n * so the upload, copy, and download paths agree on syntax.\n *\n * @param start - Inclusive starting byte.\n * @param end - Inclusive ending byte.\n *\n * @returns The header value (e.g. `'bytes=0-99'`).\n */\nexport function byteRangeHeader(start: number, end: number): string {\n  return `bytes=${start}-${end}`\n}\n"],"names":[],"mappings":";;AA4CO,SAAS,WAAW,WAAmB,WAAgC;AAC5E,QAAM,QAAqB,CAAA;AAC3B,MAAI,SAAS;AACb,MAAI,QAAQ;AACZ,SAAO,SAAS,WAAW;AACzB,UAAM,SAAS,KAAK,IAAI,WAAW,YAAY,MAAM;AACrD,UAAM,MAAM,SAAS,SAAS;AAC9B,UAAM,KAAK;AAAA,MACT,YAAY,QAAQ;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IAAA,CACD;AACD,cAAU;AACV;AAAA,EACF;AACA,SAAO;AACT;AAYO,SAAS,gBAAgB,OAAe,KAAqB;AAClE,SAAO,SAAS,KAAK,IAAI,GAAG;AAC9B;;;"}

package/dist/util/plan-ranges.d.cts

@@ -0,0 +1,56 @@
+/**
+ * Inclusive byte range plan for a single chunk of a larger sequence.
+ *
+ * Carries every commonly-needed shape so the three call sites (multipart
+ * upload, server-side multipart copy, parallel-ranged download) can
+ * destructure the fields they want without re-deriving them:
+ *
+ * - `partNumber` is 1-based to match the B2 `b2_upload_part` /
+ *   `b2_copy_part` wire format.
+ * - `index` is 0-based for callers that key into a `Map` or array slot.
+ * - `offset` + `length` are the upload-style framing (where in the
+ *   source to read, how many bytes).
+ * - `start` + `end` (both inclusive) are the HTTP `Range:` /
+ *   `Content-Range:` framing.
+ */
+export interface RangePlan {
+    /** 1-based part number for B2 multipart endpoints. */
+    readonly partNumber: number;
+    /** 0-based slot index for in-memory bookkeeping. */
+    readonly index: number;
+    /** Inclusive byte offset where this range begins. */
+    readonly offset: number;
+    /** Number of bytes in this range. */
+    readonly length: number;
+    /** Alias for {@link offset} — convenient for `bytes=start-end` formatters. */
+    readonly start: number;
+    /** Inclusive byte offset where this range ends (`offset + length - 1`). */
+    readonly end: number;
+}
+/**
+ * Lays out a sequence of contiguous, non-overlapping byte ranges over
+ * `[0, totalSize)`. Every produced range is at most `chunkSize` bytes
+ * long; the final range may be shorter if `totalSize` is not a multiple
+ * of `chunkSize`.
+ *
+ * Replaces three near-identical hand-rolled loops in
+ * `upload/large.ts`, `copy/large.ts`, and `download/parallel.ts`.
+ *
+ * @param totalSize - Total number of bytes to cover.
+ * @param chunkSize - Target size of each range in bytes (last range may be smaller).
+ *
+ * @returns Ordered, non-overlapping range plans. Empty array when `totalSize === 0`.
+ */
+export declare function planRanges(totalSize: number, chunkSize: number): RangePlan[];
+/**
+ * Format an HTTP `Range:` request-header value covering the given
+ * inclusive byte offsets. Centralises the `bytes=<start>-<end>` template
+ * so the upload, copy, and download paths agree on syntax.
+ *
+ * @param start - Inclusive starting byte.
+ * @param end - Inclusive ending byte.
+ *
+ * @returns The header value (e.g. `'bytes=0-99'`).
+ */
+export declare function byteRangeHeader(start: number, end: number): string;
+//# sourceMappingURL=plan-ranges.d.ts.map

package/dist/util/plan-ranges.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-ranges.d.ts","sourceRoot":"","sources":["../../src/util/plan-ranges.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS;IACxB,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAmB5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/util/plan-ranges.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Inclusive byte range plan for a single chunk of a larger sequence.
+ *
+ * Carries every commonly-needed shape so the three call sites (multipart
+ * upload, server-side multipart copy, parallel-ranged download) can
+ * destructure the fields they want without re-deriving them:
+ *
+ * - `partNumber` is 1-based to match the B2 `b2_upload_part` /
+ *   `b2_copy_part` wire format.
+ * - `index` is 0-based for callers that key into a `Map` or array slot.
+ * - `offset` + `length` are the upload-style framing (where in the
+ *   source to read, how many bytes).
+ * - `start` + `end` (both inclusive) are the HTTP `Range:` /
+ *   `Content-Range:` framing.
+ */
+export interface RangePlan {
+    /** 1-based part number for B2 multipart endpoints. */
+    readonly partNumber: number;
+    /** 0-based slot index for in-memory bookkeeping. */
+    readonly index: number;
+    /** Inclusive byte offset where this range begins. */
+    readonly offset: number;
+    /** Number of bytes in this range. */
+    readonly length: number;
+    /** Alias for {@link offset} — convenient for `bytes=start-end` formatters. */
+    readonly start: number;
+    /** Inclusive byte offset where this range ends (`offset + length - 1`). */
+    readonly end: number;
+}
+/**
+ * Lays out a sequence of contiguous, non-overlapping byte ranges over
+ * `[0, totalSize)`. Every produced range is at most `chunkSize` bytes
+ * long; the final range may be shorter if `totalSize` is not a multiple
+ * of `chunkSize`.
+ *
+ * Replaces three near-identical hand-rolled loops in
+ * `upload/large.ts`, `copy/large.ts`, and `download/parallel.ts`.
+ *
+ * @param totalSize - Total number of bytes to cover.
+ * @param chunkSize - Target size of each range in bytes (last range may be smaller).
+ *
+ * @returns Ordered, non-overlapping range plans. Empty array when `totalSize === 0`.
+ */
+export declare function planRanges(totalSize: number, chunkSize: number): RangePlan[];
+/**
+ * Format an HTTP `Range:` request-header value covering the given
+ * inclusive byte offsets. Centralises the `bytes=<start>-<end>` template
+ * so the upload, copy, and download paths agree on syntax.
+ *
+ * @param start - Inclusive starting byte.
+ * @param end - Inclusive ending byte.
+ *
+ * @returns The header value (e.g. `'bytes=0-99'`).
+ */
+export declare function byteRangeHeader(start: number, end: number): string;
+//# sourceMappingURL=plan-ranges.d.ts.map

package/dist/util/plan-ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-ranges.d.ts","sourceRoot":"","sources":["../../src/util/plan-ranges.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS;IACxB,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAmB5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/util/plan-ranges.js

@@ -0,0 +1,28 @@
+function planRanges(totalSize, chunkSize) {
+  const plans = [];
+  let offset = 0;
+  let index = 0;
+  while (offset < totalSize) {
+    const length = Math.min(chunkSize, totalSize - offset);
+    const end = offset + length - 1;
+    plans.push({
+      partNumber: index + 1,
+      index,
+      offset,
+      length,
+      start: offset,
+      end
+    });
+    offset += length;
+    index++;
+  }
+  return plans;
+}
+function byteRangeHeader(start, end) {
+  return `bytes=${start}-${end}`;
+}
+export {
+  byteRangeHeader,
+  planRanges
+};
+//# sourceMappingURL=plan-ranges.js.map

package/dist/util/plan-ranges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-ranges.js","sources":["../../src/util/plan-ranges.ts"],"sourcesContent":["/**\n * Inclusive byte range plan for a single chunk of a larger sequence.\n *\n * Carries every commonly-needed shape so the three call sites (multipart\n * upload, server-side multipart copy, parallel-ranged download) can\n * destructure the fields they want without re-deriving them:\n *\n * - `partNumber` is 1-based to match the B2 `b2_upload_part` /\n *   `b2_copy_part` wire format.\n * - `index` is 0-based for callers that key into a `Map` or array slot.\n * - `offset` + `length` are the upload-style framing (where in the\n *   source to read, how many bytes).\n * - `start` + `end` (both inclusive) are the HTTP `Range:` /\n *   `Content-Range:` framing.\n */\nexport interface RangePlan {\n  /** 1-based part number for B2 multipart endpoints. */\n  readonly partNumber: number\n  /** 0-based slot index for in-memory bookkeeping. */\n  readonly index: number\n  /** Inclusive byte offset where this range begins. */\n  readonly offset: number\n  /** Number of bytes in this range. */\n  readonly length: number\n  /** Alias for {@link offset} — convenient for `bytes=start-end` formatters. */\n  readonly start: number\n  /** Inclusive byte offset where this range ends (`offset + length - 1`). */\n  readonly end: number\n}\n\n/**\n * Lays out a sequence of contiguous, non-overlapping byte ranges over\n * `[0, totalSize)`. Every produced range is at most `chunkSize` bytes\n * long; the final range may be shorter if `totalSize` is not a multiple\n * of `chunkSize`.\n *\n * Replaces three near-identical hand-rolled loops in\n * `upload/large.ts`, `copy/large.ts`, and `download/parallel.ts`.\n *\n * @param totalSize - Total number of bytes to cover.\n * @param chunkSize - Target size of each range in bytes (last range may be smaller).\n *\n * @returns Ordered, non-overlapping range plans. Empty array when `totalSize === 0`.\n */\nexport function planRanges(totalSize: number, chunkSize: number): RangePlan[] {\n  const plans: RangePlan[] = []\n  let offset = 0\n  let index = 0\n  while (offset < totalSize) {\n    const length = Math.min(chunkSize, totalSize - offset)\n    const end = offset + length - 1\n    plans.push({\n      partNumber: index + 1,\n      index,\n      offset,\n      length,\n      start: offset,\n      end,\n    })\n    offset += length\n    index++\n  }\n  return plans\n}\n\n/**\n * Format an HTTP `Range:` request-header value covering the given\n * inclusive byte offsets. Centralises the `bytes=<start>-<end>` template\n * so the upload, copy, and download paths agree on syntax.\n *\n * @param start - Inclusive starting byte.\n * @param end - Inclusive ending byte.\n *\n * @returns The header value (e.g. `'bytes=0-99'`).\n */\nexport function byteRangeHeader(start: number, end: number): string {\n  return `bytes=${start}-${end}`\n}\n"],"names":[],"mappings":"AA4CO,SAAS,WAAW,WAAmB,WAAgC;AAC5E,QAAM,QAAqB,CAAA;AAC3B,MAAI,SAAS;AACb,MAAI,QAAQ;AACZ,SAAO,SAAS,WAAW;AACzB,UAAM,SAAS,KAAK,IAAI,WAAW,YAAY,MAAM;AACrD,UAAM,MAAM,SAAS,SAAS;AAC9B,UAAM,KAAK;AAAA,MACT,YAAY,QAAQ;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IAAA,CACD;AACD,cAAU;AACV;AAAA,EACF;AACA,SAAO;AACT;AAYO,SAAS,gBAAgB,OAAe,KAAqB;AAClE,SAAO,SAAS,KAAK,IAAI,GAAG;AAC9B;"}

package/dist/util/text-codec.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
+exports.utf8Decoder = utf8Decoder;
+exports.utf8Encoder = utf8Encoder;
+//# sourceMappingURL=text-codec.cjs.map

package/dist/util/text-codec.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec.cjs","sources":["../../src/util/text-codec.ts"],"sourcesContent":["/**\n * Shared UTF-8 codec singletons.\n *\n * Every byte boundary in this SDK is UTF-8: JSON request and response bodies,\n * webhook payloads, simulator stream chunks, and B2 percent-encoding inputs.\n * Allocating a fresh `TextEncoder` / `TextDecoder` per call is wasteful and\n * makes the encoding assumption invisible. Importing these constants makes\n * \"we use UTF-8\" explicit at every call site and avoids the per-call\n * allocation entirely.\n *\n * Both classes are spec-defined as stateless across encode / decode calls,\n * so a process-wide singleton is safe.\n *\n * @packageDocumentation\n */\n\n/**\n * Process-wide UTF-8 `TextEncoder`. Use this instead of\n * `new TextEncoder()` for any string → bytes conversion in the SDK.\n */\nexport const utf8Encoder = new TextEncoder()\n\n/**\n * Process-wide UTF-8 `TextDecoder`. Use this instead of\n * `new TextDecoder()` for any bytes → string conversion in the SDK.\n */\nexport const utf8Decoder = new TextDecoder()\n"],"names":[],"mappings":";;AAoBO,MAAM,cAAc,IAAI,YAAA;AAMxB,MAAM,cAAc,IAAI,YAAA;;;"}

package/dist/util/text-codec.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Shared UTF-8 codec singletons.
+ *
+ * Every byte boundary in this SDK is UTF-8: JSON request and response bodies,
+ * webhook payloads, simulator stream chunks, and B2 percent-encoding inputs.
+ * Allocating a fresh `TextEncoder` / `TextDecoder` per call is wasteful and
+ * makes the encoding assumption invisible. Importing these constants makes
+ * "we use UTF-8" explicit at every call site and avoids the per-call
+ * allocation entirely.
+ *
+ * Both classes are spec-defined as stateless across encode / decode calls,
+ * so a process-wide singleton is safe.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Process-wide UTF-8 `TextEncoder`. Use this instead of
+ * `new TextEncoder()` for any string → bytes conversion in the SDK.
+ */
+export declare const utf8Encoder: TextEncoder;
+/**
+ * Process-wide UTF-8 `TextDecoder`. Use this instead of
+ * `new TextDecoder()` for any bytes → string conversion in the SDK.
+ */
+export declare const utf8Decoder: TextDecoder;
+//# sourceMappingURL=text-codec.d.ts.map

package/dist/util/text-codec.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec.d.ts","sourceRoot":"","sources":["../../src/util/text-codec.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAA;AAE5C;;;GAGG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAA"}

package/dist/util/text-codec.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared UTF-8 codec singletons.
+ *
+ * Every byte boundary in this SDK is UTF-8: JSON request and response bodies,
+ * webhook payloads, simulator stream chunks, and B2 percent-encoding inputs.
+ * Allocating a fresh `TextEncoder` / `TextDecoder` per call is wasteful and
+ * makes the encoding assumption invisible. Importing these constants makes
+ * "we use UTF-8" explicit at every call site and avoids the per-call
+ * allocation entirely.
+ *
+ * Both classes are spec-defined as stateless across encode / decode calls,
+ * so a process-wide singleton is safe.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Process-wide UTF-8 `TextEncoder`. Use this instead of
+ * `new TextEncoder()` for any string → bytes conversion in the SDK.
+ */
+export declare const utf8Encoder: TextEncoder;
+/**
+ * Process-wide UTF-8 `TextDecoder`. Use this instead of
+ * `new TextDecoder()` for any bytes → string conversion in the SDK.
+ */
+export declare const utf8Decoder: TextDecoder;
+//# sourceMappingURL=text-codec.d.ts.map

package/dist/util/text-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec.d.ts","sourceRoot":"","sources":["../../src/util/text-codec.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAA;AAE5C;;;GAGG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAA"}

package/dist/util/text-codec.js

@@ -0,0 +1,7 @@
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
+export {
+  utf8Decoder,
+  utf8Encoder
+};
+//# sourceMappingURL=text-codec.js.map

package/dist/util/text-codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec.js","sources":["../../src/util/text-codec.ts"],"sourcesContent":["/**\n * Shared UTF-8 codec singletons.\n *\n * Every byte boundary in this SDK is UTF-8: JSON request and response bodies,\n * webhook payloads, simulator stream chunks, and B2 percent-encoding inputs.\n * Allocating a fresh `TextEncoder` / `TextDecoder` per call is wasteful and\n * makes the encoding assumption invisible. Importing these constants makes\n * \"we use UTF-8\" explicit at every call site and avoids the per-call\n * allocation entirely.\n *\n * Both classes are spec-defined as stateless across encode / decode calls,\n * so a process-wide singleton is safe.\n *\n * @packageDocumentation\n */\n\n/**\n * Process-wide UTF-8 `TextEncoder`. Use this instead of\n * `new TextEncoder()` for any string → bytes conversion in the SDK.\n */\nexport const utf8Encoder = new TextEncoder()\n\n/**\n * Process-wide UTF-8 `TextDecoder`. Use this instead of\n * `new TextDecoder()` for any bytes → string conversion in the SDK.\n */\nexport const utf8Decoder = new TextDecoder()\n"],"names":[],"mappings":"AAoBO,MAAM,cAAc,IAAI,YAAA;AAMxB,MAAM,cAAc,IAAI,YAAA;"}

package/dist/util/to-error.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+exports.toError = toError;
+//# sourceMappingURL=to-error.cjs.map

package/dist/util/to-error.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-error.cjs","sources":["../../src/util/to-error.ts"],"sourcesContent":["/**\n * Coerce an unknown caught value to a real error instance.\n *\n * Existing error objects pass through unchanged so call sites preserve\n * the original stack and any subclass identity. Other values are\n * wrapped in a fresh Error whose message is `String(value)`. Centralises\n * the conditional that previously recurred at every async-boundary\n * catch site in the upload, copy, sync, and stream paths.\n *\n * @param value - Value caught from a `try`/`catch` or rejected promise.\n *\n * @returns An `Error` representing `value`.\n */\nexport function toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value))\n}\n"],"names":[],"mappings":";;AAaO,SAAS,QAAQ,OAAuB;AAC7C,SAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AACjE;;"}

package/dist/util/to-error.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Coerce an unknown caught value to a real error instance.
+ *
+ * Existing error objects pass through unchanged so call sites preserve
+ * the original stack and any subclass identity. Other values are
+ * wrapped in a fresh Error whose message is `String(value)`. Centralises
+ * the conditional that previously recurred at every async-boundary
+ * catch site in the upload, copy, sync, and stream paths.
+ *
+ * @param value - Value caught from a `try`/`catch` or rejected promise.
+ *
+ * @returns An `Error` representing `value`.
+ */
+export declare function toError(value: unknown): Error;
+//# sourceMappingURL=to-error.d.ts.map

package/dist/util/to-error.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-error.d.ts","sourceRoot":"","sources":["../../src/util/to-error.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C"}

package/dist/util/to-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Coerce an unknown caught value to a real error instance.
+ *
+ * Existing error objects pass through unchanged so call sites preserve
+ * the original stack and any subclass identity. Other values are
+ * wrapped in a fresh Error whose message is `String(value)`. Centralises
+ * the conditional that previously recurred at every async-boundary
+ * catch site in the upload, copy, sync, and stream paths.
+ *
+ * @param value - Value caught from a `try`/`catch` or rejected promise.
+ *
+ * @returns An `Error` representing `value`.
+ */
+export declare function toError(value: unknown): Error;
+//# sourceMappingURL=to-error.d.ts.map

package/dist/util/to-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-error.d.ts","sourceRoot":"","sources":["../../src/util/to-error.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C"}

package/dist/util/to-error.js

@@ -0,0 +1,7 @@
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+export {
+  toError
+};
+//# sourceMappingURL=to-error.js.map

package/dist/util/to-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-error.js","sources":["../../src/util/to-error.ts"],"sourcesContent":["/**\n * Coerce an unknown caught value to a real error instance.\n *\n * Existing error objects pass through unchanged so call sites preserve\n * the original stack and any subclass identity. Other values are\n * wrapped in a fresh Error whose message is `String(value)`. Centralises\n * the conditional that previously recurred at every async-boundary\n * catch site in the upload, copy, sync, and stream paths.\n *\n * @param value - Value caught from a `try`/`catch` or rejected promise.\n *\n * @returns An `Error` representing `value`.\n */\nexport function toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value))\n}\n"],"names":[],"mappings":"AAaO,SAAS,QAAQ,OAAuB;AAC7C,SAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AACjE;"}