pema 0.8.2 → 0.9.0

package/lib/private/index.d.ts

@@ -1,4 +1,5 @@
 export type { default as ArrayType } from "#ArrayType";
+export type { default as AsyncType } from "#AsyncType";
 export type { default as BlobType } from "#BlobType";
 export type { default as BooleanType } from "#BooleanType";
 export type { default as ConstructorType } from "#ConstructorType";
@@ -6,7 +7,7 @@ export type { default as DataKey } from "#DataKey";
 export type { default as DataType } from "#DataType";
 export type { default as DateType } from "#DateType";
 export type { default as DefaultType } from "#DefaultType";
-export type { default as EnumType } from "#EnumType";
+export type { Enum, default as EnumType } from "#EnumType";
 export type { default as FunctionType } from "#FunctionType";
 export type { default as Id } from "#Id";
 export type { default as InferStore } from "#InferStore";
@@ -16,7 +17,7 @@ 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";
@@ -40,6 +41,7 @@ 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 async_schema from "#async";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
 /**
@@ -47,262 +49,107 @@ import type Schema from "#Schema";
 */
 declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 declare namespace schema {
-    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: {
+    var _a: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>>;
+    export { _a as array };
+    export { async_schema as async };
+    export var _b: import("./BigIntType.js").default<"i64", undefined>;
+    export { _b as bigint };
+    export var _c: import("./BigUintType.js").default<"u64", undefined>;
+    export { _c as biguint };
+    export var _d: import("#BlobType").default;
+    export { _d as blob };
+    export var _e: import("#BooleanType").default<undefined>;
+    export { _e as boolean };
+    export var _f: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+    export { _f as constructor };
+    export var _g: import("#DateType").default<undefined>;
+    export { _g as date };
+    export var _h: {
         (): 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 { _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: {
+    export { _h as dict };
+    export var _j: <const V extends import("@rcompat/type").Dict<number>>(values: V) => import("#EnumType").Enum<V, undefined>;
+    export { _j as enum };
+    export var _k: import("#NumberType").default<"f32", undefined>;
+    export { _k as f32 };
+    export var _l: import("#NumberType").default<"f64", undefined>;
+    export { _l as f64 };
+    export var _m: import("./FileType.js").default;
+    export { _m as file };
+    export var _o: import("#FunctionType").default;
+    export { _o as function };
+    export var _p: import("./BigIntType.js").default<"i128", undefined>;
+    export { _p as i128 };
+    export var _q: import("./IntType.js").default<"i16", undefined>;
+    export { _q as i16 };
+    export var _r: import("./IntType.js").default<"i32", undefined>;
+    export { _r as i32 };
+    export var _s: import("./BigIntType.js").default<"i64", undefined>;
+    export { _s as i64 };
+    export var _t: import("./IntType.js").default<"i8", undefined>;
+    export { _t as i8 };
+    export var _u: import("./IntType.js").default<"i32", undefined>;
+    export { _u as int };
+    export var _v: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+    export { _v as is };
+    export var _w: {
         (): 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: {
+    export { _w as json };
+    export var _x: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, undefined>;
+    export { _x as literal };
+    export var _y: import("#NullType").default;
+    export { _y as null };
+    export var _z: import("#NumberType").default<"f64", undefined>;
+    export { _z as number };
+    export var _0: <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 { _0 as object };
+    export var _1: <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 { _1 as omit };
+    export var _2: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, undefined>;
+    export { _2 as record };
+    export var _3: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }>;
+    export { _3 as partial };
+    export var _4: <T>() => import("#PureType").default<T, "PureType">;
+    export { _4 as pure };
+    export var _5: import("#StringType").default;
+    export { _5 as string };
+    export var _6: import("./SymbolType.js").default;
+    export { _6 as symbol };
+    export var _7: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
+    export { _7 as tuple };
+    export var _8: import("./BigUintType.js").default<"u128", undefined>;
+    export { _8 as u128 };
+    export var _9: import("#UintType").default<"u16", undefined>;
+    export { _9 as u16 };
+    export var _10: import("#UintType").default<"u32", undefined>;
+    export { _10 as u32 };
+    export var _11: import("./BigUintType.js").default<"u64", undefined>;
+    export { _11 as u64 };
+    export var _12: import("#UintType").default<"u8", undefined>;
+    export { _12 as u8 };
+    export var _13: import("#UintType").default<"u32", undefined>;
+    export { _13 as uint };
+    export var _14: import("#UndefinedType").default;
+    export { _14 as undefined };
+    export var _15: {
         (): 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 error: (path: string, message: string) => import("./ParseError.js").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 { _15 as union };
+    export var _16: import("#UnknownType").default;
+    export { _16 as unknown };
+    export var _17: import("#URLType").default<undefined>;
+    export { _17 as url };
+    export var _18: import("#UUIDType").default;
+    export { _18 as uuid };
+    export var error: (path: string, message: string) => import("./ParseError.js").default;
+    export { loose };
+    export { strict };
+}
+declare function loose<const S extends Schema>(s: S): NormalizeSchema<S>;
+declare function strict<const S extends Schema>(s: S): NormalizeSchema<S>;
 export default schema;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -1,5 +1,6 @@
 import E from "#errors";
 import array from "#array";
+import async_schema from "#async";
 import bigint from "#bigint";
 import biguint from "#biguint";
 import blob from "#blob";
@@ -61,6 +62,7 @@ function strict(s) {
     return i;
 }
 schema.array = array.vanilla;
+schema.async = async_schema;
 schema.bigint = bigint.vanilla;
 schema.biguint = biguint.vanilla;
 schema.blob = blob.vanilla;

package/lib/private/is.d.ts

@@ -1,8 +1,11 @@
 import IsType from "#IsType";
+declare const vanilla: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
+declare const loose: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
+declare const strict: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
 declare const is: {
-    vanilla: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
-    loose: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
-    strict: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
 };
 export default is;
 //# sourceMappingURL=is.d.ts.map

package/lib/private/normalize.js

@@ -10,9 +10,9 @@ import is from "@rcompat/is";
 export default function normalize(x) {
     if (is_parsed(x))
         return x;
-    if (x === null)
+    if (is.null(x))
         return new NullType();
-    if (x === undefined)
+    if (is.undefined(x))
         return new UndefinedType();
     if (is.string(x) || is.number(x) || is.boolean(x))
         return new LiteralType(x);

package/lib/private/optional.d.ts

@@ -1,5 +1,5 @@
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
-declare const _default: <const T extends Parsed<unknown>>(type: T) => OptionalType<T>;
 export default _default;
+declare function _default<const T extends Parsed<unknown>>(type: T): OptionalType<T>;
 //# sourceMappingURL=optional.d.ts.map

package/lib/private/path/next.d.ts

@@ -1,3 +1,4 @@
 import type ParseOptions from "#ParseOptions";
-export default function next(s: number | string, options?: ParseOptions): ParseOptions;
+declare function next(s: number | string, options?: ParseOptions): ParseOptions;
+export default next;
 //# sourceMappingURL=next.d.ts.map

package/lib/private/path/next.js

@@ -1,9 +1,11 @@
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
-export default function next(s, options) {
+import is from "@rcompat/is";
+function next(s, options) {
     const base = options?.[ParsedKey] ?? "";
-    return options === undefined
+    return is.undefined(options)
         ? { [ParsedKey]: join("", String(s)) }
         : { ...options, [ParsedKey]: join(base, String(s)) };
 }
+export default next;
 //# sourceMappingURL=next.js.map

package/lib/private/record.d.ts

@@ -1,10 +1,16 @@
 import type Parsed from "#Parsed";
 import RecordType from "#RecordType";
 import type RecordTypeKey from "#RecordTypeKey";
+/**
+* Value is a record of the given key and value types.
+*/
+declare const vanilla: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, undefined>;
+declare const loose: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, true>;
+declare const strict: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value, false>;
 declare const record: {
-    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>;
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
 };
 export default record;
 //# sourceMappingURL=record.d.ts.map

package/lib/private/schema-errors.d.ts

@@ -9,6 +9,7 @@ declare const errors: {
     max_limit_not_finite: (limit: number) => import("@rcompat/error").TemplateError;
     extend_key_collision: (key: string) => import("@rcompat/error").TemplateError;
     union_at_least_two_members: () => import("@rcompat/error").TemplateError;
+    enum_invalid_key: (key: string) => import("@rcompat/error").TemplateError;
 };
 export type Code = keyof typeof errors;
 export declare const Code: { [K in Code]: K; };

package/lib/private/schema-errors.js

@@ -11,6 +11,7 @@ const errors = error.coded({
     max_limit_not_finite: (limit) => t `max: limit ${limit} must be a finite number`,
     extend_key_collision: (key) => t `extend: key ${key} already exists and cannot be overridden`,
     union_at_least_two_members: () => t `union type must have at least two members`,
+    enum_invalid_key: (key) => t `enum: key ${key} must be SCREAMING_SNAKE_CASE`,
 });
 export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
 export default errors;

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

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

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

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

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

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

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

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

package/lib/private/test.js

@@ -1,4 +1,5 @@
 import ParseError from "#ParseError";
+import is from "@rcompat/is";
 import test from "@rcompat/test";
 const issue_types = [
     "invalid_type",
@@ -20,7 +21,7 @@ export default test.extend((assert, subject) => {
                 if (ParseError.is(e)) {
                     const issue = e.issues[0];
                     assert(issue.type).equals(type);
-                    if (path !== undefined)
+                    if (is.defined(path))
                         assert(issue.path).equals(path);
                 }
                 else {
@@ -44,10 +45,10 @@ export default test.extend((assert, subject) => {
                     assert(e.issues.length).equals(matchers.length);
                     for (let i = 0; i < matchers.length; i++) {
                         assert(e.issues[i].type).equals(matchers[i].type);
-                        if (matchers[i].path !== undefined) {
+                        if (is.defined(matchers[i].path)) {
                             assert(e.issues[i].path).equals(matchers[i].path);
                         }
-                        if (matchers[i].message !== undefined) {
+                        if (is.defined(matchers[i].message)) {
                             assert(e.issues[i].message).equals(matchers[i].message);
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pema",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,14 +17,14 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.13.0",
-    "@rcompat/cli": "^0.24.0",
-    "@rcompat/error": "^0.8.0",
-    "@rcompat/is": "^0.11.0",
-    "@rcompat/symbol": "^0.2.0"
+    "@rcompat/assert": "^0.14.0",
+    "@rcompat/cli": "^0.25.0",
+    "@rcompat/error": "^0.9.0",
+    "@rcompat/is": "^0.12.0",
+    "@rcompat/symbol": "^0.3.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.17.0"
+    "@rcompat/type": "^0.18.0"
   },
   "imports": {
     "#*": {
@@ -43,7 +43,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsgo",
+    "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",