pema 0.6.1 → 0.7.0

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

package/lib/private/index.js

@@ -6,11 +6,11 @@ import boolean from "#boolean";
 import constructor from "#constructor";
 import date from "#date";
 import dict from "#dict";
-import enum_ from "#enum";
+import enum$ from "#enum";
 import f32 from "#f32";
 import f64 from "#f64";
 import file from "#file";
-import fn from "#function";
+import function$ from "#function";
 import i128 from "#i128";
 import i16 from "#i16";
 import i32 from "#i32";
@@ -19,10 +19,14 @@ import i8 from "#i8";
 import int from "#int";
 import is from "#is";
 import json from "#json";
+import literal from "#literal";
+import Loose from "#Loose";
 import normalize from "#normalize";
+import null$ from "#null";
 import number from "#number";
 import object from "#object";
 import omit from "#omit";
+import partial from "#partial";
 import pure from "#pure";
 import record from "#record";
 import string from "#string";
@@ -34,6 +38,7 @@ import u32 from "#u32";
 import u64 from "#u64";
 import u8 from "#u8";
 import uint from "#uint";
+import undefined$ from "#undefined";
 import union from "#union";
 import unknown from "#unknown";
 import url from "#url";
@@ -44,44 +49,146 @@ import uuid from "#uuid";
 function schema(s) {
     return normalize(s);
 }
