pema 0.6.1 → 0.8.0

package/lib/private/ArrayType.d.ts

@@ -1,6 +1,8 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
@@ -11,9 +13,10 @@ import type { Primitive } from "@rcompat/type";
 type Next<T> = {
     validators?: Validator<T>[];
 };
-export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait, DefaultTrait<Infer<T>[]> {
+export default class ArrayType<T extends Parsed<unknown>, M extends Mode = undefined> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait, DefaultTrait<Infer<T>[]> {
     #private;
-    constructor(item: T, validators?: Validator<Array<Infer<T>>>[]);
+    [Loose]: M;
+    constructor(item: T, mode?: M, validators?: Validator<Array<Infer<T>>>[]);
     get name(): "array";
     optional(): OptionalType<this>;
     default(value: (() => Infer<T>[]) | Infer<T>[]): DefaultType<this, Infer<T>[]>;
@@ -29,7 +32,7 @@ export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T,
     min(limit: number): this;
     max(limit: number): this;
     length(from: number, to: number): this;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "array";
         of: import("./Serialized.js").default;

package/lib/private/ArrayType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import EnumType from "#EnumType";
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
@@ -9,21 +10,25 @@ import join from "#path/join";
 import next from "#path/next";
 import rebase from "#path/rebase";
 import PrimitiveType from "#PrimitiveType";
+import resolve from "#resolve";
 import S from "#schema-errors";
 import length from "#validator/length";
 import max from "#validator/max";
 import min from "#validator/min";
 import unique from "#validator/unique";
 import uniqueBy from "#validator/unique-by";
+import is from "@rcompat/is";
 function isPrimitive(x) {
     return x instanceof PrimitiveType || x instanceof EnumType;
 }
 export default class ArrayType extends GenericType {
     #item;
     #validators;
-    constructor(item, validators = []) {
+    [Loose];
+    constructor(item, mode, validators = []) {
         super();
         this.#item = item;
+        this[Loose] = mode;
         this.#validators = validators;
     }
     get name() {
@@ -37,7 +42,7 @@ export default class ArrayType extends GenericType {
     }
     derive(_next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#item, [...this.#validators, ..._next.validators ?? []]);
+        return new Constructor(this.#item, this[Loose], [...this.#validators, ..._next.validators ?? []]);
     }
     /**
      * Member values are unique — only for primitive subtypes.
@@ -67,9 +72,13 @@ export default class ArrayType extends GenericType {
     length(from, to) {
         return this.derive({ validators: [length(from, to)] });
     }
-    parse(x, options = {}) {
-        const path = options[ParsedKey] ?? "";
-        if (!Array.isArray(x))
+    parse(u, options = {}) {
+        const x = resolve(u);
+        const $options = this[Loose] !== undefined
+            ? { ...options, [Loose]: this[Loose] }
+            : options;
+        const path = $options[ParsedKey] ?? "";
+        if (!is.array(x))
             throw E.invalid_type(x, "array", path);
         const item = this.#item;
         const len = x.length;
@@ -77,7 +86,7 @@ export default class ArrayType extends GenericType {
         for (let i = 0; i < len; i++) {
             if (!(i in x))
                 throw E.invalid_type(undefined, item.name, join(path, i));
-            out[i] = item.parse(x[i], next(i, options));
+            out[i] = item.parse(x[i], next(i, $options));
         }
         const validators = this.#validators;
         for (let i = 0; i < validators.length; i++) {

package/lib/private/BigIntType.d.ts

@@ -3,7 +3,7 @@ import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 import type Storable from "#Storable";
-export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storable<T> {
+export default class BigIntType<T extends BigIntDataType = "i64", L extends boolean | undefined = undefined> extends NumericType<T, bigint, "BigIntType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BigUintType.d.ts

@@ -3,7 +3,7 @@ import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 import type Storable from "#Storable";
-export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storable<T> {
+export default class BigUintType<T extends BigUintDataType = "u64", L extends boolean | undefined = undefined> extends NumericType<T, bigint, "BigUintType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BooleanType.d.ts

@@ -1,7 +1,11 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
-export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
+export default class BooleanType<M extends Mode = undefined> extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
+    [Loose]: M;
+    constructor(mode?: M);
     get name(): "boolean";
     get datatype(): "boolean";
     [CoerceKey](x: unknown): unknown;

package/lib/private/BooleanType.js

@@ -1,8 +1,14 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import is from "@rcompat/is";
 export default class BooleanType extends PrimitiveType {
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
     get name() {
         return "boolean";
     }

package/lib/private/BuiltinType.d.ts

@@ -6,6 +6,6 @@ export default abstract class BuiltinType<StaticType, Name extends string> exten
     #private;
     abstract get Type(): AbstractNewable;
     constructor(options?: ParseOptions);
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
 }
 //# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -1,5 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import E from "#errors";
+import Loose from "#Loose";
+import resolve from "#resolve";
 import Type from "#Type";
 export default class BuiltinType extends Type {
     #options;
@@ -11,9 +13,11 @@ export default class BuiltinType extends Type {
         const Constructor = this.constructor;
         return new Constructor({ ...this.#options, ...next });
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         const $options = { ...this.#options, ...options };
-        const $x = $options.coerce === true ? this[CoerceKey](x) : x;
+        const loose = this[Loose] ?? $options[Loose] ?? false;
+        const $x = loose ? this[CoerceKey](x) : x;
         if (!($x instanceof this.Type))
             throw E.invalid_type($x, this.name, $options);
         return $x;

package/lib/private/ConstructorType.d.ts

@@ -12,7 +12,7 @@ export default class ConstructorType<C extends AbstractNewable> extends GenericT
     get name(): string;
     optional(): OptionalType<this>;
     default(value: (() => InstanceType<C>) | InstanceType<C>): DefaultType<this, InstanceType<C>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "newable";
         of: string;

package/lib/private/ConstructorType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
@@ -17,7 +18,8 @@ export default class ConstructorType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!(x instanceof this.#type))
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/DateType.d.ts

@@ -1,9 +1,12 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
-export default class DateType extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
+export default class DateType<M extends boolean | undefined = undefined> extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
     [CoerceKey]: typeof coerce;
+    [Loose]: M;
+    constructor(mode?: M);
     get Type(): DateConstructor;
     get name(): "date";
     get datatype(): "datetime";

package/lib/private/DateType.js

@@ -1,9 +1,15 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
 export default class DateType extends BuiltinType {
     [CoerceKey] = coerce;
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
     get Type() {
         return Date;
     }

package/lib/private/DefaultType.d.ts

@@ -8,7 +8,7 @@ export default class DefaultType<S extends Parsed<unknown>, D extends Infer<S>>
     get name(): "default";
     get schema(): S;
     get input(): Infer<S> | undefined;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "default";
         of: import("./Serialized.js").default;

package/lib/private/DefaultType.js

@@ -1,3 +1,4 @@
+import resolve from "#resolve";
 import VirtualType from "#VirtualType";
 import is from "@rcompat/is";
 export default class DefaultType extends VirtualType {
@@ -17,13 +18,13 @@ export default class DefaultType extends VirtualType {
     get input() {
         return undefined;
     }
-    parse(x, options = {}) {
-        let $x = x;
+    parse(u, options = {}) {
+        let x = resolve(u);
         // default fallback
-        if (is.undefined($x)) {
-            $x = is.function(this.#default) ? this.#default() : this.#default;
+        if (is.undefined(x)) {
+            x = is.function(this.#default) ? this.#default() : this.#default;
         }
-        return this.#schema.parse($x, options);
+        return this.#schema.parse(x, options);
     }
     toJSON() {
         return { type: this.name, of: this.#schema.toJSON() };

package/lib/private/EnumType.d.ts

@@ -11,7 +11,7 @@ export default class EnumType<T extends readonly Literal[]> extends GenericType<
     get name(): string;
     optional(): OptionalType<this>;
     default<D extends T[number]>(value: (() => D) | D): DefaultType<EnumType<T>, D>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "enum";
         values: T[number][];

package/lib/private/EnumType.js

@@ -2,6 +2,8 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class EnumType extends GenericType {
     #values;
     constructor(values) {
@@ -17,8 +19,9 @@ export default class EnumType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
-        if (typeof x !== "string" || !this.#values.includes(x)) {
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.string(x) || !this.#values.includes(x)) {
             throw E.invalid_type(x, this.name, options);
         }
         return x;

package/lib/private/FunctionType.d.ts

@@ -7,7 +7,7 @@ import type { UnknownFunction } from "@rcompat/type";
 export default class FunctionType extends GenericType<UnknownFunction, UnknownFunction, "FunctionType"> implements OptionalTrait {
     get name(): "function";
     optional(): OptionalType<this>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "function";
     };

package/lib/private/FunctionType.js

@@ -1,6 +1,8 @@
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import E from "#errors";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class FunctionType extends GenericType {
     get name() {
         return "function";
@@ -8,8 +10,9 @@ export default class FunctionType extends GenericType {
     optional() {
         return new OptionalType(this);
     }
-    parse(x, options = {}) {
-        if (typeof x !== "function")
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.function(x))
             throw E.invalid_type(x, this.name, options);
         return x;
     }

package/lib/private/IntType.d.ts

@@ -4,9 +4,9 @@ import type IntDataType from "#IntDataType";
 import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
 import type Storable from "#Storable";
-export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storable<T> {
+export default class IntType<T extends IntDataType, L extends boolean | undefined = undefined> extends NumericType<T, number, "IntType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
-    parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
+    parse(u: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/lib/private/IntType.js

@@ -7,8 +7,8 @@ export default class IntType extends NumericType {
     get name() {
         return "number";
     }
-    parse(x, options = {}) {
-        return super.parse(x, {
+    parse(u, options = {}) {
+        return super.parse(u, {
             ...options,
             validators: [integer],
         });

package/lib/private/IsType.d.ts

@@ -11,7 +11,7 @@ export default class IsType<T> extends Parsed<T> implements OptionalTrait, Defau
     get name(): "is";
     optional(): OptionalType<this>;
     default(value: (() => T) | T): DefaultType<this, T>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "is";
     };

package/lib/private/IsType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import OptionalType from "#OptionalType";
 import Parsed from "#Parsed";
+import resolve from "#resolve";
 export default class IsType extends Parsed {
     #predicate;
     constructor(predicate) {
@@ -17,7 +18,8 @@ export default class IsType extends Parsed {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!this.#predicate(x))
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/JSONType.d.ts

@@ -16,7 +16,7 @@ export default class JSONType<S extends JSONInput = undefined> extends Storable<
     get datatype(): "json";
     optional(): OptionalType<this>;
     default(value: (() => Infer<this>) | Infer<this>): DefaultType<this, Infer<this>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "json";
         datatype: "json";

package/lib/private/JSONType.js

@@ -1,6 +1,7 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
 import Storable from "#Storable";
 import is from "@rcompat/is";
 export default class JSONType extends Storable {
@@ -21,7 +22,8 @@ export default class JSONType extends Storable {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (this.#inner !== undefined) {
             // delegate to inner schema for typed validation
             return this.#inner.parse(x, options);

package/lib/private/LiteralType.d.ts

@@ -1,18 +1,20 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
+import type Mode from "#Mode";
 type Literal = string | boolean | number;
-export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
+export default class LiteralType<T extends Literal, M extends Mode = undefined> extends GenericType<T, T, "LiteralType"> {
     #private;
-    constructor(literal: T);
-    static new<T extends Literal>(literal: T): LiteralType<T>;
+    [Loose]: M;
     static get Literal(): Literal;
+    constructor(literal: T, mode?: M);
     get name(): string;
     optional(): OptionalType<this>;
     default(value: (() => T) | T): DefaultType<this, T>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "literal";
         value: T;

package/lib/private/LiteralType.js

@@ -1,19 +1,20 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import E from "#errors";
+import resolve from "#resolve";
 export default class LiteralType extends GenericType {
     #literal;
-    constructor(literal) {
-        super();
-        this.#literal = literal;
-    }
-    static new(literal) {
-        return new LiteralType(literal);
-    }
+    [Loose];
     static get Literal() {
         return undefined;
     }
+    constructor(literal, mode) {
+        super();
+        this.#literal = literal;
+        this[Loose] = mode;
+    }
     get name() {
         return JSON.stringify(this.#literal);
     }
@@ -23,7 +24,8 @@ export default class LiteralType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (x !== this.#literal)
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/Loose.d.ts

@@ -0,0 +1,4 @@
+declare const Loose: unique symbol;
+type Loose = typeof Loose;
+export { Loose as default };
+//# sourceMappingURL=Loose.d.ts.map

package/lib/private/Loose.js

@@ -0,0 +1,3 @@
+const Loose = Symbol("Loose");
+export { Loose as default };
+//# sourceMappingURL=Loose.js.map

package/lib/private/Mode.d.ts

@@ -0,0 +1,3 @@
+type Mode = boolean | undefined;
+export type { Mode as default };
+//# sourceMappingURL=Mode.d.ts.map

package/lib/private/Mode.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Mode.js.map

package/lib/private/NormalizeSchema.d.ts

@@ -7,13 +7,13 @@ import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type { AbstractNewable } from "@rcompat/type";
+import type { AbstractNewable, Dict } from "@rcompat/type";
 type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-export type NormalizeSchemaObject<T extends Record<string, unknown>> = {
+export type NormalizeSchemaObject<T extends Dict> = {
     -readonly [K in keyof T]: NormalizeSchema<T[K]>;
 };
-type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
+type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Dict ? ObjectType<NormalizeSchemaObject<S>> : never;
 export type { NormalizeSchema as default };
 //# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NullType.d.ts

@@ -3,7 +3,7 @@ import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 export default class NullType extends PrimitiveType<null, "NullType"> {
     get name(): "null";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "null";
     };

package/lib/private/NullType.js

@@ -1,11 +1,14 @@
 import PrimitiveType from "#PrimitiveType";
 import E from "#errors";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class NullType extends PrimitiveType {
     get name() {
         return "null";
     }
-    parse(x, options = {}) {
-        if (x !== null)
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.null(x))
             throw E.invalid_type(x, this.name, options);
         return x;
     }

package/lib/private/NumberType.d.ts

@@ -2,7 +2,7 @@ import CoerceKey from "#CoerceKey";
 import type FloatDataType from "#FloatDataType";
 import NumericType from "#NumericType";
 import coerce from "#coerce/float";
-export default class NumberType<T extends FloatDataType = "f64"> extends NumericType<T, number, "NumberType"> {
+export default class NumberType<T extends FloatDataType = "f64", L extends boolean | undefined = undefined> extends NumericType<T, number, "NumberType", L> {
     [CoerceKey]: typeof coerce;
     get name(): "number";
 }

package/lib/private/NumericType.d.ts

@@ -1,17 +1,21 @@
 import type DataKey from "#DataKey";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 import type Storable from "#Storable";
 import type Validator from "#Validator";
+import type { Dict } from "@rcompat/type";
 type Next<T> = {
     options?: ParseOptions;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
-    constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
+    [Loose]: M;
+    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
     derive(next: Next<T>): this;
-    values(anyof: Record<string, T>): this;
+    values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;
     max(to: T): this;

package/lib/private/NumericType.js

@@ -1,3 +1,4 @@
+import Loose from "#Loose";
 import PrimitiveType from "#PrimitiveType";
 import max from "#validator/max";
 import min from "#validator/min";
@@ -5,13 +6,15 @@ import range from "#validator/range";
 import values from "#validator/values";
 export default class NumericType extends PrimitiveType {
     #datatype;
-    constructor(datatype, validators = [], options = {}) {
+    [Loose];
+    constructor(datatype, mode = undefined, validators = [], options = {}) {
         super(validators, options);
         this.#datatype = datatype;
+        this[Loose] = mode;
     }
     derive(next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#datatype, [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
+        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
     }
     values(anyof) {
         return this.derive({ validators: [values(anyof)] });