alepha 0.13.0 → 0.13.2

package/dist/file/index.cjs

@@ -1,1212 +0,0 @@
-let alepha = require("alepha");
-let node_fs = require("node:fs");
-let node_fs_promises = require("node:fs/promises");
-let node_path = require("node:path");
-let node_stream = require("node:stream");
-let node_url = require("node:url");
-
-//#region src/file/providers/FileSystemProvider.ts
-/**
-* FileSystem interface providing utilities for working with files.
-*/
-var FileSystemProvider = class {};
-
-//#endregion
-//#region src/file/services/FileDetector.ts
-/**
-* Service for detecting file types and getting content types.
-*
-* @example
-* ```typescript
-* const detector = alepha.inject(FileDetector);
-*
-* // Get content type from filename
-* const mimeType = detector.getContentType("image.png"); // "image/png"
-*
-* // Detect file type by magic bytes
-* const stream = createReadStream('image.png');
-* const result = await detector.detectFileType(stream, 'image.png');
-* console.log(result.mimeType); // 'image/png'
-* console.log(result.verified); // true if magic bytes match
-* ```
-*/
-var FileDetector = class FileDetector {
-	/**
-	* Magic byte signatures for common file formats.
-	* Each signature is represented as an array of bytes or null (wildcard).
-	*/
-	static MAGIC_BYTES = {
-		png: [{
-			signature: [
-				137,
-				80,
-				78,
-				71,
-				13,
-				10,
-				26,
-				10
-			],
-			mimeType: "image/png"
-		}],
-		jpg: [
-			{
-				signature: [
-					255,
-					216,
-					255,
-					224
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					225
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					226
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					227
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					232
-				],
-				mimeType: "image/jpeg"
-			}
-		],
-		jpeg: [
-			{
-				signature: [
-					255,
-					216,
-					255,
-					224
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					225
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					226
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					227
-				],
-				mimeType: "image/jpeg"
-			},
-			{
-				signature: [
-					255,
-					216,
-					255,
-					232
-				],
-				mimeType: "image/jpeg"
-			}
-		],
-		gif: [{
-			signature: [
-				71,
-				73,
-				70,
-				56,
-				55,
-				97
-			],
-			mimeType: "image/gif"
-		}, {
-			signature: [
-				71,
-				73,
-				70,
-				56,
-				57,
-				97
-			],
-			mimeType: "image/gif"
-		}],
-		webp: [{
-			signature: [
-				82,
-				73,
-				70,
-				70,
-				null,
-				null,
-				null,
-				null,
-				87,
-				69,
-				66,
-				80
-			],
-			mimeType: "image/webp"
-		}],
-		bmp: [{
-			signature: [66, 77],
-			mimeType: "image/bmp"
-		}],
-		ico: [{
-			signature: [
-				0,
-				0,
-				1,
-				0
-			],
-			mimeType: "image/x-icon"
-		}],
-		tiff: [{
-			signature: [
-				73,
-				73,
-				42,
-				0
-			],
-			mimeType: "image/tiff"
-		}, {
-			signature: [
-				77,
-				77,
-				0,
-				42
-			],
-			mimeType: "image/tiff"
-		}],
-		tif: [{
-			signature: [
-				73,
-				73,
-				42,
-				0
-			],
-			mimeType: "image/tiff"
-		}, {
-			signature: [
-				77,
-				77,
-				0,
-				42
-			],
-			mimeType: "image/tiff"
-		}],
-		pdf: [{
-			signature: [
-				37,
-				80,
-				68,
-				70,
-				45
-			],
-			mimeType: "application/pdf"
-		}],
-		zip: [
-			{
-				signature: [
-					80,
-					75,
-					3,
-					4
-				],
-				mimeType: "application/zip"
-			},
-			{
-				signature: [
-					80,
-					75,
-					5,
-					6
-				],
-				mimeType: "application/zip"
-			},
-			{
-				signature: [
-					80,
-					75,
-					7,
-					8
-				],
-				mimeType: "application/zip"
-			}
-		],
-		rar: [{
-			signature: [
-				82,
-				97,
-				114,
-				33,
-				26,
-				7
-			],
-			mimeType: "application/vnd.rar"
-		}],
-		"7z": [{
-			signature: [
-				55,
-				122,
-				188,
-				175,
-				39,
-				28
-			],
-			mimeType: "application/x-7z-compressed"
-		}],
-		tar: [{
-			signature: [
-				117,
-				115,
-				116,
-				97,
-				114
-			],
-			mimeType: "application/x-tar"
-		}],
-		gz: [{
-			signature: [31, 139],
-			mimeType: "application/gzip"
-		}],
-		tgz: [{
-			signature: [31, 139],
-			mimeType: "application/gzip"
-		}],
-		mp3: [
-			{
-				signature: [255, 251],
-				mimeType: "audio/mpeg"
-			},
-			{
-				signature: [255, 243],
-				mimeType: "audio/mpeg"
-			},
-			{
-				signature: [255, 242],
-				mimeType: "audio/mpeg"
-			},
-			{
-				signature: [
-					73,
-					68,
-					51
-				],
-				mimeType: "audio/mpeg"
-			}
-		],
-		wav: [{
-			signature: [
-				82,
-				73,
-				70,
-				70,
-				null,
-				null,
-				null,
-				null,
-				87,
-				65,
-				86,
-				69
-			],
-			mimeType: "audio/wav"
-		}],
-		ogg: [{
-			signature: [
-				79,
-				103,
-				103,
-				83
-			],
-			mimeType: "audio/ogg"
-		}],
-		flac: [{
-			signature: [
-				102,
-				76,
-				97,
-				67
-			],
-			mimeType: "audio/flac"
-		}],
-		mp4: [
-			{
-				signature: [
-					null,
-					null,
-					null,
-					null,
-					102,
-					116,
-					121,
-					112
-				],
-				mimeType: "video/mp4"
-			},
-			{
-				signature: [
-					null,
-					null,
-					null,
-					null,
-					102,
-					116,
-					121,
-					112,
-					105,
-					115,
-					111,
-					109
-				],
-				mimeType: "video/mp4"
-			},
-			{
-				signature: [
-					null,
-					null,
-					null,
-					null,
-					102,
-					116,
-					121,
-					112,
-					109,
-					112,
-					52,
-					50
-				],
-				mimeType: "video/mp4"
-			}
-		],
-		webm: [{
-			signature: [
-				26,
-				69,
-				223,
-				163
-			],
-			mimeType: "video/webm"
-		}],
-		avi: [{
-			signature: [
-				82,
-				73,
-				70,
-				70,
-				null,
-				null,
-				null,
-				null,
-				65,
-				86,
-				73,
-				32
-			],
-			mimeType: "video/x-msvideo"
-		}],
-		mov: [{
-			signature: [
-				null,
-				null,
-				null,
-				null,
-				102,
-				116,
-				121,
-				112,
-				113,
-				116,
-				32,
-				32
-			],
-			mimeType: "video/quicktime"
-		}],
-		mkv: [{
-			signature: [
-				26,
-				69,
-				223,
-				163
-			],
-			mimeType: "video/x-matroska"
-		}],
-		docx: [{
-			signature: [
-				80,
-				75,
-				3,
-				4
-			],
-			mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-		}],
-		xlsx: [{
-			signature: [
-				80,
-				75,
-				3,
-				4
-			],
-			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-		}],
-		pptx: [{
-			signature: [
-				80,
-				75,
-				3,
-				4
-			],
-			mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-		}],
-		doc: [{
-			signature: [
-				208,
-				207,
-				17,
-				224,
-				161,
-				177,
-				26,
-				225
-			],
-			mimeType: "application/msword"
-		}],
-		xls: [{
-			signature: [
-				208,
-				207,
-				17,
-				224,
-				161,
-				177,
-				26,
-				225
-			],
-			mimeType: "application/vnd.ms-excel"
-		}],
-		ppt: [{
-			signature: [
-				208,
-				207,
-				17,
-				224,
-				161,
-				177,
-				26,
-				225
-			],
-			mimeType: "application/vnd.ms-powerpoint"
-		}]
-	};
-	/**
-	* All possible format signatures for checking against actual file content
-	*/
-	static ALL_SIGNATURES = Object.entries(FileDetector.MAGIC_BYTES).flatMap(([ext, signatures]) => signatures.map((sig) => ({
-		ext,
-		...sig
-	})));
-	/**
-	* MIME type map for file extensions.
-	*
-	* Can be used to get the content type of file based on its extension.
-	* Feel free to add more mime types in your project!
-	*/
-	static mimeMap = {
-		json: "application/json",
-		txt: "text/plain",
-		html: "text/html",
-		htm: "text/html",
-		xml: "application/xml",
-		csv: "text/csv",
-		pdf: "application/pdf",
-		md: "text/markdown",
-		markdown: "text/markdown",
-		rtf: "application/rtf",
-		css: "text/css",
-		js: "application/javascript",
-		mjs: "application/javascript",
-		ts: "application/typescript",
-		jsx: "text/jsx",
-		tsx: "text/tsx",
-		zip: "application/zip",
-		rar: "application/vnd.rar",
-		"7z": "application/x-7z-compressed",
-		tar: "application/x-tar",
-		gz: "application/gzip",
-		tgz: "application/gzip",
-		png: "image/png",
-		jpg: "image/jpeg",
-		jpeg: "image/jpeg",
-		gif: "image/gif",
-		webp: "image/webp",
-		svg: "image/svg+xml",
-		bmp: "image/bmp",
-		ico: "image/x-icon",
-		tiff: "image/tiff",
-		tif: "image/tiff",
-		mp3: "audio/mpeg",
-		wav: "audio/wav",
-		ogg: "audio/ogg",
-		m4a: "audio/mp4",
-		aac: "audio/aac",
-		flac: "audio/flac",
-		mp4: "video/mp4",
-		webm: "video/webm",
-		avi: "video/x-msvideo",
-		mov: "video/quicktime",
-		wmv: "video/x-ms-wmv",
-		flv: "video/x-flv",
-		mkv: "video/x-matroska",
-		doc: "application/msword",
-		docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-		xls: "application/vnd.ms-excel",
-		xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-		ppt: "application/vnd.ms-powerpoint",
-		pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-		woff: "font/woff",
-		woff2: "font/woff2",
-		ttf: "font/ttf",
-		otf: "font/otf",
-		eot: "application/vnd.ms-fontobject"
-	};
-	/**
-	* Reverse MIME type map for looking up extensions from MIME types.
-	* Prefers shorter, more common extensions when multiple exist.
-	*/
-	static reverseMimeMap = (() => {
-		const reverse = {};
-		for (const [ext, mimeType] of Object.entries(FileDetector.mimeMap)) if (!reverse[mimeType]) reverse[mimeType] = ext;
-		return reverse;
-	})();
-	/**
-	* Returns the file extension for a given MIME type.
-	*
-	* @param mimeType - The MIME type to look up
-	* @returns The file extension (without dot), or "bin" if not found
-	*
-	* @example
-	* ```typescript
-	* const detector = alepha.inject(FileDetector);
-	* const ext = detector.getExtensionFromMimeType("image/png"); // "png"
-	* const ext2 = detector.getExtensionFromMimeType("application/octet-stream"); // "bin"
-	* ```
-	*/
-	getExtensionFromMimeType(mimeType) {
-		return FileDetector.reverseMimeMap[mimeType] || "bin";
-	}
-	/**
-	* Returns the content type of file based on its filename.
-	*
-	* @param filename - The filename to check
-	* @returns The MIME type
-	*
-	* @example
-	* ```typescript
-	* const detector = alepha.inject(FileDetector);
-	* const mimeType = detector.getContentType("image.png"); // "image/png"
-	* ```
-	*/
-	getContentType(filename) {
-		const ext = filename.toLowerCase().split(".").pop() || "";
-		return FileDetector.mimeMap[ext] || "application/octet-stream";
-	}
-	/**
-	* Detects the file type by checking magic bytes against the stream content.
-	*
-	* @param stream - The readable stream to check
-	* @param filename - The filename (used to get the extension)
-	* @returns File type information including MIME type, extension, and verification status
-	*
-	* @example
-	* ```typescript
-	* const detector = alepha.inject(FileDetector);
-	* const stream = createReadStream('image.png');
-	* const result = await detector.detectFileType(stream, 'image.png');
-	* console.log(result.mimeType); // 'image/png'
-	* console.log(result.verified); // true if magic bytes match
-	* ```
-	*/
-	async detectFileType(stream, filename) {
-		const expectedMimeType = this.getContentType(filename);
-		const lastDotIndex = filename.lastIndexOf(".");
-		const ext = lastDotIndex > 0 ? filename.substring(lastDotIndex + 1).toLowerCase() : "";
-		const { buffer, stream: newStream } = await this.peekBytes(stream, 16);
-		const expectedSignatures = FileDetector.MAGIC_BYTES[ext];
-		if (expectedSignatures) {
-			for (const { signature, mimeType } of expectedSignatures) if (this.matchesSignature(buffer, signature)) return {
-				mimeType,
-				extension: ext,
-				verified: true,
-				stream: newStream
-			};
-		}
-		for (const { ext: detectedExt, signature, mimeType } of FileDetector.ALL_SIGNATURES) if (detectedExt !== ext && this.matchesSignature(buffer, signature)) return {
-			mimeType,
-			extension: detectedExt,
-			verified: true,
-			stream: newStream
-		};
-		return {
-			mimeType: expectedMimeType,
-			extension: ext,
-			verified: false,
-			stream: newStream
-		};
-	}
-	/**
-	* Reads all bytes from a stream and returns the first N bytes along with a new stream containing all data.
-	* This approach reads the entire stream upfront to avoid complex async handling issues.
-	*
-	* @protected
-	*/
-	async peekBytes(stream, numBytes) {
-		const chunks = [];
-		for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-		const allData = Buffer.concat(chunks);
-		return {
-			buffer: allData.subarray(0, numBytes),
-			stream: node_stream.Readable.from(allData)
-		};
-	}
-	/**
-	* Checks if a buffer matches a magic byte signature.
-	*
-	* @protected
-	*/
-	matchesSignature(buffer, signature) {
-		if (buffer.length < signature.length) return false;
-		for (let i = 0; i < signature.length; i++) if (signature[i] !== null && buffer[i] !== signature[i]) return false;
-		return true;
-	}
-};
-
-//#endregion
-//#region src/file/providers/NodeFileSystemProvider.ts
-/**
-* Node.js implementation of FileSystem interface.
-*
-* @example
-* ```typescript
-* const fs = alepha.inject(NodeFileSystemProvider);
-*
-* // Create from URL
-* const file1 = fs.createFile({ url: "file:///path/to/file.png" });
-*
-* // Create from Buffer
-* const file2 = fs.createFile({ buffer: Buffer.from("hello"), name: "hello.txt" });
-*
-* // Create from text
-* const file3 = fs.createFile({ text: "Hello, world!", name: "greeting.txt" });
-*
-* // File operations
-* await fs.mkdir("/tmp/mydir", { recursive: true });
-* await fs.cp("/src/file.txt", "/dest/file.txt");
-* await fs.mv("/old/path.txt", "/new/path.txt");
-* const files = await fs.ls("/tmp");
-* await fs.rm("/tmp/file.txt");
-* ```
-*/
-var NodeFileSystemProvider = class {
-	detector = (0, alepha.$inject)(FileDetector);
-	/**
-	* Creates a FileLike object from various sources.
-	*
-	* @param options - Options for creating the file
-	* @returns A FileLike object
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // From URL
-	* const file1 = fs.createFile({ url: "https://example.com/image.png" });
-	*
-	* // From Buffer
-	* const file2 = fs.createFile({
-	*   buffer: Buffer.from("hello"),
-	*   name: "hello.txt",
-	*   type: "text/plain"
-	* });
-	*
-	* // From text
-	* const file3 = fs.createFile({ text: "Hello!", name: "greeting.txt" });
-	*
-	* // From stream with detection
-	* const stream = createReadStream("/path/to/file.png");
-	* const file4 = fs.createFile({ stream, name: "image.png" });
-	* ```
-	*/
-	createFile(options) {
-		if ("path" in options) {
-			const path = options.path;
-			const filename = path.split("/").pop() || "file";
-			return this.createFileFromUrl(`file://${path}`, {
-				type: options.type,
-				name: options.name || filename
-			});
-		}
-		if ("url" in options) return this.createFileFromUrl(options.url, {
-			type: options.type,
-			name: options.name
-		});
-		if ("response" in options) {
-			if (!options.response.body) throw new alepha.AlephaError("Response has no body stream");
-			const res = options.response;
-			const sizeHeader = res.headers.get("content-length");
-			const size = sizeHeader ? parseInt(sizeHeader, 10) : void 0;
-			let name = options.name;
-			const contentDisposition = res.headers.get("content-disposition");
-			if (contentDisposition && !name) {
-				const match = contentDisposition.match(/filename="?([^"]+)"?/);
-				if (match) name = match[1];
-			}
-			const type = options.type || res.headers.get("content-type") || void 0;
-			return this.createFileFromStream(options.response.body, {
-				type,
-				name,
-				size
-			});
-		}
-		if ("file" in options) return this.createFileFromWebFile(options.file, {
-			type: options.type,
-			name: options.name,
-			size: options.size
-		});
-		if ("buffer" in options) return this.createFileFromBuffer(options.buffer, {
-			type: options.type,
-			name: options.name
-		});
-		if ("arrayBuffer" in options) return this.createFileFromBuffer(Buffer.from(options.arrayBuffer), {
-			type: options.type,
-			name: options.name
-		});
-		if ("text" in options) return this.createFileFromBuffer(Buffer.from(options.text, "utf-8"), {
-			type: options.type || "text/plain",
-			name: options.name || "file.txt"
-		});
-		if ("stream" in options) return this.createFileFromStream(options.stream, {
-			type: options.type,
-			name: options.name,
-			size: options.size
-		});
-		throw new alepha.AlephaError("Invalid createFile options: no valid source provided");
-	}
-	/**
-	* Removes a file or directory.
-	*
-	* @param path - The path to remove
-	* @param options - Remove options
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // Remove a file
-	* await fs.rm("/tmp/file.txt");
-	*
-	* // Remove a directory recursively
-	* await fs.rm("/tmp/mydir", { recursive: true });
-	*
-	* // Remove with force (no error if doesn't exist)
-	* await fs.rm("/tmp/maybe-exists.txt", { force: true });
-	* ```
-	*/
-	async rm(path, options) {
-		await (0, node_fs_promises.rm)(path, options);
-	}
-	/**
-	* Copies a file or directory.
-	*
-	* @param src - Source path
-	* @param dest - Destination path
-	* @param options - Copy options
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // Copy a file
-	* await fs.cp("/src/file.txt", "/dest/file.txt");
-	*
-	* // Copy a directory recursively
-	* await fs.cp("/src/dir", "/dest/dir", { recursive: true });
-	*
-	* // Copy with force (overwrite existing)
-	* await fs.cp("/src/file.txt", "/dest/file.txt", { force: true });
-	* ```
-	*/
-	async cp(src, dest, options) {
-		if ((await (0, node_fs_promises.stat)(src)).isDirectory()) {
-			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
-			await (0, node_fs_promises.cp)(src, dest, {
-				recursive: true,
-				force: options?.force ?? false
-			});
-		} else await (0, node_fs_promises.copyFile)(src, dest);
-	}
-	/**
-	* Moves/renames a file or directory.
-	*
-	* @param src - Source path
-	* @param dest - Destination path
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // Move/rename a file
-	* await fs.mv("/old/path.txt", "/new/path.txt");
-	*
-	* // Move a directory
-	* await fs.mv("/old/dir", "/new/dir");
-	* ```
-	*/
-	async mv(src, dest) {
-		await (0, node_fs_promises.rename)(src, dest);
-	}
-	/**
-	* Creates a directory.
-	*
-	* @param path - The directory path to create
-	* @param options - Mkdir options
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // Create a directory
-	* await fs.mkdir("/tmp/mydir");
-	*
-	* // Create nested directories
-	* await fs.mkdir("/tmp/path/to/dir", { recursive: true });
-	*
-	* // Create with specific permissions
-	* await fs.mkdir("/tmp/mydir", { mode: 0o755 });
-	* ```
-	*/
-	async mkdir(path, options) {
-		await (0, node_fs_promises.mkdir)(path, options);
-	}
-	/**
-	* Lists files in a directory.
-	*
-	* @param path - The directory path to list
-	* @param options - List options
-	* @returns Array of filenames
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // List files in a directory
-	* const files = await fs.ls("/tmp");
-	* console.log(files); // ["file1.txt", "file2.txt", "subdir"]
-	*
-	* // List with hidden files
-	* const allFiles = await fs.ls("/tmp", { hidden: true });
-	*
-	* // List recursively
-	* const allFilesRecursive = await fs.ls("/tmp", { recursive: true });
-	* ```
-	*/
-	async ls(path, options) {
-		const entries = await (0, node_fs_promises.readdir)(path);
-		const filteredEntries = options?.hidden ? entries : entries.filter((e) => !e.startsWith("."));
-		if (options?.recursive) {
-			const allFiles = [];
-			for (const entry of filteredEntries) {
-				const fullPath = (0, node_path.join)(path, entry);
-				if ((await (0, node_fs_promises.stat)(fullPath)).isDirectory()) {
-					allFiles.push(entry);
-					const subFiles = await this.ls(fullPath, options);
-					allFiles.push(...subFiles.map((f) => (0, node_path.join)(entry, f)));
-				} else allFiles.push(entry);
-			}
-			return allFiles;
-		}
-		return filteredEntries;
-	}
-	/**
-	* Checks if a file or directory exists.
-	*
-	* @param path - The path to check
-	* @returns True if the path exists, false otherwise
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* if (await fs.exists("/tmp/file.txt")) {
-	*   console.log("File exists");
-	* }
-	* ```
-	*/
-	async exists(path) {
-		try {
-			await (0, node_fs_promises.access)(path);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Reads the content of a file.
-	*
-	* @param path - The file path to read
-	* @returns The file content as a Buffer
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* const buffer = await fs.readFile("/tmp/file.txt");
-	* console.log(buffer.toString("utf-8"));
-	* ```
-	*/
-	async readFile(path) {
-		return await (0, node_fs_promises.readFile)(path);
-	}
-	/**
-	* Writes data to a file.
-	*
-	* @param path - The file path to write to
-	* @param data - The data to write (Buffer or string)
-	*
-	* @example
-	* ```typescript
-	* const fs = alepha.inject(NodeFileSystemProvider);
-	*
-	* // Write string
-	* await fs.writeFile("/tmp/file.txt", "Hello, world!");
-	*
-	* // Write Buffer
-	* await fs.writeFile("/tmp/file.bin", Buffer.from([0x01, 0x02, 0x03]));
-	* ```
-	*/
-	async writeFile(path, data) {
-		if ((0, alepha.isFileLike)(data)) {
-			await (0, node_fs_promises.writeFile)(path, node_stream.Readable.from(data.stream()));
-			return;
-		}
-		await (0, node_fs_promises.writeFile)(path, data);
-	}
-	/**
-	* Creates a FileLike object from a Web File.
-	*
-	* @protected
-	*/
-	createFileFromWebFile(source, options = {}) {
-		const name = options.name ?? source.name;
-		return {
-			name,
-			type: options.type ?? (source.type || this.detector.getContentType(name)),
-			size: options.size ?? source.size ?? 0,
-			lastModified: source.lastModified || Date.now(),
-			stream: () => source.stream(),
-			arrayBuffer: async () => {
-				return await source.arrayBuffer();
-			},
-			text: async () => {
-				return await source.text();
-			}
-		};
-	}
-	/**
-	* Creates a FileLike object from a Buffer.
-	*
-	* @protected
-	*/
-	createFileFromBuffer(source, options = {}) {
-		const name = options.name ?? "file";
-		return {
-			name,
-			type: options.type ?? this.detector.getContentType(options.name ?? name),
-			size: source.byteLength,
-			lastModified: Date.now(),
-			stream: () => node_stream.Readable.from(source),
-			arrayBuffer: async () => {
-				return this.bufferToArrayBuffer(source);
-			},
-			text: async () => {
-				return source.toString("utf-8");
-			}
-		};
-	}
-	/**
-	* Creates a FileLike object from a stream.
-	*
-	* @protected
-	*/
-	createFileFromStream(source, options = {}) {
-		let buffer = null;
-		return {
-			name: options.name ?? "file",
-			type: options.type ?? this.detector.getContentType(options.name ?? "file"),
-			size: options.size ?? 0,
-			lastModified: Date.now(),
-			stream: () => source,
-			_buffer: null,
-			arrayBuffer: async () => {
-				buffer ??= await this.streamToBuffer(source);
-				return this.bufferToArrayBuffer(buffer);
-			},
-			text: async () => {
-				buffer ??= await this.streamToBuffer(source);
-				return buffer.toString("utf-8");
-			}
-		};
-	}
-	/**
-	* Creates a FileLike object from a URL.
-	*
-	* @protected
-	*/
-	createFileFromUrl(url, options = {}) {
-		const parsedUrl = new URL(url);
-		const filename = options.name || parsedUrl.pathname.split("/").pop() || "file";
-		let buffer = null;
-		return {
-			name: filename,
-			type: options.type ?? this.detector.getContentType(filename),
-			size: 0,
-			lastModified: Date.now(),
-			stream: () => this.createStreamFromUrl(url),
-			arrayBuffer: async () => {
-				buffer ??= await this.loadFromUrl(url);
-				return this.bufferToArrayBuffer(buffer);
-			},
-			text: async () => {
-				buffer ??= await this.loadFromUrl(url);
-				return buffer.toString("utf-8");
-			},
-			filepath: url
-		};
-	}
-	/**
-	* Gets a streaming response from a URL.
-	*
-	* @protected
-	*/
-	getStreamingResponse(url) {
-		const stream = new node_stream.PassThrough();
-		fetch(url).then((res) => node_stream.Readable.fromWeb(res.body).pipe(stream)).catch((err) => stream.destroy(err));
-		return stream;
-	}
-	/**
-	* Loads data from a URL.
-	*
-	* @protected
-	*/
-	async loadFromUrl(url) {
-		const parsedUrl = new URL(url);
-		if (parsedUrl.protocol === "file:") return await (0, node_fs_promises.readFile)((0, node_url.fileURLToPath)(url));
-		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") {
-			const response = await fetch(url);
-			if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-			const arrayBuffer = await response.arrayBuffer();
-			return Buffer.from(arrayBuffer);
-		} else throw new Error(`Unsupported protocol: ${parsedUrl.protocol}`);
-	}
-	/**
-	* Creates a stream from a URL.
-	*
-	* @protected
-	*/
-	createStreamFromUrl(url) {
-		const parsedUrl = new URL(url);
-		if (parsedUrl.protocol === "file:") return (0, node_fs.createReadStream)((0, node_url.fileURLToPath)(url));
-		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") return this.getStreamingResponse(url);
-		else throw new alepha.AlephaError(`Unsupported protocol: ${parsedUrl.protocol}`);
-	}
-	/**
-	* Converts a stream-like object to a Buffer.
-	*
-	* @protected
-	*/
-	async streamToBuffer(streamLike) {
-		const stream = streamLike instanceof node_stream.Readable ? streamLike : node_stream.Readable.fromWeb(streamLike);
-		return new Promise((resolve, reject) => {
-			const buffer = [];
-			stream.on("data", (chunk) => buffer.push(Buffer.from(chunk)));
-			stream.on("end", () => resolve(Buffer.concat(buffer)));
-			stream.on("error", (err) => reject(new alepha.AlephaError("Error converting stream", { cause: err })));
-		});
-	}
-	/**
-	* Converts a Node.js Buffer to an ArrayBuffer.
-	*
-	* @protected
-	*/
-	bufferToArrayBuffer(buffer) {
-		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-	}
-};
-
-//#endregion
-//#region src/file/index.ts
-/**
-* Provides file system capabilities for Alepha applications with support for multiple file sources and operations.
-*
-* The file module enables working with files from various sources (URLs, buffers, streams) and provides
-* utilities for file type detection, content type determination, and common file system operations.
-*
-* @see {@link FileDetector}
-* @see {@link FileSystemProvider}
-* @see {@link NodeFileSystemProvider}
-* @module alepha.file
-*/
-const AlephaFile = (0, alepha.$module)({
-	name: "alepha.file",
-	descriptors: [],
-	services: [
-		FileDetector,
-		FileSystemProvider,
-		NodeFileSystemProvider
-	],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: FileSystemProvider,
-		use: NodeFileSystemProvider
-	})
-});
-
-//#endregion
-exports.AlephaFile = AlephaFile;
-exports.FileDetector = FileDetector;
-exports.FileSystemProvider = FileSystemProvider;
-exports.NodeFileSystemProvider = NodeFileSystemProvider;
-//# sourceMappingURL=index.cjs.map