-schema.array = array;
-schema.bigint = bigint;
-schema.biguint = biguint;
-schema.blob = blob;
-schema.boolean = boolean;
-schema.constructor = constructor;
-schema.date = date;
-schema.dict = dict;
-schema.enum = enum_;
-schema.f32 = f32;
-schema.f64 = f64;
-schema.file = file;
-schema.function = fn;
-schema.i128 = i128;
-schema.i16 = i16;
-schema.i32 = i32;
-schema.i64 = i64;
-schema.i8 = i8;
-schema.int = int;
-schema.is = is;
-schema.json = json;
-schema.number = number;
-schema.object = object;
-schema.omit = omit;
-schema.record = record;
-schema.pure = pure;
-schema.string = string;
-schema.symbol = symbol;
-schema.tuple = tuple;
-schema.u128 = u128;
-schema.u16 = u16;
-schema.u32 = u32;
-schema.u64 = u64;
-schema.u8 = u8;
-schema.uint = uint;
-schema.union = union;
-schema.unknown = unknown;
-schema.url = url;
-schema.uuid = uuid;
+function loose(s) {
+    const i = normalize(s);
+    i[Loose] = true;
+    return i;
+}
+function strict(s) {
+    const i = normalize(s);
+    i[Loose] = false;
+    return i;
+}
+schema.array = array.vanilla;
+schema.bigint = bigint.vanilla;
+schema.biguint = biguint.vanilla;
+schema.blob = blob.vanilla;
+schema.boolean = boolean.vanilla;
+schema.constructor = constructor.vanilla;
+schema.date = date.vanilla;
+schema.dict = dict.vanilla;
+schema.enum = enum$.vanilla;
+schema.f32 = f32.vanilla;
+schema.f64 = f64.vanilla;
+schema.file = file.vanilla;
+schema.function = function$.vanilla;
+schema.i128 = i128.vanilla;
+schema.i16 = i16.vanilla;
+schema.i32 = i32.vanilla;
+schema.i64 = i64.vanilla;
+schema.i8 = i8.vanilla;
+schema.int = int.vanilla;
+schema.is = is.vanilla;
+schema.json = json.vanilla;
+schema.literal = literal.vanilla;
+schema.null = null$.vanilla;
+schema.number = number.vanilla;
+schema.object = object.vanilla;
+schema.omit = omit.vanilla;
+schema.record = record.vanilla;
+schema.partial = partial.vanilla;
+schema.pure = pure.vanilla;
+schema.string = string.vanilla;
+schema.symbol = symbol.vanilla;
+schema.tuple = tuple.vanilla;
+schema.u128 = u128.vanilla;
+schema.u16 = u16.vanilla;
+schema.u32 = u32.vanilla;
+schema.u64 = u64.vanilla;
+schema.u8 = u8.vanilla;
+schema.uint = uint.vanilla;
+schema.undefined = undefined$.vanilla;
+schema.union = union.vanilla;
+schema.unknown = unknown.vanilla;
+schema.url = url.vanilla;
+schema.uuid = uuid.vanilla;
+loose.array = array.loose;
+loose.bigint = bigint.loose;
+loose.biguint = biguint.loose;
+loose.blob = blob.loose;
+loose.boolean = boolean.loose;
+loose.constructor = constructor.loose;
+loose.date = date.loose;
+loose.dict = dict.loose;
+loose.enum = enum$.loose;
+loose.f32 = f32.loose;
+loose.f64 = f64.loose;
+loose.file = file.loose;
+loose.function = function$.loose;
+loose.i128 = i128.loose;
+loose.i16 = i16.loose;
+loose.i32 = i32.loose;
+loose.i64 = i64.loose;
+loose.i8 = i8.loose;
+loose.int = int.loose;
+loose.is = is.loose;
+loose.json = json.loose;
+loose.literal = literal.loose;
+loose.null = null$.loose;
+loose.number = number.loose;
+loose.object = object.loose;
+loose.omit = omit.loose;
+loose.record = record.loose;
+loose.partial = partial.loose;
+loose.pure = pure.loose;
+loose.string = string.loose;
+loose.symbol = symbol.loose;
+loose.tuple = tuple.loose;
+loose.u128 = u128.loose;
+loose.u16 = u16.loose;
+loose.u32 = u32.loose;
+loose.u64 = u64.loose;
+loose.u8 = u8.loose;
+loose.uint = uint.loose;
+loose.undefined = undefined$.loose;
+loose.union = union.loose;
+loose.unknown = unknown.loose;
+loose.url = url.loose;
+loose.uuid = uuid.loose;
+strict.array = array.strict;
+strict.bigint = bigint.strict;
+strict.biguint = biguint.strict;
+strict.blob = blob.strict;
+strict.boolean = boolean.strict;
+strict.constructor = constructor.strict;
+strict.date = date.strict;
+strict.dict = dict.strict;
+strict.enum = enum$.strict;
+strict.f32 = f32.strict;
+strict.f64 = f64.strict;
+strict.file = file.strict;
+strict.function = function$.strict;
+strict.i128 = i128.strict;
+strict.i16 = i16.strict;
+strict.i32 = i32.strict;
+strict.i64 = i64.strict;
+strict.i8 = i8.strict;
+strict.int = int.strict;
+strict.is = is.strict;
+strict.json = json.strict;
+strict.literal = literal.strict;
+strict.null = null$.strict;
+strict.number = number.strict;
+strict.object = object.strict;
+strict.omit = omit.strict;
+strict.record = record.strict;
+strict.partial = partial.strict;
+strict.pure = pure.strict;
+strict.string = string.strict;
+strict.symbol = symbol.strict;
+strict.tuple = tuple.strict;
+strict.u128 = u128.strict;
+strict.u16 = u16.strict;
+strict.u32 = u32.strict;
+strict.u64 = u64.strict;
+strict.u8 = u8.strict;
+strict.uint = uint.strict;
+strict.undefined = undefined$.strict;
+strict.union = union.strict;
+strict.unknown = unknown.strict;
+strict.url = url.strict;
+strict.uuid = uuid.strict;
+schema.loose = loose;
+schema.strict = strict;
 export default schema;
 //# sourceMappingURL=index.js.map

package/lib/private/is-parsed.d.ts

@@ -0,0 +1,3 @@
+import type Parsed from "#Parsed";
+export default function is_parsed(x: unknown): x is Parsed<unknown>;
+//# sourceMappingURL=is-parsed.d.ts.map

package/lib/private/is-parsed.js

@@ -0,0 +1,7 @@
+import ParsedKey from "#ParsedKey";
+import is from "@rcompat/is";
+export default function is_parsed(x) {
+    return is.object(x) && ParsedKey in x;
+}
+;
+//# sourceMappingURL=is-parsed.js.map