@visulima/storage 1.0.0-alpha.17 → 1.0.0-alpha.19

package/dist/packem_shared/AzureStorage-98-LRZ1e.js

@@ -1,359 +0,0 @@
-import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
-import { p as partMatch, d as detectFileTypeFromStream, g as getFileStatus } from './part-match-Dt738Ddb.js';
-import { throwErrorCode, ERRORS } from './ERRORS-D0apMqnc.js';
-import { B as BaseStorage, t as toMilliseconds } from './storage-5XW1E7XU.js';
-import { createRetryWrapper } from './isRetryableError-Dycp7127.js';
-import { L as LocalMetaStorage } from './local-meta-storage-D-pPc3FI.js';
-import AzureFile from './AzureFile-C0kug4w4.js';
-import AzureMetaStorage from './AzureSMetaStorage-BEbXX9Uk.js';
-import { n as normalize } from './path-aV9lMdcn-DMU5H1-h.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class AzureStorage extends BaseStorage {
-  static name = "azure";
-  checksumTypes = ["md5"];
-  meta;
-  client;
-  containerClient;
-  root;
-  retry;
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  constructor(config) {
-    super(config);
-    if (!config.containerName) {
-      throw new Error("Missing required parameter: Azure container name.");
-    }
-    const connectionString = config.connectionString || process.env.AZURE_STORAGE_CONNECTION_STRING || void 0;
-    if (connectionString) {
-      this.client = BlobServiceClient.fromConnectionString(connectionString);
-    } else {
-      const accountKey = config.accountKey || process.env.AZURE_STORAGE_ACCOUNT_KEY || void 0;
-      const accountName = config.accountName || process.env.AZURE_STORAGE_ACCOUNT || void 0;
-      if (!config.accountKey) {
-        throw new Error("Missing required parameter: Azure blob storage account key.");
-      }
-      if (!config.accountName) {
-        throw new Error("Missing required parameter: Azure blob storage account name.");
-      }
-      const signedCredentials = new StorageSharedKeyCredential(accountName, accountKey);
-      this.client = new BlobServiceClient(config.endpoint ?? `https://${accountName}.blob.core.windows.net`, signedCredentials);
-    }
-    this.containerClient = this.client.getContainerClient(config.containerName);
-    this.root = config.root ? normalize(config.root).replace(/^\//, "") : "";
-    const retryConfig = {
-      backoffMultiplier: 2,
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      maxRetries: 3,
-      retryableStatusCodes: [408, 429, 500, 502, 503, 504],
-      shouldRetry: (error) => {
-        const errorWithCode = error;
-        if (errorWithCode.statusCode && [408, 429, 500, 502, 503, 504].includes(errorWithCode.statusCode)) {
-          return true;
-        }
-        if (error instanceof Error) {
-          const errorCode = errorWithCode.code;
-          if (errorCode === "ECONNRESET" || errorCode === "ETIMEDOUT" || errorCode === "ENOTFOUND" || errorCode === "ECONNREFUSED") {
-            return true;
-          }
-        }
-        return false;
-      },
-      ...config.retryConfig
-    };
-    this.retry = createRetryWrapper(retryConfig);
-    if (config.metaStorage) {
-      this.meta = config.metaStorage;
-    } else {
-      let metaConfig = { ...config, ...config.metaStorageConfig, logger: this.logger };
-      const localMeta = "directory" in metaConfig;
-      if (localMeta) {
-        this.logger?.debug("Using local meta storage");
-        this.meta = new LocalMetaStorage(metaConfig);
-      } else {
-        if (connectionString === metaConfig.connectionString) {
-          metaConfig = { ...metaConfig, client: this.client };
-        }
-        this.meta = new AzureMetaStorage(metaConfig);
-      }
-    }
-    this.isReady = false;
-    this.accessCheck().then(() => {
-      this.isReady = true;
-      return void 0;
-    }).catch((error) => {
-      this.logger?.error("Storage access check failed: %O", error);
-    });
-  }
-  async create(config) {
-    return this.instrumentOperation("create", async () => {
-      const processedConfig = { ...config };
-      if (config.ttl) {
-        const ttlMs = typeof config.ttl === "string" ? toMilliseconds(config.ttl) : config.ttl;
-        if (ttlMs !== void 0) {
-          processedConfig.expiredAt = Date.now() + ttlMs;
-        }
-      }
-      const file = new AzureFile(processedConfig);
-      file.name = this.namingFunction(file);
-      await this.validate(file);
-      try {
-        const existing = await this.getMeta(file.id);
-        if (existing.bytesWritten >= 0) {
-          return existing;
-        }
-      } catch {
-      }
-      const blobClient = this.containerClient.getBlockBlobClient(this.getFullPath(file.name));
-      const stringifiedMetaValues = {};
-      for (const [key, value] of Object.entries(file.metadata || {})) {
-        stringifiedMetaValues[key] = JSON.stringify(value);
-      }
-      const response = await this.retry(
-        () => blobClient.uploadData(Buffer.from(""), {
-          blobHTTPHeaders: {
-            blobContentType: file.contentType
-          },
-          metadata: {
-            name: file.name,
-            originalName: file.originalName,
-            ...stringifiedMetaValues
-          }
-        })
-      );
-      if (response.requestId === void 0) {
-        return throwErrorCode(ERRORS.FILE_ERROR, "azure create upload error");
-      }
-      file.requestId = response.requestId;
-      file.uri = response._response.headers.get("location");
-      file.bytesWritten = 0;
-      await this.saveMeta(file);
-      file.status = "created";
-      await this.onCreate(file);
-      return file;
-    });
-  }
-  /**
-   * Deletes an upload and its metadata.
-   * @param query File query containing the file ID to delete.
-   * @param query.id File ID to delete.
-   * @returns Promise resolving to the deleted file object with status: "deleted".
-   * @throws {UploadError} If the file metadata cannot be found.
-   */
-  async delete({ id }) {
-    return this.instrumentOperation("delete", async () => {
-      const file = await this.getMeta(id);
-      file.status = "deleted";
-      await Promise.all([
-        this.deleteMeta(file.id),
-        this.retry(() => this.containerClient.getBlockBlobClient(this.getFullPath(file.name)).deleteIfExists())
-      ]);
-      const deletedFile = { ...file };
-      await this.onDelete(deletedFile);
-      return deletedFile;
-    });
-  }
-  /**
-   * Moves an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the moved file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async move(name, destination) {
-    return this.instrumentOperation("move", async () => {
-      const copiedFile = await this.copy(name, destination);
-      const source = this.getFullPath(name);
-      await this.retry(() => this.containerClient.getBlockBlobClient(source).deleteIfExists());
-      return copiedFile;
-    });
-  }
-  async write(part) {
-    return this.instrumentOperation("write", async () => {
-      let file;
-      if ("contentType" in part && "metadata" in part && !("body" in part) && !("start" in part)) {
-        file = part;
-      } else {
-        file = await this.getMeta(part.id);
-        await this.checkIfExpired(file);
-      }
-      if (file.status === "completed") {
-        return file;
-      }
-      if (!partMatch(part, file)) {
-        return throwErrorCode(ERRORS.FILE_CONFLICT);
-      }
-      await this.lock(part.id);
-      try {
-        if (hasContent(part)) {
-          if ((file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
-            try {
-              const { fileType, stream: detectedStream } = await detectFileTypeFromStream(part.body);
-              if (fileType?.mime) {
-                file.contentType = fileType.mime;
-              }
-              part.body = detectedStream;
-            } catch {
-            }
-          }
-          const blobClient = this.containerClient.getBlockBlobClient(this.getFullPath(file.name));
-          const abortController = new AbortController();
-          part.body.on("error", () => {
-            abortController.abort();
-          });
-          const response = await this.retry(
-            () => blobClient.uploadStream(part.body, void 0, void 0, {
-              abortSignal: abortController.signal,
-              blobHTTPHeaders: {
-                blobContentType: file.contentType ?? "application/octet-stream"
-              },
-              metadata: file.metadata
-            })
-          );
-          if (response.requestId === void 0) {
-            return throwErrorCode(ERRORS.FILE_ERROR, "azure write upload error");
-          }
-          file.requestId = response.requestId;
-          file.bytesWritten += part.contentLength || 0;
-          file.status = getFileStatus(file);
-          if (file.status === "completed") {
-            file.uri = response._response.headers.get("location");
-            await this.deleteMeta(file.id);
-          }
-        }
-      } finally {
-        await this.unlock(part.id);
-      }
-      return file;
-    });
-  }
-  async get({ id }) {
-    return this.instrumentOperation("get", async () => {
-      const blobClient = this.containerClient.getBlockBlobClient(id);
-      const exists = await this.retry(() => blobClient.exists());
-      if (!exists) {
-        try {
-          await this.getMeta(id);
-          return throwErrorCode(ERRORS.GONE);
-        } catch {
-          return throwErrorCode(ERRORS.FILE_NOT_FOUND);
-        }
-      }
-      const response = await this.retry(() => blobClient.getProperties());
-      const { contentLength, contentType, etag, expiresOn, lastModified, metadata } = response;
-      return {
-        content: await this.retry(() => blobClient.downloadToBuffer()),
-        contentType,
-        ETag: etag,
-        expiredAt: expiresOn,
-        id,
-        metadata: metadata || {},
-        modifiedAt: lastModified,
-        name: metadata?.name || id,
-        originalName: metadata?.originalName || "",
-        size: contentLength
-      };
-    });
-  }
-  /**
-   * Checks if a file exists by verifying both metadata and the actual Azure blob.
-   * Returns true only if both the metadata and the blob exist.
-   * @param query File query containing the file ID to check.
-   * @returns Promise resolving to true if both metadata and blob exist, false otherwise.
-   */
-  async exists({ id }) {
-    return this.instrumentOperation("exists", async () => {
-      try {
-        await this.getMeta(id);
-        const blobClient = this.containerClient.getBlockBlobClient(id);
-        const exists = await this.retry(() => blobClient.exists());
-        return exists;
-      } catch {
-        return false;
-      }
-    });
-  }
-  /**
-   * Copies an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the copied file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async copy(name, destination) {
-    return this.instrumentOperation("copy", async () => {
-      const source = this.containerClient.getBlockBlobClient(this.getFullPath(name));
-      const exists = await this.retry(() => source.exists());
-      if (!exists) {
-        try {
-          await this.getMeta(name);
-          return throwErrorCode(ERRORS.GONE);
-        } catch {
-          return throwErrorCode(ERRORS.FILE_NOT_FOUND);
-        }
-      }
-      const target = this.containerClient.getBlockBlobClient(this.getFullPath(destination));
-      const poller = await this.retry(() => target.beginCopyFromURL(source.url));
-      await this.retry(() => poller.pollUntilDone());
-      const sourceFile = await this.getMeta(name);
-      return { ...sourceFile, id: destination, name: destination };
-    });
-  }
-  async list(limit = 1e3) {
-    return this.instrumentOperation(
-      "list",
-      async () => {
-        const files = [];
-        let truncated = true;
-        let token;
-        while (truncated) {
-          try {
-            const iterator = this.containerClient.listBlobsFlat({
-              includeMetadata: true,
-              prefix: this.root
-            }).byPage({ continuationToken: token, maxPageSize: limit });
-            const next = await this.retry(() => iterator.next());
-            const response = next.value;
-            if (response !== void 0 && "segment" in response) {
-              response.segment.blobItems.forEach((blob) => {
-                if (!blob.deleted) {
-                  files.push({
-                    createdAt: blob.properties.createdOn,
-                    id: blob.name,
-                    modifiedAt: blob.properties.lastModified
-                  });
-                }
-              });
-            }
-            truncated = response?.continuationToken !== void 0;
-            if (truncated) {
-              token = response.continuationToken;
-            }
-          } catch (error) {
-            const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-            await this.onError(httpError);
-            throw error;
-          }
-        }
-        return files;
-      },
-      { limit }
-    );
-  }
-  /**
-   * Prefixes the given filePath with the storage root location (assetFolder if configured).
-   * @param filePath Relative file path to prefix.
-   * @returns Full path with asset folder prefix if configured, otherwise returns original path.
-   */
-  getFullPath(filePath) {
-    if (this.assetFolder !== void 0) {
-      return `${this.assetFolder}/${filePath}`;
-    }
-    return filePath;
-  }
-  async accessCheck() {
-    await this.retry(() => this.containerClient.getProperties());
-  }
-}
-
-export { AzureStorage as default };

