ag-toolkit 0.5.0 → 0.6.0

package/dist/tests/format.test.js

@@ -1,76 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatConfigValue, formatDate } from "../lib/format.js";
-describe("formatDate", () => {
-    test("should format valid date to ISO date string", () => {
-        const date = new Date("2024-01-15T10:30:00Z");
-        expect(formatDate(date)).toBe("2024-01-15");
-    });
-    test("should handle different dates", () => {
-        expect(formatDate(new Date("2023-12-31T00:00:00Z"))).toBe("2023-12-31");
-        expect(formatDate(new Date("2024-06-15T23:59:59Z"))).toBe("2024-06-15");
-    });
-    test("should return '--' for null", () => {
-        expect(formatDate(null)).toBe("--");
-    });
-    test("should handle dates at year boundaries", () => {
-        expect(formatDate(new Date("2024-01-01T00:00:00Z"))).toBe("2024-01-01");
-        expect(formatDate(new Date("2024-12-31T23:59:59Z"))).toBe("2024-12-31");
-    });
-    test("should handle dates with different times on same day", () => {
-        expect(formatDate(new Date("2024-03-15T00:00:00Z"))).toBe("2024-03-15");
-        expect(formatDate(new Date("2024-03-15T12:00:00Z"))).toBe("2024-03-15");
-        expect(formatDate(new Date("2024-03-15T23:59:59Z"))).toBe("2024-03-15");
-    });
-});
-describe("formatConfigValue", () => {
-    describe("arrays", () => {
-        test("should join array elements with comma and space", () => {
-            expect(formatConfigValue(["item1", "item2", "item3"])).toBe("item1, item2, item3");
-            expect(formatConfigValue([1, 2, 3])).toBe("1, 2, 3");
-        });
-        test("should return '(not set)' for empty arrays", () => {
-            expect(formatConfigValue([])).toBe("(not set)");
-        });
-        test("should handle arrays with single element", () => {
-            expect(formatConfigValue(["single"])).toBe("single");
-        });
-        test("should handle arrays with mixed types", () => {
-            expect(formatConfigValue([1, "two", true])).toBe("1, two, true");
-        });
-    });
-    describe("null, undefined, and empty string", () => {
-        test("should return '(not set)' for undefined", () => {
-            expect(formatConfigValue(undefined)).toBe("(not set)");
-        });
-        test("should return '(not set)' for null", () => {
-            expect(formatConfigValue(null)).toBe("(not set)");
-        });
-        test("should return '(not set)' for empty string", () => {
-            expect(formatConfigValue("")).toBe("(not set)");
-        });
-    });
-    describe("other values", () => {
-        test("should convert strings to string", () => {
-            expect(formatConfigValue("test")).toBe("test");
-            expect(formatConfigValue("hello world")).toBe("hello world");
-        });
-        test("should convert numbers to string", () => {
-            expect(formatConfigValue(42)).toBe("42");
-            expect(formatConfigValue(0)).toBe("0");
-            expect(formatConfigValue(-10)).toBe("-10");
-            expect(formatConfigValue(3.14)).toBe("3.14");
-        });
-        test("should convert booleans to string", () => {
-            expect(formatConfigValue(true)).toBe("true");
-            expect(formatConfigValue(false)).toBe("false");
-        });
-        test("should convert objects to string", () => {
-            expect(formatConfigValue({ a: 1, b: 2 })).toBe("[object Object]");
-        });
-        test("should handle special numeric values", () => {
-            expect(formatConfigValue(Number.NaN)).toBe("NaN");
-            expect(formatConfigValue(Number.POSITIVE_INFINITY)).toBe("Infinity");
-            expect(formatConfigValue(Number.NEGATIVE_INFINITY)).toBe("-Infinity");
-        });
-    });
-});

package/dist/tests/isDeepEqual.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/isDeepEqual.test.js

