pema 0.7.0 → 0.8.0

package/lib/private/index.d.ts

@@ -47,61 +47,259 @@ import type Schema from "#Schema";
 */
 declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 declare namespace schema {
-    export var array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>>;
-    export var bigint: import("./BigIntType.js").default<"i64">;
-    export var biguint: import("./BigUintType.js").default<"u64">;
-    export var blob: import("#BlobType").default;
-    export var boolean: import("#BooleanType").default;
-    export var constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
-    export var date: import("#DateType").default;
-    export var dict: {
+    var array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>>;
+}
+declare namespace schema {
+    var bigint: import("./BigIntType.js").default<"i64", undefined>;
+}
+declare namespace schema {
+    var biguint: import("./BigUintType.js").default<"u64", undefined>;
+}
+declare namespace schema {
+    var blob: import("#BlobType").default;
+}
+declare namespace schema {
+    var boolean: import("#BooleanType").default<undefined>;
+}
+declare namespace schema {
+    var constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+}
+declare namespace schema {
+    var date: import("#DateType").default<undefined>;
+}
+declare namespace schema {
+    var dict: {
         (): import("#RecordType").default<import("#StringType").default, import("#StringType").default>;
         <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value>;
     };
+}
+declare namespace schema {
     var _a: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
-    export var f32: import("#NumberType").default<"f32">;
-    export var f64: import("#NumberType").default<"f64">;
-    export var file: import("./FileType.js").default;
+    export { _a as enum };
+}
+declare namespace schema {
+    var f32: import("#NumberType").default<"f32", undefined>;
+}
+declare namespace schema {
+    var f64: import("#NumberType").default<"f64", undefined>;
+}
+declare namespace schema {
+    var file: import("./FileType.js").default;
+}
+declare namespace schema {
     var _b: import("#FunctionType").default;
-    export var i128: import("./BigIntType.js").default<"i128">;
-    export var i16: import("./IntType.js").default<"i16">;
-    export var i32: import("./IntType.js").default<"i32">;
-    export var i64: import("./BigIntType.js").default<"i64">;
-    export var i8: import("./IntType.js").default<"i8">;
-    export var int: import("./IntType.js").default<"i32">;
-    export var is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
-    export var json: {
+    export { _b as function };
+}
+declare namespace schema {
+    var i128: import("./BigIntType.js").default<"i128", undefined>;
+}
+declare namespace schema {
+    var i16: import("./IntType.js").default<"i16", undefined>;
+}
+declare namespace schema {
+    var i32: import("./IntType.js").default<"i32", undefined>;
+}
+declare namespace schema {
+    var i64: import("./BigIntType.js").default<"i64", undefined>;
+}
+declare namespace schema {
+    var i8: import("./IntType.js").default<"i8", undefined>;
+}
+declare namespace schema {
+    var int: import("./IntType.js").default<"i32", undefined>;
+}
+declare namespace schema {
+    var is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+}
+declare namespace schema {
+    var json: {
         (): import("#JSONType").default<undefined>;
         <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
     };
-    export var literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T>;
+}
+declare namespace schema {
+    var literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, undefined>;
+}
+declare namespace schema {
     var _c: import("#NullType").default;
-    export var number: import("#NumberType").default<"f64">;
-    export var object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }>;
-    export var omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K>;
-    export var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value>;
-    export var partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }>;
-    export var pure: <T>() => import("#PureType").default<T, "PureType">;
-    export var string: import("#StringType").default;
-    export var symbol: import("./SymbolType.js").default;
-    export var tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
-    export var u128: import("./BigUintType.js").default<"u128">;
-    export var u16: import("#UintType").default<"u16">;
-    export var u32: import("#UintType").default<"u32">;
-    export var u64: import("./BigUintType.js").default<"u64">;
-    export var u8: import("#UintType").default<"u8">;
-    export var uint: import("#UintType").default<"u32">;
-    export var undefined: import("#UndefinedType").default;
-    export var union: {
+    export { _c as null };
+}
+declare namespace schema {
+    var number: import("#NumberType").default<"f64", undefined>;
+}
+declare namespace schema {
+    var object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }>;
+}
+declare namespace schema {
+    var omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K>;
+}
+declare namespace schema {
+    var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, undefined>;
+}
+declare namespace schema {
+    var partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }>;
+}
+declare namespace schema {
+    var pure: <T>() => import("#PureType").default<T, "PureType">;
+}
+declare namespace schema {
+    var string: import("#StringType").default;
+}
+declare namespace schema {
+    var symbol: import("./SymbolType.js").default;
+}
+declare namespace schema {
+    var tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
+}
+declare namespace schema {
+    var u128: import("./BigUintType.js").default<"u128", undefined>;
+}
+declare namespace schema {
+    var u16: import("#UintType").default<"u16", undefined>;
+}
+declare namespace schema {
+    var u32: import("#UintType").default<"u32", undefined>;
+}
+declare namespace schema {
+    var u64: import("./BigUintType.js").default<"u64", undefined>;
+}
+declare namespace schema {
+    var u8: import("#UintType").default<"u8", undefined>;
+}
+declare namespace schema {
+    var uint: import("#UintType").default<"u32", undefined>;
+}
+declare namespace schema {
+    var undefined: import("#UndefinedType").default;
+}
+declare namespace schema {
+    var union: {
         (): import("#UnionType").default<[]>;
         <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
     };
-    export var unknown: import("#UnknownType").default;
-    export var url: import("#URLType").default;
-    export var uuid: import("#UUIDType").default;
-    export var loose: typeof schema;
-    export var strict: typeof schema;
-    export { _a as enum, _b as function, _c as null };
+}
+declare namespace schema {
+    var unknown: import("#UnknownType").default;
+}
+declare namespace schema {
+    var url: import("#URLType").default<undefined>;
+}
+declare namespace schema {
+    var uuid: import("#UUIDType").default;
+}
+declare namespace schema {
+    var loose: {
+        <const S extends Schema>(s: S): NormalizeSchema<S>;
+        array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, true>;
+        bigint: import("./BigIntType.js").default<"i64", true>;
+        biguint: import("./BigUintType.js").default<"u64", true>;
+        blob: import("#BlobType").default;
+        boolean: import("#BooleanType").default<true>;
+        constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+        date: import("#DateType").default<true>;
+        dict: {
+            (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, true>;
+            <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, true>;
+        };
+        enum: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
+        f32: import("#NumberType").default<"f32", true>;
+        f64: import("#NumberType").default<"f64", true>;
+        file: import("./FileType.js").default;
+        function: import("#FunctionType").default;
+        i128: import("./BigIntType.js").default<"i128", true>;
+        i16: import("./IntType.js").default<"i16", true>;
+        i32: import("./IntType.js").default<"i32", true>;
+        i64: import("./BigIntType.js").default<"i64", true>;
+        i8: import("./IntType.js").default<"i8", true>;
+        int: import("./IntType.js").default<"i32", true>;
+        is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+        json: {
+            (): import("#JSONType").default<undefined>;
+            <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
+        };
+        literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, true>;
+        null: import("#NullType").default;
+        number: import("#NumberType").default<"f64", true>;
+        object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, true>;
+        omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, true>;
+        record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, true>;
+        partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, true>;
+        pure: <T>() => import("#PureType").default<T, "PureType">;
+        string: import("#StringType").default;
+        symbol: import("./SymbolType.js").default;
+        tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
+        u128: import("./BigUintType.js").default<"u128", true>;
+        u16: import("#UintType").default<"u16", true>;
+        u32: import("#UintType").default<"u32", true>;
+        u64: import("./BigUintType.js").default<"u64", true>;
+        u8: import("#UintType").default<"u8", true>;
+        uint: import("#UintType").default<"u32", true>;
+        undefined: import("#UndefinedType").default;
+        union: {
+            (): import("#UnionType").default<[], true>;
+            <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
+        };
+        unknown: import("#UnknownType").default;
+        url: import("#URLType").default<true>;
+        uuid: import("#UUIDType").default;
+    };
+}
+declare namespace schema {
+    var strict: {
+        <const S extends Schema>(s: S): NormalizeSchema<S>;
+        array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, false>;
+        bigint: import("./BigIntType.js").default<"i64", false>;
+        biguint: import("./BigUintType.js").default<"u64", false>;
+        blob: import("#BlobType").default;
+        boolean: import("#BooleanType").default<false>;
+        constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+        date: import("#DateType").default<false>;
+        dict: {
+            (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, false>;
+            <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, false>;
+        };
+        enum: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
+        f32: import("#NumberType").default<"f32", false>;
+        f64: import("#NumberType").default<"f64", false>;
+        file: import("./FileType.js").default;
+        function: import("#FunctionType").default;
+        i128: import("./BigIntType.js").default<"i128", false>;
+        i16: import("./IntType.js").default<"i16", false>;
+        i32: import("./IntType.js").default<"i32", false>;
+        i64: import("./BigIntType.js").default<"i64", false>;
+        i8: import("./IntType.js").default<"i8", false>;
+        int: import("./IntType.js").default<"i32", false>;
+        is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+        json: {
+            (): import("#JSONType").default<undefined>;
+            <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
+        };
+        literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, false>;
+        null: import("#NullType").default;
+        number: import("#NumberType").default<"f64", false>;
+        object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, false>;
+        omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, false>;
+        record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, false>;
+        partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, false>;
+        pure: <T>() => import("#PureType").default<T, "PureType">;
+        string: import("#StringType").default;
+        symbol: import("./SymbolType.js").default;
+        tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
+        u128: import("./BigUintType.js").default<"u128", false>;
+        u16: import("#UintType").default<"u16", false>;
+        u32: import("#UintType").default<"u32", false>;
+        u64: import("./BigUintType.js").default<"u64", false>;
+        u8: import("#UintType").default<"u8", false>;
+        uint: import("#UintType").default<"u32", false>;
+        undefined: import("#UndefinedType").default;
+        union: {
+            (): import("#UnionType").default<[], false>;
+            <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
+        };
+        unknown: import("#UnknownType").default;
+        url: import("#URLType").default<false>;
+        uuid: import("#UUIDType").default;
+    };
 }
 export default schema;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/is.js

@@ -1,15 +1,10 @@
 import IsType from "#IsType";
-import Loose from "#Loose";
 const vanilla = (predicate) => new IsType(predicate);
 const loose = (predicate) => {
-    const i = new IsType(predicate);
-    i[Loose] = true;
-    return i;
+    return new IsType(predicate);
 };
 const strict = (predicate) => {
-    const i = new IsType(predicate);
-    i[Loose] = false;
-    return i;
+    return new IsType(predicate);
 };
 const is = { vanilla, loose, strict };
 export default is;

package/lib/private/json.js

@@ -1,17 +1,12 @@
 import JSONType from "#JSONType";
-import Loose from "#Loose";
 function vanilla(inner) {
     return new JSONType(inner);
 }
 function loose(inner) {
-    const i = new JSONType(inner);
-    i[Loose] = true;
-    return i;
+    return new JSONType(inner);
 }
 function strict(inner) {
-    const i = new JSONType(inner);
-    i[Loose] = false;
-    return i;
+    return new JSONType(inner);
 }
 const json = { vanilla, loose, strict };
 export default json;

package/lib/private/literal.d.ts

@@ -1,12 +1,12 @@
 import LiteralType from "#LiteralType";
 type Literal = string | boolean | number;
-declare function vanilla<T extends Literal>(literal: T): LiteralType<T>;
-declare function loose<T extends Literal>(literal: T): LiteralType<T>;
-declare function strict<T extends Literal>(literal: T): LiteralType<T>;
-declare const literal: {
+declare function vanilla<T extends Literal>(literal: T): LiteralType<T, undefined>;
+declare function loose<T extends Literal>(literal: T): LiteralType<T, true>;
+declare function strict<T extends Literal>(literal: T): LiteralType<T, false>;
+declare const _default: {
     vanilla: typeof vanilla;
     loose: typeof loose;
     strict: typeof strict;
 };
-export default literal;
+export default _default;
 //# sourceMappingURL=literal.d.ts.map

package/lib/private/literal.js

@@ -1,18 +1,12 @@
 import LiteralType from "#LiteralType";
-import Loose from "#Loose";
 function vanilla(literal) {
     return new LiteralType(literal);
 }
 function loose(literal) {
-    const i = new LiteralType(literal);
-    i[Loose] = true;
-    return i;
+    return new LiteralType(literal, true);
 }
 function strict(literal) {
-    const i = new LiteralType(literal);
-    i[Loose] = false;
-    return i;
+    return new LiteralType(literal, false);
 }
-const literal = { vanilla, loose, strict };
-export default literal;
+export default { vanilla, loose, strict };
 //# sourceMappingURL=literal.js.map

package/lib/private/null.js

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

package/lib/private/object.d.ts

@@ -6,8 +6,8 @@ type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EmptyDict
     [K in keyof S]: NormalizeSchema<S[K]>;
 };
 declare function vanilla<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
-declare function loose<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
-declare function strict<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+declare function loose<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>, true>;
+declare function strict<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>, false>;
 declare const object: {
     vanilla: typeof vanilla;
     loose: typeof loose;

package/lib/private/object.js

@@ -1,4 +1,3 @@
-import Loose from "#Loose";
 import normalize from "#normalize";
 import ObjectType from "#ObjectType";
 function vanilla(properties) {
@@ -13,18 +12,14 @@ function loose(properties) {
     for (const [k, v] of Object.entries(properties)) {
         props[k] = normalize(v);
     }
-    const i = new ObjectType(props);
-    i[Loose] = true;
-    return i;
+    return new ObjectType(props, true);
 }
 function strict(properties) {
     const props = {};
     for (const [k, v] of Object.entries(properties)) {
         props[k] = normalize(v);
     }
-    const i = new ObjectType(props);
-    i[Loose] = false;
-    return i;
+    return new ObjectType(props, false);
 }
 const object = { vanilla, loose, strict };
 export default object;

package/lib/private/omit.d.ts

@@ -3,8 +3,8 @@ import OmitType from "#OmitType";
 import type Parsed from "#Parsed";
 import type { Dict } from "@rcompat/type";
 declare function vanilla<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
-declare function loose<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
-declare function strict<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+declare function loose<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K, true>;
+declare function strict<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K, false>;
 declare const omit: {
     vanilla: typeof vanilla;
     loose: typeof loose;

package/lib/private/omit.js

@@ -1,17 +1,12 @@
-import Loose from "#Loose";
 import OmitType from "#OmitType";
 function vanilla(type, ...keys) {
     return new OmitType(type, keys);
 }
 function loose(type, ...keys) {
-    const i = new OmitType(type, keys);
-    i[Loose] = true;
-    return i;
+    return new OmitType(type, keys, true);
 }
 function strict(type, ...keys) {
-    const i = new OmitType(type, keys);
-    i[Loose] = false;
-    return i;
+    return new OmitType(type, keys, false);
 }
 const omit = { vanilla, loose, strict };
 export default omit;

package/lib/private/partial.d.ts

@@ -5,8 +5,8 @@ type StripReadonly<T> = {
     -readonly [K in keyof T]: T[K];
 };
 declare function vanilla<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
-declare function loose<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
-declare function strict<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
+declare function loose<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>, true>;
+declare function strict<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>, false>;
 declare const partial: {
     vanilla: typeof vanilla;
     loose: typeof loose;

package/lib/private/partial.js

@@ -1,4 +1,3 @@
-import Loose from "#Loose";
 import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
 function vanilla(input) {
@@ -7,15 +6,11 @@ function vanilla(input) {
 }
 function loose(input) {
     const dict = input instanceof ObjectType ? input.properties : input;
-    const i = new PartialType(dict);
-    i[Loose] = true;
-    return i;
+    return new PartialType(dict, true);
 }
 function strict(input) {
     const dict = input instanceof ObjectType ? input.properties : input;
-    const i = new PartialType(dict);
-    i[Loose] = false;
-    return i;
+    return new PartialType(dict, false);
 }
 const partial = { vanilla, loose, strict };
 export default partial;

package/lib/private/pure.js

@@ -1,17 +1,12 @@
-import Loose from "#Loose";
 import PureType from "#PureType";
 function vanilla() {
     return new PureType();
 }
 function loose() {
-    const i = new PureType();
-    i[Loose] = true;
-    return i;
+    return new PureType();
 }
 function strict() {
-    const i = new PureType();
-    i[Loose] = false;
-    return i;
+    return new PureType();
 }
 const pure = { vanilla, loose, strict };
 export default pure;

package/lib/private/record.d.ts

@@ -2,9 +2,9 @@ import type Parsed from "#Parsed";
 import RecordType from "#RecordType";
 import type RecordTypeKey from "#RecordTypeKey";
 declare const record: {
-    vanilla: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
-    loose: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
-    strict: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
+    vanilla: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, undefined>;
+    loose: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, true>;
+    strict: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, false>;
 };
 export default record;
 //# sourceMappingURL=record.d.ts.map

package/lib/private/record.js

@@ -1,18 +1,13 @@
-import Loose from "#Loose";
 import RecordType from "#RecordType";
 /**
 * Value is a record of the given key and value types.
 */
 const vanilla = (k, v) => new RecordType(k, v);
 const loose = (k, v) => {
-    const i = new RecordType(k, v);
-    i[Loose] = true;
-    return i;
+    return new RecordType(k, v, true);
 };
 const strict = (k, v) => {
-    const i = new RecordType(k, v);
-    i[Loose] = false;
-    return i;
+    return new RecordType(k, v, false);
 };
 const record = { vanilla, loose, strict };
 export default record;

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

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

package/lib/private/spec/bigint.js

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

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

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

package/lib/private/spec/biguint.js

@@ -15,6 +15,7 @@ export default (t, min, max) => {
         assert(strict).out_of_range([-1n, min - 1n, max + 1n]);
     });
     test.case("loose", assert => {
+        assert(loose).type();
         assert(loose.parse(0n)).equals(0n).type();
         assert(loose.parse(1n)).equals(1n).type();
         assert(loose.parse(0)).equals(0n).type();
@@ -33,6 +34,12 @@ export default (t, min, max) => {
             assert(d.parse(0n)).equals(0n).type();
             assert(d).invalid_type([1.2, -1.2]);
         });
+        [strict.default(-1n), strict.default(() => -1n)].forEach(d => {
+            assert(d).type();
+            assert(d).out_of_range([undefined]);
+            assert(d.parse(1n)).equals(1n).type();
+            assert(d.parse(0n)).equals(0n).type();
+        });
     });
     test.case("validator - range", assert => {
         const r = strict.range(0n, 10n);

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

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