package/dist/packem_shared/BaseTransformer-9965D4pb.js

@@ -1,83 +0,0 @@
-import { Readable } from 'node:stream';
-import mime from 'mime';
-import { N as NoOpCache } from './cache-B88MXQ_2.js';
-
-class BaseTransformer {
-  /**
-   * Creates a new BaseTransformer instance with common functionality.
-   * @param storage The storage backend for retrieving and storing files.
-   * @param config Configuration options for the transformer.
-   * @param logger Optional logger instance for logging operations.
-   * @protected
-   */
-  constructor(storage, config, logger) {
-    this.storage = storage;
-    this.config = config;
-    this.logger = logger;
-    this.cache = config.cache ?? new NoOpCache();
-  }
-  storage;
-  config;
-  logger;
-  cache;
-  /**
-   * Streams transform of a file with the given steps (for large files).
-   * @param fileId Unique identifier of the file to transform.
-   * @param steps Array of transformation steps to apply.
-   * @returns Promise resolving to streaming result with headers, size, and stream.
-   */
-  async transformStream(fileId, steps) {
-    const result = await this.transform(fileId, steps);
-    if (result && "buffer" in result) {
-      const { buffer } = result;
-      return {
-        headers: {
-          "Content-Length": buffer.length.toString(),
-          "Content-Type": this.getContentTypeFromResult(result)
-        },
-        size: buffer.length,
-        stream: Readable.from(buffer)
-      };
-    }
-    throw new Error("Streaming transformation not supported for this transformer");
-  }
-  /**
-   * Clears cache for a specific file or all files.
-   * @param fileId Optional file identifier to clear cache for specific file.
-   */
-  clearCache(fileId) {
-    if (fileId) {
-      this.cache?.delete(fileId);
-    } else {
-      this.cache?.clear?.();
-    }
-  }
-  /**
-   * Gets cache statistics.
-   * @returns Cache statistics including max size and current size.
-   */
-  getCacheStats() {
-    return {
-      maxSize: -1,
-      // -1 indicates unlimited or unknown max size
-      size: this.cache?.size ?? 0
-    };
-  }
-  /**
-   * Gets content type from transformation result based on format.
-   * @param result Transformation result object containing format information.
-   * @returns Content type string (MIME type).
-   */
-  // eslint-disable-next-line class-methods-use-this
-  getContentTypeFromResult(result) {
-    if (result?.format) {
-      const contentType = mime.getType(result.format);
-      if (contentType) {
-        return contentType;
-      }
-    }
-    return "application/octet-stream";
-  }
-}
-
-export { BaseTransformer as default };

