pema 0.6.1 → 0.8.0

package/lib/private/function.js

@@ -2,5 +2,9 @@ import FunctionType from "#FunctionType";
 /**
  * Value is a function.
  */
-export default new FunctionType();
+const vanilla = new FunctionType();
+const loose = new FunctionType();
+const strict = new FunctionType();
+const function$ = { vanilla, loose, strict };
+export default function$;
 //# sourceMappingURL=function.js.map

package/lib/private/i128.d.ts

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

package/lib/private/i128.js

@@ -2,5 +2,9 @@ import BigIntType from "#BigIntType";
 import range from "#validator/range";
 const from = -(2n ** 127n);
 const to = 2n ** 127n - 1n;
-export default new BigIntType("i128", [range(from, to)]);
+const vanilla = new BigIntType("i128", undefined, [range(from, to)]);
+const loose = new BigIntType("i128", true, [range(from, to)]);
+const strict = new BigIntType("i128", false, [range(from, to)]);
+const i128 = { vanilla, loose, strict };
+export default i128;
 //# sourceMappingURL=i128.js.map

package/lib/private/i16.d.ts

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

package/lib/private/i16.js

@@ -2,5 +2,9 @@ import IntType from "#IntType";
 import range from "#validator/range";
 const from = -(2 ** 15);
 const to = 2 ** 15 - 1;
-export default new IntType("i16", [range(from, to)]);
+const vanilla = new IntType("i16", undefined, [range(from, to)]);
+const loose = new IntType("i16", true, [range(from, to)]);
+const strict = new IntType("i16", false, [range(from, to)]);
+const i16 = { vanilla, loose, strict };
+export default i16;
 //# sourceMappingURL=i16.js.map

package/lib/private/i32.d.ts

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

package/lib/private/i32.js

@@ -2,5 +2,9 @@ import IntType from "#IntType";
 import range from "#validator/range";
 const from = -(2 ** 31);
 const to = 2 ** 31 - 1;
-export default new IntType("i32", [range(from, to)]);
+const vanilla = new IntType("i32", undefined, [range(from, to)]);
+const loose = new IntType("i32", true, [range(from, to)]);
+const strict = new IntType("i32", false, [range(from, to)]);
+const i32 = { vanilla, loose, strict };
+export default i32;
 //# sourceMappingURL=i32.js.map

package/lib/private/i64.d.ts

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

package/lib/private/i64.js

@@ -2,5 +2,9 @@ import BigIntType from "#BigIntType";
 import range from "#validator/range";
 const from = -(2n ** 63n);
 const to = (2n ** 63n) - 1n;
-export default new BigIntType("i64", [range(from, to)]);
+const vanilla = new BigIntType("i64", undefined, [range(from, to)]);
+const loose = new BigIntType("i64", true, [range(from, to)]);
+const strict = new BigIntType("i64", false, [range(from, to)]);
+const i64 = { vanilla, loose, strict };
+export default i64;
 //# sourceMappingURL=i64.js.map

package/lib/private/i8.d.ts

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

package/lib/private/i8.js

@@ -2,5 +2,9 @@ import IntType from "#IntType";
 import range from "#validator/range";
 const from = -(2 ** 7);
 const to = 2 ** 7 - 1;
-export default new IntType("i8", [range(from, to)]);
+const vanilla = new IntType("i8", undefined, [range(from, to)]);
+const loose = new IntType("i8", true, [range(from, to)]);
+const strict = new IntType("i8", false, [range(from, to)]);
+const i8 = { vanilla, loose, strict };
+export default i8;
 //# sourceMappingURL=i8.js.map

package/lib/private/index.d.ts

@@ -1,4 +1,5 @@
 export type { default as ArrayType } from "#ArrayType";
+export type { default as BlobType } from "#BlobType";
 export type { default as BooleanType } from "#BooleanType";
 export type { default as ConstructorType } from "#ConstructorType";
 export type { default as DataKey } from "#DataKey";
@@ -13,13 +14,15 @@ export type { default as InferStoreOut } from "#InferStoreOut";
 export type { default as Issue } from "#Issue";
 export type { default as IsType } from "#IsType";
 export type { default as JSONPayload } from "#json/JSONPayload";
+export type { default as JSONType } from "#JSONType";
 export type { default as LiteralType } from "#LiteralType";
-export type { default as NormalizeSchema, NormalizeSchemaObject } from "#NormalizeSchema";
+export type { default as NormalizeSchema, NormalizeSchemaObject, } from "#NormalizeSchema";
 export type { default as NullType } from "#NullType";
 export type { default as NumberType } from "#NumberType";
 export type { default as ObjectType } from "#ObjectType";
 export type { default as OptionalType } from "#OptionalType";
 export type { default as Parsed } from "#Parsed";
+export type { default as PartialType } from "#PartialType";
 export type { default as PureType } from "#PureType";
 export type { default as RecordType } from "#RecordType";
 export type { default as Schema } from "#Schema";
@@ -33,10 +36,10 @@ export type { default as UintType } from "#UintType";
 export type { default as UndefinedType } from "#UndefinedType";
 export type { default as UnionType } from "#UnionType";
 export type { default as UnknownType } from "#UnknownType";
+export type { default as URLType } from "#URLType";
 export type { default as UUIDType } from "#UUIDType";
 export type { default as UUIDV4Type } from "#UUIDV4Type";
 export type { default as UUIDV7Type } from "#UUIDV7Type";
-import enum_ from "#enum";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
 /**
@@ -44,46 +47,259 @@ import type Schema from "#Schema";
 */
 declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 declare namespace schema {
-    export var array: typeof import("#array").default;
-    export var bigint: import("./BigIntType.js").default<"i64">;
-    export var biguint: import("./BigUintType.js").default<"u64">;
-    export var blob: import("./BlobType.js").default;
-    export var boolean: import("#BooleanType").default;
-    export var constructor: <const C extends import("@rcompat/type").AbstractNewable>(constructor: C) => import("#ConstructorType").default<C>;
-    export var date: import("#DateType").default;
-    export var dict: typeof import("#dict").default;
-    var _a: typeof enum_;
-    export var f32: import("#NumberType").default<"f32">;
-    export var f64: import("#NumberType").default<"f64">;
-    export var file: import("./FileType.js").default;
+    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 { _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: typeof import("#json").default;
-    export var number: import("#NumberType").default<"f64">;
-    export var object: typeof import("#object").default;
-    export var omit: typeof import("#omit").default;
-    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 pure: typeof import("#pure").default;
-    export var string: import("#StringType").default;
-    export var symbol: import("./SymbolType.js").default;
-    export var tuple: typeof import("#tuple").default;
-    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 union: typeof import("#union").default;
-    export var unknown: import("#UnknownType").default;
-    export var url: import("./URLType.js").default;
-    export var uuid: import("#UUIDType").default;
-    export { _a as enum, _b as function };
+    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>;
+    };
+}
+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 { _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]>; }>;
+    };
+}
+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