@chunkflowjs/upload-server 0.0.1-alpha.1

package/dist/index.mjs

@@ -0,0 +1,536 @@
+import { createReadStream, existsSync, promises } from "fs";
+import { dirname, join } from "path";
+import { randomBytes } from "crypto";
+import { sign, verify } from "jsonwebtoken";
+
+//#region src/local-storage-adapter.ts
+/**
+* Local filesystem storage adapter
+*
+* Stores chunks in the local filesystem using a directory structure
+* based on the first two characters of the chunk hash for better performance.
+*
+* Directory structure: baseDir/ab/abcdef123456...
+*/
+var LocalStorageAdapter = class {
+	baseDir;
+	initialized = false;
+	constructor(options = {}) {
+		this.baseDir = options.baseDir || "./uploads";
+	}
+	/**
+	* Initialize the storage adapter by creating the base directory
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		try {
+			await promises.mkdir(this.baseDir, { recursive: true });
+			this.initialized = true;
+		} catch (error) {
+			throw new Error(`Failed to initialize local storage: ${error.message}`);
+		}
+	}
+	/**
+	* Get the file path for a chunk hash
+	* Uses the first two characters as a subdirectory for better performance
+	*/
+	getChunkPath(chunkHash) {
+		if (chunkHash.length < 2) throw new Error("Chunk hash must be at least 2 characters long");
+		const subDir = chunkHash.substring(0, 2);
+		return join(this.baseDir, subDir, chunkHash);
+	}
+	/**
+	* Save a chunk to the local filesystem
+	*/
+	async saveChunk(chunkHash, data) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		const chunkDir = dirname(chunkPath);
+		try {
+			await promises.mkdir(chunkDir, { recursive: true });
+			await promises.writeFile(chunkPath, data);
+		} catch (error) {
+			throw new Error(`Failed to save chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Get a chunk from the local filesystem
+	*/
+	async getChunk(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			return await promises.readFile(chunkPath);
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw new Error(`Failed to get chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Check if a chunk exists in the local filesystem
+	*/
+	async chunkExists(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			await promises.access(chunkPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Check if multiple chunks exist in the local filesystem
+	*/
+	async chunksExist(chunkHashes) {
+		if (!this.initialized) await this.initialize();
+		return await Promise.all(chunkHashes.map((hash) => this.chunkExists(hash)));
+	}
+	/**
+	* Get a readable stream for a chunk
+	*/
+	async getChunkStream(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		if (!existsSync(chunkPath)) return null;
+		try {
+			return createReadStream(chunkPath);
+		} catch (error) {
+			throw new Error(`Failed to create stream for chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Delete a chunk from the local filesystem
+	*/
+	async deleteChunk(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			await promises.unlink(chunkPath);
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw new Error(`Failed to delete chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Clean up resources (no-op for local storage)
+	*/
+	async cleanup() {
+		this.initialized = false;
+	}
+};
+
+//#endregion
+//#region src/memory-database-adapter.ts
+/**
+* In-memory database adapter for testing and development
+*
+* This adapter stores all data in memory and is useful for:
+* - Unit testing without database dependencies
+* - Development and prototyping
+* - Simple deployments that don't require persistence
+*/
+var MemoryDatabaseAdapter = class {
+	files = /* @__PURE__ */ new Map();
+	chunks = /* @__PURE__ */ new Map();
+	fileChunks = /* @__PURE__ */ new Map();
+	async initialize() {}
+	async createFile(fileId, options) {
+		if (this.files.has(fileId)) throw new Error(`File ${fileId} already exists`);
+		const now = /* @__PURE__ */ new Date();
+		const file = {
+			fileId,
+			filename: options.filename,
+			size: options.size,
+			mimeType: options.mimeType,
+			fileHash: options.fileHash,
+			uploadToken: options.uploadToken,
+			chunkSize: options.chunkSize,
+			totalChunks: options.totalChunks,
+			uploadedChunks: 0,
+			status: "pending",
+			createdAt: now,
+			updatedAt: now
+		};
+		this.files.set(fileId, file);
+		return { ...file };
+	}
+	async getFile(fileId) {
+		const file = this.files.get(fileId);
+		return file ? { ...file } : null;
+	}
+	async getFileByHash(fileHash) {
+		for (const file of this.files.values()) if (file.fileHash === fileHash) return { ...file };
+		return null;
+	}
+	async getFileByToken(uploadToken) {
+		for (const file of this.files.values()) if (file.uploadToken === uploadToken) return { ...file };
+		return null;
+	}
+	async updateFile(fileId, options) {
+		const file = this.files.get(fileId);
+		if (!file) throw new Error(`File ${fileId} not found`);
+		const updated = {
+			...file,
+			...options,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.files.set(fileId, updated);
+		return { ...updated };
+	}
+	async deleteFile(fileId) {
+		this.files.delete(fileId);
+	}
+	async upsertChunk(chunkHash, size) {
+		const existing = this.chunks.get(chunkHash);
+		if (existing) {
+			const updated = {
+				...existing,
+				refCount: existing.refCount + 1
+			};
+			this.chunks.set(chunkHash, updated);
+			return { ...updated };
+		}
+		const chunk = {
+			chunkHash,
+			size,
+			refCount: 1,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.chunks.set(chunkHash, chunk);
+		return { ...chunk };
+	}
+	async getChunk(chunkHash) {
+		const chunk = this.chunks.get(chunkHash);
+		return chunk ? { ...chunk } : null;
+	}
+	async chunkExists(chunkHash) {
+		return this.chunks.has(chunkHash);
+	}
+	async chunksExist(chunkHashes) {
+		return chunkHashes.map((hash) => this.chunks.has(hash));
+	}
+	async decrementChunkRef(chunkHash) {
+		const chunk = this.chunks.get(chunkHash);
+		if (!chunk) return;
+		if (chunk.refCount <= 1) this.chunks.delete(chunkHash);
+		else {
+			const updated = {
+				...chunk,
+				refCount: chunk.refCount - 1
+			};
+			this.chunks.set(chunkHash, updated);
+		}
+	}
+	async createFileChunk(fileId, chunkHash, chunkIndex) {
+		const fileChunk = {
+			fileId,
+			chunkHash,
+			chunkIndex,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		const fileChunks = this.fileChunks.get(fileId) || [];
+		fileChunks.push(fileChunk);
+		this.fileChunks.set(fileId, fileChunks);
+		return { ...fileChunk };
+	}
+	async getFileChunks(fileId) {
+		return (this.fileChunks.get(fileId) || []).slice().sort((a, b) => a.chunkIndex - b.chunkIndex).map((fc) => ({ ...fc }));
+	}
+	async getFileChunkHashes(fileId) {
+		return (await this.getFileChunks(fileId)).map((fc) => fc.chunkHash);
+	}
+	async deleteFileChunks(fileId) {
+		this.fileChunks.delete(fileId);
+	}
+	async transaction(callback) {
+		return callback();
+	}
+	async cleanup() {
+		this.files.clear();
+		this.chunks.clear();
+		this.fileChunks.clear();
+	}
+};
+
+//#endregion
+//#region src/upload-service.ts
+/**
+* Upload service for handling file uploads with chunking and deduplication
+*/
+var UploadService = class {
+	storageAdapter;
+	databaseAdapter;
+	jwtSecret;
+	tokenExpiration;
+	minChunkSize;
+	maxChunkSize;
+	constructor(options) {
+		this.storageAdapter = options.storageAdapter;
+		this.databaseAdapter = options.databaseAdapter;
+		this.jwtSecret = options.jwtSecret;
+		this.tokenExpiration = options.tokenExpiration || 1440 * 60;
+		this.minChunkSize = options.minChunkSize || 256 * 1024;
+		this.maxChunkSize = options.maxChunkSize || 10 * 1024 * 1024;
+	}
+	/**
+	* Initialize the upload service
+	*/
+	async initialize() {
+		await this.storageAdapter.initialize();
+		await this.databaseAdapter.initialize();
+	}
+	/**
+	* Clean up resources
+	*/
+	async cleanup() {
+		await this.storageAdapter.cleanup();
+		await this.databaseAdapter.cleanup();
+	}
+	/**
+	* Generate a unique file ID
+	*/
+	generateFileId() {
+		return randomBytes(16).toString("hex");
+	}
+	/**
+	* Generate an upload token
+	*/
+	generateUploadToken(fileId) {
+		return sign({
+			fileId,
+			type: "upload"
+		}, this.jwtSecret, { expiresIn: this.tokenExpiration });
+	}
+	/**
+	* Verify an upload token
+	*/
+	verifyUploadToken(token) {
+		try {
+			const payload = verify(token, this.jwtSecret);
+			if (payload.type !== "upload") throw new Error("Invalid token type");
+			return { fileId: payload.fileId };
+		} catch (error) {
+			throw new Error(`Invalid upload token: ${error.message}`);
+		}
+	}
+	/**
+	* Negotiate chunk size based on file size and client preference
+	*/
+	negotiateChunkSize(fileSize, clientChunkSize) {
+		if (clientChunkSize) {
+			if (clientChunkSize > this.maxChunkSize) return this.maxChunkSize;
+			return clientChunkSize;
+		}
+		if (fileSize < 10 * 1024 * 1024) return Math.max(256 * 1024, this.minChunkSize);
+		else if (fileSize < 100 * 1024 * 1024) return Math.max(1024 * 1024, this.minChunkSize);
+		else if (fileSize < 1024 * 1024 * 1024) return Math.max(2 * 1024 * 1024, this.minChunkSize);
+		else return Math.max(5 * 1024 * 1024, this.minChunkSize);
+	}
+	/**
+	* Create a new file upload session
+	*
+	* Generates a unique file ID and upload token, negotiates chunk size,
+	* and saves file metadata to the database.
+	*/
+	async createFile(request) {
+		const fileId = this.generateFileId();
+		const uploadToken = this.generateUploadToken(fileId);
+		const chunkSize = this.negotiateChunkSize(request.fileSize, request.preferredChunkSize);
+		const totalChunks = Math.ceil(request.fileSize / chunkSize);
+		await this.databaseAdapter.createFile(fileId, {
+			filename: request.fileName,
+			size: request.fileSize,
+			mimeType: request.fileType,
+			fileHash: "",
+			uploadToken,
+			chunkSize,
+			totalChunks
+		});
+		return {
+			uploadToken,
+			negotiatedChunkSize: chunkSize
+		};
+	}
+	/**
+	* Verify file and chunk hashes for instant upload (秒传)
+	*
+	* Checks if the file hash already exists (full instant upload)
+	* or if any chunks already exist (partial instant upload).
+	* For existing chunks, automatically creates file-chunk relationships.
+	*/
+	async verifyHash(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		if (request.fileHash) {
+			const existingFile = await this.databaseAdapter.getFileByHash(request.fileHash);
+			if (existingFile && existingFile.status === "completed") return {
+				fileExists: true,
+				fileUrl: existingFile.url,
+				existingChunks: [],
+				missingChunks: []
+			};
+		}
+		if (request.chunkHashes && request.chunkHashes.length > 0) {
+			const chunkExistence = await this.databaseAdapter.chunksExist(request.chunkHashes);
+			const existingChunks = [];
+			const missingChunks = [];
+			for (let index = 0; index < chunkExistence.length; index++) if (chunkExistence[index]) {
+				existingChunks.push(index);
+				const chunkHash = request.chunkHashes[index];
+				try {
+					if (!(await this.databaseAdapter.getFileChunks(fileId)).some((fc) => fc.chunkIndex === index && fc.chunkHash === chunkHash)) {
+						await this.databaseAdapter.createFileChunk(fileId, chunkHash, index);
+						const chunk = await this.databaseAdapter.getChunk(chunkHash);
+						if (chunk) await this.databaseAdapter.upsertChunk(chunkHash, chunk.size);
+					}
+				} catch (error) {
+					console.error(`Failed to create file-chunk relationship for chunk ${index}:`, error);
+				}
+			} else missingChunks.push(index);
+			const uploadedChunks = (await this.databaseAdapter.getFileChunks(fileId)).length;
+			const status = uploadedChunks === file.totalChunks ? "completed" : uploadedChunks > 0 ? "uploading" : "pending";
+			await this.databaseAdapter.updateFile(fileId, {
+				uploadedChunks,
+				status
+			});
+			return {
+				fileExists: false,
+				existingChunks,
+				missingChunks
+			};
+		}
+		return {
+			fileExists: false,
+			existingChunks: [],
+			missingChunks: []
+		};
+	}
+	/**
+	* Upload a chunk
+	*
+	* Validates the upload token and chunk hash, saves the chunk to storage
+	* with deduplication, and updates file metadata.
+	*/
+	async uploadChunk(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		let chunkBuffer;
+		if (Buffer.isBuffer(request.chunk)) chunkBuffer = request.chunk;
+		else {
+			const arrayBuffer = await request.chunk.arrayBuffer();
+			chunkBuffer = Buffer.from(arrayBuffer);
+		}
+		if ((await import("spark-md5")).default.ArrayBuffer.hash(chunkBuffer) !== request.chunkHash) throw new Error("Chunk hash mismatch");
+		if (!await this.storageAdapter.chunkExists(request.chunkHash)) await this.storageAdapter.saveChunk(request.chunkHash, chunkBuffer);
+		await this.databaseAdapter.upsertChunk(request.chunkHash, chunkBuffer.length);
+		await this.databaseAdapter.createFileChunk(fileId, request.chunkHash, request.chunkIndex);
+		const uploadedChunks = (await this.databaseAdapter.getFileChunks(fileId)).length;
+		const status = uploadedChunks === file.totalChunks ? "completed" : "uploading";
+		await this.databaseAdapter.updateFile(fileId, {
+			uploadedChunks,
+			status
+		});
+		return {
+			success: true,
+			chunkHash: request.chunkHash
+		};
+	}
+	/**
+	* Merge file chunks (logical merge)
+	*
+	* Verifies all chunks are uploaded and updates file status to completed.
+	* Generates a file access URL.
+	*/
+	async mergeFile(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		if (file.uploadedChunks !== file.totalChunks) throw new Error(`Not all chunks uploaded: ${file.uploadedChunks}/${file.totalChunks}`);
+		const url = `/upload/files/${fileId}`;
+		await this.databaseAdapter.updateFile(fileId, {
+			fileHash: request.fileHash,
+			status: "completed",
+			completedAt: /* @__PURE__ */ new Date(),
+			url
+		});
+		return {
+			success: true,
+			fileUrl: url,
+			fileId
+		};
+	}
+	/**
+	* Get file metadata
+	*
+	* Retrieves file metadata from database without creating a stream.
+	*/
+	async getFileMetadata(fileId) {
+		return await this.databaseAdapter.getFile(fileId);
+	}
+	/**
+	* Get file stream for download
+	*
+	* Reads chunks in order and creates a stream pipeline for file output.
+	* Supports Range requests for partial content.
+	*/
+	async getFileStream(fileId, range) {
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file || file.status !== "completed") return null;
+		const chunkHashes = await this.databaseAdapter.getFileChunkHashes(fileId);
+		const { Readable } = await import("stream");
+		const storageAdapter = this.storageAdapter;
+		let currentChunkIndex = 0;
+		let bytesRead = 0;
+		const startByte = range?.start || 0;
+		const endByte = range?.end || file.size - 1;
+		return {
+			stream: new Readable({ async read() {
+				try {
+					while (currentChunkIndex < chunkHashes.length) {
+						const chunkHash = chunkHashes[currentChunkIndex];
+						const chunkData = await storageAdapter.getChunk(chunkHash);
+						if (!chunkData) {
+							this.destroy(/* @__PURE__ */ new Error(`Chunk ${chunkHash} not found`));
+							return;
+						}
+						const chunkStart = currentChunkIndex * file.chunkSize;
+						const chunkEnd = chunkStart + chunkData.length - 1;
+						if (chunkEnd < startByte) {
+							currentChunkIndex++;
+							continue;
+						}
+						if (chunkStart > endByte) {
+							this.push(null);
+							return;
+						}
+						let sliceStart = 0;
+						let sliceEnd = chunkData.length;
+						if (chunkStart < startByte) sliceStart = startByte - chunkStart;
+						if (chunkEnd > endByte) sliceEnd = endByte - chunkStart + 1;
+						const slicedData = chunkData.slice(sliceStart, sliceEnd);
+						this.push(slicedData);
+						bytesRead += slicedData.length;
+						currentChunkIndex++;
+						if (bytesRead >= endByte - startByte + 1) {
+							this.push(null);
+							return;
+						}
+						return;
+					}
+					this.push(null);
+				} catch (error) {
+					this.destroy(error);
+				}
+			} }),
+			size: range ? endByte - startByte + 1 : file.size,
+			mimeType: file.mimeType
+		};
+	}
+};
+
+//#endregion
+export { LocalStorageAdapter, MemoryDatabaseAdapter, UploadService };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["fs"],"sources":["../src/local-storage-adapter.ts","../src/memory-database-adapter.ts","../src/upload-service.ts"],"sourcesContent":["import { promises as fs } from \"fs\";\nimport { createReadStream, existsSync } from \"fs\";\nimport { join, dirname } from \"path\";\nimport { Readable } from \"stream\";\nimport type { StorageAdapter } from \"./storage-adapter\";\n\n/**\n * Options for LocalStorageAdapter\n */\nexport interface LocalStorageAdapterOptions {\n  /**\n   * Base directory for storing chunks\n   * @default './uploads'\n   */\n  baseDir?: string;\n}\n\n/**\n * Local filesystem storage adapter\n *\n * Stores chunks in the local filesystem using a directory structure\n * based on the first two characters of the chunk hash for better performance.\n *\n * Directory structure: baseDir/ab/abcdef123456...\n */\nexport class LocalStorageAdapter implements StorageAdapter {\n  private baseDir: string;\n  private initialized = false;\n\n  constructor(options: LocalStorageAdapterOptions = {}) {\n    this.baseDir = options.baseDir || \"./uploads\";\n  }\n\n  /**\n   * Initialize the storage adapter by creating the base directory\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      return;\n    }\n\n    try {\n      await fs.mkdir(this.baseDir, { recursive: true });\n      this.initialized = true;\n    } catch (error) {\n      throw new Error(`Failed to initialize local storage: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Get the file path for a chunk hash\n   * Uses the first two characters as a subdirectory for better performance\n   */\n  private getChunkPath(chunkHash: string): string {\n    if (chunkHash.length < 2) {\n      throw new Error(\"Chunk hash must be at least 2 characters long\");\n    }\n\n    const subDir = chunkHash.substring(0, 2);\n    return join(this.baseDir, subDir, chunkHash);\n  }\n\n  /**\n   * Save a chunk to the local filesystem\n   */\n  async saveChunk(chunkHash: string, data: Buffer): Promise<void> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const chunkPath = this.getChunkPath(chunkHash);\n    const chunkDir = dirname(chunkPath);\n\n    try {\n      // Create subdirectory if it doesn't exist\n      await fs.mkdir(chunkDir, { recursive: true });\n\n      // Write chunk data to file\n      await fs.writeFile(chunkPath, data);\n    } catch (error) {\n      throw new Error(`Failed to save chunk ${chunkHash}: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Get a chunk from the local filesystem\n   */\n  async getChunk(chunkHash: string): Promise<Buffer | null> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const chunkPath = this.getChunkPath(chunkHash);\n\n    try {\n      const data = await fs.readFile(chunkPath);\n      return data;\n    } catch (error: any) {\n      if (error.code === \"ENOENT\") {\n        return null;\n      }\n      throw new Error(`Failed to get chunk ${chunkHash}: ${error.message}`);\n    }\n  }\n\n  /**\n   * Check if a chunk exists in the local filesystem\n   */\n  async chunkExists(chunkHash: string): Promise<boolean> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const chunkPath = this.getChunkPath(chunkHash);\n\n    try {\n      await fs.access(chunkPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Check if multiple chunks exist in the local filesystem\n   */\n  async chunksExist(chunkHashes: string[]): Promise<boolean[]> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const results = await Promise.all(chunkHashes.map((hash) => this.chunkExists(hash)));\n\n    return results;\n  }\n\n  /**\n   * Get a readable stream for a chunk\n   */\n  async getChunkStream(chunkHash: string): Promise<Readable | null> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const chunkPath = this.getChunkPath(chunkHash);\n\n    // Check if file exists synchronously for stream creation\n    if (!existsSync(chunkPath)) {\n      return null;\n    }\n\n    try {\n      const stream = createReadStream(chunkPath);\n      return stream;\n    } catch (error) {\n      throw new Error(\n        `Failed to create stream for chunk ${chunkHash}: ${(error as Error).message}`,\n      );\n    }\n  }\n\n  /**\n   * Delete a chunk from the local filesystem\n   */\n  async deleteChunk(chunkHash: string): Promise<void> {\n    if (!this.initialized) {\n      await this.initialize();\n    }\n\n    const chunkPath = this.getChunkPath(chunkHash);\n\n    try {\n      await fs.unlink(chunkPath);\n    } catch (error: any) {\n      if (error.code === \"ENOENT\") {\n        // File doesn't exist, consider it deleted\n        return;\n      }\n      throw new Error(`Failed to delete chunk ${chunkHash}: ${error.message}`);\n    }\n  }\n\n  /**\n   * Clean up resources (no-op for local storage)\n   */\n  async cleanup(): Promise<void> {\n    // No cleanup needed for local filesystem\n    this.initialized = false;\n  }\n}\n","import type {\n  DatabaseAdapter,\n  FileMetadata,\n  ChunkEntity,\n  FileChunkEntity,\n  CreateFileOptions,\n  UpdateFileOptions,\n} from \"./database-adapter\";\n\n/**\n * In-memory database adapter for testing and development\n *\n * This adapter stores all data in memory and is useful for:\n * - Unit testing without database dependencies\n * - Development and prototyping\n * - Simple deployments that don't require persistence\n */\nexport class MemoryDatabaseAdapter implements DatabaseAdapter {\n  private files: Map<string, FileMetadata> = new Map();\n  private chunks: Map<string, ChunkEntity> = new Map();\n  private fileChunks: Map<string, FileChunkEntity[]> = new Map();\n\n  async initialize(): Promise<void> {\n    // No initialization needed for in-memory adapter\n  }\n\n  async createFile(fileId: string, options: CreateFileOptions): Promise<FileMetadata> {\n    if (this.files.has(fileId)) {\n      throw new Error(`File ${fileId} already exists`);\n    }\n\n    const now = new Date();\n    const file: FileMetadata = {\n      fileId,\n      filename: options.filename,\n      size: options.size,\n      mimeType: options.mimeType,\n      fileHash: options.fileHash,\n      uploadToken: options.uploadToken,\n      chunkSize: options.chunkSize,\n      totalChunks: options.totalChunks,\n      uploadedChunks: 0,\n      status: \"pending\",\n      createdAt: now,\n      updatedAt: now,\n    };\n\n    this.files.set(fileId, file);\n    return { ...file };\n  }\n\n  async getFile(fileId: string): Promise<FileMetadata | null> {\n    const file = this.files.get(fileId);\n    return file ? { ...file } : null;\n  }\n\n  async getFileByHash(fileHash: string): Promise<FileMetadata | null> {\n    for (const file of this.files.values()) {\n      if (file.fileHash === fileHash) {\n        return { ...file };\n      }\n    }\n    return null;\n  }\n\n  async getFileByToken(uploadToken: string): Promise<FileMetadata | null> {\n    for (const file of this.files.values()) {\n      if (file.uploadToken === uploadToken) {\n        return { ...file };\n      }\n    }\n    return null;\n  }\n\n  async updateFile(fileId: string, options: UpdateFileOptions): Promise<FileMetadata> {\n    const file = this.files.get(fileId);\n    if (!file) {\n      throw new Error(`File ${fileId} not found`);\n    }\n\n    const updated: FileMetadata = {\n      ...file,\n      ...options,\n      updatedAt: new Date(),\n    };\n\n    this.files.set(fileId, updated);\n    return { ...updated };\n  }\n\n  async deleteFile(fileId: string): Promise<void> {\n    this.files.delete(fileId);\n  }\n\n  async upsertChunk(chunkHash: string, size: number): Promise<ChunkEntity> {\n    const existing = this.chunks.get(chunkHash);\n\n    if (existing) {\n      // Increment reference count\n      const updated: ChunkEntity = {\n        ...existing,\n        refCount: existing.refCount + 1,\n      };\n      this.chunks.set(chunkHash, updated);\n      return { ...updated };\n    }\n\n    // Create new chunk\n    const chunk: ChunkEntity = {\n      chunkHash,\n      size,\n      refCount: 1,\n      createdAt: new Date(),\n    };\n\n    this.chunks.set(chunkHash, chunk);\n    return { ...chunk };\n  }\n\n  async getChunk(chunkHash: string): Promise<ChunkEntity | null> {\n    const chunk = this.chunks.get(chunkHash);\n    return chunk ? { ...chunk } : null;\n  }\n\n  async chunkExists(chunkHash: string): Promise<boolean> {\n    return this.chunks.has(chunkHash);\n  }\n\n  async chunksExist(chunkHashes: string[]): Promise<boolean[]> {\n    return chunkHashes.map((hash) => this.chunks.has(hash));\n  }\n\n  async decrementChunkRef(chunkHash: string): Promise<void> {\n    const chunk = this.chunks.get(chunkHash);\n    if (!chunk) {\n      return;\n    }\n\n    if (chunk.refCount <= 1) {\n      // Delete chunk if reference count reaches 0\n      this.chunks.delete(chunkHash);\n    } else {\n      // Decrement reference count\n      const updated: ChunkEntity = {\n        ...chunk,\n        refCount: chunk.refCount - 1,\n      };\n      this.chunks.set(chunkHash, updated);\n    }\n  }\n\n  async createFileChunk(\n    fileId: string,\n    chunkHash: string,\n    chunkIndex: number,\n  ): Promise<FileChunkEntity> {\n    const fileChunk: FileChunkEntity = {\n      fileId,\n      chunkHash,\n      chunkIndex,\n      createdAt: new Date(),\n    };\n\n    const fileChunks = this.fileChunks.get(fileId) || [];\n    fileChunks.push(fileChunk);\n    this.fileChunks.set(fileId, fileChunks);\n\n    return { ...fileChunk };\n  }\n\n  async getFileChunks(fileId: string): Promise<FileChunkEntity[]> {\n    const fileChunks = this.fileChunks.get(fileId) || [];\n    // Sort by chunk index\n    return fileChunks\n      .slice()\n      .sort((a, b) => a.chunkIndex - b.chunkIndex)\n      .map((fc) => ({ ...fc }));\n  }\n\n  async getFileChunkHashes(fileId: string): Promise<string[]> {\n    const fileChunks = await this.getFileChunks(fileId);\n    return fileChunks.map((fc) => fc.chunkHash);\n  }\n\n  async deleteFileChunks(fileId: string): Promise<void> {\n    this.fileChunks.delete(fileId);\n  }\n\n  async transaction<T>(callback: () => Promise<T>): Promise<T> {\n    // For in-memory adapter, just execute the callback\n    // In a real database adapter, this would start a transaction\n    return callback();\n  }\n\n  async cleanup(): Promise<void> {\n    this.files.clear();\n    this.chunks.clear();\n    this.fileChunks.clear();\n  }\n}\n","import { randomBytes } from \"crypto\";\nimport { sign, verify } from \"jsonwebtoken\";\nimport type { StorageAdapter } from \"./storage-adapter\";\nimport type { DatabaseAdapter, FileMetadata } from \"./database-adapter\";\nimport type {\n  CreateFileRequest,\n  CreateFileResponse,\n  VerifyHashRequest,\n  VerifyHashResponse,\n  UploadChunkRequest,\n  UploadChunkResponse,\n  MergeFileRequest,\n  MergeFileResponse,\n  UploadToken,\n} from \"@chunkflowjs/protocol\";\n\n/**\n * Options for UploadService\n */\nexport interface UploadServiceOptions {\n  /** Storage adapter for chunk storage */\n  storageAdapter: StorageAdapter;\n\n  /** Database adapter for metadata storage */\n  databaseAdapter: DatabaseAdapter;\n\n  /** JWT secret for token generation and verification */\n  jwtSecret: string;\n\n  /** Token expiration time in seconds (default: 24 hours) */\n  tokenExpiration?: number;\n\n  /** Minimum chunk size in bytes (default: 256KB) */\n  minChunkSize?: number;\n\n  /** Maximum chunk size in bytes (default: 10MB) */\n  maxChunkSize?: number;\n\n  /** Default chunk size in bytes (default: 2MB) */\n  defaultChunkSize?: number;\n}\n\n/**\n * Upload service for handling file uploads with chunking and deduplication\n */\nexport class UploadService {\n  private storageAdapter: StorageAdapter;\n  private databaseAdapter: DatabaseAdapter;\n  private jwtSecret: string;\n  private tokenExpiration: number;\n  private minChunkSize: number;\n  private maxChunkSize: number;\n\n  constructor(options: UploadServiceOptions) {\n    this.storageAdapter = options.storageAdapter;\n    this.databaseAdapter = options.databaseAdapter;\n    this.jwtSecret = options.jwtSecret;\n    this.tokenExpiration = options.tokenExpiration || 24 * 60 * 60; // 24 hours\n    this.minChunkSize = options.minChunkSize || 256 * 1024; // 256KB\n    this.maxChunkSize = options.maxChunkSize || 10 * 1024 * 1024; // 10MB\n  }\n\n  /**\n   * Initialize the upload service\n   */\n  async initialize(): Promise<void> {\n    await this.storageAdapter.initialize();\n    await this.databaseAdapter.initialize();\n  }\n\n  /**\n   * Clean up resources\n   */\n  async cleanup(): Promise<void> {\n    await this.storageAdapter.cleanup();\n    await this.databaseAdapter.cleanup();\n  }\n\n  /**\n   * Generate a unique file ID\n   */\n  private generateFileId(): string {\n    return randomBytes(16).toString(\"hex\");\n  }\n\n  /**\n   * Generate an upload token\n   */\n  private generateUploadToken(fileId: string): string {\n    const payload = {\n      fileId,\n      type: \"upload\",\n    };\n\n    return sign(payload, this.jwtSecret, {\n      expiresIn: this.tokenExpiration,\n    });\n  }\n\n  /**\n   * Verify an upload token\n   */\n  private verifyUploadToken(token: string): { fileId: string } {\n    try {\n      const payload = verify(token, this.jwtSecret) as { fileId: string; type: string };\n\n      if (payload.type !== \"upload\") {\n        throw new Error(\"Invalid token type\");\n      }\n\n      return { fileId: payload.fileId };\n    } catch (error) {\n      throw new Error(`Invalid upload token: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Negotiate chunk size based on file size and client preference\n   */\n  private negotiateChunkSize(fileSize: number, clientChunkSize?: number): number {\n    // If client provides a chunk size, validate and use it\n    if (clientChunkSize) {\n      // Allow small chunk sizes for testing, but enforce max\n      if (clientChunkSize > this.maxChunkSize) {\n        return this.maxChunkSize;\n      }\n      // Only enforce minimum for auto-negotiated sizes\n      return clientChunkSize;\n    }\n\n    // Auto-negotiate based on file size\n    if (fileSize < 10 * 1024 * 1024) {\n      // < 10MB: use 256KB chunks\n      return Math.max(256 * 1024, this.minChunkSize);\n    } else if (fileSize < 100 * 1024 * 1024) {\n      // < 100MB: use 1MB chunks\n      return Math.max(1024 * 1024, this.minChunkSize);\n    } else if (fileSize < 1024 * 1024 * 1024) {\n      // < 1GB: use 2MB chunks\n      return Math.max(2 * 1024 * 1024, this.minChunkSize);\n    } else {\n      // >= 1GB: use 5MB chunks\n      return Math.max(5 * 1024 * 1024, this.minChunkSize);\n    }\n  }\n\n  /**\n   * Create a new file upload session\n   *\n   * Generates a unique file ID and upload token, negotiates chunk size,\n   * and saves file metadata to the database.\n   */\n  async createFile(request: CreateFileRequest): Promise<CreateFileResponse> {\n    // Generate file ID and upload token\n    const fileId = this.generateFileId();\n    const uploadToken = this.generateUploadToken(fileId);\n\n    // Negotiate chunk size\n    const chunkSize = this.negotiateChunkSize(request.fileSize, request.preferredChunkSize);\n\n    // Calculate total chunks\n    const totalChunks = Math.ceil(request.fileSize / chunkSize);\n\n    // Save file metadata to database\n    await this.databaseAdapter.createFile(fileId, {\n      filename: request.fileName,\n      size: request.fileSize,\n      mimeType: request.fileType,\n      fileHash: \"\", // Will be set during hash verification\n      uploadToken,\n      chunkSize,\n      totalChunks,\n    });\n\n    return {\n      uploadToken: uploadToken as unknown as UploadToken,\n      negotiatedChunkSize: chunkSize,\n    };\n  }\n\n  /**\n   * Verify file and chunk hashes for instant upload (秒传)\n   *\n   * Checks if the file hash already exists (full instant upload)\n   * or if any chunks already exist (partial instant upload).\n   * For existing chunks, automatically creates file-chunk relationships.\n   */\n  async verifyHash(request: VerifyHashRequest): Promise<VerifyHashResponse> {\n    // Verify upload token\n    const { fileId } = this.verifyUploadToken(request.uploadToken);\n\n    // Get file metadata\n    const file = await this.databaseAdapter.getFile(fileId);\n    if (!file) {\n      throw new Error(\"File not found\");\n    }\n\n    // Check if file hash already exists (full instant upload)\n    if (request.fileHash) {\n      const existingFile = await this.databaseAdapter.getFileByHash(request.fileHash);\n      if (existingFile && existingFile.status === \"completed\") {\n        // File already exists, return instant upload response\n        return {\n          fileExists: true,\n          fileUrl: existingFile.url,\n          existingChunks: [],\n          missingChunks: [],\n        };\n      }\n    }\n\n    // Check which chunks already exist (partial instant upload)\n    if (request.chunkHashes && request.chunkHashes.length > 0) {\n      const chunkExistence = await this.databaseAdapter.chunksExist(request.chunkHashes);\n\n      const existingChunks: number[] = [];\n      const missingChunks: number[] = [];\n\n      // Process each chunk\n      for (let index = 0; index < chunkExistence.length; index++) {\n        const exists = chunkExistence[index];\n        if (exists) {\n          existingChunks.push(index);\n\n          // Automatically create file-chunk relationship for existing chunks\n          const chunkHash = request.chunkHashes[index];\n          try {\n            // Check if relationship already exists\n            const existingRelations = await this.databaseAdapter.getFileChunks(fileId);\n            const relationExists = existingRelations.some(\n              (fc) => fc.chunkIndex === index && fc.chunkHash === chunkHash,\n            );\n\n            if (!relationExists) {\n              // Create file-chunk relationship\n              await this.databaseAdapter.createFileChunk(fileId, chunkHash, index);\n\n              // Increment chunk reference count\n              const chunk = await this.databaseAdapter.getChunk(chunkHash);\n              if (chunk) {\n                await this.databaseAdapter.upsertChunk(chunkHash, chunk.size);\n              }\n            }\n          } catch (error) {\n            // Log error but don't fail the verification\n            console.error(`Failed to create file-chunk relationship for chunk ${index}:`, error);\n          }\n        } else {\n          missingChunks.push(index);\n        }\n      }\n\n      // Update file metadata with uploaded chunks count\n      const fileChunks = await this.databaseAdapter.getFileChunks(fileId);\n      const uploadedChunks = fileChunks.length;\n      const status =\n        uploadedChunks === file.totalChunks\n          ? \"completed\"\n          : uploadedChunks > 0\n            ? \"uploading\"\n            : \"pending\";\n\n      await this.databaseAdapter.updateFile(fileId, {\n        uploadedChunks,\n        status,\n      });\n\n      return {\n        fileExists: false,\n        existingChunks,\n        missingChunks,\n      };\n    }\n\n    return {\n      fileExists: false,\n      existingChunks: [],\n      missingChunks: [],\n    };\n  }\n\n  /**\n   * Upload a chunk\n   *\n   * Validates the upload token and chunk hash, saves the chunk to storage\n   * with deduplication, and updates file metadata.\n   */\n  async uploadChunk(request: UploadChunkRequest): Promise<UploadChunkResponse> {\n    // Verify upload token\n    const { fileId } = this.verifyUploadToken(request.uploadToken);\n\n    // Get file metadata\n    const file = await this.databaseAdapter.getFile(fileId);\n    if (!file) {\n      throw new Error(\"File not found\");\n    }\n\n    // Convert chunk to Buffer if it's a Blob\n    let chunkBuffer: Buffer;\n    if (Buffer.isBuffer(request.chunk)) {\n      chunkBuffer = request.chunk;\n    } else {\n      // It's a Blob, convert to Buffer\n      const arrayBuffer = await request.chunk.arrayBuffer();\n      chunkBuffer = Buffer.from(arrayBuffer);\n    }\n\n    // Verify chunk hash\n    const SparkMD5 = (await import(\"spark-md5\")).default;\n    // Use the same method as in tests - hash the buffer directly\n    // @ts-ignore - SparkMD5 accepts Buffer but TypeScript doesn't recognize it\n    const calculatedHash = SparkMD5.ArrayBuffer.hash(chunkBuffer);\n    if (calculatedHash !== request.chunkHash) {\n      throw new Error(\"Chunk hash mismatch\");\n    }\n\n    // Check if chunk already exists in storage\n    const chunkExists = await this.storageAdapter.chunkExists(request.chunkHash);\n\n    if (!chunkExists) {\n      // Save chunk to storage (deduplication happens here)\n      await this.storageAdapter.saveChunk(request.chunkHash, chunkBuffer);\n    }\n\n    // Upsert chunk in database (increment ref count if exists)\n    await this.databaseAdapter.upsertChunk(request.chunkHash, chunkBuffer.length);\n\n    // Create file-chunk relationship\n    await this.databaseAdapter.createFileChunk(fileId, request.chunkHash, request.chunkIndex);\n\n    // Get actual uploaded chunks count\n    const fileChunks = await this.databaseAdapter.getFileChunks(fileId);\n    const uploadedChunks = fileChunks.length;\n    const status = uploadedChunks === file.totalChunks ? \"completed\" : \"uploading\";\n\n    await this.databaseAdapter.updateFile(fileId, {\n      uploadedChunks,\n      status,\n    });\n\n    return {\n      success: true,\n      chunkHash: request.chunkHash,\n    };\n  }\n\n  /**\n   * Merge file chunks (logical merge)\n   *\n   * Verifies all chunks are uploaded and updates file status to completed.\n   * Generates a file access URL.\n   */\n  async mergeFile(request: MergeFileRequest): Promise<MergeFileResponse> {\n    // Verify upload token\n    const { fileId } = this.verifyUploadToken(request.uploadToken);\n\n    // Get file metadata\n    const file = await this.databaseAdapter.getFile(fileId);\n    if (!file) {\n      throw new Error(\"File not found\");\n    }\n\n    // Verify all chunks are uploaded\n    if (file.uploadedChunks !== file.totalChunks) {\n      throw new Error(`Not all chunks uploaded: ${file.uploadedChunks}/${file.totalChunks}`);\n    }\n\n    // Generate file access URL\n    const url = `/upload/files/${fileId}`;\n\n    // Update file with hash, status, and URL\n    await this.databaseAdapter.updateFile(fileId, {\n      fileHash: request.fileHash,\n      status: \"completed\",\n      completedAt: new Date(),\n      url,\n    });\n\n    return {\n      success: true,\n      fileUrl: url,\n      fileId,\n    };\n  }\n\n  /**\n   * Get file metadata\n   *\n   * Retrieves file metadata from database without creating a stream.\n   */\n  async getFileMetadata(fileId: string): Promise<FileMetadata | null> {\n    return await this.databaseAdapter.getFile(fileId);\n  }\n\n  /**\n   * Get file stream for download\n   *\n   * Reads chunks in order and creates a stream pipeline for file output.\n   * Supports Range requests for partial content.\n   */\n  async getFileStream(\n    fileId: string,\n    range?: { start: number; end: number },\n  ): Promise<{ stream: NodeJS.ReadableStream; size: number; mimeType: string } | null> {\n    // Get file metadata\n    const file = await this.databaseAdapter.getFile(fileId);\n    if (!file || file.status !== \"completed\") {\n      return null;\n    }\n\n    // Get chunk hashes in order\n    const chunkHashes = await this.databaseAdapter.getFileChunkHashes(fileId);\n\n    // Create a readable stream that reads chunks in order\n    const { Readable } = await import(\"stream\");\n    const storageAdapter = this.storageAdapter;\n\n    let currentChunkIndex = 0;\n    let bytesRead = 0;\n    const startByte = range?.start || 0;\n    const endByte = range?.end || file.size - 1;\n\n    const stream = new Readable({\n      async read() {\n        try {\n          // Skip chunks until we find one in the requested range\n          while (currentChunkIndex < chunkHashes.length) {\n            const chunkHash = chunkHashes[currentChunkIndex];\n            const chunkData = await storageAdapter.getChunk(chunkHash);\n\n            if (!chunkData) {\n              this.destroy(new Error(`Chunk ${chunkHash} not found`));\n              return;\n            }\n\n            // Handle range requests\n            const chunkStart = currentChunkIndex * file.chunkSize;\n            const chunkEnd = chunkStart + chunkData.length - 1;\n\n            // Skip chunks outside the requested range\n            if (chunkEnd < startByte) {\n              currentChunkIndex++;\n              continue;\n            }\n\n            // Stop if we've passed the requested range\n            if (chunkStart > endByte) {\n              this.push(null); // End of stream\n              return;\n            }\n\n            // This chunk is in the requested range\n            let sliceStart = 0;\n            let sliceEnd = chunkData.length;\n\n            if (chunkStart < startByte) {\n              sliceStart = startByte - chunkStart;\n            }\n\n            if (chunkEnd > endByte) {\n              sliceEnd = endByte - chunkStart + 1;\n            }\n\n            const slicedData = chunkData.slice(sliceStart, sliceEnd);\n            this.push(slicedData);\n\n            bytesRead += slicedData.length;\n            currentChunkIndex++;\n\n            // Check if we've sent all requested bytes\n            if (bytesRead >= endByte - startByte + 1) {\n              this.push(null); // End of stream\n              return;\n            }\n\n            // Exit the loop to allow backpressure handling\n            return;\n          }\n\n          // All chunks processed\n          this.push(null); // End of stream\n        } catch (error) {\n          this.destroy(error as Error);\n        }\n      },\n    });\n\n    const size = range ? endByte - startByte + 1 : file.size;\n\n    return {\n      stream,\n      size,\n      mimeType: file.mimeType,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAyBA,IAAa,sBAAb,MAA2D;CACzD,AAAQ;CACR,AAAQ,cAAc;CAEtB,YAAY,UAAsC,EAAE,EAAE;AACpD,OAAK,UAAU,QAAQ,WAAW;;;;;CAMpC,MAAM,aAA4B;AAChC,MAAI,KAAK,YACP;AAGF,MAAI;AACF,SAAMA,SAAG,MAAM,KAAK,SAAS,EAAE,WAAW,MAAM,CAAC;AACjD,QAAK,cAAc;WACZ,OAAO;AACd,SAAM,IAAI,MAAM,uCAAwC,MAAgB,UAAU;;;;;;;CAQtF,AAAQ,aAAa,WAA2B;AAC9C,MAAI,UAAU,SAAS,EACrB,OAAM,IAAI,MAAM,gDAAgD;EAGlE,MAAM,SAAS,UAAU,UAAU,GAAG,EAAE;AACxC,SAAO,KAAK,KAAK,SAAS,QAAQ,UAAU;;;;;CAM9C,MAAM,UAAU,WAAmB,MAA6B;AAC9D,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;EAGzB,MAAM,YAAY,KAAK,aAAa,UAAU;EAC9C,MAAM,WAAW,QAAQ,UAAU;AAEnC,MAAI;AAEF,SAAMA,SAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;AAG7C,SAAMA,SAAG,UAAU,WAAW,KAAK;WAC5B,OAAO;AACd,SAAM,IAAI,MAAM,wBAAwB,UAAU,IAAK,MAAgB,UAAU;;;;;;CAOrF,MAAM,SAAS,WAA2C;AACxD,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;EAGzB,MAAM,YAAY,KAAK,aAAa,UAAU;AAE9C,MAAI;AAEF,UADa,MAAMA,SAAG,SAAS,UAAU;WAElC,OAAY;AACnB,OAAI,MAAM,SAAS,SACjB,QAAO;AAET,SAAM,IAAI,MAAM,uBAAuB,UAAU,IAAI,MAAM,UAAU;;;;;;CAOzE,MAAM,YAAY,WAAqC;AACrD,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;EAGzB,MAAM,YAAY,KAAK,aAAa,UAAU;AAE9C,MAAI;AACF,SAAMA,SAAG,OAAO,UAAU;AAC1B,UAAO;UACD;AACN,UAAO;;;;;;CAOX,MAAM,YAAY,aAA2C;AAC3D,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;AAKzB,SAFgB,MAAM,QAAQ,IAAI,YAAY,KAAK,SAAS,KAAK,YAAY,KAAK,CAAC,CAAC;;;;;CAQtF,MAAM,eAAe,WAA6C;AAChE,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;EAGzB,MAAM,YAAY,KAAK,aAAa,UAAU;AAG9C,MAAI,CAAC,WAAW,UAAU,CACxB,QAAO;AAGT,MAAI;AAEF,UADe,iBAAiB,UAAU;WAEnC,OAAO;AACd,SAAM,IAAI,MACR,qCAAqC,UAAU,IAAK,MAAgB,UACrE;;;;;;CAOL,MAAM,YAAY,WAAkC;AAClD,MAAI,CAAC,KAAK,YACR,OAAM,KAAK,YAAY;EAGzB,MAAM,YAAY,KAAK,aAAa,UAAU;AAE9C,MAAI;AACF,SAAMA,SAAG,OAAO,UAAU;WACnB,OAAY;AACnB,OAAI,MAAM,SAAS,SAEjB;AAEF,SAAM,IAAI,MAAM,0BAA0B,UAAU,IAAI,MAAM,UAAU;;;;;;CAO5E,MAAM,UAAyB;AAE7B,OAAK,cAAc;;;;;;;;;;;;;;AC1KvB,IAAa,wBAAb,MAA8D;CAC5D,AAAQ,wBAAmC,IAAI,KAAK;CACpD,AAAQ,yBAAmC,IAAI,KAAK;CACpD,AAAQ,6BAA6C,IAAI,KAAK;CAE9D,MAAM,aAA4B;CAIlC,MAAM,WAAW,QAAgB,SAAmD;AAClF,MAAI,KAAK,MAAM,IAAI,OAAO,CACxB,OAAM,IAAI,MAAM,QAAQ,OAAO,iBAAiB;EAGlD,MAAM,sBAAM,IAAI,MAAM;EACtB,MAAM,OAAqB;GACzB;GACA,UAAU,QAAQ;GAClB,MAAM,QAAQ;GACd,UAAU,QAAQ;GAClB,UAAU,QAAQ;GAClB,aAAa,QAAQ;GACrB,WAAW,QAAQ;GACnB,aAAa,QAAQ;GACrB,gBAAgB;GAChB,QAAQ;GACR,WAAW;GACX,WAAW;GACZ;AAED,OAAK,MAAM,IAAI,QAAQ,KAAK;AAC5B,SAAO,EAAE,GAAG,MAAM;;CAGpB,MAAM,QAAQ,QAA8C;EAC1D,MAAM,OAAO,KAAK,MAAM,IAAI,OAAO;AACnC,SAAO,OAAO,EAAE,GAAG,MAAM,GAAG;;CAG9B,MAAM,cAAc,UAAgD;AAClE,OAAK,MAAM,QAAQ,KAAK,MAAM,QAAQ,CACpC,KAAI,KAAK,aAAa,SACpB,QAAO,EAAE,GAAG,MAAM;AAGtB,SAAO;;CAGT,MAAM,eAAe,aAAmD;AACtE,OAAK,MAAM,QAAQ,KAAK,MAAM,QAAQ,CACpC,KAAI,KAAK,gBAAgB,YACvB,QAAO,EAAE,GAAG,MAAM;AAGtB,SAAO;;CAGT,MAAM,WAAW,QAAgB,SAAmD;EAClF,MAAM,OAAO,KAAK,MAAM,IAAI,OAAO;AACnC,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,QAAQ,OAAO,YAAY;EAG7C,MAAM,UAAwB;GAC5B,GAAG;GACH,GAAG;GACH,2BAAW,IAAI,MAAM;GACtB;AAED,OAAK,MAAM,IAAI,QAAQ,QAAQ;AAC/B,SAAO,EAAE,GAAG,SAAS;;CAGvB,MAAM,WAAW,QAA+B;AAC9C,OAAK,MAAM,OAAO,OAAO;;CAG3B,MAAM,YAAY,WAAmB,MAAoC;EACvE,MAAM,WAAW,KAAK,OAAO,IAAI,UAAU;AAE3C,MAAI,UAAU;GAEZ,MAAM,UAAuB;IAC3B,GAAG;IACH,UAAU,SAAS,WAAW;IAC/B;AACD,QAAK,OAAO,IAAI,WAAW,QAAQ;AACnC,UAAO,EAAE,GAAG,SAAS;;EAIvB,MAAM,QAAqB;GACzB;GACA;GACA,UAAU;GACV,2BAAW,IAAI,MAAM;GACtB;AAED,OAAK,OAAO,IAAI,WAAW,MAAM;AACjC,SAAO,EAAE,GAAG,OAAO;;CAGrB,MAAM,SAAS,WAAgD;EAC7D,MAAM,QAAQ,KAAK,OAAO,IAAI,UAAU;AACxC,SAAO,QAAQ,EAAE,GAAG,OAAO,GAAG;;CAGhC,MAAM,YAAY,WAAqC;AACrD,SAAO,KAAK,OAAO,IAAI,UAAU;;CAGnC,MAAM,YAAY,aAA2C;AAC3D,SAAO,YAAY,KAAK,SAAS,KAAK,OAAO,IAAI,KAAK,CAAC;;CAGzD,MAAM,kBAAkB,WAAkC;EACxD,MAAM,QAAQ,KAAK,OAAO,IAAI,UAAU;AACxC,MAAI,CAAC,MACH;AAGF,MAAI,MAAM,YAAY,EAEpB,MAAK,OAAO,OAAO,UAAU;OACxB;GAEL,MAAM,UAAuB;IAC3B,GAAG;IACH,UAAU,MAAM,WAAW;IAC5B;AACD,QAAK,OAAO,IAAI,WAAW,QAAQ;;;CAIvC,MAAM,gBACJ,QACA,WACA,YAC0B;EAC1B,MAAM,YAA6B;GACjC;GACA;GACA;GACA,2BAAW,IAAI,MAAM;GACtB;EAED,MAAM,aAAa,KAAK,WAAW,IAAI,OAAO,IAAI,EAAE;AACpD,aAAW,KAAK,UAAU;AAC1B,OAAK,WAAW,IAAI,QAAQ,WAAW;AAEvC,SAAO,EAAE,GAAG,WAAW;;CAGzB,MAAM,cAAc,QAA4C;AAG9D,UAFmB,KAAK,WAAW,IAAI,OAAO,IAAI,EAAE,EAGjD,OAAO,CACP,MAAM,GAAG,MAAM,EAAE,aAAa,EAAE,WAAW,CAC3C,KAAK,QAAQ,EAAE,GAAG,IAAI,EAAE;;CAG7B,MAAM,mBAAmB,QAAmC;AAE1D,UADmB,MAAM,KAAK,cAAc,OAAO,EACjC,KAAK,OAAO,GAAG,UAAU;;CAG7C,MAAM,iBAAiB,QAA+B;AACpD,OAAK,WAAW,OAAO,OAAO;;CAGhC,MAAM,YAAe,UAAwC;AAG3D,SAAO,UAAU;;CAGnB,MAAM,UAAyB;AAC7B,OAAK,MAAM,OAAO;AAClB,OAAK,OAAO,OAAO;AACnB,OAAK,WAAW,OAAO;;;;;;;;;ACxJ3B,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CAER,YAAY,SAA+B;AACzC,OAAK,iBAAiB,QAAQ;AAC9B,OAAK,kBAAkB,QAAQ;AAC/B,OAAK,YAAY,QAAQ;AACzB,OAAK,kBAAkB,QAAQ,mBAAmB,OAAU;AAC5D,OAAK,eAAe,QAAQ,gBAAgB,MAAM;AAClD,OAAK,eAAe,QAAQ,gBAAgB,KAAK,OAAO;;;;;CAM1D,MAAM,aAA4B;AAChC,QAAM,KAAK,eAAe,YAAY;AACtC,QAAM,KAAK,gBAAgB,YAAY;;;;;CAMzC,MAAM,UAAyB;AAC7B,QAAM,KAAK,eAAe,SAAS;AACnC,QAAM,KAAK,gBAAgB,SAAS;;;;;CAMtC,AAAQ,iBAAyB;AAC/B,SAAO,YAAY,GAAG,CAAC,SAAS,MAAM;;;;;CAMxC,AAAQ,oBAAoB,QAAwB;AAMlD,SAAO,KALS;GACd;GACA,MAAM;GACP,EAEoB,KAAK,WAAW,EACnC,WAAW,KAAK,iBACjB,CAAC;;;;;CAMJ,AAAQ,kBAAkB,OAAmC;AAC3D,MAAI;GACF,MAAM,UAAU,OAAO,OAAO,KAAK,UAAU;AAE7C,OAAI,QAAQ,SAAS,SACnB,OAAM,IAAI,MAAM,qBAAqB;AAGvC,UAAO,EAAE,QAAQ,QAAQ,QAAQ;WAC1B,OAAO;AACd,SAAM,IAAI,MAAM,yBAA0B,MAAgB,UAAU;;;;;;CAOxE,AAAQ,mBAAmB,UAAkB,iBAAkC;AAE7E,MAAI,iBAAiB;AAEnB,OAAI,kBAAkB,KAAK,aACzB,QAAO,KAAK;AAGd,UAAO;;AAIT,MAAI,WAAW,KAAK,OAAO,KAEzB,QAAO,KAAK,IAAI,MAAM,MAAM,KAAK,aAAa;WACrC,WAAW,MAAM,OAAO,KAEjC,QAAO,KAAK,IAAI,OAAO,MAAM,KAAK,aAAa;WACtC,WAAW,OAAO,OAAO,KAElC,QAAO,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,aAAa;MAGnD,QAAO,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,aAAa;;;;;;;;CAUvD,MAAM,WAAW,SAAyD;EAExE,MAAM,SAAS,KAAK,gBAAgB;EACpC,MAAM,cAAc,KAAK,oBAAoB,OAAO;EAGpD,MAAM,YAAY,KAAK,mBAAmB,QAAQ,UAAU,QAAQ,mBAAmB;EAGvF,MAAM,cAAc,KAAK,KAAK,QAAQ,WAAW,UAAU;AAG3D,QAAM,KAAK,gBAAgB,WAAW,QAAQ;GAC5C,UAAU,QAAQ;GAClB,MAAM,QAAQ;GACd,UAAU,QAAQ;GAClB,UAAU;GACV;GACA;GACA;GACD,CAAC;AAEF,SAAO;GACQ;GACb,qBAAqB;GACtB;;;;;;;;;CAUH,MAAM,WAAW,SAAyD;EAExE,MAAM,EAAE,WAAW,KAAK,kBAAkB,QAAQ,YAAY;EAG9D,MAAM,OAAO,MAAM,KAAK,gBAAgB,QAAQ,OAAO;AACvD,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,iBAAiB;AAInC,MAAI,QAAQ,UAAU;GACpB,MAAM,eAAe,MAAM,KAAK,gBAAgB,cAAc,QAAQ,SAAS;AAC/E,OAAI,gBAAgB,aAAa,WAAW,YAE1C,QAAO;IACL,YAAY;IACZ,SAAS,aAAa;IACtB,gBAAgB,EAAE;IAClB,eAAe,EAAE;IAClB;;AAKL,MAAI,QAAQ,eAAe,QAAQ,YAAY,SAAS,GAAG;GACzD,MAAM,iBAAiB,MAAM,KAAK,gBAAgB,YAAY,QAAQ,YAAY;GAElF,MAAM,iBAA2B,EAAE;GACnC,MAAM,gBAA0B,EAAE;AAGlC,QAAK,IAAI,QAAQ,GAAG,QAAQ,eAAe,QAAQ,QAEjD,KADe,eAAe,QAClB;AACV,mBAAe,KAAK,MAAM;IAG1B,MAAM,YAAY,QAAQ,YAAY;AACtC,QAAI;AAOF,SAAI,EALsB,MAAM,KAAK,gBAAgB,cAAc,OAAO,EACjC,MACtC,OAAO,GAAG,eAAe,SAAS,GAAG,cAAc,UACrD,EAEoB;AAEnB,YAAM,KAAK,gBAAgB,gBAAgB,QAAQ,WAAW,MAAM;MAGpE,MAAM,QAAQ,MAAM,KAAK,gBAAgB,SAAS,UAAU;AAC5D,UAAI,MACF,OAAM,KAAK,gBAAgB,YAAY,WAAW,MAAM,KAAK;;aAG1D,OAAO;AAEd,aAAQ,MAAM,sDAAsD,MAAM,IAAI,MAAM;;SAGtF,eAAc,KAAK,MAAM;GAM7B,MAAM,kBADa,MAAM,KAAK,gBAAgB,cAAc,OAAO,EACjC;GAClC,MAAM,SACJ,mBAAmB,KAAK,cACpB,cACA,iBAAiB,IACf,cACA;AAER,SAAM,KAAK,gBAAgB,WAAW,QAAQ;IAC5C;IACA;IACD,CAAC;AAEF,UAAO;IACL,YAAY;IACZ;IACA;IACD;;AAGH,SAAO;GACL,YAAY;GACZ,gBAAgB,EAAE;GAClB,eAAe,EAAE;GAClB;;;;;;;;CASH,MAAM,YAAY,SAA2D;EAE3E,MAAM,EAAE,WAAW,KAAK,kBAAkB,QAAQ,YAAY;EAG9D,MAAM,OAAO,MAAM,KAAK,gBAAgB,QAAQ,OAAO;AACvD,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,iBAAiB;EAInC,IAAI;AACJ,MAAI,OAAO,SAAS,QAAQ,MAAM,CAChC,eAAc,QAAQ;OACjB;GAEL,MAAM,cAAc,MAAM,QAAQ,MAAM,aAAa;AACrD,iBAAc,OAAO,KAAK,YAAY;;AAQxC,OAJkB,MAAM,OAAO,cAAc,QAGb,YAAY,KAAK,YAAY,KACtC,QAAQ,UAC7B,OAAM,IAAI,MAAM,sBAAsB;AAMxC,MAAI,CAFgB,MAAM,KAAK,eAAe,YAAY,QAAQ,UAAU,CAI1E,OAAM,KAAK,eAAe,UAAU,QAAQ,WAAW,YAAY;AAIrE,QAAM,KAAK,gBAAgB,YAAY,QAAQ,WAAW,YAAY,OAAO;AAG7E,QAAM,KAAK,gBAAgB,gBAAgB,QAAQ,QAAQ,WAAW,QAAQ,WAAW;EAIzF,MAAM,kBADa,MAAM,KAAK,gBAAgB,cAAc,OAAO,EACjC;EAClC,MAAM,SAAS,mBAAmB,KAAK,cAAc,cAAc;AAEnE,QAAM,KAAK,gBAAgB,WAAW,QAAQ;GAC5C;GACA;GACD,CAAC;AAEF,SAAO;GACL,SAAS;GACT,WAAW,QAAQ;GACpB;;;;;;;;CASH,MAAM,UAAU,SAAuD;EAErE,MAAM,EAAE,WAAW,KAAK,kBAAkB,QAAQ,YAAY;EAG9D,MAAM,OAAO,MAAM,KAAK,gBAAgB,QAAQ,OAAO;AACvD,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,iBAAiB;AAInC,MAAI,KAAK,mBAAmB,KAAK,YAC/B,OAAM,IAAI,MAAM,4BAA4B,KAAK,eAAe,GAAG,KAAK,cAAc;EAIxF,MAAM,MAAM,iBAAiB;AAG7B,QAAM,KAAK,gBAAgB,WAAW,QAAQ;GAC5C,UAAU,QAAQ;GAClB,QAAQ;GACR,6BAAa,IAAI,MAAM;GACvB;GACD,CAAC;AAEF,SAAO;GACL,SAAS;GACT,SAAS;GACT;GACD;;;;;;;CAQH,MAAM,gBAAgB,QAA8C;AAClE,SAAO,MAAM,KAAK,gBAAgB,QAAQ,OAAO;;;;;;;;CASnD,MAAM,cACJ,QACA,OACmF;EAEnF,MAAM,OAAO,MAAM,KAAK,gBAAgB,QAAQ,OAAO;AACvD,MAAI,CAAC,QAAQ,KAAK,WAAW,YAC3B,QAAO;EAIT,MAAM,cAAc,MAAM,KAAK,gBAAgB,mBAAmB,OAAO;EAGzE,MAAM,EAAE,aAAa,MAAM,OAAO;EAClC,MAAM,iBAAiB,KAAK;EAE5B,IAAI,oBAAoB;EACxB,IAAI,YAAY;EAChB,MAAM,YAAY,OAAO,SAAS;EAClC,MAAM,UAAU,OAAO,OAAO,KAAK,OAAO;AAqE1C,SAAO;GACL,QApEa,IAAI,SAAS,EAC1B,MAAM,OAAO;AACX,QAAI;AAEF,YAAO,oBAAoB,YAAY,QAAQ;MAC7C,MAAM,YAAY,YAAY;MAC9B,MAAM,YAAY,MAAM,eAAe,SAAS,UAAU;AAE1D,UAAI,CAAC,WAAW;AACd,YAAK,wBAAQ,IAAI,MAAM,SAAS,UAAU,YAAY,CAAC;AACvD;;MAIF,MAAM,aAAa,oBAAoB,KAAK;MAC5C,MAAM,WAAW,aAAa,UAAU,SAAS;AAGjD,UAAI,WAAW,WAAW;AACxB;AACA;;AAIF,UAAI,aAAa,SAAS;AACxB,YAAK,KAAK,KAAK;AACf;;MAIF,IAAI,aAAa;MACjB,IAAI,WAAW,UAAU;AAEzB,UAAI,aAAa,UACf,cAAa,YAAY;AAG3B,UAAI,WAAW,QACb,YAAW,UAAU,aAAa;MAGpC,MAAM,aAAa,UAAU,MAAM,YAAY,SAAS;AACxD,WAAK,KAAK,WAAW;AAErB,mBAAa,WAAW;AACxB;AAGA,UAAI,aAAa,UAAU,YAAY,GAAG;AACxC,YAAK,KAAK,KAAK;AACf;;AAIF;;AAIF,UAAK,KAAK,KAAK;aACR,OAAO;AACd,UAAK,QAAQ,MAAe;;MAGjC,CAAC;GAMA,MAJW,QAAQ,UAAU,YAAY,IAAI,KAAK;GAKlD,UAAU,KAAK;GAChB"}

package/dist/local-storage-adapter.d.ts

@@ -0,0 +1,20 @@
+import { Readable } from "stream";
+import type { StorageAdapter } from "./storage-adapter";
+export interface LocalStorageAdapterOptions {
+    baseDir?: string;
+}
+export declare class LocalStorageAdapter implements StorageAdapter {
+    private baseDir;
+    private initialized;
+    constructor(options?: LocalStorageAdapterOptions);
+    initialize(): Promise<void>;
+    private getChunkPath;
+    saveChunk(chunkHash: string, data: Buffer): Promise<void>;
+    getChunk(chunkHash: string): Promise<Buffer | null>;
+    chunkExists(chunkHash: string): Promise<boolean>;
+    chunksExist(chunkHashes: string[]): Promise<boolean[]>;
+    getChunkStream(chunkHash: string): Promise<Readable | null>;
+    deleteChunk(chunkHash: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=local-storage-adapter.d.ts.map

package/dist/local-storage-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-adapter.d.ts","sourceRoot":"","sources":["../src/local-storage-adapter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKxD,MAAM,WAAW,0BAA0B;IAKzC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAUD,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,0BAA+B;IAO9C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBjC,OAAO,CAAC,YAAY;IAYd,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBzD,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqBnD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkBhD,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAatD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAyB3D,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAI/B"}

package/dist/memory-database-adapter.d.ts

@@ -0,0 +1,25 @@
+import type { DatabaseAdapter, FileMetadata, ChunkEntity, FileChunkEntity, CreateFileOptions, UpdateFileOptions } from "./database-adapter";
+export declare class MemoryDatabaseAdapter implements DatabaseAdapter {
+    private files;
+    private chunks;
+    private fileChunks;
+    initialize(): Promise<void>;
+    createFile(fileId: string, options: CreateFileOptions): Promise<FileMetadata>;
+    getFile(fileId: string): Promise<FileMetadata | null>;
+    getFileByHash(fileHash: string): Promise<FileMetadata | null>;
+    getFileByToken(uploadToken: string): Promise<FileMetadata | null>;
+    updateFile(fileId: string, options: UpdateFileOptions): Promise<FileMetadata>;
+    deleteFile(fileId: string): Promise<void>;
+    upsertChunk(chunkHash: string, size: number): Promise<ChunkEntity>;
+    getChunk(chunkHash: string): Promise<ChunkEntity | null>;
+    chunkExists(chunkHash: string): Promise<boolean>;
+    chunksExist(chunkHashes: string[]): Promise<boolean[]>;
+    decrementChunkRef(chunkHash: string): Promise<void>;
+    createFileChunk(fileId: string, chunkHash: string, chunkIndex: number): Promise<FileChunkEntity>;
+    getFileChunks(fileId: string): Promise<FileChunkEntity[]>;
+    getFileChunkHashes(fileId: string): Promise<string[]>;
+    deleteFileChunks(fileId: string): Promise<void>;
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=memory-database-adapter.d.ts.map

package/dist/memory-database-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-database-adapter.d.ts","sourceRoot":"","sources":["../src/memory-database-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAU5B,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,UAAU,CAA6C;IAEzD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IAyB7E,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAKrD,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAS7D,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IASjE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IAgB7E,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAyBlE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAKxD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIhD,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAItD,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBnD,eAAe,CACnB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,CAAC;IAerB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IASzD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKrD,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAMtD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}