@bgord/tools 1.4.0 → 1.4.2

package/dist/tests/iban-schema.vo.test.js

@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { IbanSchema } from "../src/iban-schema.vo";
-describe("IBAN", () => {
-    test("normalizes and formats valid IBANs", () => {
-        const cases = [
-            "PL61 1090 1014 0000 0712 1981 2874",
-            "pl61 1090 1014 0000 0712 1981 2874",
-            "DE44 5001 0517 5407 3249 31",
-            "GB82WEST12345698765432",
-        ];
-        for (const value of cases) {
-            expect(v.safeParse(IbanSchema, value).success).toEqual(true);
-        }
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(IbanSchema, "_PL61 1090 1014 0000 0712 1981 2874")).toThrow("iban.schema.invalid");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(IbanSchema, "PL61 1090 1014 0000 0712 1981 2874_")).toThrow("iban.schema.invalid");
-    });
-    test("rejects non-string input - number", () => {
-        expect(() => v.parse(IbanSchema, 123)).toThrow("iban.schema.type");
-    });
-    test("rejects non-string input - null", () => {
-        expect(() => v.parse(IbanSchema, null)).toThrow("iban.schema.type");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(IbanSchema, "")).toThrow("iban.schema.invalid");
-    });
-    test("rejects invalid format", () => {
-        const invalid = [
-            "INVALID_VALUE",
-            "61 1090 1014 0000 0712 1981 2874",
-            "PL61 1090 1014 00",
-            "PL61 1090 1014 0000 0712 1981 2874 00000 00",
-            "PL61 1090 1014 $000 0712 1981 2874",
-        ];
-        for (const value of invalid) {
-            expect(() => v.parse(IbanSchema, value)).toThrow("iban.schema.invalid");
-        }
-    });
-});

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

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

package/dist/tests/iban.vo.test.js

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { IBAN } from "../src/iban.vo";
-describe("IBAN", () => {
-    test("normalizes and formats", () => {
-        const cases = [
-            [
-                "PL61 1090 1014 0000 0712 1981 2874",
-                "PL61109010140000071219812874",
-                "PL61 1090 1014 0000 0712 1981 2874",
-            ],
-            [
-                "pl61 1090 1014 0000 0712 1981 2874",
-                "PL61109010140000071219812874",
-                "PL61 1090 1014 0000 0712 1981 2874",
-            ],
-            ["DE44 5001 0517 5407 3249 31", "DE44500105175407324931", "DE44 5001 0517 5407 3249 31"],
-            ["GB82WEST12345698765432", "GB82WEST12345698765432", "GB82 WEST 1234 5698 7654 32"],
-        ];
-        for (const [input, normalized, formatted] of cases) {
-            const iban = new IBAN(input);
-            // @ts-expect-error
-            expect(iban.toString()).toEqual(normalized);
-            expect(iban.format()).toEqual(formatted);
-            expect(iban.countryCode).toEqual(normalized.slice(0, 2));
-        }
-    });
-    test("equals", () => {
-        const a = new IBAN("PL61 1090 1014 0000 0712 1981 2874");
-        const b = new IBAN("PL61109010140000071219812874");
-        const c = new IBAN("DE44 5001 0517 5407 3249 31");
-        expect(a.equals(b)).toEqual(true);
-        expect(a.equals(c)).toEqual(false);
-    });
-    test("rejects invalid format", () => {
-        const invalid = [
-            "INVALID_VALUE",
-            "61 1090 1014 0000 0712 1981 2874",
-            "PL61 1090 1014 00",
-            "PL61 1090 1014 0000 0712 1981 2874 00000 00",
-            "PL61 1090 1014 $000 0712 1981 2874",
-        ];
-        for (const value of invalid) {
-            expect(() => new IBAN(value)).toThrow("iban.schema.invalid");
-        }
-    });
-});

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

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

