pema 0.7.0 → 0.8.0

package/lib/private/spec/int.js

@@ -1,6 +1,6 @@
 import test from "#test";
 export default (t, min, max) => {
-    const { strict, loose } = t;
+    const { vanilla, strict, loose } = t;
     test.case("fail", assert => {
         assert(strict).invalid_type(["1", 0n, 1n, 1.1, -1.1]);
     });
@@ -15,6 +15,7 @@ export default (t, min, max) => {
         assert(strict).out_of_range([min - 1, max + 1]);
     });
     test.case("loose", assert => {
+        assert(loose).type();
         assert(loose.parse(0)).equals(0).type();
         assert(loose.parse(1)).equals(1).type();
         assert(loose.parse("1")).equals(1).type();

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

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

package/lib/private/spec/uint.js

@@ -15,6 +15,7 @@ export default (t, min, max) => {
         assert(strict).out_of_range([-1, min - 1, max + 1]);
     });
     test.case("loose", assert => {
+        assert(loose).type();
         assert(loose.parse(0)).equals(0).type();
         assert(loose.parse(1)).equals(1).type();
         assert(loose.parse("1")).equals(1).type();

package/lib/private/string.js

@@ -1,10 +1,7 @@
-import Loose from "#Loose";
 import StringType from "#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.js

@@ -1,10 +1,7 @@
-import Loose from "#Loose";
 import SymbolType from "#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/tuple.d.ts

@@ -5,8 +5,8 @@ type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
 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 function loose<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>, true>;
+declare function strict<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>, false>;
 declare const tuple: {
     vanilla: typeof vanilla;
     loose: typeof loose;

package/lib/private/tuple.js

@@ -1,4 +1,3 @@
-import Loose from "#Loose";
 import TupleType from "#TupleType";
 import normalize from "#normalize";
 function vanilla(...items) {
@@ -8,15 +7,11 @@ function vanilla(...items) {
 }
 function loose(...items) {
     const parsed = items.map(normalize);
-    const i = new TupleType(parsed);
-    i[Loose] = true;
-    return i;
+    return new TupleType(parsed, true);
 }
 function strict(...items) {
     const parsed = items.map(normalize);
-    const i = new TupleType(parsed);
-    i[Loose] = false;
-    return i;
+    return new TupleType(parsed, false);
 }
 const tuple = { vanilla, loose, strict };
 export default tuple;

package/lib/private/u128.d.ts

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

package/lib/private/u128.js

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

package/lib/private/u16.d.ts

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

package/lib/private/u16.js

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

package/lib/private/u32.d.ts

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

package/lib/private/u32.js

@@ -1,16 +1,10 @@
-import Loose from "#Loose";
 import UintType from "#UintType";
 import range from "#validator/range";
 const from = 0;
 const to = 2 ** 32 - 1;
-/**
-* Value is an unsigned integer.
-*/
-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 vanilla = new UintType("u32", undefined, [range(from, to)]);
+const loose = new UintType("u32", true, [range(from, to)]);
+const strict = new UintType("u32", false, [range(from, to)]);
 const u32 = { vanilla, loose, strict };
 export default u32;
 //# sourceMappingURL=u32.js.map

package/lib/private/u64.d.ts

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

package/lib/private/u64.js

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

package/lib/private/u8.d.ts

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

package/lib/private/u8.js

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

package/lib/private/undefined.d.ts

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

package/lib/private/undefined.js

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

package/lib/private/union.d.ts

@@ -6,10 +6,10 @@ type NormalizeArray<T extends Schema[]> = {
 };
 declare function vanilla(): UnionType<[]>;
 declare function vanilla<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>>;
-declare function loose(): UnionType<[]>;
-declare function loose<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>>;
-declare function strict(): UnionType<[]>;
-declare function strict<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>>;
+declare function loose(): UnionType<[], true>;
+declare function loose<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>, true>;
+declare function strict(): UnionType<[], false>;
+declare function strict<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>, false>;
 declare const union: {
     vanilla: typeof vanilla;
     loose: typeof loose;

package/lib/private/union.js

@@ -1,18 +1,13 @@
-import Loose from "#Loose";
 import UnionType from "#UnionType";
 import normalize from "#normalize";
 function vanilla(...types) {
     return new UnionType(types.map(normalize));
 }
 function loose(...types) {
-    const i = new UnionType(types.map(normalize));
-    i[Loose] = true;
-    return i;
+    return new UnionType(types.map(normalize), true);
 }
 function strict(...types) {
-    const i = new UnionType(types.map(normalize));
-    i[Loose] = false;
-    return i;
+    return new UnionType(types.map(normalize), false);
 }
 const union = { vanilla, loose, strict };
 export default union;

package/lib/private/unknown.d.ts

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

package/lib/private/unknown.js

@@ -1,13 +1,9 @@
-import Loose from "#Loose";
 import UnknownType from "#UnknownType";
 /**
 * Value is an unknown type.
 */
 const vanilla = new UnknownType();
 const loose = new UnknownType();
-loose[Loose] = true;
 const strict = new UnknownType();
-strict[Loose] = false;
-const unknown = { vanilla, loose, strict };
-export default unknown;
+export default { vanilla, loose, strict };
 //# sourceMappingURL=unknown.js.map

package/lib/private/url.d.ts

@@ -1,8 +1,8 @@
 import URLType from "#URLType";
 declare const url: {
-    vanilla: URLType;
-    loose: URLType;
-    strict: URLType;
+    vanilla: URLType<undefined>;
+    loose: URLType<true>;
+    strict: URLType<false>;
 };
 export default url;
 //# sourceMappingURL=url.d.ts.map

package/lib/private/url.js

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

package/lib/private/uuid.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pema",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -43,7 +43,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsgo",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",