@@ -1,203 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { isDeepEqual } from "../lib/isDeepEqual.js";
-describe("isDeepEqual", () => {
-    describe("primitive values", () => {
-        test("should return true for identical primitive values", () => {
-            expect(isDeepEqual(1, 1)).toBe(true);
-            expect(isDeepEqual("hello", "hello")).toBe(true);
-            expect(isDeepEqual(true, true)).toBe(true);
-            expect(isDeepEqual(null, null)).toBe(true);
-            expect(isDeepEqual(undefined, undefined)).toBe(true);
-        });
-        test("should return false for different primitive values", () => {
-            expect(isDeepEqual(1, 2)).toBe(false);
-            expect(isDeepEqual("hello", "world")).toBe(false);
-            expect(isDeepEqual(true, false)).toBe(false);
-            expect(isDeepEqual(null, undefined)).toBe(false);
-        });
-        test("should handle NaN correctly", () => {
-            expect(isDeepEqual(Number.NaN, Number.NaN)).toBe(true);
-        });
-        test("should handle +0 and -0 correctly", () => {
-            expect(isDeepEqual(0, 0)).toBe(true);
-            expect(isDeepEqual(+0, +0)).toBe(true);
-        });
-    });
-    describe("arrays", () => {
-        test("should return true for identical arrays with strictOrder", () => {
-            expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-            expect(isDeepEqual(["a", "b", "c"], ["a", "b", "c"])).toBe(true);
-            expect(isDeepEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 2 }])).toBe(true);
-        });
-        test("should return false for arrays with different order when strictOrder is true", () => {
-            expect(isDeepEqual([1, 2, 3], [3, 2, 1])).toBe(false);
-            expect(isDeepEqual(["a", "b", "c"], ["c", "b", "a"])).toBe(false);
-        });
-        test("should return true for arrays with different order when strictOrder is false", () => {
-            expect(isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false })).toBe(true);
-            expect(isDeepEqual(["a", "b", "c"], ["c", "b", "a"], { strictOrder: false })).toBe(true);
-        });
-        test("should return false when array elements don't match with strictOrder false", () => {
-            expect(isDeepEqual([1, 2, 3], [1, 2, 4], { strictOrder: false })).toBe(false);
-            expect(isDeepEqual([1, 2, 3], [1, 4, 5], { strictOrder: false })).toBe(false);
-        });
-        test("should return false for arrays with different lengths", () => {
-            expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false);
-            expect(isDeepEqual([1, 2, 3], [1, 2])).toBe(false);
-        });
-        test("should return false for arrays with different elements", () => {
-            expect(isDeepEqual([1, 2, 3], [1, 2, 4])).toBe(false);
-            expect(isDeepEqual(["a", "b"], ["a", "c"])).toBe(false);
-        });
-        test("should handle nested arrays", () => {
-            expect(isDeepEqual([
-                [1, 2],
-                [3, 4],
-            ], [
-                [1, 2],
-                [3, 4],
-            ])).toBe(true);
-            expect(isDeepEqual([
-                [1, 2],
-                [3, 4],
-            ], [
-                [1, 2],
-                [3, 5],
-            ])).toBe(false);
-        });
-    });
-    describe("objects", () => {
-        test("should return true for identical objects", () => {
-            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-            expect(isDeepEqual({ b: 2, a: 1 }, { a: 1, b: 2 })).toBe(true);
-        });
-        test("should return false for objects with different keys", () => {
-            expect(isDeepEqual({ a: 1 }, { b: 1 })).toBe(false);
-            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-        });
-        test("should return false for objects with different values", () => {
-            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-        });
-        test("should handle nested objects", () => {
-            expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })).toBe(true);
-            expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 2 } } })).toBe(false);
-        });
-        test("should handle objects with arrays", () => {
-            expect(isDeepEqual({ a: [1, 2, 3], b: "test" }, { a: [1, 2, 3], b: "test" })).toBe(true);
-        });
-    });
-    describe("Date objects", () => {
-        test("should return true for identical dates", () => {
-            const date1 = new Date("2024-01-01");
-            const date2 = new Date("2024-01-01");
-            expect(isDeepEqual(date1, date2)).toBe(true);
-        });
-        test("should return false for different dates", () => {
-            const date1 = new Date("2024-01-01");
-            const date2 = new Date("2024-01-02");
-            expect(isDeepEqual(date1, date2)).toBe(false);
-        });
-    });
-    describe("RegExp objects", () => {
-        test("should return true for identical regex patterns", () => {
-            expect(isDeepEqual(/test/g, /test/g)).toBe(true);
-            expect(isDeepEqual(/hello/i, /hello/i)).toBe(true);
-        });
-        test("should return false for different regex patterns", () => {
-            expect(isDeepEqual(/test/g, /test/i)).toBe(false);
-            expect(isDeepEqual(/hello/, /world/)).toBe(false);
-        });
-    });
-    describe("Set objects", () => {
-        test("should return true for identical sets", () => {
-            expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true);
-            expect(isDeepEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))).toBe(true);
-        });
-        test("should return false for different sets", () => {
-            expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false);
-            expect(isDeepEqual(new Set([1, 2]), new Set([1, 2, 3]))).toBe(false);
-        });
-        test("should handle sets with objects", () => {
-            expect(isDeepEqual(new Set([{ a: 1 }, { b: 2 }]), new Set([{ a: 1 }, { b: 2 }]))).toBe(true);
-        });
-    });
-    describe("Map objects", () => {
-        test("should return true for identical maps", () => {
-            expect(isDeepEqual(new Map([
-                ["a", 1],
-                ["b", 2],
-            ]), new Map([
-                ["a", 1],
-                ["b", 2],
-            ]))).toBe(true);
-            expect(isDeepEqual(new Map([
-                ["a", 1],
-                ["b", 2],
-            ]), new Map([
-                ["b", 2],
-                ["a", 1],
-            ]))).toBe(true);
-        });
-        test("should return false for different maps", () => {
-            expect(isDeepEqual(new Map([
-                ["a", 1],
-                ["b", 2],
-            ]), new Map([
-                ["a", 1],
-                ["b", 3],
-            ]))).toBe(false);
-            expect(isDeepEqual(new Map([["a", 1]]), new Map([
-                ["a", 1],
-                ["b", 2],
-            ]))).toBe(false);
-        });
-    });
-    describe("TypedArray", () => {
-        test("should return true for identical typed arrays", () => {
-            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true);
-            expect(isDeepEqual(new Int16Array([10, 20, 30]), new Int16Array([10, 20, 30]))).toBe(true);
-        });
-        test("should return false for different typed arrays", () => {
-            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))).toBe(false);
-        });
-        test("should return false for typed arrays with different types", () => {
-            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Int8Array([1, 2, 3]))).toBe(false);
-        });
-        test("should return false for typed arrays with different lengths", () => {
-            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2]))).toBe(false);
-            expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2, 3]))).toBe(false);
-        });
-    });
-    describe("circular references", () => {
-        test("should handle circular references", () => {
-            const obj1 = { a: 1 };
-            obj1.self = obj1;
-            const obj2 = { a: 1 };
-            obj2.self = obj2;
-            expect(isDeepEqual(obj1, obj2)).toBe(true);
-        });
-    });
-    describe("mixed types", () => {
-        test("should return false for different types", () => {
-            expect(isDeepEqual(1, "1")).toBe(false);
-            expect(isDeepEqual([1], { 0: 1 })).toBe(false);
-            expect(isDeepEqual(null, {})).toBe(false);
-            expect(isDeepEqual(undefined, null)).toBe(false);
-        });
-        test("should handle complex nested structures", () => {
-            const obj1 = {
-                a: [1, 2, { b: 3 }],
-                c: new Set([4, 5]),
-                d: new Map([["e", 6]]),
-                f: new Date("2024-01-01"),
-            };
-            const obj2 = {
-                a: [1, 2, { b: 3 }],
-                c: new Set([4, 5]),
-                d: new Map([["e", 6]]),
-                f: new Date("2024-01-01"),
-            };
-            expect(isDeepEqual(obj1, obj2)).toBe(true);
-        });
-    });
-});

