@ooneex/utils 0.0.6 → 0.0.8

package/tests/capitalizeWord.spec.ts

@@ -1,163 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { capitalizeWord } from "@/index";
-
-describe("capitalizeWord", () => {
-  describe("basic functionality", () => {
-    test("should capitalize first letter of lowercase word", () => {
-      expect(capitalizeWord("hello")).toBe("Hello");
-    });
-
-    test("should capitalize first letter and lowercase the rest", () => {
-      expect(capitalizeWord("hELLO")).toBe("Hello");
-    });
-
-    test("should handle single character", () => {
-      expect(capitalizeWord("a")).toBe("A");
-    });
-
-    test("should handle uppercase single character", () => {
-      expect(capitalizeWord("A")).toBe("A");
-    });
-
-    test("should handle already capitalized word", () => {
-      expect(capitalizeWord("Hello")).toBe("Hello");
-    });
-
-    test("should handle mixed case word", () => {
-      expect(capitalizeWord("hElLo")).toBe("Hello");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("should return empty string when input is empty", () => {
-      expect(capitalizeWord("")).toBe("");
-    });
-
-    test("should handle words with numbers", () => {
-      expect(capitalizeWord("hello123")).toBe("Hello123");
-    });
-
-    test("should handle words starting with numbers", () => {
-      expect(capitalizeWord("123hello")).toBe("123hello");
-    });
-
-    test("should handle special characters", () => {
-      expect(capitalizeWord("!hello")).toBe("!hello");
-    });
-
-    test("should handle words with special characters", () => {
-      expect(capitalizeWord("hello-world")).toBe("Hello-world");
-    });
-
-    test("should handle accented characters", () => {
-      expect(capitalizeWord("école")).toBe("École");
-    });
-
-    test("should handle non-latin characters", () => {
-      expect(capitalizeWord("привет")).toBe("Привет");
-    });
-  });
-
-  describe("whitespace handling", () => {
-    test("should handle words with leading spaces", () => {
-      expect(capitalizeWord(" hello")).toBe(" hello");
-    });
-
-    test("should handle words with trailing spaces", () => {
-      expect(capitalizeWord("hello ")).toBe("Hello ");
-    });
-
-    test("should handle single space", () => {
-      expect(capitalizeWord(" ")).toBe(" ");
-    });
-
-    test("should handle multiple spaces", () => {
-      expect(capitalizeWord("   ")).toBe("   ");
-    });
-
-    test("should handle tab character", () => {
-      expect(capitalizeWord("\t")).toBe("\t");
-    });
-
-    test("should handle newline character", () => {
-      expect(capitalizeWord("\n")).toBe("\n");
-    });
-  });
-
-  describe("parametrized tests", () => {
-    test.each([
-      ["word", "Word"],
-      ["WORD", "Word"],
-      ["wORD", "Word"],
-      ["test", "Test"],
-      ["javascript", "Javascript"],
-      ["typescript", "Typescript"],
-      ["react", "React"],
-    ])("capitalizeWord(%s) should return %s", (input, expected) => {
-      expect(capitalizeWord(input)).toBe(expected);
-    });
-  });
-
-  describe("type safety", () => {
-    test("should handle very long strings", () => {
-      const longString = "a".repeat(1000);
-      const result = capitalizeWord(longString);
-      expect(result).toHaveLength(1000);
-      expect(result[0]).toBe("A");
-      expect(result.slice(1)).toBe("a".repeat(999));
-    });
-
-    test("should handle unicode characters", () => {
-      expect(capitalizeWord("émile")).toBe("Émile");
-      expect(capitalizeWord("ñoño")).toBe("Ñoño");
-      expect(capitalizeWord("café")).toBe("Café");
-    });
-
-    test("should handle emoji", () => {
-      expect(capitalizeWord("😀hello")).toBe("😀hello");
-      expect(capitalizeWord("hello😀")).toBe("Hello😀");
-    });
-  });
-
-  describe("function behavior", () => {
-    test("should not mutate original string", () => {
-      const original = "hello";
-      const result = capitalizeWord(original);
-      expect(original).toBe("hello");
-      expect(result).toBe("Hello");
-    });
-
-    test("should return string type", () => {
-      const result = capitalizeWord("test");
-      expect(typeof result).toBe("string");
-    });
-
-    test("should handle consecutive calls consistently", () => {
-      const word = "hello";
-      const result1 = capitalizeWord(word);
-      const result2 = capitalizeWord(word);
-      expect(result1).toBe(result2);
-      expect(result1).toBe("Hello");
-    });
-  });
-
-  describe("real world examples", () => {
-    test("should capitalize common names", () => {
-      expect(capitalizeWord("john")).toBe("John");
-      expect(capitalizeWord("mary")).toBe("Mary");
-      expect(capitalizeWord("david")).toBe("David");
-    });
-
-    test("should handle programming terms", () => {
-      expect(capitalizeWord("function")).toBe("Function");
-      expect(capitalizeWord("variable")).toBe("Variable");
-      expect(capitalizeWord("method")).toBe("Method");
-    });
-
-    test("should handle common words", () => {
-      expect(capitalizeWord("the")).toBe("The");
-      expect(capitalizeWord("and")).toBe("And");
-      expect(capitalizeWord("but")).toBe("But");
-    });
-  });
-});

package/tests/dataURLtoFile.spec.ts

@@ -1,472 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { dataURLtoFile } from "@/index";
-
-describe("dataURLtoFile", () => {
-  describe("basic functionality", () => {
-    test("should convert a simple text data URL to a File", () => {
-      const dataUrl = "data:text/plain;base64,SGVsbG8gV29ybGQ=";
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.name).toBe(filename);
-      expect(file.type).toMatch(/^text\/plain(;.*)?$/);
-      expect(file.size).toBe(11); // "Hello World" is 11 bytes
-    });
-
-    test("should convert an image data URL to a File", () => {
-      // Simple 1x1 red pixel PNG
-      const dataUrl =
-        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
-      const filename = "pixel.png";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("image/png");
-      expect(file.size).toBeGreaterThan(0);
-    });
-
-    test("should convert a JSON data URL to a File", () => {
-      const jsonData = JSON.stringify({ message: "test", value: 123 });
-      const base64Data = btoa(jsonData);
-      const dataUrl = `data:application/json;base64,${base64Data}`;
-      const filename = "data.json";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.name).toBe(filename);
-      expect(file.type).toMatch(/^application\/json(;.*)?$/);
-      expect(file.size).toBe(jsonData.length);
-    });
-
-    test("should preserve the original filename", () => {
-      const dataUrl = "data:text/plain;base64,dGVzdA==";
-      const filename = "custom-filename.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.name).toBe(filename);
-    });
-  });
-
-  describe("mime type handling", () => {
-    test("should extract correct mime type from data URL", () => {
-      const testCases = [
-        { dataUrl: "data:image/jpeg;base64,/9j/4AAQ", expectedType: "image/jpeg" },
-        { dataUrl: "data:application/pdf;base64,JVBERi0x", expectedType: "application/pdf" },
-        { dataUrl: "data:video/mp4;base64,AAAAIGZ0eXA=", expectedType: "video/mp4" },
-        { dataUrl: "data:audio/mpeg;base64,SUQzAwAAAAA=", expectedType: "audio/mpeg" },
-        { dataUrl: "data:text/html;base64,PGh0bWw+", expectedType: "text/html" },
-        { dataUrl: "data:text/css;base64,Ym9keSB7", expectedType: "text/css" },
-        { dataUrl: "data:text/javascript;base64,Y29uc29sZS5sb2c=", expectedType: "text/javascript" },
-      ];
-
-      testCases.forEach(({ dataUrl, expectedType }) => {
-        const file = dataURLtoFile(dataUrl, "test");
-        expect(file.type).toMatch(new RegExp(`^${expectedType.replace(/[+/]/g, "\\$&")}(;.*)?$`));
-      });
-    });
-
-    test("should handle data URL with charset parameter", () => {
-      const dataUrl = "data:text/plain;charset=utf-8;base64,SGVsbG8gV29ybGQ=";
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.type).toMatch(/^text\/plain(;.*)?$/);
-    });
-
-    test("should handle malformed mime type gracefully", () => {
-      const dataUrl = "data:invalid-mime-type;base64,dGVzdA==";
-      const filename = "test";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.type).toBe("invalid-mime-type");
-    });
-
-    test("should handle data URL without explicit mime type", () => {
-      const dataUrl = "data:;base64,dGVzdA==";
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("");
-    });
-  });
-
-  describe("base64 decoding", () => {
-    test("should correctly decode base64 data", async () => {
-      const originalText = "Hello, World! This is a test string.";
-      const base64Data = btoa(originalText);
-      const dataUrl = `data:text/plain;base64,${base64Data}`;
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-      const decodedText = await file.text();
-
-      expect(decodedText).toBe(originalText);
-    });
-
-    test("should handle empty base64 data", () => {
-      const dataUrl = "data:text/plain;base64,";
-      const filename = "empty.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.size).toBe(0);
-    });
-
-    test("should handle base64 data with padding", () => {
-      const testCases = [
-        { data: "YQ==", expected: "a" }, // 1 char with padding
-        { data: "YWI=", expected: "ab" }, // 2 chars with padding
-        { data: "YWJj", expected: "abc" }, // 3 chars no padding
-        { data: "YWJjZA==", expected: "abcd" }, // 4 chars with padding
-      ];
-
-      testCases.forEach(({ data, expected }) => {
-        const dataUrl = `data:text/plain;base64,${data}`;
-        const file = dataURLtoFile(dataUrl, "test.txt");
-        expect(file.size).toBe(expected.length);
-      });
-    });
-
-    test("should handle Unicode characters properly when base64 encoded", async () => {
-      // Use a simple ASCII string first to avoid btoa Unicode issues
-      const asciiText = "Hello World 123!";
-      const base64Data = btoa(asciiText);
-      const dataUrl = `data:text/plain;base64,${base64Data}`;
-      const filename = "ascii.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-      const decodedText = await file.text();
-
-      expect(decodedText).toBe(asciiText);
-    });
-  });
-
-  describe("edge cases", () => {
-    test("should handle very long filenames", () => {
-      const dataUrl = "data:text/plain;base64,dGVzdA==";
-      const longFilename = `${"a".repeat(255)}.txt`;
-
-      const file = dataURLtoFile(dataUrl, longFilename);
-
-      expect(file.name).toBe(longFilename);
-    });
-
-    test("should handle special characters in filename", () => {
-      const dataUrl = "data:text/plain;base64,dGVzdA==";
-      const specialFilename = "test file with spaces & symbols!@#$%^&*()_+.txt";
-
-      const file = dataURLtoFile(dataUrl, specialFilename);
-
-      expect(file.name).toBe(specialFilename);
-    });
-
-    test("should handle binary data correctly", () => {
-      // Create a simple binary data string that works with btoa
-      const binaryData = String.fromCharCode(0, 1, 2, 3, 127, 126, 125);
-      const base64Data = btoa(binaryData);
-      const dataUrl = `data:application/octet-stream;base64,${base64Data}`;
-      const filename = "binary.dat";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.type).toBe("application/octet-stream");
-      expect(file.size).toBe(binaryData.length);
-    });
-
-    test("should handle data URL with multiple parameters", () => {
-      const dataUrl = "data:text/plain;charset=utf-8;boundary=something;base64,dGVzdA==";
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.type).toMatch(/^text\/plain(;.*)?$/);
-    });
-  });
-
-  describe("malformed input handling", () => {
-    test("should handle data URL with only header", () => {
-      const dataUrl = "data:text/plain;base64,";
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.size).toBe(0);
-    });
-
-    test("should handle data URL with missing parts", () => {
-      const dataUrl = "data:text/plain";
-      const filename = "test.txt";
-
-      // This will likely fail due to invalid base64, but shouldn't crash the function structure
-      expect(() => {
-        dataURLtoFile(dataUrl, filename);
-      }).toThrow();
-    });
-
-    test("should handle invalid base64 data", () => {
-      const dataUrl = "data:text/plain;base64,invalid!!!base64!!!";
-      const filename = "test.txt";
-
-      expect(() => {
-        dataURLtoFile(dataUrl, filename);
-      }).toThrow();
-    });
-  });
-
-  describe("file properties validation", () => {
-    test("should create file with correct properties", () => {
-      const dataUrl =
-        "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwA/8A8A";
-      const filename = "image.jpg";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("image/jpeg");
-      expect(file.size).toBeGreaterThan(0);
-      expect(file.lastModified).toBeTypeOf("number");
-      expect(Math.abs(file.lastModified - Date.now())).toBeLessThan(1000);
-    });
-
-    test("should create file with ArrayBuffer content", async () => {
-      const dataUrl = "data:application/octet-stream;base64,AAECAw=="; // [0, 1, 2, 3]
-      const filename = "test.bin";
-
-      const file = dataURLtoFile(dataUrl, filename);
-      const arrayBuffer = await file.arrayBuffer();
-      const uint8Array = new Uint8Array(arrayBuffer);
-
-      expect(Array.from(uint8Array)).toEqual([0, 1, 2, 3]);
-    });
-
-    test("should allow reading file as different types", async () => {
-      const originalText = "Hello, World!";
-      const base64Data = btoa(originalText);
-      const dataUrl = `data:text/plain;base64,${base64Data}`;
-      const filename = "test.txt";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      // Test reading as text
-      const text = await file.text();
-      expect(text).toBe(originalText);
-
-      // Test reading as array buffer
-      const arrayBuffer = await file.arrayBuffer();
-      expect(arrayBuffer).toBeInstanceOf(ArrayBuffer);
-      expect(arrayBuffer.byteLength).toBe(originalText.length);
-
-      // Test creating blob URL
-      const blobUrl = URL.createObjectURL(file);
-      expect(typeof blobUrl).toBe("string");
-      expect(blobUrl.startsWith("blob:")).toBe(true);
-
-      // Clean up
-      URL.revokeObjectURL(blobUrl);
-    });
-  });
-
-  describe("real world scenarios", () => {
-    test("should handle typical image upload scenario", () => {
-      // Simulate a small PNG image data URL
-      const dataUrl =
-        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
-      const filename = "profile-picture.png";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("image/png");
-      expect(file.size).toBeGreaterThan(0);
-    });
-
-    test("should handle PDF document conversion", () => {
-      // Simple PDF header
-      const pdfData = btoa("%PDF-1.4");
-      const dataUrl = `data:application/pdf;base64,${pdfData}`;
-      const filename = "document.pdf";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("application/pdf");
-      expect(file.size).toBe(8); // "%PDF-1.4" is 8 characters
-    });
-
-    test("should handle CSV data export", () => {
-      const csvData = "Name,Age,Email\nJohn,30,john@example.com\nJane,25,jane@example.com";
-      const base64Data = btoa(csvData);
-      const dataUrl = `data:text/csv;base64,${base64Data}`;
-      const filename = "export.csv";
-
-      const file = dataURLtoFile(dataUrl, filename);
-
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("text/csv");
-      expect(file.size).toBe(csvData.length);
-    });
-
-    test("should handle canvas image export", () => {
-      // Simulate canvas.toDataURL() result
-      const canvasDataUrl =
-        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAAdgAAAHYBTnsmCAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAFYSURBVBiVY/z//z8DJQAggJiYmBj+//8PJv7//w9WB+aD2WA+iA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lgPpgN5oPZYD6YDeaD2WA+mA3mg9lg/n8AAwMDAAAAAElFTkSuQmCC";
-      const filename = "drawing.png";
-
-      const file = dataURLtoFile(canvasDataUrl, filename);
-
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("image/png");
-      expect(file.size).toBeGreaterThan(100); // Should be a reasonable size for an image
-    });
-  });
-
-  describe("parametrized tests", () => {
-    test.each([
-      ["text/plain", "SGVsbG8=", "Hello"],
-      ["text/html", "PGh0bWw+PC9odG1sPg==", "<html></html>"],
-      ["application/json", "eyJrZXkiOiJ2YWx1ZSJ9", '{"key":"value"}'],
-      ["image/svg+xml", "PHN2Zz48L3N2Zz4=", "<svg></svg>"],
-    ])("should handle %s mime type correctly", async (mimeType, base64Data, expectedContent) => {
-      const dataUrl = `data:${mimeType};base64,${base64Data}`;
-      const filename = `test.${mimeType.split("/")[1]}`;
-
-      const file = dataURLtoFile(dataUrl, filename);
-      const content = await file.text();
-
-      expect(file.type).toMatch(new RegExp(`^${mimeType.replace(/[+/]/g, "\\$&")}(;.*)?$`));
-      expect(content).toBe(expectedContent);
-    });
-
-    test.each([
-      ["test.txt"],
-      ["my-file.pdf"],
-      ["image_01.jpg"],
-      ["document with spaces.docx"],
-      ["file.with.multiple.dots.txt"],
-      ["🎉emoji-filename.txt"],
-    ])("should preserve filename: %s", (filename) => {
-      const dataUrl = "data:text/plain;base64,dGVzdA==";
-      const file = dataURLtoFile(dataUrl, filename);
-      expect(file.name).toBe(filename);
-    });
-  });
-
-  describe("integration with File API", () => {
-    test("should work with FormData", () => {
-      const dataUrl = "data:text/plain;base64,SGVsbG8gV29ybGQ=";
-      const filename = "test.txt";
-      const file = dataURLtoFile(dataUrl, filename);
-
-      const formData = new FormData();
-      formData.append("file", file);
-
-      const retrievedFile = formData.get("file") as File;
-      expect(retrievedFile).toBeInstanceOf(File);
-      expect(retrievedFile.name).toBe(filename);
-    });
-
-    test("should be compatible with URL.createObjectURL", () => {
-      const dataUrl =
-        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
-      const filename = "pixel.png";
-      const file = dataURLtoFile(dataUrl, filename);
-
-      const objectUrl = URL.createObjectURL(file);
-
-      expect(typeof objectUrl).toBe("string");
-      expect(objectUrl.startsWith("blob:")).toBe(true);
-
-      // Clean up
-      URL.revokeObjectURL(objectUrl);
-    });
-
-    test("should work with file size limits", () => {
-      const dataUrl = "data:text/plain;base64,dGVzdA=="; // "test" = 4 bytes
-      const filename = "small.txt";
-      const file = dataURLtoFile(dataUrl, filename);
-
-      const maxSize = 10;
-      expect(file.size <= maxSize).toBe(true);
-    });
-  });
-
-  describe("performance considerations", () => {
-    test("should handle reasonably large files", () => {
-      // Create a larger base64 string (about 1KB)
-      const largeText = "A".repeat(1000);
-      const base64Data = btoa(largeText);
-      const dataUrl = `data:text/plain;base64,${base64Data}`;
-      const filename = "large.txt";
-
-      const startTime = performance.now();
-      const file = dataURLtoFile(dataUrl, filename);
-      const endTime = performance.now();
-
-      expect(file).toBeInstanceOf(File);
-      expect(file.size).toBe(1000);
-      expect(endTime - startTime).toBeLessThan(100); // Should be fast
-    });
-
-    test("should create independent files from same data", () => {
-      const dataUrl = "data:text/plain;base64,SGVsbG8=";
-
-      const file1 = dataURLtoFile(dataUrl, "file1.txt");
-      const file2 = dataURLtoFile(dataUrl, "file2.txt");
-
-      expect(file1).not.toBe(file2); // Different objects
-      expect(file1.name).toBe("file1.txt");
-      expect(file2.name).toBe("file2.txt");
-      expect(file1.size).toBe(file2.size);
-      expect(file1.type).toBe(file2.type);
-    });
-  });
-
-  describe("limitations and constraints", () => {
-    test("should document base64 requirement", () => {
-      // This function specifically requires base64 encoded data
-      const validDataUrl = "data:text/plain;base64,SGVsbG8=";
-
-      expect(() => {
-        dataURLtoFile(validDataUrl, "test.txt");
-      }).not.toThrow();
-    });
-
-    test("should handle mime type extraction correctly", () => {
-      // The function uses a regex to extract mime type between : and ;
-      const dataUrl = "data:custom/type;param=value;base64,dGVzdA==";
-      const file = dataURLtoFile(dataUrl, "test");
-
-      expect(file.type).toBe("custom/type");
-    });
-
-    test("should create Uint8Array internally", async () => {
-      const dataUrl = "data:application/octet-stream;base64,AAECAw==";
-      const file = dataURLtoFile(dataUrl, "test.bin");
-
-      const buffer = await file.arrayBuffer();
-      const uint8Array = new Uint8Array(buffer);
-
-      // Verify the internal Uint8Array was created correctly
-      expect(uint8Array[0]).toBe(0);
-      expect(uint8Array[1]).toBe(1);
-      expect(uint8Array[2]).toBe(2);
-      expect(uint8Array[3]).toBe(3);
-    });
-  });
-});