package/dist/tests/image.vo.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { ImageHeight, ImageWidth } from "../src/image.vo";
-describe("ImageWidth", () => {
-    test("happy path", () => {
-        expect(v.safeParse(ImageWidth, 1).success).toEqual(true);
-        expect(v.safeParse(ImageWidth, 100).success).toEqual(true);
-        expect(v.safeParse(ImageWidth, 10_000).success).toEqual(true);
-    });
-    test("rejects non-numeric - null", () => {
-        expect(() => v.parse(ImageWidth, null)).toThrow("image.width.type");
-    });
-    test("rejects non-numeric - string", () => {
-        expect(() => v.parse(ImageWidth, "100")).toThrow("image.width.type");
-    });
-    test("rejects too small", () => {
-        expect(() => v.parse(ImageWidth, 0)).toThrow("image.width.length");
-    });
-    test("rejects too big", () => {
-        expect(() => v.parse(ImageWidth, 10_001)).toThrow("image.width.length");
-    });
-});
-describe("ImageHeight", () => {
-    test("happy path", () => {
-        expect(v.safeParse(ImageHeight, 1).success).toEqual(true);
-        expect(v.safeParse(ImageHeight, 100).success).toEqual(true);
-        expect(v.safeParse(ImageHeight, 10_000).success).toEqual(true);
-    });
-    test("rejects non-numeric - null", () => {
-        expect(() => v.parse(ImageHeight, null)).toThrow("image.height.type");
-    });
-    test("rejects non-numeric - string", () => {
-        expect(() => v.parse(ImageHeight, "100")).toThrow("image.height.type");
-    });
-    test("rejects too small", () => {
-        expect(() => v.parse(ImageHeight, 0)).toThrow("image.height.length");
-    });
-    test("rejects too big", () => {
-        expect(() => v.parse(ImageHeight, 10_001)).toThrow("image.height.length");
-    });
-});

package/dist/tests/integer-non-negative.vo.test.d.ts

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

package/dist/tests/integer-non-negative.vo.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { IntegerNonNegative } from "../src/integer-non-negative.vo";
-describe("IntegerNonNegative VO", () => {
-    test("happy path", () => {
-        expect(v.safeParse(IntegerNonNegative, 0).success).toEqual(true);
-        expect(v.safeParse(IntegerNonNegative, 1).success).toEqual(true);
-        expect(v.safeParse(IntegerNonNegative, 130).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(IntegerNonNegative, null)).toThrow("integer.non.negative.type");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(IntegerNonNegative, "100")).toThrow("integer.non.negative.type");
-    });
-    test("rejects fraction", () => {
-        expect(() => v.parse(IntegerNonNegative, 100.5)).toThrow("integer.non.negative.type");
-    });
-    test("rejects negative", () => {
-        expect(() => v.parse(IntegerNonNegative, -1)).toThrow("integer.non.negative.invalid");
-    });
-});

package/dist/tests/integer-positive.vo.test.d.ts

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

package/dist/tests/integer-positive.vo.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { IntegerPositive } from "../src/integer-positive.vo";
-describe("IntegerPositive VO", () => {
-    test("happy path", () => {
-        expect(v.safeParse(IntegerPositive, 1).success).toEqual(true);
-        expect(v.safeParse(IntegerPositive, 130).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(IntegerPositive, null)).toThrow("integer.positive.type");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(IntegerPositive, "100")).toThrow("integer.positive.type");
-    });
-    test("rejects fraction", () => {
-        expect(() => v.parse(IntegerPositive, 100.5)).toThrow("integer.positive.type");
-    });
-    test("rejects 0", () => {
-        expect(() => v.parse(IntegerPositive, 0)).toThrow("integer.positive.invalid");
-    });
-});

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

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

package/dist/tests/integer.vo.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Integer } from "../src/integer.vo";
-describe("Integer VO", () => {
-    test("happy path", () => {
-        expect(v.safeParse(Integer, -130).success).toEqual(true);
-        expect(v.safeParse(Integer, -1).success).toEqual(true);
-        expect(v.safeParse(Integer, 0).success).toEqual(true);
-        expect(v.safeParse(Integer, 1).success).toEqual(true);
-        expect(v.safeParse(Integer, 130).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(Integer, null)).toThrow("integer.type");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(Integer, "100")).toThrow("integer.type");
-    });
-    test("rejects fraction", () => {
-        expect(() => v.parse(Integer, 100.5)).toThrow("integer.type");
-    });
-});

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

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

