@backblaze-labs/b2-sdk 0.1.0

package/dist/streams/hash.js

@@ -0,0 +1,101 @@
+let nodeCreateHash;
+async function getNodeCreateHash() {
+  if (nodeCreateHash !== void 0) return nodeCreateHash;
+  try {
+    const crypto2 = await import("node:crypto");
+    if (typeof crypto2.createHash !== "function") throw new Error("createHash unavailable");
+    nodeCreateHash = (algo) => {
+      const h = crypto2.createHash(algo);
+      return {
+        update(data) {
+          h.update(data);
+        },
+        digest(encoding) {
+          return h.digest(encoding);
+        }
+      };
+    };
+  } catch {
+    nodeCreateHash = null;
+  }
+  return nodeCreateHash;
+}
+class IncrementalSha1 {
+  /** Buffered chunks for WebCrypto fallback path. */
+  chunks = [];
+  /** Total bytes fed into the hash so far. */
+  totalLength = 0;
+  /** Node.js hash instance, or null if using WebCrypto fallback. */
+  nodeHash = null;
+  /** Resolves once the crypto backend has been loaded. */
+  initPromise;
+  /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */
+  constructor() {
+    this.initPromise = getNodeCreateHash().then((factory) => {
+      if (factory) this.nodeHash = factory("sha1");
+    });
+  }
+  /**
+   * Feed data into the hash. Async because it lazily initializes the crypto backend.
+   * @param data - The bytes to include in the hash computation.
+   *
+   * @returns A promise that resolves once the data has been consumed.
+   */
+  async update(data) {
+    await this.initPromise;
+    if (this.nodeHash) {
+      this.nodeHash.update(data);
+    } else {
+      this.chunks.push(new Uint8Array(data));
+    }
+    this.totalLength += data.byteLength;
+  }
+  /**
+   * Finalize the hash and return the hex-encoded SHA-1 digest.
+   * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.
+   */
+  async digest() {
+    await this.initPromise;
+    if (this.nodeHash) {
+      return this.nodeHash.digest("hex");
+    }
+    const combined = new Uint8Array(this.totalLength);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const hashBuffer = await crypto.subtle.digest("SHA-1", combined.buffer);
+    return hexEncode(new Uint8Array(hashBuffer));
+  }
+  /**
+   * Total number of bytes fed into the hash so far.
+   *
+   * @returns The cumulative byte count across all update calls.
+   */
+  get bytesProcessed() {
+    return this.totalLength;
+  }
+}
+function hexEncode(bytes) {
+  const hex = [];
+  for (const b of bytes) {
+    hex.push(b.toString(16).padStart(2, "0"));
+  }
+  return hex.join("");
+}
+async function sha1Hex(data) {
+  const factory = await getNodeCreateHash();
+  if (factory) {
+    const h = factory("sha1");
+    h.update(data);
+    return h.digest("hex");
+  }
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data.buffer);
+  return hexEncode(new Uint8Array(hashBuffer));
+}
+export {
+  IncrementalSha1,
+  sha1Hex
+};
+//# sourceMappingURL=hash.js.map

