pema 0.6.0 → 0.7.0

package/lib/private/dict.d.ts

@@ -6,6 +6,16 @@ import type StringType from "#StringType";
  *
  * @param of - The value type (defaults to p.string)
  */
-export default function dict(): RecordType<StringType, StringType>;
-export default function dict<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+declare function vanilla(): RecordType<StringType, StringType>;
+declare function vanilla<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+declare function loose(): RecordType<StringType, StringType>;
+declare function loose<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+declare function strict(): RecordType<StringType, StringType>;
+declare function strict<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+declare const dict: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default dict;
 //# sourceMappingURL=dict.d.ts.map

package/lib/private/dict.js

@@ -1,6 +1,14 @@
 import record from "#record";
 import string from "#string";
-export default function dict(of = string) {
-    return record(string, of);
+function vanilla(of = string.strict) {
+    return record.vanilla(string.strict, of);
 }
+function loose(of = string.loose) {
+    return record.loose(string.loose, of);
+}
+function strict(of = string.loose) {
+    return record.strict(string.loose, of);
+}
+const dict = { vanilla, loose, strict };
+export default dict;
 //# sourceMappingURL=dict.js.map

package/lib/private/enum.d.ts

@@ -1,3 +1,11 @@
 import EnumType from "#EnumType";
-export default function _enum<T extends readonly string[]>(values: T): EnumType<T>;
+declare function vanilla<T extends readonly string[]>(values: T): EnumType<T>;
+declare function loose<T extends readonly string[]>(values: T): EnumType<T>;
+declare function strict<T extends readonly string[]>(values: T): EnumType<T>;
+declare const _enum: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default _enum;
 //# sourceMappingURL=enum.d.ts.map

package/lib/private/enum.js

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

package/lib/private/errors.js

@@ -1,16 +1,15 @@
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
+import is from "@rcompat/is";
 function print_got(x) {
-    if (x === undefined)
+    if (is.undefined(x))
         return "undefined";
-    if (x === null)
+    if (is.null(x))
         return "null";
-    return `\`${x?.toString() ?? x}\` (${typeof x})`;
+    return `\`${x.toString()}\` (${typeof x})`;
 }
 function invalid_type(input, expected, options = "") {
-    const path = typeof options === "string"
-        ? options
-        : options[ParsedKey] ?? "";
+    const path = is.string(options) ? options : options[ParsedKey] ?? "";
     return new ParseError([{
             type: "invalid_type",
             input,

package/lib/private/f32.d.ts

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

package/lib/private/f32.js

@@ -1,4 +1,11 @@
+import Loose from "#Loose";
 import NumberType from "#NumberType";
 import f32 from "#validator/f32";
-export default new NumberType("f32", [f32]);
+const vanilla = new NumberType("f32", [f32]);
+const loose = new NumberType("f32", [f32]);
+loose[Loose] = true;
+const strict = new NumberType("f32", [f32]);
+strict[Loose] = false;
+const f32$ = { vanilla, loose, strict };
+export default f32$;
 //# sourceMappingURL=f32.js.map

package/lib/private/f64.d.ts

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

package/lib/private/f64.js

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

package/lib/private/file.d.ts

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

package/lib/private/file.js

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

package/lib/private/function.d.ts

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

package/lib/private/function.js

@@ -1,6 +1,13 @@
 import FunctionType from "#FunctionType";
+import Loose from "#Loose";
 /**
  * Value is a function.
  */
-export default new FunctionType();
+const vanilla = new FunctionType();
+const loose = new FunctionType();
+loose[Loose] = true;
+const strict = new FunctionType();
+strict[Loose] = false;
+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">;
+    loose: BigIntType<"i128">;
+    strict: BigIntType<"i128">;
+};
+export default i128;
 //# sourceMappingURL=i128.d.ts.map

package/lib/private/i128.js

@@ -1,6 +1,13 @@
 import BigIntType from "#BigIntType";
+import Loose from "#Loose";
 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", [range(from, to)]);
+const loose = new BigIntType("i128", [range(from, to)]);
+loose[Loose] = true;
+const strict = new BigIntType("i128", [range(from, to)]);
+strict[Loose] = false;
+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">;
+    loose: IntType<"i16">;
+    strict: IntType<"i16">;
+};
+export default i16;
 //# sourceMappingURL=i16.d.ts.map

package/lib/private/i16.js

@@ -1,6 +1,13 @@
 import IntType from "#IntType";
+import Loose from "#Loose";
 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", [range(from, to)]);
+const loose = new IntType("i16", [range(from, to)]);
+loose[Loose] = true;
+const strict = new IntType("i16", [range(from, to)]);
+strict[Loose] = false;
+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">;
+    loose: IntType<"i32">;
+    strict: IntType<"i32">;
+};
+export default i32;
 //# sourceMappingURL=i32.d.ts.map

package/lib/private/i32.js

@@ -1,6 +1,13 @@
 import IntType from "#IntType";
+import Loose from "#Loose";
 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", [range(from, to)]);
+const loose = new IntType("i32", [range(from, to)]);
+loose[Loose] = true;
+const strict = new IntType("i32", [range(from, to)]);
+strict[Loose] = false;
+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">;
+    loose: BigIntType<"i64">;
+    strict: BigIntType<"i64">;
+};
+export default i64;
 //# sourceMappingURL=i64.d.ts.map

package/lib/private/i64.js

@@ -1,6 +1,13 @@
 import BigIntType from "#BigIntType";
+import Loose from "#Loose";
 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", [range(from, to)]);
+const loose = new BigIntType("i64", [range(from, to)]);
+loose[Loose] = true;
+const strict = new BigIntType("i64", [range(from, to)]);
+strict[Loose] = false;
+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">;
+    loose: IntType<"i8">;
+    strict: IntType<"i8">;
+};
+export default i8;
 //# sourceMappingURL=i8.d.ts.map

package/lib/private/i8.js

@@ -1,6 +1,13 @@
 import IntType from "#IntType";
+import Loose from "#Loose";
 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", [range(from, to)]);
+const loose = new IntType("i8", [range(from, to)]);
+loose[Loose] = true;
+const strict = new IntType("i8", [range(from, to)]);
+strict[Loose] = false;
+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,15 +47,18 @@ 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 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.js").default;
+    export var blob: import("#BlobType").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 constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
     export var date: import("#DateType").default;
-    export var dict: typeof import("#dict").default;
-    var _a: typeof enum_;
+    export 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>;
+    };
+    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;
@@ -64,26 +70,38 @@ declare namespace schema {
     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 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>;
+    var _c: import("#NullType").default;
     export var number: import("#NumberType").default<"f64">;
-    export var object: typeof import("#object").default;
-    export var omit: typeof import("#omit").default;
+    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 pure: typeof import("#pure").default;
+    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: typeof import("#tuple").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 union: typeof import("#union").default;
+    export var undefined: import("#UndefinedType").default;
+    export 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.js").default;
+    export var url: import("#URLType").default;
     export var uuid: import("#UUIDType").default;
-    export { _a as enum, _b as function };
+    export var loose: typeof schema;
+    export var strict: typeof schema;
+    export { _a as enum, _b as function, _c as null };
 }
 export default schema;
 //# sourceMappingURL=index.d.ts.map