package/dist/tests/isValidBranchName.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/isValidBranchName.test.js

@@ -1,89 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { isValidBranchName } from "../lib/isValidBranchName.js";
-describe("isValidBranchName", () => {
-    describe("valid branch names", () => {
-        test("should return true for simple branch names", () => {
-            expect(isValidBranchName("main")).toBe(true);
-            expect(isValidBranchName("develop")).toBe(true);
-            expect(isValidBranchName("feature")).toBe(true);
-        });
-        test("should return true for branch names with hyphens", () => {
-            expect(isValidBranchName("feature-branch")).toBe(true);
-            expect(isValidBranchName("bug-fix")).toBe(true);
-        });
-        test("should return true for branch names with underscores", () => {
-            expect(isValidBranchName("feature_branch")).toBe(true);
-            expect(isValidBranchName("bug_fix")).toBe(true);
-        });
-        test("should return true for branch names with dots", () => {
-            expect(isValidBranchName("release.1.0")).toBe(true);
-            expect(isValidBranchName("v1.2.3")).toBe(true);
-        });
-        test("should return true for branch names with slashes", () => {
-            expect(isValidBranchName("feature/new-feature")).toBe(true);
-            expect(isValidBranchName("bugfix/issue-123")).toBe(true);
-            expect(isValidBranchName("release/v1.0.0")).toBe(true);
-        });
-        test("should return true for branch names with numbers", () => {
-            expect(isValidBranchName("feature123")).toBe(true);
-            expect(isValidBranchName("v1.2.3")).toBe(true);
-        });
-        test("should return true for mixed valid characters", () => {
-            expect(isValidBranchName("feature/ABC-123_test.v1")).toBe(true);
-            expect(isValidBranchName("release/2024.01.01")).toBe(true);
-        });
-    });
-    describe("invalid branch names", () => {
-        test("should return false for empty strings", () => {
-            expect(isValidBranchName("")).toBe(false);
-        });
-        test("should return false for branch names with invalid characters", () => {
-            expect(isValidBranchName("feature@branch")).toBe(false);
-            expect(isValidBranchName("bug#fix")).toBe(false);
-            expect(isValidBranchName("test branch")).toBe(false);
-            expect(isValidBranchName("feature:branch")).toBe(false);
-        });
-        test("should return false for branch names with double dots", () => {
-            expect(isValidBranchName("feature..branch")).toBe(false);
-            expect(isValidBranchName("test..test")).toBe(false);
-        });
-        test("should return false for branch names starting with slash", () => {
-            expect(isValidBranchName("/feature")).toBe(false);
-            expect(isValidBranchName("/main")).toBe(false);
-        });
-        test("should return false for branch names ending with slash", () => {
-            expect(isValidBranchName("feature/")).toBe(false);
-            expect(isValidBranchName("main/")).toBe(false);
-        });
-        test("should return false for branch names with double slashes", () => {
-            expect(isValidBranchName("feature//branch")).toBe(false);
-            expect(isValidBranchName("test//test")).toBe(false);
-        });
-        test("should return false for branch names ending with dot", () => {
-            expect(isValidBranchName("feature.")).toBe(false);
-            expect(isValidBranchName("branch.")).toBe(false);
-        });
-        test("should return false for components starting with dot", () => {
-            expect(isValidBranchName("feature/.hidden")).toBe(false);
-            expect(isValidBranchName(".hidden/branch")).toBe(false);
-        });
-        test("should return false for components ending with .lock", () => {
-            expect(isValidBranchName("feature/branch.lock")).toBe(false);
-            expect(isValidBranchName("test.lock")).toBe(false);
-        });
-    });
-    describe("edge cases", () => {
-        test("should handle single character branch names", () => {
-            expect(isValidBranchName("a")).toBe(true);
-            expect(isValidBranchName("1")).toBe(true);
-        });
-        test("should handle very long branch names", () => {
-            const longName = "a".repeat(255);
-            expect(isValidBranchName(longName)).toBe(true);
-        });
-        test("should handle branch names with multiple slashes", () => {
-            expect(isValidBranchName("feature/sub/branch")).toBe(true);
-            expect(isValidBranchName("a/b/c/d/e")).toBe(true);
-        });
-    });
-});

