pema 0.4.0 → 0.6.0

package/lib/private/spec/bigint.js

@@ -1,73 +1,62 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, min, max) => {
     test.case("fail", assert => {
-        assert(() => i.parse("1")).throws(expect("bi", "1"));
-        assert(() => i.parse(1.1)).throws(expect("bi", 1.1));
-        assert(() => i.parse(-1.1)).throws(expect("bi", -1.1));
-        assert(() => i.parse(0)).throws(expect("bi", 0));
-        assert(() => i.parse(1)).throws(expect("bi", 1));
+        assert(t).invalid_type(["1", 1.1, -1.1, 0, 1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(0n)).equals(0n).type();
-        assert(i.parse(1n)).equals(1n).type();
+        assert(t).type();
+        assert(t.parse(0n)).equals(0n).type();
+        assert(t.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        assert(i.parse(min)).equals(min).type();
-        assert(i.parse(max)).equals(max).type();
-        assert(() => i.parse(min - 1n)).throws(`${min - 1n} is out of range`);
-        assert(() => i.parse(max + 1n)).throws(`${max + 1n} is out of range`);
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([min - 1n, max + 1n]);
     });
     test.case("coerced", assert => {
-        const coerced = i.coerce;
-        assert(coerced.parse(0n)).equals(0n).type();
-        assert(coerced.parse(1n)).equals(1n).type();
-        assert(coerced.parse(0)).equals(0n).type();
-        assert(coerced.parse(1)).equals(1n).type();
-        assert(coerced.parse("1")).equals(1n).type();
-        assert(coerced.parse("1.0")).equals(1n).type();
-        assert(coerced.parse("1.")).equals(1n).type();
-        assert(() => coerced.parse("0.1")).throws(expect("bi", "0.1"));
-        assert(() => coerced.parse(".1")).throws(expect("bi", ".1"));
-        assert(coerced.parse(-1)).equals(-1n).type();
-        assert(coerced.parse("-1")).equals(-1n).type();
-        assert(coerced.parse("-1.0")).equals(-1n).type();
-        assert(coerced.parse("-1.")).equals(-1n).type();
-        assert(() => coerced.parse("-0.1")).throws(expect("bi", "-0.1"));
-        assert(() => coerced.parse("-.1")).throws(expect("bi", "-.1"));
+        assert(t.coerce(0n)).equals(0n).type();
+        assert(t.coerce(1n)).equals(1n).type();
+        assert(t.coerce(0)).equals(0n).type();
+        assert(t.coerce(1)).equals(1n).type();
+        assert(t.coerce("1")).equals(1n).type();
+        assert(t.coerce("1.0")).equals(1n).type();
+        assert(t.coerce("1.")).equals(1n).type();
+        assert(t).coerce_invalid_type(["0.1", ".1"]);
+        assert(t.coerce(-1)).equals(-1n).type();
+        assert(t.coerce("-1")).equals(-1n).type();
+        assert(t.coerce("-1.0")).equals(-1n).type();
+        assert(t.coerce("-1.")).equals(-1n).type();
+        assert(t).coerce_invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [i.default(1n), i.default(() => 1n)].forEach(d => {
+        [t.default(1n), t.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
             assert(d.parse(0n)).equals(0n).type();
-            assert(() => d.parse(1.2)).throws(expect("bi", 1.2));
-            assert(() => d.parse(-1.2)).throws(expect("bi", -1.2));
+            assert(d).invalid_type([1.2, -1.2]);
         });
     });
     test.case("validator - range", assert => {
-        const r = i.range(-10n, 10n);
+        const r = t.range(-10n, 10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(-11n)).throws("-11 is out of range");
-        assert(() => r.parse(11n)).throws("11 is out of range");
+        assert(r).out_of_range([-11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(-10n);
+        const r = t.min(-10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(-11n)).throws("-11 is lower than min (-10)");
+        assert(r).too_small([-11n]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10n);
+        const r = t.max(10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(11n)).throws("11 is greater than max (10)");
+        assert(r).too_large([11n]);
     });
 };
 //# sourceMappingURL=bigint.js.map

package/lib/private/spec/biguint.d.ts

@@ -1,5 +1,5 @@
 import type BigUintDataType from "#BigUintDataType";
 import type BigUintType from "#BigUintType";
-declare const _default: <T extends BigUintDataType>(i: BigUintType<T>, min: bigint, max: bigint) => void;
+declare const _default: <T extends BigUintDataType>(t: BigUintType<T>, min: bigint, max: bigint) => void;
 export default _default;
 //# sourceMappingURL=biguint.d.ts.map

package/lib/private/spec/biguint.js

@@ -1,73 +1,57 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, min, max) => {
     test.case("fail", assert => {
-        assert(() => i.parse("1")).throws(expect("bi", "1"));
-        assert(() => i.parse(1.1)).throws(expect("bi", 1.1));
-        assert(() => i.parse(-1.1)).throws(expect("bi", -1.1));
-        assert(() => i.parse(-1n)).throws("-1 is out of range");
-        assert(() => i.parse(0)).throws(expect("bi", 0));
-        assert(() => i.parse(1)).throws(expect("bi", 1));
+        assert(t).invalid_type(["1", 0, 1, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(0n)).equals(0n).type();
-        assert(i.parse(1n)).equals(1n).type();
+        assert(t).type();
+        assert(t.parse(0n)).equals(0n).type();
+        assert(t.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        assert(i.parse(min)).equals(min).type();
-        assert(i.parse(max)).equals(max).type();
-        assert(() => i.parse(min - 1n)).throws(`${min - 1n} is out of range`);
-        assert(() => i.parse(max + 1n)).throws(`${max + 1n} is out of range`);
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([-1n, min - 1n, max + 1n]);
     });
     test.case("coerced", assert => {
-        const coerced = i.coerce;
-        assert(coerced.parse(0n)).equals(0n).type();
-        assert(coerced.parse(1n)).equals(1n).type();
-        assert(coerced.parse(0)).equals(0n).type();
-        assert(coerced.parse(1)).equals(1n).type();
-        assert(coerced.parse("1")).equals(1n).type();
-        assert(coerced.parse("1.0")).equals(1n).type();
-        assert(coerced.parse("1.")).equals(1n).type();
-        assert(() => coerced.parse("0.1")).throws(expect("bi", "0.1"));
-        assert(() => coerced.parse(".1")).throws(expect("bi", ".1"));
-        assert(() => coerced.parse(-1)).throws("-1 is out of range");
-        assert(() => coerced.parse("-1")).throws("-1 is out of range");
-        assert(() => coerced.parse("-1.0")).throws("-1 is out of range");
-        assert(() => coerced.parse("-1.")).throws("-1 is out of range");
-        assert(() => coerced.parse("-0.1")).throws(expect("bi", "-0.1"));
-        assert(() => coerced.parse("-.1")).throws(expect("bi", "-.1"));
+        assert(t.coerce(0n)).equals(0n).type();
+        assert(t.coerce(1n)).equals(1n).type();
+        assert(t.coerce(0)).equals(0n).type();
+        assert(t.coerce(1)).equals(1n).type();
+        assert(t.coerce("1")).equals(1n).type();
+        assert(t.coerce("1.0")).equals(1n).type();
+        assert(t.coerce("1.")).equals(1n).type();
+        assert(t).coerce_invalid_type(["0.1", .1, "-0.1", "-.1"]);
+        assert(t).coerce_out_of_range([-1, "-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [i.default(1n), i.default(() => 1n)].forEach(d => {
+        [t.default(1n), t.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
             assert(d.parse(0n)).equals(0n).type();
-            assert(() => d.parse(1.2)).throws(expect("bi", 1.2));
-            assert(() => d.parse(-1.2)).throws(expect("bi", -1.2));
+            assert(d).invalid_type([1.2, -1.2]);
         });
     });
     test.case("validator - range", assert => {
-        const r = i.range(0n, 10n);
+        const r = t.range(0n, 10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(-1n)).throws("-1 is out of range");
-        assert(() => r.parse(-11n)).throws("-11 is out of range");
-        assert(() => r.parse(11n)).throws("11 is out of range");
+        assert(r).out_of_range([-1n, -11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(0n);
-        assert(r.parse(0n)).equals(0n).type();
+        const r = t.min(10n);
+        assert(r.parse(20n)).equals(20n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(-1n)).throws("-1 is out of range");
+        assert(r).out_of_range([-1n]);
+        assert(r).too_small([0n]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10n);
+        const r = t.max(10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
-        assert(() => r.parse(-1n)).throws("-1 is out of range");
-        assert(() => r.parse(11n)).throws("11 is greater than max (10)");
+        assert(r).out_of_range([-1n]);
+        assert(r).too_large([11n]);
     });
 };
 //# sourceMappingURL=biguint.js.map

package/lib/private/spec/int.d.ts

@@ -1,5 +1,5 @@
 import type IntDataType from "#IntDataType";
 import type IntType from "#IntType";
-declare const _default: <T extends IntDataType>(i: IntType<T>, min: number, max: number) => void;
+declare const _default: <T extends IntDataType>(t: IntType<T>, min: number, max: number) => void;
 export default _default;
 //# sourceMappingURL=int.d.ts.map

package/lib/private/spec/int.js

@@ -1,70 +1,59 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, min, max) => {
     test.case("fail", assert => {
-        assert(() => i.parse("1")).throws(expect("n", "1"));
-        assert(() => i.parse(1.1)).throws("1.1 is not an integer");
-        assert(() => i.parse(-1.1)).throws("-1.1 is not an integer");
-        assert(() => i.parse(0n)).throws(expect("n", 0n));
-        assert(() => i.parse(1n)).throws(expect("n", 1n));
+        assert(t).invalid_type(["1", 0n, 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(0)).equals(0).type();
-        assert(i.parse(1)).equals(1).type();
+        assert(t).type();
+        assert(t.parse(0)).equals(0).type();
+        assert(t.parse(1)).equals(1).type();
     });
     test.case("range", assert => {
-        assert(i.parse(min)).equals(min).type();
-        assert(i.parse(max)).equals(max).type();
-        assert(() => i.parse(min - 1)).throws(`${min - 1} is out of range`);
-        assert(() => i.parse(max + 1)).throws(`${max + 1} is out of range`);
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([min - 1, max + 1]);
     });
     test.case("coerced", assert => {
-        const coerced = i.coerce;
-        assert(coerced.parse(0)).equals(0).type();
-        assert(coerced.parse(1)).equals(1).type();
-        assert(coerced.parse("1")).equals(1).type();
-        assert(coerced.parse("1.0")).equals(1).type();
-        assert(coerced.parse("1.")).equals(1).type();
-        assert(() => coerced.parse("0.1")).throws("0.1 is not an integer");
-        assert(() => coerced.parse(".1")).throws("0.1 is not an integer");
-        assert(coerced.parse("-1")).equals(-1).type();
-        assert(coerced.parse("-1.0")).equals(-1).type();
-        assert(coerced.parse("-1.")).equals(-1).type();
-        assert(() => coerced.parse("-0.1")).throws("-0.1 is not an integer");
-        assert(() => coerced.parse("-.1")).throws("-0.1 is not an integer");
+        assert(t.coerce(0)).equals(0).type();
+        assert(t.coerce(1)).equals(1).type();
+        assert(t.coerce("1")).equals(1).type();
+        assert(t.coerce("1.0")).equals(1).type();
+        assert(t.coerce("1.")).equals(1).type();
+        assert(t).invalid_type(["0.1", ".1"]);
+        assert(t.coerce("-1")).equals(-1).type();
+        assert(t.coerce("-1.0")).equals(-1).type();
+        assert(t.coerce("-1.")).equals(-1).type();
+        assert(t).invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [i.default(1), i.default(() => 1)].forEach(d => {
+        [t.default(1), t.default(() => 1)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1).type();
             assert(d.parse(1)).equals(1).type();
             assert(d.parse(0)).equals(0).type();
-            assert(() => d.parse(1.2)).throws("1.2 is not an integer");
-            assert(() => d.parse(-1.2)).throws("-1.2 is not an integer");
+            assert(d).invalid_type(["1.2", "-1.2"]);
         });
     });
     test.case("validator - range", assert => {
-        const r = i.range(-10, 10);
+        const r = t.range(-10, 10);
         assert(r.parse(-10)).equals(-10).type();
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-11)).throws("-11 is out of range");
-        assert(() => r.parse(11)).throws("11 is out of range");
+        assert(r).out_of_range([-11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(-10);
+        const r = t.min(-10);
         assert(r.parse(-10)).equals(-10).type();
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-11)).throws("-11 is lower than min (-10)");
+        assert(r).too_small([-11]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10);
+        const r = t.max(10);
         assert(r.parse(-10)).equals(-10).type();
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(11)).throws("11 is greater than max (10)");
+        assert(r).too_large([11]);
     });
 };
 //# sourceMappingURL=int.js.map

package/lib/private/spec/uint.d.ts

@@ -1,5 +1,5 @@
 import type UintDataType from "#UintDataType";
 import type UintType from "#UintType";
-declare const _default: <T extends UintDataType>(i: UintType<T>, min: number, max: number) => void;
+declare const _default: <T extends UintDataType>(t: UintType<T>, min: number, max: number) => void;
 export default _default;
 //# sourceMappingURL=uint.d.ts.map

package/lib/private/spec/uint.js

@@ -1,73 +1,61 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, min, max) => {
     test.case("fail", assert => {
-        assert(() => i.parse("1")).throws(expect("n", "1"));
-        assert(() => i.parse(1.1)).throws("1.1 is not an integer");
-        assert(() => i.parse(-1.1)).throws("-1.1 is not an integer");
-        assert(() => i.parse(-1)).throws("-1 is out of range");
-        assert(() => i.parse(1n)).throws(expect("n", 1n));
+        assert(t).invalid_type(["1", 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(1)).equals(1).type();
+        assert(t).type();
+        assert(t.parse(1)).equals(1).type();
     });
     test.case("range", assert => {
-        assert(i.parse(0)).equals(0).type();
-        assert(i.parse(min)).equals(min).type();
-        assert(i.parse(max)).equals(max).type();
-        assert(() => i.parse(min - 1)).throws(`${min - 1} is out of range`);
-        assert(() => i.parse(max + 1)).throws(`${max + 1} is out of range`);
-    });
-    test.case("coerced", assert => {
-        const coerced = i.coerce;
-        assert(coerced.parse(0)).equals(0).type();
-        assert(coerced.parse(1)).equals(1).type();
-        assert(coerced.parse("1")).equals(1).type();
-        assert(coerced.parse("1.0")).equals(1).type();
-        assert(coerced.parse("1.")).equals(1).type();
-        assert(() => coerced.parse("0.1")).throws("0.1 is not an integer");
-        assert(() => coerced.parse(".1")).throws("0.1 is not an integer");
-        assert(() => coerced.parse("-1")).throws("-1 is out of range");
-        assert(() => coerced.parse("-1.0")).throws("-1 is out of range");
-        assert(() => coerced.parse("-1.")).throws("-1 is out of range");
+        assert(t.parse(0)).equals(0).type();
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([-1, min - 1, max + 1]);
+    });
+    test.case("coerce", assert => {
+        assert(t.coerce(0)).equals(0).type();
+        assert(t.coerce(1)).equals(1).type();
+        assert(t.coerce("1")).equals(1).type();
+        assert(t.coerce("1.0")).equals(1).type();
+        assert(t.coerce("1.")).equals(1).type();
+        assert(t).coerce_invalid_type(["0.1", ".1"]);
+        assert(t).coerce_out_of_range(["-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [i.default(1), i.default(() => 1)].forEach(d => {
+        [t.default(1), t.default(() => 1)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1).type();
             assert(d.parse(1)).equals(1).type();
             assert(d.parse(0)).equals(0).type();
-            assert(() => d.parse(1.2)).throws("1.2 is not an integer");
-            assert(() => d.parse(-1.2)).throws("-1.2 is not an integer");
+            assert(d).invalid_type(["1.2", "-1.2"]);
         });
-        [i.default(-1), i.default(() => -1)].forEach(d => {
+        [t.default(-1), t.default(() => -1)].forEach(d => {
             assert(d).type();
-            assert(() => d.parse(undefined)).throws("-1 is out of range");
+            assert(d).out_of_range([undefined]);
             assert(d.parse(1)).equals(1).type();
             assert(d.parse(0)).equals(0).type();
         });
     });
     test.case("validator - range", assert => {
-        const r = i.range(0, 10);
+        const r = t.range(0, 10);
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-1)).throws("-1 is out of range");
-        assert(() => r.parse(-11)).throws("-11 is out of range");
-        assert(() => r.parse(11)).throws("11 is out of range");
+        assert(r).out_of_range([-1, -11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(0);
-        assert(r.parse(0)).equals(0).type();
+        const r = t.min(10);
+        assert(r.parse(20)).equals(20).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-1)).throws("-1 is out of range");
+        assert(r).out_of_range([-1]);
+        assert(r).too_small([0]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10);
+        const r = t.max(10);
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-1)).throws("-1 is out of range");
-        assert(() => r.parse(11)).throws("11 is greater than max (10)");
+        assert(r).out_of_range([-1]);
+        assert(r).too_large([11]);
     });
 };
 //# sourceMappingURL=uint.js.map

package/lib/private/test.d.ts

@@ -0,0 +1,34 @@
+import type IssueType from "#IssueType";
+import type { JSONPointer } from "@rcompat/type";
+type Input = [unknown, string?];
+type IssueMatcher = {
+    type: IssueType;
+    path?: string;
+    message?: string;
+};
+declare const _default: import("@rcompat/test/index").ExtendedTest<{
+    parse_issue: (type: IssueType, inputs: Input[]) => void;
+    coerce_issue: (type: IssueType, inputs: Input[]) => void;
+    parse_issues(input: unknown, matchers: IssueMatcher[]): void;
+    coerce_issues(input: unknown, matchers: IssueMatcher[]): void;
+} & {
+    invalid_type: (inputs: unknown[], path?: JSONPointer) => void;
+    invalid_format: (inputs: unknown[], path?: JSONPointer) => void;
+    too_small: (inputs: unknown[], path?: JSONPointer) => void;
+    too_large: (inputs: unknown[], path?: JSONPointer) => void;
+    out_of_range: (inputs: unknown[], path?: JSONPointer) => void;
+    not_in_set: (inputs: unknown[], path?: JSONPointer) => void;
+    duplicate: (inputs: unknown[], path?: JSONPointer) => void;
+    network_error: (inputs: unknown[], path?: JSONPointer) => void;
+} & {
+    coerce_invalid_type: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_invalid_format: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_too_small: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_too_large: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_out_of_range: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_not_in_set: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_duplicate: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_network_error: (inputs: unknown[], path?: JSONPointer) => void;
+}>;
+export default _default;
+//# sourceMappingURL=test.d.ts.map

package/lib/private/test.js

@@ -0,0 +1,107 @@
+import ParseError from "#ParseError";
+import test from "@rcompat/test";
+const issue_types = [
+    "invalid_type",
+    "invalid_format",
+    "too_small",
+    "too_large",
+    "out_of_range",
+    "not_in_set",
+    "duplicate",
+];
+export default test.extend((assert, subject) => {
+    const parse_issue = (type, inputs) => {
+        for (const [input, path] of inputs) {
+            try {
+                subject.parse(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    const issue = e.issues[0];
+                    assert(issue.type).equals(type);
+                    if (path !== undefined)
+                        assert(issue.path).equals(path);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    };
+    const coerce_issue = (type, inputs) => {
+        for (const [input, path] of inputs) {
+            try {
+                subject.coerce(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    const issue = e.issues[0];
+                    assert(issue.type).equals(type);
+                    if (path !== undefined)
+                        assert(issue.path).equals(path);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    };
+    const shortcuts = Object.fromEntries(issue_types.flatMap(type => [
+        [type, (inputs, path = "") => parse_issue(type, inputs.map(input => [input, path]))],
+        [`coerce_${type}`, (inputs, path = "") => coerce_issue(type, inputs.map(input => [input, path]))],
+    ]));
+    return {
+        parse_issue,
+        coerce_issue,
+        parse_issues(input, matchers) {
+            try {
+                subject.parse(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    assert(e.issues.length).equals(matchers.length);
+                    for (let i = 0; i < matchers.length; i++) {
+                        assert(e.issues[i].type).equals(matchers[i].type);
+                        if (matchers[i].path !== undefined) {
+                            assert(e.issues[i].path).equals(matchers[i].path);
+                        }
+                        if (matchers[i].message !== undefined) {
+                            assert(e.issues[i].message).equals(matchers[i].message);
+                        }
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+        },
+        coerce_issues(input, matchers) {
+            try {
+                subject.coerce(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    assert(e.issues.length).equals(matchers.length);
+                    for (let i = 0; i < matchers.length; i++) {
+                        assert(e.issues[i].type).equals(matchers[i].type);
+                        if (matchers[i].path !== undefined) {
+                            assert(e.issues[i].path).equals(matchers[i].path);
+                        }
+                        if (matchers[i].message !== undefined) {
+                            assert(e.issues[i].message).equals(matchers[i].message);
+                        }
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+        },
+        ...shortcuts,
+    };
+});
+//# sourceMappingURL=test.js.map

package/lib/private/uuid.d.ts

@@ -0,0 +1,4 @@
+import UUIDType from "#UUIDType";
+declare const _default: UUIDType;
+export default _default;
+//# sourceMappingURL=uuid.d.ts.map

package/lib/private/uuid.js

@@ -0,0 +1,3 @@
+import UUIDType from "#UUIDType";
+export default new UUIDType();
+//# sourceMappingURL=uuid.js.map

package/lib/private/validator/ends-with.d.ts

@@ -1,4 +1,3 @@
 import type Validator from "#Validator";
-declare const _default: (suffix: string) => Validator<string>;
-export default _default;
+export default function ends_with(suffix: string): Validator<string>;
 //# sourceMappingURL=ends-with.d.ts.map

package/lib/private/validator/ends-with.js

@@ -1,11 +1,9 @@
-import ParseError from "#ParseError";
-export default (suffix) => (x) => {
-    if (!x.endsWith(suffix)) {
-        throw new ParseError([{
-                input: x,
-                message: `"${x}" does not end with "${suffix}"`,
-                path: "",
-            }]);
-    }
-};
+import E from "#errors";
+export default function ends_with(suffix) {
+    return (x) => {
+        if (!x.endsWith(suffix)) {
+            throw E.invalid_format(x, `"${x}" does not end with "${suffix}"`);
+        }
+    };
+}
 //# sourceMappingURL=ends-with.js.map

package/lib/private/validator/f32.js

@@ -1,11 +1,6 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 export default function f32(x) {
-    if (x !== new Float32Array([x])[0]) {
-        throw new ParseError([{
-                input: x,
-                message: `${x} is not a 32-bit float`,
-                path: "",
-            }]);
-    }
+    if (x !== new Float32Array([x])[0])
+        throw E.out_of_range(x, `${x} is not a 32-bit float`);
 }
 //# sourceMappingURL=f32.js.map