package/dist/tests/language.vo.test.js

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Language } from "../src/language.vo";
-describe("Language", () => {
-    test("happy path", () => {
-        expect(v.safeParse(Language, "en").success).toEqual(true);
-        expect(v.safeParse(Language, "es").success).toEqual(true);
-        expect(v.safeParse(Language, "pl").success).toEqual(true);
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(Language, "")).toThrow("language.bad.chars");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(Language, null)).toThrow("language.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(Language, 123)).toThrow("language.type");
-    });
-    test("rejects non-lowercase", () => {
-        expect(() => v.parse(Language, "EN")).toThrow("language.bad.chars");
-        expect(() => v.parse(Language, "ES")).toThrow("language.bad.chars");
-        expect(() => v.parse(Language, "PL")).toThrow("language.bad.chars");
-    });
-    test("rejects strings < 1 and > 2", () => {
-        expect(() => v.parse(Language, "e")).toThrow("language.bad.chars");
-        expect(() => v.parse(Language, "eng")).toThrow("language.bad.chars");
-    });
-});

package/dist/tests/linear-regression.service.test.d.ts

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

package/dist/tests/linear-regression.service.test.js

@@ -1,111 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { LinearRegression } from "../src/linear-regression.service";
-describe("LinearRegression", () => {
-    test("throws when sum of x values is too big", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: Number.MAX_SAFE_INTEGER, y: 2 },
-            { x: Number.MAX_SAFE_INTEGER, y: 4 },
-        ])).toThrow("linear.regression.sum.x.too.big");
-    });
-    test("throws when sum of y values is too big", () => {
-        expect(() => LinearRegression.fromPairs([
-            { y: Number.MAX_SAFE_INTEGER, x: 2 },
-            { y: Number.MAX_SAFE_INTEGER, x: 4 },
-        ])).toThrow("linear.regression.sum.y.too.big");
-    });
-    test("throws when sum of x times y values is too big", () => {
-        const x = 10_000_000;
-        const y = 100_000_000_000_000;
-        expect(() => LinearRegression.fromPairs([
-            { x, y },
-            { x, y },
-        ])).toThrow("linear.regression.sum.x.times.y.too.big");
-    });
-    test("throws when sum of x squared values is too big", () => {
-        const value = Number.MAX_SAFE_INTEGER;
-        expect(() => LinearRegression.fromPairs([
-            { x: value, y: 0 },
-            { x: -value, y: 0 },
-        ])).toThrow("linear.regression.sum.x.squared.too.big");
-    });
-    test("throws where no min two pairs are provided - empty array", () => {
-        expect(() => LinearRegression.fromPairs([])).toThrow("linear.regression.min.pairs");
-    });
-    test("throws where no min two pairs are provided - one", () => {
-        expect(() => LinearRegression.fromPairs([{ x: 1, y: 2 }])).toThrow("linear.regression.min.pairs");
-    });
-    test("predicts correctly from two pairs", () => {
-        const model = LinearRegression.fromPairs([
-            { x: 1, y: 2 },
-            { x: 2, y: 4 },
-        ]);
-        expect(model.predict(4)).toEqual(8);
-    });
-    test("predicts correctly from three pairs", () => {
-        const model = LinearRegression.fromPairs([
-            { x: 1, y: 2 },
-            { x: 2, y: 4 },
-            { x: 3, y: 6 },
-        ]);
-        expect(model.predict(10)).toEqual(20);
-    });
-    test("predicts correctly for line with non-zero intercept", () => {
-        const model = LinearRegression.fromPairs([
-            { x: 1, y: 3 },
-            { x: 2, y: 5 },
-        ]);
-        expect(model.predict(3)).toEqual(7);
-        expect(model.inspect()).toEqual({ a: 1, b: 2 });
-    });
-    test("works the same way when constructed directly", () => {
-        const model = LinearRegression.fromPairs([
-            { x: 1, y: 2 },
-            { x: 2, y: 4 },
-            { x: 3, y: 6 },
-        ]);
-        const params = model.inspect();
-        const reconstructed = new LinearRegression(params);
-        expect(reconstructed.predict(10)).toEqual(20);
-    });
-    test("works for all zeros in y", () => {
-        const model = LinearRegression.fromPairs([
-            { x: 0, y: 0 },
-            { x: 1, y: 0 },
-            { x: 2, y: 0 },
-        ]);
-        const params = model.inspect();
-        const reconstructed = new LinearRegression(params);
-        expect(reconstructed.predict(10)).toEqual(0);
-    });
-    test("fails for all zeros (x has zero variance)", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: 0, y: 0 },
-            { x: 0, y: 0 },
-            { x: 0, y: 0 },
-        ])).toThrow("linear.regression.model.creation");
-    });
-    test("incalculable result with identical x values", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: 0, y: 0 },
-            { x: 0, y: 0 },
-        ])).toThrow("linear.regression.model.creation");
-    });
-    test("throws when sum of x is max safe integer", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: Number.MAX_SAFE_INTEGER, y: 0 },
-            { x: 0, y: 0 },
-        ])).toThrow("linear.regression.sum.x.too.big");
-    });
-    test("throws when sum of y is max safe integer", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: 0, y: Number.MAX_SAFE_INTEGER },
-            { x: 0, y: 0 },
-        ])).toThrow("linear.regression.sum.y.too.big");
-    });
-    test("throws when sum of xy is max safe integer", () => {
-        expect(() => LinearRegression.fromPairs([
-            { x: Number.MAX_SAFE_INTEGER - 2, y: 2 },
-            { x: 0, y: 0 },
-        ])).toThrow("linear.regression.sum.x.times.y.too.big");
-    });
-});

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

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