package/dist/tests/match.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/match.test.js

@@ -1,86 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { matchPattern } from "../lib/match.js";
-describe("matchPattern", () => {
-    describe("exact string matching", () => {
-        test("should match identical strings", () => {
-            expect(matchPattern("hello", "hello")).toBe(true);
-            expect(matchPattern("test123", "test123")).toBe(true);
-        });
-        test("should not match different strings", () => {
-            expect(matchPattern("hello", "world")).toBe(false);
-            expect(matchPattern("test", "test123")).toBe(false);
-        });
-        test("should be case-sensitive for exact matches", () => {
-            expect(matchPattern("Hello", "hello")).toBe(false);
-            expect(matchPattern("TEST", "test")).toBe(false);
-        });
-        test("should handle empty strings", () => {
-            expect(matchPattern("", "")).toBe(true);
-            expect(matchPattern("test", "")).toBe(false);
-            expect(matchPattern("", "test")).toBe(false);
-        });
-    });
-    describe("regex pattern matching", () => {
-        test("should match regex patterns with delimiters", () => {
-            expect(matchPattern("hello", "/hello/")).toBe(true);
-            expect(matchPattern("test123", "/test\\d+/")).toBe(true);
-            expect(matchPattern("abc", "/[a-z]+/")).toBe(true);
-        });
-        test("should not match when regex pattern doesn't match", () => {
-            expect(matchPattern("hello", "/world/")).toBe(false);
-            expect(matchPattern("abc", "/\\d+/")).toBe(false);
-        });
-        test("should support regex flags", () => {
-            expect(matchPattern("Hello", "/hello/i")).toBe(true);
-            expect(matchPattern("TEST", "/test/i")).toBe(true);
-            expect(matchPattern("Hello", "/hello/")).toBe(false);
-        });
-        test("should support global flag", () => {
-            expect(matchPattern("test test", "/test/g")).toBe(true);
-        });
-        test("should support multiline flag", () => {
-            expect(matchPattern("line1\nline2", "/^line2/m")).toBe(true);
-        });
-        test("should handle complex regex patterns", () => {
-            expect(matchPattern("email@example.com", "/^[\\w.-]+@[\\w.-]+\\.\\w+$/")).toBe(true);
-            expect(matchPattern("2024-01-01", "/^\\d{4}-\\d{2}-\\d{2}$/")).toBe(true);
-            expect(matchPattern("invalid-date", "/^\\d{4}-\\d{2}-\\d{2}$/")).toBe(false);
-        });
-        test("should handle patterns with special characters", () => {
-            expect(matchPattern("(test)", "/\\(test\\)/")).toBe(true);
-            expect(matchPattern("[abc]", "/\\[abc\\]/")).toBe(true);
-            expect(matchPattern("a.b", "/a\\.b/")).toBe(true);
-        });
-        test("should return false for invalid regex patterns", () => {
-            expect(matchPattern("test", "/(/")).toBe(false);
-            expect(matchPattern("test", "/[/")).toBe(false);
-            expect(matchPattern("test", "/*/")).toBe(false);
-        });
-        test("should handle patterns with multiple slashes", () => {
-            expect(matchPattern("path/to/file", "/path\\/to\\/file/")).toBe(true);
-        });
-    });
-    describe("edge cases", () => {
-        test("should treat patterns without proper delimiters as exact strings", () => {
-            expect(matchPattern("/test", "/test")).toBe(true);
-            expect(matchPattern("test/", "test/")).toBe(true);
-        });
-        test("should handle patterns that look like regex but aren't properly formatted", () => {
-            expect(matchPattern("/test", "/test")).toBe(true);
-            expect(matchPattern("test/", "test/")).toBe(true);
-        });
-        test("should handle empty regex pattern", () => {
-            expect(matchPattern("test", "//")).toBe(true);
-            expect(matchPattern("", "//")).toBe(true);
-        });
-        test("should handle patterns with only opening slash", () => {
-            expect(matchPattern("/hello", "/hello")).toBe(true);
-            expect(matchPattern("hello", "/hello")).toBe(false);
-        });
-        test("should handle anchored patterns", () => {
-            expect(matchPattern("hello world", "/^hello/")).toBe(true);
-            expect(matchPattern("hello world", "/world$/")).toBe(true);
-            expect(matchPattern("hello world", "/^world/")).toBe(false);
-        });
-    });
-});

