pema 0.6.0 → 0.7.0

package/lib/private/spec/bigint.js

@@ -1,35 +1,36 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 1.1, -1.1, 0, 1]);
+        assert(strict).invalid_type(["1", 1.1, -1.1, 0, 1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(0n)).equals(0n).type();
-        assert(t.parse(1n)).equals(1n).type();
+        assert(strict).type();
+        assert(strict.parse(0n)).equals(0n).type();
+        assert(strict.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        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 => {
-        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"]);
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([min - 1n, max + 1n]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0n)).equals(0n).type();
+        assert(loose.parse(1n)).equals(1n).type();
+        assert(loose.parse(0)).equals(0n).type();
+        assert(loose.parse(1)).equals(1n).type();
+        assert(loose.parse("1")).equals(1n).type();
+        assert(loose.parse("1.0")).equals(1n).type();
+        assert(loose.parse("1.")).equals(1n).type();
+        assert(loose).invalid_type(["0.1", ".1"]);
+        assert(loose.parse(-1)).equals(-1n).type();
+        assert(loose.parse("-1")).equals(-1n).type();
+        assert(loose.parse("-1.0")).equals(-1n).type();
+        assert(loose.parse("-1.")).equals(-1n).type();
+        assert(loose).invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [t.default(1n), t.default(() => 1n)].forEach(d => {
+        [strict.default(1n), strict.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
@@ -38,21 +39,21 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(-10n, 10n);
+        const r = strict.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).out_of_range([-11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(-10n);
+        const r = strict.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).too_small([-11n]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10n);
+        const r = strict.max(10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();

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

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

package/lib/private/spec/biguint.js

@@ -1,31 +1,32 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 0, 1, 1.1, -1.1]);
+        assert(strict).invalid_type(["1", 0, 1, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(0n)).equals(0n).type();
-        assert(t.parse(1n)).equals(1n).type();
+        assert(strict).type();
+        assert(strict.parse(0n)).equals(0n).type();
+        assert(strict.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        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 => {
-        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."]);
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([-1n, min - 1n, max + 1n]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0n)).equals(0n).type();
+        assert(loose.parse(1n)).equals(1n).type();
+        assert(loose.parse(0)).equals(0n).type();
+        assert(loose.parse(1)).equals(1n).type();
+        assert(loose.parse("1")).equals(1n).type();
+        assert(loose.parse("1.0")).equals(1n).type();
+        assert(loose.parse("1.")).equals(1n).type();
+        assert(loose).invalid_type(["0.1", .1, "-0.1", "-.1"]);
+        assert(loose).out_of_range([-1, "-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [t.default(1n), t.default(() => 1n)].forEach(d => {
+        [strict.default(1n), strict.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
@@ -34,20 +35,20 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(0n, 10n);
+        const r = strict.range(0n, 10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n, -11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(10n);
+        const r = strict.min(10n);
         assert(r.parse(20n)).equals(20n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n]);
         assert(r).too_small([0n]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10n);
+        const r = strict.max(10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n]);

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

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

package/lib/private/spec/int.js

@@ -1,32 +1,33 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 0n, 1n, 1.1, -1.1]);
+        assert(strict).invalid_type(["1", 0n, 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(0)).equals(0).type();
-        assert(t.parse(1)).equals(1).type();
+        assert(strict).type();
+        assert(strict.parse(0)).equals(0).type();
+        assert(strict.parse(1)).equals(1).type();
     });
     test.case("range", assert => {
-        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 => {
-        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"]);
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([min - 1, max + 1]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0)).equals(0).type();
+        assert(loose.parse(1)).equals(1).type();
+        assert(loose.parse("1")).equals(1).type();
+        assert(loose.parse("1.0")).equals(1).type();
+        assert(loose.parse("1.")).equals(1).type();
+        assert(strict).invalid_type(["0.1", ".1"]);
+        assert(loose.parse("-1")).equals(-1).type();
+        assert(loose.parse("-1.0")).equals(-1).type();
+        assert(loose.parse("-1.")).equals(-1).type();
+        assert(strict).invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [t.default(1), t.default(() => 1)].forEach(d => {
+        [strict.default(1), strict.default(() => 1)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1).type();
             assert(d.parse(1)).equals(1).type();
@@ -35,21 +36,21 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(-10, 10);
+        const r = strict.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).out_of_range([-11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(-10);
+        const r = strict.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).too_small([-11]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10);
+        const r = strict.max(10);
         assert(r.parse(-10)).equals(-10).type();
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();

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

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

package/lib/private/spec/uint.js

@@ -1,36 +1,37 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 1n, 1.1, -1.1]);
+        assert(strict).invalid_type(["1", 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(1)).equals(1).type();
+        assert(strict).type();
+        assert(strict.parse(1)).equals(1).type();
     });
     test.case("range", assert => {
-        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."]);
+        assert(strict.parse(0)).equals(0).type();
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([-1, min - 1, max + 1]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0)).equals(0).type();
+        assert(loose.parse(1)).equals(1).type();
+        assert(loose.parse("1")).equals(1).type();
+        assert(loose.parse("1.0")).equals(1).type();
+        assert(loose.parse("1.")).equals(1).type();
+        assert(loose).invalid_type(["0.1", ".1"]);
+        assert(loose).out_of_range(["-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [t.default(1), t.default(() => 1)].forEach(d => {
+        [strict.default(1), strict.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).invalid_type(["1.2", "-1.2"]);
         });
-        [t.default(-1), t.default(() => -1)].forEach(d => {
+        [strict.default(-1), strict.default(() => -1)].forEach(d => {
             assert(d).type();
             assert(d).out_of_range([undefined]);
             assert(d.parse(1)).equals(1).type();
@@ -38,20 +39,20 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(0, 10);
+        const r = strict.range(0, 10);
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
         assert(r).out_of_range([-1, -11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(10);
+        const r = strict.min(10);
         assert(r.parse(20)).equals(20).type();
         assert(r.parse(10)).equals(10).type();
         assert(r).out_of_range([-1]);
         assert(r).too_small([0]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10);
+        const r = strict.max(10);
         assert(r.parse(0)).equals(0).type();
         assert(r.parse(10)).equals(10).type();
         assert(r).out_of_range([-1]);

package/lib/private/string.d.ts

@@ -1,7 +1,8 @@
 import StringType from "#StringType";
-/**
-* Value is a string.
-*/
-declare const _default: StringType;
-export default _default;
+declare const string: {
+    vanilla: StringType;
+    loose: StringType;
+    strict: StringType;
+};
+export default string;
 //# sourceMappingURL=string.d.ts.map

package/lib/private/string.js

@@ -1,6 +1,10 @@
+import Loose from "#Loose";
 import StringType from "#StringType";
-/**
-* Value is a string.
-*/
-export default new StringType();
+const vanilla = new StringType();
+const loose = new StringType();
+loose[Loose] = true;
+const strict = new StringType();
+strict[Loose] = false;
+const string = { vanilla, loose, strict };
+export default string;
 //# sourceMappingURL=string.js.map

package/lib/private/symbol.d.ts

@@ -1,4 +1,8 @@
 import SymbolType from "#SymbolType";
-declare const _default: SymbolType;
-export default _default;
+declare const symbol: {
+    vanilla: SymbolType;
+    loose: SymbolType;
+    strict: SymbolType;
+};
+export default symbol;
 //# sourceMappingURL=symbol.d.ts.map

package/lib/private/symbol.js

@@ -1,3 +1,10 @@
+import Loose from "#Loose";
 import SymbolType from "#SymbolType";
-export default new SymbolType();
+const vanilla = new SymbolType();
+const loose = new SymbolType();
+loose[Loose] = true;
+const strict = new SymbolType();
+strict[Loose] = false;
+const symbol = { vanilla, loose, strict };
+export default symbol;
 //# sourceMappingURL=symbol.js.map

package/lib/private/test.d.ts

@@ -6,29 +6,12 @@ type IssueMatcher = {
     path?: string;
     message?: string;
 };
+type Shortcuts = {
+    [K in IssueType]: (inputs: unknown[], path?: JSONPointer) => void;
+};
 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;
-}>;
+} & Shortcuts>;
 export default _default;
 //# sourceMappingURL=test.d.ts.map

package/lib/private/test.js

@@ -29,32 +29,11 @@ export default test.extend((assert, subject) => {
             }
         }
     };
-    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);
@@ -78,29 +57,6 @@ export default test.extend((assert, subject) => {
                 }
             }
         },
-        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,
     };
 });

package/lib/private/tuple.d.ts

@@ -4,6 +4,13 @@ import TupleType from "#TupleType";
 type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-export default function tuple<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>>;
-export {};
+declare function vanilla<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>>;
+declare function loose<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>>;
+declare function strict<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>>;
+declare const tuple: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default tuple;
 //# sourceMappingURL=tuple.d.ts.map

package/lib/private/tuple.js

@@ -1,8 +1,23 @@
+import Loose from "#Loose";
 import TupleType from "#TupleType";
 import normalize from "#normalize";
-export default function tuple(...items) {
+function vanilla(...items) {
     // normalize each item so the class only sees Parsed
     const parsed = items.map(normalize);
     return new TupleType(parsed);
 }
+function loose(...items) {
+    const parsed = items.map(normalize);
+    const i = new TupleType(parsed);
+    i[Loose] = true;
+    return i;
+}
+function strict(...items) {
+    const parsed = items.map(normalize);
+    const i = new TupleType(parsed);
+    i[Loose] = false;
+    return i;
+}
+const tuple = { vanilla, loose, strict };
+export default tuple;
 //# sourceMappingURL=tuple.js.map

package/lib/private/u128.d.ts

@@ -1,4 +1,8 @@
 import BigUintType from "#BigUintType";
-declare const _default: BigUintType<"u128">;
-export default _default;
+declare const u128: {
+    vanilla: BigUintType<"u128">;
+    loose: BigUintType<"u128">;
+    strict: BigUintType<"u128">;
+};
+export default u128;
 //# sourceMappingURL=u128.d.ts.map

package/lib/private/u128.js

@@ -1,6 +1,13 @@
 import BigUintType from "#BigUintType";
+import Loose from "#Loose";
 import range from "#validator/range";
 const from = 0n;
 const to = 2n ** 128n - 1n;
-export default new BigUintType("u128", [range(from, to)]);
+const vanilla = new BigUintType("u128", [range(from, to)]);
+const loose = new BigUintType("u128", [range(from, to)]);
+loose[Loose] = true;
+const strict = new BigUintType("u128", [range(from, to)]);
+strict[Loose] = false;
+const u128 = { vanilla, loose, strict };
+export default u128;
 //# sourceMappingURL=u128.js.map

package/lib/private/u16.d.ts

@@ -1,4 +1,8 @@
 import UintType from "#UintType";
-declare const _default: UintType<"u16">;
-export default _default;
+declare const u16: {
+    vanilla: UintType<"u16">;
+    loose: UintType<"u16">;
+    strict: UintType<"u16">;
+};
+export default u16;
 //# sourceMappingURL=u16.d.ts.map

package/lib/private/u16.js

@@ -1,6 +1,13 @@
+import Loose from "#Loose";
 import UintType from "#UintType";
 import range from "#validator/range";
 const from = 0;
 const to = 2 ** 16 - 1;
-export default new UintType("u16", [range(from, to)]);
+const vanilla = new UintType("u16", [range(from, to)]);
+const loose = new UintType("u16", [range(from, to)]);
+loose[Loose] = true;
+const strict = new UintType("u16", [range(from, to)]);
+strict[Loose] = false;
+const u16 = { vanilla, loose, strict };
+export default u16;
 //# sourceMappingURL=u16.js.map

package/lib/private/u32.d.ts

@@ -1,7 +1,8 @@
 import UintType from "#UintType";
-/**
-* Value is an unsigned integer.
-*/
-declare const _default: UintType<"u32">;
-export default _default;
+declare const u32: {
+    vanilla: UintType<"u32">;
+    loose: UintType<"u32">;
+    strict: UintType<"u32">;
+};
+export default u32;
 //# sourceMappingURL=u32.d.ts.map

package/lib/private/u32.js

@@ -1,3 +1,4 @@
+import Loose from "#Loose";
 import UintType from "#UintType";
 import range from "#validator/range";
 const from = 0;
@@ -5,5 +6,11 @@ const to = 2 ** 32 - 1;
 /**
 * Value is an unsigned integer.
 */
-export default new UintType("u32", [range(from, to)]);
+const vanilla = new UintType("u32", [range(from, to)]);
+const loose = new UintType("u32", [range(from, to)]);
+loose[Loose] = true;
+const strict = new UintType("u32", [range(from, to)]);
+strict[Loose] = false;
+const u32 = { vanilla, loose, strict };
+export default u32;
 //# sourceMappingURL=u32.js.map

package/lib/private/u64.d.ts

@@ -1,4 +1,8 @@
 import BigUintType from "#BigUintType";
-declare const _default: BigUintType<"u64">;
-export default _default;
+declare const u64: {
+    vanilla: BigUintType<"u64">;
+    loose: BigUintType<"u64">;
+    strict: BigUintType<"u64">;
+};
+export default u64;
 //# sourceMappingURL=u64.d.ts.map