package/dist/tests/mean.service.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Mean } from "../src/mean.service";
-import { RoundingToNearestStrategy } from "../src/rounding-to-nearest.strategy";
-describe("Mean", () => {
-    test("throws for empty values array", () => {
-        expect(() => Mean.calculate([])).toThrow("mean.not.enough.values");
-    });
-    test("works for one value", () => {
-        expect(Mean.calculate([1])).toEqual(1);
-    });
-    test("works for two values", () => {
-        expect(Mean.calculate([1, 2])).toEqual(1.5);
-    });
-    test("works for three values", () => {
-        expect(Mean.calculate([1, 3, 6])).toEqual(3.33);
-    });
-    test("works for all zeros", () => {
-        expect(Mean.calculate([0, 0, 0])).toEqual(0);
-    });
-    test("non-default rounding", () => {
-        expect(Mean.calculate([1, 3, 6], new RoundingToNearestStrategy())).toEqual(3);
-    });
-});

package/dist/tests/mime-registry-entry.vo.test.d.ts

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

package/dist/tests/mime-registry-entry.vo.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Extension } from "../src/extension.vo";
-import { Mime } from "../src/mime.vo";
-import { MimeRegistryEntry } from "../src/mime-registry-entry.vo";
-describe("MimeRegistryEntry", () => {
-    test("happy path", () => {
-        const jpegMime = Mime.fromString("image/jpeg");
-        const jpgExtension = v.parse(Extension, "jpg");
-        const jpegExtension = v.parse(Extension, "jpeg");
-        const entry = new MimeRegistryEntry(jpegMime, [jpgExtension, jpegExtension]);
-        expect(entry.mime.isSatisfiedBy(jpegMime)).toEqual(true);
-        expect(entry.extensions).toEqual([jpgExtension, jpegExtension]);
-    });
-});

package/dist/tests/mime-registry.service.test.d.ts

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