package/dist/tests/package.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/package.test.js

@@ -1,77 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { loadPackageJson } from "../lib/package.js";
-describe("loadPackageJson", () => {
-    let testDir;
-    let testScriptPath;
-    beforeEach(() => {
-        testDir = join(tmpdir(), `package-test-${Date.now()}`);
-        const scriptDir = join(testDir, "lib");
-        Bun.spawnSync(["mkdir", "-p", scriptDir]);
-        testScriptPath = join(scriptDir, "test-script.js");
-    });
-    afterEach(() => {
-        Bun.spawnSync(["rm", "-rf", testDir]);
-    });
-    test("should load and parse package.json", () => {
-        const packageJson = {
-            name: "test-package",
-            version: "1.0.0",
-            description: "Test package",
-        };
-        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
-        writeFileSync(testScriptPath, "");
-        const scriptUrl = `file://${testScriptPath}`;
-        const result = loadPackageJson(scriptUrl);
-        expect(result.name).toBe("test-package");
-        expect(result.version).toBe("1.0.0");
-        // biome-ignore lint/complexity/useLiteralKeys: ignore
-        expect(result["description"]).toBe("Test package");
-    });
-    test("should handle package.json with additional properties", () => {
-        const packageJson = {
-            name: "test-package",
-            version: "2.0.0",
-            author: "Test Author",
-            license: "MIT",
-            dependencies: {
-                "some-package": "^1.0.0",
-            },
-        };
-        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
-        writeFileSync(testScriptPath, "");
-        const scriptUrl = `file://${testScriptPath}`;
-        const result = loadPackageJson(scriptUrl);
-        expect(result.name).toBe("test-package");
-        expect(result.version).toBe("2.0.0");
-        // biome-ignore lint/complexity/useLiteralKeys: ignore
-        expect(result["author"]).toBe("Test Author");
-        // biome-ignore lint/complexity/useLiteralKeys: ignore
-        expect(result["license"]).toBe("MIT");
-    });
-    test("should throw error when package.json doesn't exist", () => {
-        writeFileSync(testScriptPath, "");
-        const scriptUrl = `file://${testScriptPath}`;
-        expect(() => loadPackageJson(scriptUrl)).toThrow();
-    });
-    test("should throw error for invalid JSON in package.json", () => {
-        writeFileSync(join(testDir, "package.json"), "{ invalid json }");
-        writeFileSync(testScriptPath, "");
-        const scriptUrl = `file://${testScriptPath}`;
-        expect(() => loadPackageJson(scriptUrl)).toThrow();
-    });
-    test("should handle package.json with minimal required fields", () => {
-        const packageJson = {
-            name: "minimal-package",
-            version: "0.0.1",
-        };
-        writeFileSync(join(testDir, "package.json"), JSON.stringify(packageJson));
-        writeFileSync(testScriptPath, "");
-        const scriptUrl = `file://${testScriptPath}`;
-        const result = loadPackageJson(scriptUrl);
-        expect(result.name).toBe("minimal-package");
-        expect(result.version).toBe("0.0.1");
-    });
-});