package/dist/streams/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sources":["../../src/streams/hash.ts"],"sourcesContent":["/** Internal wrapper around a Node.js Hash instance. */\ntype NodeHasher = { update(data: Uint8Array): void; digest(encoding: string): string }\n\n/** Factory that creates a NodeHasher for a given algorithm name. */\ntype NodeHashFactory = (algorithm: string) => NodeHasher\n\nlet nodeCreateHash: NodeHashFactory | null | undefined\n\n/**\n * Lazily loads `node:crypto` and caches the factory. Returns null in non-Node runtimes.\n *\n * @returns The cached hash factory, or null if Node crypto is unavailable.\n */\nasync function getNodeCreateHash(): Promise<NodeHashFactory | null> {\n  if (nodeCreateHash !== undefined) return nodeCreateHash\n  try {\n    // @ts-ignore -- node:crypto may not exist in browser/edge runtimes\n    const crypto = await import('node:crypto')\n    // Vite's browser shim resolves the import but does not implement\n    // `createHash`. Probe explicitly so we fall through to the WebCrypto\n    // path instead of returning a broken factory.\n    if (typeof crypto.createHash !== 'function') throw new Error('createHash unavailable')\n    nodeCreateHash = (algo: string) => {\n      const h = crypto.createHash(algo)\n      return {\n        update(data: Uint8Array) {\n          h.update(data)\n        },\n        digest(encoding: string) {\n          return h.digest(encoding as 'hex') as string\n        },\n      }\n    }\n    /* v8 ignore next 3 -- non-Node runtime fallback, unreachable in Node tests */\n  } catch {\n    nodeCreateHash = null\n  }\n  return nodeCreateHash\n}\n\n/**\n * Incrementally computes SHA-1 hashes over streaming data.\n * Uses Node.js `crypto` when available, falling back to WebCrypto.\n */\nexport class IncrementalSha1 {\n  /** Buffered chunks for WebCrypto fallback path. */\n  private chunks: Uint8Array[] = []\n  /** Total bytes fed into the hash so far. */\n  private totalLength = 0\n  /** Node.js hash instance, or null if using WebCrypto fallback. */\n  private nodeHash: NodeHasher | null = null\n  /** Resolves once the crypto backend has been loaded. */\n  private initPromise: Promise<void>\n\n  /** Creates a new IncrementalSha1 and lazily initializes the crypto backend. */\n  constructor() {\n    this.initPromise = getNodeCreateHash().then((factory) => {\n      if (factory) this.nodeHash = factory('sha1')\n    })\n  }\n\n  /**\n   * Feed data into the hash. Async because it lazily initializes the crypto backend.\n   * @param data - The bytes to include in the hash computation.\n   *\n   * @returns A promise that resolves once the data has been consumed.\n   */\n  async update(data: Uint8Array): Promise<void> {\n    await this.initPromise\n    if (this.nodeHash) {\n      this.nodeHash.update(data)\n    } else {\n      this.chunks.push(new Uint8Array(data))\n    }\n    this.totalLength += data.byteLength\n  }\n\n  /**\n   * Finalize the hash and return the hex-encoded SHA-1 digest.\n   * @returns The lowercase hex-encoded SHA-1 digest of all data fed so far.\n   */\n  async digest(): Promise<string> {\n    await this.initPromise\n    if (this.nodeHash) {\n      return this.nodeHash.digest('hex')\n    }\n\n    /* v8 ignore start -- WebCrypto fallback path, only reachable when node:crypto is unavailable */\n    const combined = new Uint8Array(this.totalLength)\n    let offset = 0\n    for (const chunk of this.chunks) {\n      combined.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n\n    const hashBuffer = await crypto.subtle.digest('SHA-1', combined.buffer as ArrayBuffer)\n    return hexEncode(new Uint8Array(hashBuffer))\n    /* v8 ignore stop */\n  }\n\n  /**\n   * Total number of bytes fed into the hash so far.\n   *\n   * @returns The cumulative byte count across all update calls.\n   */\n  get bytesProcessed(): number {\n    return this.totalLength\n  }\n}\n\n/* v8 ignore start -- WebCrypto fallback path, only reachable when node:crypto is unavailable (browser/edge runtimes) */\n/**\n * Convert a byte array to a lowercase hex string.\n * @param bytes - The raw bytes to encode as hexadecimal characters.\n *\n * @returns The lowercase hex-encoded string representation of the input bytes.\n */\nfunction hexEncode(bytes: Uint8Array): string {\n  const hex: string[] = []\n  for (const b of bytes) {\n    hex.push(b.toString(16).padStart(2, '0'))\n  }\n  return hex.join('')\n}\n/* v8 ignore stop */\n\n/**\n * Compute the SHA-1 hex digest of a complete byte array in one shot.\n * @param data - The byte array to hash.\n *\n * @returns The lowercase hex-encoded SHA-1 digest of the input.\n */\nexport async function sha1Hex(data: Uint8Array): Promise<string> {\n  const factory = await getNodeCreateHash()\n  if (factory) {\n    const h = factory('sha1')\n    h.update(data)\n    return h.digest('hex')\n  }\n  /* v8 ignore next 2 -- WebCrypto fallback, only reachable when node:crypto is unavailable */\n  const hashBuffer = await crypto.subtle.digest('SHA-1', data.buffer as ArrayBuffer)\n  return hexEncode(new Uint8Array(hashBuffer))\n}\n"],"names":["crypto"],"mappings":"AAMA,IAAI;AAOJ,eAAe,oBAAqD;AAClE,MAAI,mBAAmB,OAAW,QAAO;AACzC,MAAI;AAEF,UAAMA,UAAS,MAAM,OAAO,aAAa;AAIzC,QAAI,OAAOA,QAAO,eAAe,WAAY,OAAM,IAAI,MAAM,wBAAwB;AACrF,qBAAiB,CAAC,SAAiB;AACjC,YAAM,IAAIA,QAAO,WAAW,IAAI;AAChC,aAAO;AAAA,QACL,OAAO,MAAkB;AACvB,YAAE,OAAO,IAAI;AAAA,QACf;AAAA,QACA,OAAO,UAAkB;AACvB,iBAAO,EAAE,OAAO,QAAiB;AAAA,QACnC;AAAA,MAAA;AAAA,IAEJ;AAAA,EAEF,QAAQ;AACN,qBAAiB;AAAA,EACnB;AACA,SAAO;AACT;AAMO,MAAM,gBAAgB;AAAA;AAAA,EAEnB,SAAuB,CAAA;AAAA;AAAA,EAEvB,cAAc;AAAA;AAAA,EAEd,WAA8B;AAAA;AAAA,EAE9B;AAAA;AAAA,EAGR,cAAc;AACZ,SAAK,cAAc,kBAAA,EAAoB,KAAK,CAAC,YAAY;AACvD,UAAI,QAAS,MAAK,WAAW,QAAQ,MAAM;AAAA,IAC7C,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,OAAO,MAAiC;AAC5C,UAAM,KAAK;AACX,QAAI,KAAK,UAAU;AACjB,WAAK,SAAS,OAAO,IAAI;AAAA,IAC3B,OAAO;AACL,WAAK,OAAO,KAAK,IAAI,WAAW,IAAI,CAAC;AAAA,IACvC;AACA,SAAK,eAAe,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAA0B;AAC9B,UAAM,KAAK;AACX,QAAI,KAAK,UAAU;AACjB,aAAO,KAAK,SAAS,OAAO,KAAK;AAAA,IACnC;AAGA,UAAM,WAAW,IAAI,WAAW,KAAK,WAAW;AAChD,QAAI,SAAS;AACb,eAAW,SAAS,KAAK,QAAQ;AAC/B,eAAS,IAAI,OAAO,MAAM;AAC1B,gBAAU,MAAM;AAAA,IAClB;AAEA,UAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,SAAS,MAAqB;AACrF,WAAO,UAAU,IAAI,WAAW,UAAU,CAAC;AAAA,EAE7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAI,iBAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AACF;AASA,SAAS,UAAU,OAA2B;AAC5C,QAAM,MAAgB,CAAA;AACtB,aAAW,KAAK,OAAO;AACrB,QAAI,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,EAC1C;AACA,SAAO,IAAI,KAAK,EAAE;AACpB;AASA,eAAsB,QAAQ,MAAmC;AAC/D,QAAM,UAAU,MAAM,kBAAA;AACtB,MAAI,SAAS;AACX,UAAM,IAAI,QAAQ,MAAM;AACxB,MAAE,OAAO,IAAI;AACb,WAAO,EAAE,OAAO,KAAK;AAAA,EACvB;AAEA,QAAM,aAAa,MAAM,OAAO,OAAO,OAAO,SAAS,KAAK,MAAqB;AACjF,SAAO,UAAU,IAAI,WAAW,UAAU,CAAC;AAC7C;"}

package/dist/streams/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const hash = require("./hash.cjs");
+const source = require("./source.cjs");
+const encryption = require("../types/encryption.cjs");
+exports.IncrementalSha1 = hash.IncrementalSha1;
+exports.sha1Hex = hash.sha1Hex;
+exports.BlobSource = source.BlobSource;
+exports.BufferSource = source.BufferSource;
+exports.StreamSource = source.StreamSource;
+exports.toContentSource = source.toContentSource;
+exports.EncryptionKey = encryption.EncryptionKey;
+//# sourceMappingURL=index.cjs.map

package/dist/streams/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/dist/streams/index.d.cts

@@ -0,0 +1,7 @@
+/** @packageDocumentation */
+export { IncrementalSha1, sha1Hex } from './hash.js';
+export type { ProgressEvent, ProgressListener } from './progress.js';
+export type { ContentSource } from './source.js';
+export { BlobSource, BufferSource, StreamSource, toContentSource } from './source.js';
+export { EncryptionKey } from '../types/encryption.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/streams/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/streams/index.js"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACpD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAMrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/streams/index.d.ts

@@ -0,0 +1,7 @@
+/** @packageDocumentation */
+export { IncrementalSha1, sha1Hex } from './hash.js';
+export type { ProgressEvent, ProgressListener } from './progress.js';
+export type { ContentSource } from './source.js';
+export { BlobSource, BufferSource, StreamSource, toContentSource } from './source.js';
+export { EncryptionKey } from '../types/encryption.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/streams/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/streams/index.js"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACpD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAMrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/streams/index.js

@@ -0,0 +1,13 @@
+import { IncrementalSha1, sha1Hex } from "./hash.js";
+import { BlobSource, BufferSource, StreamSource, toContentSource } from "./source.js";
+import { EncryptionKey } from "../types/encryption.js";
+export {
+  BlobSource,
+  BufferSource,
+  EncryptionKey,
+  IncrementalSha1,
+  StreamSource,
+  sha1Hex,
+  toContentSource
+};
+//# sourceMappingURL=index.js.map

package/dist/streams/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/streams/progress.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class ProgressTracker {
+  /**
+   * Creates a new ProgressTracker.
+   * @param listener - Callback to receive progress events, or undefined to disable.
+   * @param totalBytes - Expected total bytes, or null if unknown.
+   * @param totalParts - Expected total parts, or null if not a multipart transfer.
+   */
+  constructor(listener, totalBytes, totalParts) {
+    this.listener = listener;
+    this.totalBytes = totalBytes;
+    this.totalParts = totalParts;
+    this.startTime = Date.now();
+  }
+  /** Running total of bytes transferred. */
+  bytesTransferred = 0;
+  /** Running count of completed parts. */
+  partsCompleted = 0;
+  /** Timestamp when tracking began. */
+  startTime;
+  /**
+   * Record that additional bytes have been transferred and notify the listener.
+   * @param count - The number of additional bytes that were transferred.
+   */
+  addBytes(count) {
+    this.bytesTransferred += count;
+    this.emit();
+  }
+  /** Record that a multipart part has completed and notify the listener. */
+  completePart() {
+    this.partsCompleted++;
+    this.emit();
+  }
+  /** Emit the current progress snapshot to the listener, if one is registered. */
+  emit() {
+    this.listener?.({
+      bytesTransferred: this.bytesTransferred,
+      totalBytes: this.totalBytes,
+      partsCompleted: this.partsCompleted,
+      totalParts: this.totalParts,
+      elapsedMs: Date.now() - this.startTime
+    });
+  }
+}
+exports.ProgressTracker = ProgressTracker;
+//# sourceMappingURL=progress.cjs.map

package/dist/streams/progress.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.cjs","sources":["../../src/streams/progress.ts"],"sourcesContent":["/** Snapshot of upload or download progress at a point in time. */\nexport interface ProgressEvent {\n  /** Number of bytes transferred so far. */\n  readonly bytesTransferred: number\n  /** Total bytes expected, or null if unknown. */\n  readonly totalBytes: number | null\n  /** Number of multipart parts completed so far. */\n  readonly partsCompleted: number\n  /** Total number of parts expected, or null if unknown. */\n  readonly totalParts: number | null\n  /** Milliseconds elapsed since the operation started. */\n  readonly elapsedMs: number\n}\n\n/** Callback invoked each time transfer progress changes. */\nexport type ProgressListener = (event: ProgressEvent) => void\n\n/**\n * Accumulates byte and part counts and emits {@link ProgressEvent}s to a listener.\n *\n * Internal building block. The SDK wires one of these inside every\n * transfer that accepts an `onProgress` option; users supply the\n * listener callback, not the tracker. Exported only so SDK source\n * modules can import it; not re-exported through any subpath.\n *\n * @internal\n */\nexport class ProgressTracker {\n  /** Running total of bytes transferred. */\n  private bytesTransferred = 0\n  /** Running count of completed parts. */\n  private partsCompleted = 0\n  /** Timestamp when tracking began. */\n  private readonly startTime: number\n\n  /**\n   * Creates a new ProgressTracker.\n   * @param listener - Callback to receive progress events, or undefined to disable.\n   * @param totalBytes - Expected total bytes, or null if unknown.\n   * @param totalParts - Expected total parts, or null if not a multipart transfer.\n   */\n  constructor(\n    private readonly listener: ProgressListener | undefined,\n    private readonly totalBytes: number | null,\n    private readonly totalParts: number | null,\n  ) {\n    this.startTime = Date.now()\n  }\n\n  /**\n   * Record that additional bytes have been transferred and notify the listener.\n   * @param count - The number of additional bytes that were transferred.\n   */\n  addBytes(count: number): void {\n    this.bytesTransferred += count\n    this.emit()\n  }\n\n  /** Record that a multipart part has completed and notify the listener. */\n  completePart(): void {\n    this.partsCompleted++\n    this.emit()\n  }\n\n  /** Emit the current progress snapshot to the listener, if one is registered. */\n  private emit(): void {\n    this.listener?.({\n      bytesTransferred: this.bytesTransferred,\n      totalBytes: this.totalBytes,\n      partsCompleted: this.partsCompleted,\n      totalParts: this.totalParts,\n      elapsedMs: Date.now() - this.startTime,\n    })\n  }\n}\n"],"names":[],"mappings":";;AA2BO,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc3B,YACmB,UACA,YACA,YACjB;AAHiB,SAAA,WAAA;AACA,SAAA,aAAA;AACA,SAAA,aAAA;AAEjB,SAAK,YAAY,KAAK,IAAA;AAAA,EACxB;AAAA;AAAA,EAlBQ,mBAAmB;AAAA;AAAA,EAEnB,iBAAiB;AAAA;AAAA,EAER;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBjB,SAAS,OAAqB;AAC5B,SAAK,oBAAoB;AACzB,SAAK,KAAA;AAAA,EACP;AAAA;AAAA,EAGA,eAAqB;AACnB,SAAK;AACL,SAAK,KAAA;AAAA,EACP;AAAA;AAAA,EAGQ,OAAa;AACnB,SAAK,WAAW;AAAA,MACd,kBAAkB,KAAK;AAAA,MACvB,YAAY,KAAK;AAAA,MACjB,gBAAgB,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK,IAAA,IAAQ,KAAK;AAAA,IAAA,CAC9B;AAAA,EACH;AACF;;"}

package/dist/streams/progress.d.cts

@@ -0,0 +1,53 @@
+/** Snapshot of upload or download progress at a point in time. */
+export interface ProgressEvent {
+    /** Number of bytes transferred so far. */
+    readonly bytesTransferred: number;
+    /** Total bytes expected, or null if unknown. */
+    readonly totalBytes: number | null;
+    /** Number of multipart parts completed so far. */
+    readonly partsCompleted: number;
+    /** Total number of parts expected, or null if unknown. */
+    readonly totalParts: number | null;
+    /** Milliseconds elapsed since the operation started. */
+    readonly elapsedMs: number;
+}
+/** Callback invoked each time transfer progress changes. */
+export type ProgressListener = (event: ProgressEvent) => void;
+/**
+ * Accumulates byte and part counts and emits {@link ProgressEvent}s to a listener.
+ *
+ * Internal building block. The SDK wires one of these inside every
+ * transfer that accepts an `onProgress` option; users supply the
+ * listener callback, not the tracker. Exported only so SDK source
+ * modules can import it; not re-exported through any subpath.
+ *
+ * @internal
+ */
+export declare class ProgressTracker {
+    private readonly listener;
+    private readonly totalBytes;
+    private readonly totalParts;
+    /** Running total of bytes transferred. */
+    private bytesTransferred;
+    /** Running count of completed parts. */
+    private partsCompleted;
+    /** Timestamp when tracking began. */
+    private readonly startTime;
+    /**
+     * Creates a new ProgressTracker.
+     * @param listener - Callback to receive progress events, or undefined to disable.
+     * @param totalBytes - Expected total bytes, or null if unknown.
+     * @param totalParts - Expected total parts, or null if not a multipart transfer.
+     */
+    constructor(listener: ProgressListener | undefined, totalBytes: number | null, totalParts: number | null);
+    /**
+     * Record that additional bytes have been transferred and notify the listener.
+     * @param count - The number of additional bytes that were transferred.
+     */
+    addBytes(count: number): void;
+    /** Record that a multipart part has completed and notify the listener. */
+    completePart(): void;
+    /** Emit the current progress snapshot to the listener, if one is registered. */
+    private emit;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/streams/progress.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/streams/progress.js"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,4DAA4D;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;AAE7D;;;;;;;;;GASG;AACH,qBAAa,eAAe;IAexB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAhB7B,0CAA0C;IAC1C,OAAO,CAAC,gBAAgB,CAAI;IAC5B,wCAAwC;IACxC,OAAO,CAAC,cAAc,CAAI;IAC1B,qCAAqC;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAElC;;;;;OAKG;gBAEgB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,UAAU,EAAE,MAAM,GAAG,IAAI;IAK5C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B,0EAA0E;IAC1E,YAAY,IAAI,IAAI;IAKpB,gFAAgF;IAChF,OAAO,CAAC,IAAI;CASb"}

package/dist/streams/progress.d.ts

@@ -0,0 +1,53 @@
+/** Snapshot of upload or download progress at a point in time. */
+export interface ProgressEvent {
+    /** Number of bytes transferred so far. */
+    readonly bytesTransferred: number;
+    /** Total bytes expected, or null if unknown. */
+    readonly totalBytes: number | null;
+    /** Number of multipart parts completed so far. */
+    readonly partsCompleted: number;
+    /** Total number of parts expected, or null if unknown. */
+    readonly totalParts: number | null;
+    /** Milliseconds elapsed since the operation started. */
+    readonly elapsedMs: number;
+}
+/** Callback invoked each time transfer progress changes. */
+export type ProgressListener = (event: ProgressEvent) => void;
+/**
+ * Accumulates byte and part counts and emits {@link ProgressEvent}s to a listener.
+ *
+ * Internal building block. The SDK wires one of these inside every
+ * transfer that accepts an `onProgress` option; users supply the
+ * listener callback, not the tracker. Exported only so SDK source
+ * modules can import it; not re-exported through any subpath.
+ *
+ * @internal
+ */
+export declare class ProgressTracker {
+    private readonly listener;
+    private readonly totalBytes;
+    private readonly totalParts;
+    /** Running total of bytes transferred. */
+    private bytesTransferred;
+    /** Running count of completed parts. */
+    private partsCompleted;
+    /** Timestamp when tracking began. */
+    private readonly startTime;
+    /**
+     * Creates a new ProgressTracker.
+     * @param listener - Callback to receive progress events, or undefined to disable.
+     * @param totalBytes - Expected total bytes, or null if unknown.
+     * @param totalParts - Expected total parts, or null if not a multipart transfer.
+     */
+    constructor(listener: ProgressListener | undefined, totalBytes: number | null, totalParts: number | null);
+    /**
+     * Record that additional bytes have been transferred and notify the listener.
+     * @param count - The number of additional bytes that were transferred.
+     */
+    addBytes(count: number): void;
+    /** Record that a multipart part has completed and notify the listener. */
+    completePart(): void;
+    /** Emit the current progress snapshot to the listener, if one is registered. */
+    private emit;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/streams/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/streams/progress.js"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,4DAA4D;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;AAE7D;;;;;;;;;GASG;AACH,qBAAa,eAAe;IAexB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAhB7B,0CAA0C;IAC1C,OAAO,CAAC,gBAAgB,CAAI;IAC5B,wCAAwC;IACxC,OAAO,CAAC,cAAc,CAAI;IAC1B,qCAAqC;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAElC;;;;;OAKG;gBAEgB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,UAAU,EAAE,MAAM,GAAG,IAAI;IAK5C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B,0EAA0E;IAC1E,YAAY,IAAI,IAAI;IAKpB,gFAAgF;IAChF,OAAO,CAAC,IAAI;CASb"}

package/dist/streams/progress.js

@@ -0,0 +1,47 @@
+class ProgressTracker {
+  /**
+   * Creates a new ProgressTracker.
+   * @param listener - Callback to receive progress events, or undefined to disable.
+   * @param totalBytes - Expected total bytes, or null if unknown.
+   * @param totalParts - Expected total parts, or null if not a multipart transfer.
+   */
+  constructor(listener, totalBytes, totalParts) {
+    this.listener = listener;
+    this.totalBytes = totalBytes;
+    this.totalParts = totalParts;
+    this.startTime = Date.now();
+  }
+  /** Running total of bytes transferred. */
+  bytesTransferred = 0;
+  /** Running count of completed parts. */
+  partsCompleted = 0;
+  /** Timestamp when tracking began. */
+  startTime;
+  /**
+   * Record that additional bytes have been transferred and notify the listener.
+   * @param count - The number of additional bytes that were transferred.
+   */
+  addBytes(count) {
+    this.bytesTransferred += count;
+    this.emit();
+  }
+  /** Record that a multipart part has completed and notify the listener. */
+  completePart() {
+    this.partsCompleted++;
+    this.emit();
+  }
+  /** Emit the current progress snapshot to the listener, if one is registered. */
+  emit() {
+    this.listener?.({
+      bytesTransferred: this.bytesTransferred,
+      totalBytes: this.totalBytes,
+      partsCompleted: this.partsCompleted,
+      totalParts: this.totalParts,
+      elapsedMs: Date.now() - this.startTime
+    });
+  }
+}
+export {
+  ProgressTracker
+};
+//# sourceMappingURL=progress.js.map

package/dist/streams/progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.js","sources":["../../src/streams/progress.ts"],"sourcesContent":["/** Snapshot of upload or download progress at a point in time. */\nexport interface ProgressEvent {\n  /** Number of bytes transferred so far. */\n  readonly bytesTransferred: number\n  /** Total bytes expected, or null if unknown. */\n  readonly totalBytes: number | null\n  /** Number of multipart parts completed so far. */\n  readonly partsCompleted: number\n  /** Total number of parts expected, or null if unknown. */\n  readonly totalParts: number | null\n  /** Milliseconds elapsed since the operation started. */\n  readonly elapsedMs: number\n}\n\n/** Callback invoked each time transfer progress changes. */\nexport type ProgressListener = (event: ProgressEvent) => void\n\n/**\n * Accumulates byte and part counts and emits {@link ProgressEvent}s to a listener.\n *\n * Internal building block. The SDK wires one of these inside every\n * transfer that accepts an `onProgress` option; users supply the\n * listener callback, not the tracker. Exported only so SDK source\n * modules can import it; not re-exported through any subpath.\n *\n * @internal\n */\nexport class ProgressTracker {\n  /** Running total of bytes transferred. */\n  private bytesTransferred = 0\n  /** Running count of completed parts. */\n  private partsCompleted = 0\n  /** Timestamp when tracking began. */\n  private readonly startTime: number\n\n  /**\n   * Creates a new ProgressTracker.\n   * @param listener - Callback to receive progress events, or undefined to disable.\n   * @param totalBytes - Expected total bytes, or null if unknown.\n   * @param totalParts - Expected total parts, or null if not a multipart transfer.\n   */\n  constructor(\n    private readonly listener: ProgressListener | undefined,\n    private readonly totalBytes: number | null,\n    private readonly totalParts: number | null,\n  ) {\n    this.startTime = Date.now()\n  }\n\n  /**\n   * Record that additional bytes have been transferred and notify the listener.\n   * @param count - The number of additional bytes that were transferred.\n   */\n  addBytes(count: number): void {\n    this.bytesTransferred += count\n    this.emit()\n  }\n\n  /** Record that a multipart part has completed and notify the listener. */\n  completePart(): void {\n    this.partsCompleted++\n    this.emit()\n  }\n\n  /** Emit the current progress snapshot to the listener, if one is registered. */\n  private emit(): void {\n    this.listener?.({\n      bytesTransferred: this.bytesTransferred,\n      totalBytes: this.totalBytes,\n      partsCompleted: this.partsCompleted,\n      totalParts: this.totalParts,\n      elapsedMs: Date.now() - this.startTime,\n    })\n  }\n}\n"],"names":[],"mappings":"AA2BO,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc3B,YACmB,UACA,YACA,YACjB;AAHiB,SAAA,WAAA;AACA,SAAA,aAAA;AACA,SAAA,aAAA;AAEjB,SAAK,YAAY,KAAK,IAAA;AAAA,EACxB;AAAA;AAAA,EAlBQ,mBAAmB;AAAA;AAAA,EAEnB,iBAAiB;AAAA;AAAA,EAER;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBjB,SAAS,OAAqB;AAC5B,SAAK,oBAAoB;AACzB,SAAK,KAAA;AAAA,EACP;AAAA;AAAA,EAGA,eAAqB;AACnB,SAAK;AACL,SAAK,KAAA;AAAA,EACP;AAAA;AAAA,EAGQ,OAAa;AACnB,SAAK,WAAW;AAAA,MACd,kBAAkB,KAAK;AAAA,MACvB,YAAY,KAAK;AAAA,MACjB,gBAAgB,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK,IAAA,IAAQ,KAAK;AAAA,IAAA,CAC9B;AAAA,EACH;AACF;"}

package/dist/streams/source.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const collect = require("./collect.cjs");
+class BlobSource {
+  /**
+   * Create a BlobSource wrapping the given Blob.
+   * @param blob - The Blob or File to use as the underlying content.
+   */
+  constructor(blob) {
+    this.blob = blob;
+    this.size = blob.size;
+  }
+  /** {@inheritDoc} */
+  size;
+  /** Random-access: `Blob.slice()` is cheap and returns a new Blob view. */
+  canSlice = true;
+  /**
+   * Return a new BlobSource covering the specified byte range.
+   * @param start - The zero-based byte offset to begin the slice.
+   * @param end - The exclusive byte offset where the slice ends.
+   *
+   * @returns A new ContentSource representing the requested sub-range.
+   */
+  slice(start, end) {
+    return new BlobSource(this.blob.slice(start, end));
+  }
+  /**
+   * Open the Blob content as a ReadableStream.
+   * @returns A ReadableStream of the Blob bytes.
+   */
+  stream() {
+    return this.blob.stream();
+  }
+  /**
+   * Read the entire Blob content into an ArrayBuffer.
+   * @returns A promise that resolves with the full content as an ArrayBuffer.
+   */
+  toArrayBuffer() {
+    return this.blob.arrayBuffer();
+  }
+}
+class BufferSource {
+  /**
+   * Create a BufferSource wrapping the given Uint8Array.
+   * @param buffer - The byte buffer to use as the underlying content.
+   */
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.size = buffer.byteLength;
+  }
+  /** {@inheritDoc} */
+  size;
+  /** Random-access: the entire payload lives in memory. */
+  canSlice = true;
+  /**
+   * Return a new BufferSource covering the specified byte range.
+   * @param start - The zero-based byte offset to begin the slice.
+   * @param end - The exclusive byte offset where the slice ends.
+   *
+   * @returns A new ContentSource representing the requested sub-range.
+   */
+  slice(start, end) {
+    return new BufferSource(this.buffer.slice(start, end));
+  }
+  /**
+   * Open the buffer content as a ReadableStream.
+   * @returns A ReadableStream that emits the buffer bytes in a single chunk.
+   */
+  stream() {
+    const buffer = this.buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(buffer);
+        controller.close();
+      }
+    });
+  }
+  /**
+   * Read the entire buffer content into an ArrayBuffer.
+   * @returns A promise that resolves with the full content as an ArrayBuffer.
+   */
+  toArrayBuffer() {
+    return Promise.resolve(
+      this.buffer.buffer.slice(
+        this.buffer.byteOffset,
+        this.buffer.byteOffset + this.buffer.byteLength
+      )
+    );
+  }
+}
+class StreamSource {
+  /**
+   * Create a StreamSource wrapping the given ReadableStream with a known byte size.
+   * @param readable - The ReadableStream to wrap as a content source.
+   * @param size - The total number of bytes the stream will produce.
+   */
+  constructor(readable, size) {
+    this.readable = readable;
+    this.size = size;
+  }
+  /** {@inheritDoc} */
+  size;
+  /**
+   * Forward-only: ReadableStreams cannot be repositioned, so multipart
+   * uploads must take the sequential path. See the interface comment on
+   * `canSlice` for what the engine does with this flag.
+   */
+  canSlice = false;
+  /** Whether the stream has already been read. */
+  consumed = false;
+  /**
+   * Always throws because streams cannot be sliced. Buffer the stream first.
+   *
+   * @throws If slicing is attempted on a stream-backed source.
+   */
+  slice() {
+    throw new Error("StreamSource does not support slicing. Buffer the stream first.");
+  }
+  /**
+   * Open the underlying ReadableStream. Can only be called once.
+   * @returns The underlying ReadableStream of bytes.
+   *
+   * @throws If the stream has already been consumed.
+   */
+  stream() {
+    if (this.consumed) throw new Error("StreamSource can only be consumed once.");
+    this.consumed = true;
+    return this.readable;
+  }
+  /**
+   * Read the entire stream into an ArrayBuffer.
+   * @returns A promise that resolves with the full content as an ArrayBuffer.
+   */
+  async toArrayBuffer() {
+    const bytes = await collect.collectStream(this.stream());
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+}
+function toContentSource(input, size) {
+  if (input instanceof Uint8Array) {
+    return new BufferSource(input);
+  }
+  if (input instanceof Blob) {
+    return new BlobSource(input);
+  }
+  if (size === void 0) {
+    throw new Error("size is required when using a ReadableStream as input.");
+  }
+  return new StreamSource(input, size);
+}
+exports.BlobSource = BlobSource;
+exports.BufferSource = BufferSource;
+exports.StreamSource = StreamSource;
+exports.toContentSource = toContentSource;
+//# sourceMappingURL=source.cjs.map

package/dist/streams/source.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.cjs","sources":["../../src/streams/source.ts"],"sourcesContent":["import { collectStream } from './collect.ts'\n\n/**\n * Uniform adapter for upload content. Wraps File, Blob, Buffer, or ReadableStream\n * behind a common interface so upload logic does not depend on the input type.\n */\nexport interface ContentSource {\n  /** Total size of the content in bytes. */\n  readonly size: number\n  /** Pre-computed SHA-1 hex digest, if available. */\n  readonly sha1?: string\n  /**\n   * Whether {@link slice} is safe to call on this source.\n   *\n   * `true` for in-memory / random-access sources (`BufferSource`,\n   * `BlobSource`) — the multipart upload engine can dispatch part reads\n   * in parallel by slicing the source into disjoint ranges. `false`\n   * for forward-only sources (`StreamSource`) — the engine must read\n   * sequentially, one `partSize` chunk at a time. Callers that branch\n   * on this flag are expected to fall back to the sequential path\n   * rather than call `slice()` and catch the throw.\n   */\n  readonly canSlice: boolean\n  /** Return a sub-range of this source as a new ContentSource. */\n  slice(start: number, end: number): ContentSource\n  /** Open the content as a ReadableStream. */\n  stream(): ReadableStream<Uint8Array>\n  /** Read the entire content into an ArrayBuffer. */\n  toArrayBuffer(): Promise<ArrayBuffer>\n}\n\n/** ContentSource backed by a Blob or File. */\nexport class BlobSource implements ContentSource {\n  /** {@inheritDoc} */\n  readonly size: number\n  /** Random-access: `Blob.slice()` is cheap and returns a new Blob view. */\n  readonly canSlice = true\n\n  /**\n   * Create a BlobSource wrapping the given Blob.\n   * @param blob - The Blob or File to use as the underlying content.\n   */\n  constructor(private readonly blob: Blob) {\n    this.size = blob.size\n  }\n\n  /**\n   * Return a new BlobSource covering the specified byte range.\n   * @param start - The zero-based byte offset to begin the slice.\n   * @param end - The exclusive byte offset where the slice ends.\n   *\n   * @returns A new ContentSource representing the requested sub-range.\n   */\n  slice(start: number, end: number): ContentSource {\n    return new BlobSource(this.blob.slice(start, end))\n  }\n\n  /**\n   * Open the Blob content as a ReadableStream.\n   * @returns A ReadableStream of the Blob bytes.\n   */\n  stream(): ReadableStream<Uint8Array> {\n    return this.blob.stream() as ReadableStream<Uint8Array>\n  }\n\n  /**\n   * Read the entire Blob content into an ArrayBuffer.\n   * @returns A promise that resolves with the full content as an ArrayBuffer.\n   */\n  toArrayBuffer(): Promise<ArrayBuffer> {\n    return this.blob.arrayBuffer()\n  }\n}\n\n/** ContentSource backed by a Uint8Array buffer. */\nexport class BufferSource implements ContentSource {\n  /** {@inheritDoc} */\n  readonly size: number\n  /** Random-access: the entire payload lives in memory. */\n  readonly canSlice = true\n\n  /**\n   * Create a BufferSource wrapping the given Uint8Array.\n   * @param buffer - The byte buffer to use as the underlying content.\n   */\n  constructor(private readonly buffer: Uint8Array) {\n    this.size = buffer.byteLength\n  }\n\n  /**\n   * Return a new BufferSource covering the specified byte range.\n   * @param start - The zero-based byte offset to begin the slice.\n   * @param end - The exclusive byte offset where the slice ends.\n   *\n   * @returns A new ContentSource representing the requested sub-range.\n   */\n  slice(start: number, end: number): ContentSource {\n    return new BufferSource(this.buffer.slice(start, end))\n  }\n\n  /**\n   * Open the buffer content as a ReadableStream.\n   * @returns A ReadableStream that emits the buffer bytes in a single chunk.\n   */\n  stream(): ReadableStream<Uint8Array> {\n    const buffer = this.buffer\n    return new ReadableStream({\n      start(controller) {\n        controller.enqueue(buffer)\n        controller.close()\n      },\n    })\n  }\n\n  /**\n   * Read the entire buffer content into an ArrayBuffer.\n   * @returns A promise that resolves with the full content as an ArrayBuffer.\n   */\n  toArrayBuffer(): Promise<ArrayBuffer> {\n    return Promise.resolve(\n      this.buffer.buffer.slice(\n        this.buffer.byteOffset,\n        this.buffer.byteOffset + this.buffer.byteLength,\n      ) as ArrayBuffer,\n    )\n  }\n}\n\n/** ContentSource backed by a ReadableStream. Can only be consumed once and does not support slicing. */\nexport class StreamSource implements ContentSource {\n  /** {@inheritDoc} */\n  readonly size: number\n  /**\n   * Forward-only: ReadableStreams cannot be repositioned, so multipart\n   * uploads must take the sequential path. See the interface comment on\n   * `canSlice` for what the engine does with this flag.\n   */\n  readonly canSlice = false\n  /** Whether the stream has already been read. */\n  private consumed = false\n\n  /**\n   * Create a StreamSource wrapping the given ReadableStream with a known byte size.\n   * @param readable - The ReadableStream to wrap as a content source.\n   * @param size - The total number of bytes the stream will produce.\n   */\n  constructor(\n    private readonly readable: ReadableStream<Uint8Array>,\n    size: number,\n  ) {\n    this.size = size\n  }\n\n  /**\n   * Always throws because streams cannot be sliced. Buffer the stream first.\n   *\n   * @throws If slicing is attempted on a stream-backed source.\n   */\n  slice(): ContentSource {\n    throw new Error('StreamSource does not support slicing. Buffer the stream first.')\n  }\n\n  /**\n   * Open the underlying ReadableStream. Can only be called once.\n   * @returns The underlying ReadableStream of bytes.\n   *\n   * @throws If the stream has already been consumed.\n   */\n  stream(): ReadableStream<Uint8Array> {\n    if (this.consumed) throw new Error('StreamSource can only be consumed once.')\n    this.consumed = true\n    return this.readable\n  }\n\n  /**\n   * Read the entire stream into an ArrayBuffer.\n   * @returns A promise that resolves with the full content as an ArrayBuffer.\n   */\n  async toArrayBuffer(): Promise<ArrayBuffer> {\n    const bytes = await collectStream(this.stream())\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer\n  }\n}\n\n/**\n * Convert a Uint8Array, Blob, or ReadableStream into a {@link ContentSource}.\n * When passing a ReadableStream, the `size` parameter is required.\n * @param input - The content to wrap, as a Uint8Array, Blob, or ReadableStream.\n * @param size - The total byte length, required when input is a ReadableStream.\n *\n * @returns A ContentSource adapter for the given input.\n *\n * @throws If input is a ReadableStream and size is not provided.\n */\nexport function toContentSource(\n  input: Uint8Array | Blob | ReadableStream<Uint8Array>,\n  size?: number,\n): ContentSource {\n  if (input instanceof Uint8Array) {\n    return new BufferSource(input)\n  }\n  if (input instanceof Blob) {\n    return new BlobSource(input)\n  }\n  if (size === undefined) {\n    throw new Error('size is required when using a ReadableStream as input.')\n  }\n  return new StreamSource(input, size)\n}\n"],"names":["collectStream"],"mappings":";;;AAgCO,MAAM,WAAoC;AAAA;AAAA;AAAA;AAAA;AAAA,EAU/C,YAA6B,MAAY;AAAZ,SAAA,OAAA;AAC3B,SAAK,OAAO,KAAK;AAAA,EACnB;AAAA;AAAA,EAVS;AAAA;AAAA,EAEA,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBpB,MAAM,OAAe,KAA4B;AAC/C,WAAO,IAAI,WAAW,KAAK,KAAK,MAAM,OAAO,GAAG,CAAC;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAqC;AACnC,WAAO,KAAK,KAAK,OAAA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,gBAAsC;AACpC,WAAO,KAAK,KAAK,YAAA;AAAA,EACnB;AACF;AAGO,MAAM,aAAsC;AAAA;AAAA;AAAA;AAAA;AAAA,EAUjD,YAA6B,QAAoB;AAApB,SAAA,SAAA;AAC3B,SAAK,OAAO,OAAO;AAAA,EACrB;AAAA;AAAA,EAVS;AAAA;AAAA,EAEA,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBpB,MAAM,OAAe,KAA4B;AAC/C,WAAO,IAAI,aAAa,KAAK,OAAO,MAAM,OAAO,GAAG,CAAC;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAqC;AACnC,UAAM,SAAS,KAAK;AACpB,WAAO,IAAI,eAAe;AAAA,MACxB,MAAM,YAAY;AAChB,mBAAW,QAAQ,MAAM;AACzB,mBAAW,MAAA;AAAA,MACb;AAAA,IAAA,CACD;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,gBAAsC;AACpC,WAAO,QAAQ;AAAA,MACb,KAAK,OAAO,OAAO;AAAA,QACjB,KAAK,OAAO;AAAA,QACZ,KAAK,OAAO,aAAa,KAAK,OAAO;AAAA,MAAA;AAAA,IACvC;AAAA,EAEJ;AACF;AAGO,MAAM,aAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBjD,YACmB,UACjB,MACA;AAFiB,SAAA,WAAA;AAGjB,SAAK,OAAO;AAAA,EACd;AAAA;AAAA,EApBS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAW;AAAA;AAAA,EAEZ,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBnB,QAAuB;AACrB,UAAM,IAAI,MAAM,iEAAiE;AAAA,EACnF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,SAAqC;AACnC,QAAI,KAAK,SAAU,OAAM,IAAI,MAAM,yCAAyC;AAC5E,SAAK,WAAW;AAChB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,gBAAsC;AAC1C,UAAM,QAAQ,MAAMA,QAAAA,cAAc,KAAK,QAAQ;AAC/C,WAAO,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;AAAA,EACjF;AACF;AAYO,SAAS,gBACd,OACA,MACe;AACf,MAAI,iBAAiB,YAAY;AAC/B,WAAO,IAAI,aAAa,KAAK;AAAA,EAC/B;AACA,MAAI,iBAAiB,MAAM;AACzB,WAAO,IAAI,WAAW,KAAK;AAAA,EAC7B;AACA,MAAI,SAAS,QAAW;AACtB,UAAM,IAAI,MAAM,wDAAwD;AAAA,EAC1E;AACA,SAAO,IAAI,aAAa,OAAO,IAAI;AACrC;;;;;"}