package/dist/tests/mime-registry.service.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Extension } from "../src/extension.vo";
-import { Mime } from "../src/mime.vo";
-import { MimeRegistry } from "../src/mime-registry.service";
-const jpegMime = Mime.fromString("image/jpeg");
-const jpgExtension = v.parse(Extension, "jpg");
-const jpegExtension = v.parse(Extension, "jpeg");
-const pngMime = Mime.fromString("image/png");
-const pngExtension = v.parse(Extension, "png");
-const pdfMime = Mime.fromString("application/pdf");
-const csvExtension = v.parse(Extension, "csv");
-const registry = new MimeRegistry([
-    { mime: jpegMime, extensions: [jpgExtension, jpegExtension] },
-    { mime: pngMime, extensions: [pngExtension] },
-]);
-describe("MimeRegistry", () => {
-    test("fromExtension - canonical", () => {
-        expect(registry.fromExtension(pngExtension)).toEqual(pngMime);
-    });
-    test("fromExtension - aliases", () => {
-        expect(registry.fromExtension(jpgExtension)).toEqual(jpegMime);
-        expect(registry.fromExtension(jpegExtension)).toEqual(jpegMime);
-    });
-    test("fromExtension - unknown extension", () => {
-        expect(registry.fromExtension(csvExtension)).toEqual(undefined);
-    });
-    test("toExtension", () => {
-        expect(registry.toExtension(jpegMime)).toEqual(jpgExtension);
-        expect(registry.toExtension(pngMime)).toEqual(pngExtension);
-    });
-    test("toExtension - unknown mime", () => {
-        expect(registry.toExtension(pdfMime)).toEqual(undefined);
-    });
-    test("hasExtension", () => {
-        expect(registry.hasExtension(jpgExtension)).toEqual(true);
-        expect(registry.hasExtension(jpgExtension)).toEqual(true);
-        expect(registry.hasExtension(csvExtension)).toEqual(false);
-    });
-    test("hasMime", () => {
-        expect(registry.hasMime(jpegMime)).toEqual(true);
-        expect(registry.hasMime(pngMime)).toEqual(true);
-        expect(registry.hasMime(pdfMime)).toEqual(false);
-    });
-});

package/dist/tests/mime-value.vo.test.d.ts

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

package/dist/tests/mime-value.vo.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { MimeValue } from "../src/mime-value.vo";
-describe("MimeValue", () => {
-    test("happy path", () => {
-        expect(v.safeParse(MimeValue, "text/plain").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "*/*").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "image/*").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "application/octet-stream").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "video/mp4").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "application/ace+json").success).toEqual(true);
-        expect(v.safeParse(MimeValue, "video/vnd.planar").success).toEqual(true);
-        expect(v.safeParse(MimeValue, `${"a".repeat(24)}/${"a".repeat(72)}`).success).toEqual(true);
-        expect(v.safeParse(MimeValue, "application/clue_info+xml").success).toEqual(true);
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(MimeValue, "!text/plain")).toThrow("mime.value.invalid");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(MimeValue, "text/plain!")).toThrow("mime.value.invalid");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(MimeValue, "")).toThrow("mime.value.invalid");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(MimeValue, null)).toThrow("mime.value.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(MimeValue, 123)).toThrow("mime.value.type");
-    });
-    test("rejects missing type", () => {
-        expect(() => v.parse(MimeValue, "/plain")).toThrow("mime.value.invalid");
-    });
-    test("rejects too long type", () => {
-        expect(() => v.parse(MimeValue, `${"a".repeat(25)}/plain`)).toThrow("mime.value.invalid");
-    });
-    test("rejects missing subtype", () => {
-        expect(() => v.parse(MimeValue, "text/")).toThrow("mime.value.invalid");
-    });
-    test("rejects too long subtype", () => {
-        expect(() => v.parse(MimeValue, `text/${"a".repeat(73)}`)).toThrow("mime.value.invalid");
-    });
-    test("rejects no slash", () => {
-        expect(() => v.parse(MimeValue, "text")).toThrow("mime.value.invalid");
-    });
-    test("rejects only *", () => {
-        expect(() => v.parse(MimeValue, "*")).toThrow("mime.value.invalid");
-    });
-});

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

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