package/dist/packem_shared/DiskStorage-COMe_G42.js

@@ -1,12 +0,0 @@
-import 'node:fs';
-import 'node:fs/promises';
-import 'node:stream';
-export { D as default } from './disk-storage-D9RfoKjW.js';
-import './part-match-Dt738Ddb.js';
-import './ERRORS-D0apMqnc.js';
-import './storage-5XW1E7XU.js';
-import './local-meta-storage-D-pPc3FI.js';
-import './File-CPUhj3DI.js';
-import './update-size-CCGm6i1J.js';
-import './has-content-CY66ehMK.js';
-import './path-aV9lMdcn-DMU5H1-h.js';

package/dist/packem_shared/DiskStorageWithChecksum-BVaaZiyS.js

@@ -1,249 +0,0 @@
-import { createReadStream, createWriteStream } from 'node:fs';
-import { truncate } from 'node:fs/promises';
-import { Transform, pipeline } from 'node:stream';
-import { p as partMatch, d as detectFileTypeFromStream, g as getFileStatus } from './part-match-Dt738Ddb.js';
-import { throwErrorCode, ERRORS } from './ERRORS-D0apMqnc.js';
-import { D as DiskStorage, e as ensureFile, S as StreamLength, s as streamChecksum } from './disk-storage-D9RfoKjW.js';
-import { LRUCache } from 'lru-cache';
-import { createHash } from 'node:crypto';
-import { r as remove } from './local-meta-storage-D-pPc3FI.js';
-import { u as updateSize } from './update-size-CCGm6i1J.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class RangeChecksum extends Transform {
-  /**
-   * Creates a new RangeChecksum transform stream.
-   * @param hashes Range hasher instance managing multiple file hashes
-   * @param path File path identifier for this checksum operation
-   */
-  constructor(hashes, path) {
-    super();
-    this.path = path;
-    this.hashes = hashes;
-    this.hash = this.hashes.get(path) || createHash(this.hashes.algorithm);
-    this.hashCopy = this.hash.copy();
-  }
-  path;
-  hash;
-  hashCopy;
-  hashes;
-  /**
-   * Resets the hash state to its initial value.
-   * Useful for reusing the checksum calculator for multiple operations.
-   */
-  reset() {
-    this.hashes.set(this.path, this.hashCopy);
-  }
-  /**
-   * Returns the current hash digest in the specified encoding.
-   * @param encoding Output encoding format (default: 'hex')
-   * @returns Hash digest as a string
-   */
-  digest(encoding = "hex") {
-    return this.hash.copy().digest(encoding);
-  }
-  // eslint-disable-next-line no-underscore-dangle
-  _transform(chunk, _encoding, done) {
-    this.push(chunk);
-    this.hash.update(chunk);
-    done();
-  }
-  // eslint-disable-next-line class-methods-use-this,no-underscore-dangle
-  _flush(callback) {
-    callback();
-  }
-}
-
-class RangeHasher extends LRUCache {
-  /**
-   * Creates a new RangeHasher instance.
-   * @param algorithm Hash algorithm to use (default: 'sha1')
-   * @param options LRU cache configuration options
-   */
-  constructor(algorithm = "sha1", options) {
-    super({
-      ttl: 1e3,
-      ttlAutopurge: true,
-      ...options
-    });
-    this.algorithm = algorithm;
-  }
-  algorithm;
-  /**
-   * Returns the hex-encoded digest for a previously initialized path.
-   * @param path File path identifier
-   * @returns Hex-encoded hash digest, or empty string if not found
-   */
-  hex(path) {
-    return this.get(path)?.copy().digest("hex") || "";
-  }
-  /**
-   * Returns the base64-encoded digest for a previously initialized path.
-   * @param path File path identifier
-   * @returns Base64-encoded hash digest, or empty string if not found
-   */
-  base64(path) {
-    return this.get(path)?.copy().digest("base64") || "";
-  }
-  /**
-   * Initializes or continues a hasher for a file from the specified offset.
-   * Returns cached hash if available, otherwise calculates from filesystem.
-   * @param path File path to hash
-   * @param start Starting offset in bytes (default: 0)
-   * @returns Promise resolving to the hash instance
-   */
-  async init(path, start = 0) {
-    return this.get(path)?.copy() || this.updateFromFs(path, start);
-  }
-  /**
-   * Creates a transform stream that updates the rolling hash for a file path.
-   * Useful for incremental hashing during streaming operations.
-   * @param path File path identifier for hash tracking
-   * @returns RangeChecksum transform stream instance
-   */
-  digester(path) {
-    return new RangeChecksum(this, path);
-  }
-  async updateFromFs(path, start = 0, initial) {
-    const hash = await this.fromFs(path, start, initial);
-    this.set(path, hash);
-    return hash;
-  }
-  fromFs(path, start = 0, initial) {
-    return new Promise((resolve, reject) => {
-      const digester = this.digester(path);
-      if (initial !== void 0) {
-        digester.hash = initial;
-      }
-      createReadStream(path, { start }).on("error", reject).on("end", () => {
-        resolve(digester.hash);
-      }).pipe(digester).resume();
-    });
-  }
-}
-
-class DiskStorageWithChecksum extends DiskStorage {
-  hashes;
-  constructor(config) {
-    super(config);
-    this.hashes = new RangeHasher(config?.checksum === "sha1" ? "sha1" : "md5");
-  }
-  async delete({ id }) {
-    try {
-      const file = await this.getMeta(id);
-      const path = this.getFilePath(file.name);
-      this.hashes.delete(path);
-      await remove(path);
-      await this.deleteMeta(id);
-      const deletedFile = { ...file, status: "deleted" };
-      await this.onDelete(deletedFile);
-      return deletedFile;
-    } catch (error) {
-      this.logger?.error("[error]: Could not delete file: %O", error);
-      const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-      await this.onError(httpError);
-    }
-    return { id };
-  }
-  async write(part) {
-    let file;
-    if ("contentType" in part && "metadata" in part && !("body" in part) && !("start" in part)) {
-      file = part;
-    } else {
-      file = await this.getMeta(part.id);
-      await this.checkIfExpired(file);
-    }
-    if (file.status === "completed") {
-      return file;
-    }
-    if (part.size !== void 0) {
-      updateSize(file, part.size);
-    }
-    if (!partMatch(part, file)) {
-      return throwErrorCode(ERRORS.FILE_CONFLICT);
-    }
-    const path = this.getFilePath(file.name);
-    try {
-      const startPosition = part.start || 0;
-      await ensureFile(path);
-      if (file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) {
-        file.bytesWritten = startPosition;
-      }
-      await this.hashes.init(path);
-      if (hasContent(part)) {
-        if (this.isUnsupportedChecksum(part.checksumAlgorithm)) {
-          return throwErrorCode(ERRORS.UNSUPPORTED_CHECKSUM_ALGORITHM);
-        }
-        const isFirstChunk = part.start === 0 || part.start === void 0;
-        if (isFirstChunk && (file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
-          try {
-            const { fileType, stream: detectedStream } = await detectFileTypeFromStream(part.body);
-            if (fileType?.mime) {
-              file.contentType = fileType.mime;
-            }
-            part.body = detectedStream;
-          } catch {
-          }
-        }
-        const [bytesWritten, errorCode] = await this.lazyWrite({ ...part, ...file });
-        if (errorCode) {
-          await truncate(path, file.bytesWritten);
-          return throwErrorCode(errorCode);
-        }
-        if (typeof bytesWritten !== "number") {
-          await this.hashes.updateFromFs(path, file.bytesWritten);
-        }
-        file.bytesWritten = bytesWritten;
-      }
-      file.status = getFileStatus(file);
-      file.hash = {
-        algorithm: this.hashes.algorithm,
-        value: this.hashes.hex(path)
-      };
-      if (file.status === "completed") {
-        this.hashes.delete(path);
-      }
-      await this.saveMeta(file);
-      return file;
-    } catch (error) {
-      await this.hashes.updateFromFs(path, file.bytesWritten);
-      const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-      await this.onError(httpError);
-      return throwErrorCode(ERRORS.FILE_ERROR, (typeof httpError.message === "string" ? httpError.message : String(error)) || String(error));
-    }
-  }
-  lazyWrite(part) {
-    return new Promise((resolve, reject) => {
-      const path = this.getFilePath(part.name);
-      const destination = createWriteStream(path, { flags: "r+", start: part.start });
-      const lengthChecker = new StreamLength(part.contentLength || Number(part.size) - part.start);
-      const checksumChecker = streamChecksum(part.checksum, part.checksumAlgorithm);
-      const digester = this.hashes.digester(path);
-      const keepPartial = !part.checksum;
-      const failWithCode = (code) => {
-        digester.reset();
-        destination.close();
-        resolve([Number.NaN, code]);
-      };
-      lengthChecker.on("error", () => {
-        failWithCode(ERRORS.FILE_CONFLICT);
-      });
-      checksumChecker.on("error", () => {
-        failWithCode(ERRORS.CHECKSUM_MISMATCH);
-      });
-      part.body.on("aborted", () => {
-        failWithCode(keepPartial ? void 0 : ERRORS.REQUEST_ABORTED);
-      });
-      pipeline(part.body, lengthChecker, checksumChecker, digester, destination, (error) => {
-        if (error) {
-          digester.reset();
-          reject(error);
-          return;
-        }
-        resolve([part.start + destination.bytesWritten]);
-      });
-    });
-  }
-}
-
-export { DiskStorageWithChecksum as default };