package/dist/tests/sanitizeString.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/sanitizeString.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { sanitizeString } from "../lib/sanitizeString.js";
-describe("sanitizeString", () => {
-    test("should return unchanged string for printable ASCII characters", () => {
-        expect(sanitizeString("Hello World")).toBe("Hello World");
-        expect(sanitizeString("ABC123")).toBe("ABC123");
-        expect(sanitizeString("!@#$%^&*()")).toBe("!@#$%^&*()");
-    });
-    test("should preserve newlines", () => {
-        expect(sanitizeString("line1\nline2")).toBe("line1\nline2");
-        expect(sanitizeString("first\nsecond\nthird")).toBe("first\nsecond\nthird");
-    });
-    test("should preserve carriage returns", () => {
-        expect(sanitizeString("line1\rline2")).toBe("line1\rline2");
-    });
-    test("should preserve tabs", () => {
-        expect(sanitizeString("column1\tcolumn2")).toBe("column1\tcolumn2");
-        expect(sanitizeString("\tindented")).toBe("\tindented");
-    });
-    test("should remove non-printable characters", () => {
-        expect(sanitizeString("test\x00string")).toBe("teststring");
-        expect(sanitizeString("hello\x01world")).toBe("helloworld");
-        expect(sanitizeString("test\x1Bstring")).toBe("teststring");
-    });
-    test("should remove ANSI escape codes", () => {
-        expect(sanitizeString("\x1b[31mRed Text\x1b[0m")).toBe("[31mRed Text[0m");
-        expect(sanitizeString("\x1b[1;32mGreen\x1b[0m")).toBe("[1;32mGreen[0m");
-    });
-    test("should handle empty strings", () => {
-        expect(sanitizeString("")).toBe("");
-    });
-    test("should handle strings with only non-printable characters", () => {
-        expect(sanitizeString("\x00\x01\x02")).toBe("");
-    });
-    test("should handle mixed printable and non-printable characters", () => {
-        expect(sanitizeString("Hello\x00World\x01!")).toBe("HelloWorld!");
-    });
-    test("should preserve spaces", () => {
-        expect(sanitizeString("  spaces  ")).toBe("  spaces  ");
-    });
-    test("should handle unicode characters outside printable ASCII", () => {
-        expect(sanitizeString("Hello 世界")).toBe("Hello ");
-        expect(sanitizeString("Emoji 😀 test")).toBe("Emoji  test");
-    });
-    test("should handle strings with newlines, tabs, and carriage returns mixed", () => {
-        expect(sanitizeString("line1\nline2\tcolumn\rend")).toBe("line1\nline2\tcolumn\rend");
-    });
-});