package/dist/tests/mime.vo.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Mime } from "../src/mime.vo";
-describe("Mime", () => {
-    test("fromString", () => {
-        const mime = Mime.fromString("text/plain");
-        expect(mime.type).toEqual("text");
-        expect(mime.subtype).toEqual("plain");
-    });
-    test("fromString - trimmed", () => {
-        const mime = Mime.fromString("text/plain ");
-        expect(mime.type).toEqual("text");
-        expect(mime.subtype).toEqual("plain");
-    });
-    test("strips semicolon separated mime metadata", () => {
-        expect(Mime.fromString("text/plain; charset=UTF-8").toString()).toEqual("text/plain");
-    });
-    test("throws InvalidMimeError for invalid input", () => {
-        expect(() => Mime.fromString("")).toThrow("mime.value.invalid");
-        expect(() => Mime.fromString("/subtype")).toThrow("mime.value.invalid");
-        expect(() => Mime.fromString("type/")).toThrow("mime.value.invalid");
-        expect(() => Mime.fromString("no-slash")).toThrow("mime.value.invalid");
-    });
-    test("isSatisfiedBy - happy path", () => {
-        const textPlain = Mime.fromString("text/plain");
-        const textHtml = Mime.fromString("text/html");
-        const applicationJson = Mime.fromString("application/json");
-        const textWildcard = Mime.fromString("text/*");
-        const anyWildcard = Mime.fromString("*/*");
-        expect(textPlain.isSatisfiedBy(textHtml)).toEqual(false);
-        expect(textPlain.isSatisfiedBy(applicationJson)).toEqual(false);
-        expect(textPlain.isSatisfiedBy(textPlain)).toEqual(true);
-        expect(textWildcard.isSatisfiedBy(textPlain)).toEqual(true);
-        expect(anyWildcard.isSatisfiedBy(textPlain)).toEqual(true);
-    });
-    test("isSatisfiedBy - failures", () => {
-        const textPlain = Mime.fromString("text/plain");
-        const imageWildcard = Mime.fromString("image/*");
-        const wildcardPlain = Mime.fromString("*/plain");
-        const anyWildcard = Mime.fromString("*/*");
-        expect(textPlain.isSatisfiedBy(imageWildcard)).toEqual(false);
-        expect(textPlain.isSatisfiedBy(wildcardPlain)).toEqual(false);
-        expect(textPlain.isSatisfiedBy(anyWildcard)).toEqual(false);
-        expect(imageWildcard.isSatisfiedBy(wildcardPlain)).toEqual(false);
-        expect(imageWildcard.isSatisfiedBy(anyWildcard)).toEqual(false);
-        expect(wildcardPlain.isSatisfiedBy(anyWildcard)).toEqual(false);
-    });
-    test("toString", () => {
-        expect(Mime.fromString("text/plain").toString()).toEqual("text/plain");
-    });
-    test("toJSON", () => {
-        expect(Mime.fromString("text/plain").toJSON()).toEqual({ type: "text", subtype: "plain" });
-    });
-});

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

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

package/dist/tests/mimes.test.js

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Extension } from "../src/extension.vo";
-import { Mimes } from "../src/mimes";
-describe("Mimes", () => {
-    test("map", () => {
-        expect(Mimes.csv.mime.toString()).toEqual("text/csv");
-        expect(Mimes.csv.extensions).toEqual([v.parse(Extension, "csv")]);
-        expect(Mimes.jpg.mime.toString()).toEqual("image/jpeg");
-        expect(Mimes.jpg.extensions).toEqual([v.parse(Extension, "jpg"), v.parse(Extension, "jpeg")]);
-        expect(Mimes.markdown.mime.toString()).toEqual("text/markdown");
-        expect(Mimes.markdown.extensions).toEqual([v.parse(Extension, "md")]);
-        expect(Mimes.mp4.mime.toString()).toEqual("video/mp4");
-        expect(Mimes.mp4.extensions).toEqual([v.parse(Extension, "mp4")]);
-        expect(Mimes.pdf.mime.toString()).toEqual("application/pdf");
-        expect(Mimes.pdf.extensions).toEqual([v.parse(Extension, "pdf")]);
-        expect(Mimes.png.mime.toString()).toEqual("image/png");
-        expect(Mimes.png.extensions).toEqual([v.parse(Extension, "png")]);
-        expect(Mimes.text.mime.toString()).toEqual("text/plain");
-        expect(Mimes.text.extensions).toEqual([v.parse(Extension, "txt")]);
-        expect(Mimes.webp.mime.toString()).toEqual("image/webp");
-        expect(Mimes.webp.extensions).toEqual([v.parse(Extension, "webp")]);
-        expect(Mimes.wav.mime.toString()).toEqual("audio/wav");
-        expect(Mimes.wav.extensions).toEqual([v.parse(Extension, "wav")]);
-        expect(Mimes.zip.mime.toString()).toEqual("application/zip");
-        expect(Mimes.zip.extensions).toEqual([v.parse(Extension, "zip")]);
-    });
-});

package/dist/tests/min-max-scaler.service.test.d.ts

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