pema 0.8.3 → 0.9.1

package/lib/private/ArrayType.d.ts

@@ -20,7 +20,7 @@ export default class ArrayType<T extends Parsed<unknown>, M extends Mode = undef
     get name(): "array";
     optional(): OptionalType<this>;
     default(value: (() => Infer<T>[]) | Infer<T>[]): DefaultType<this, Infer<T>[]>;
-    derive(_next: Next<Array<Infer<T>>>): this;
+    with(_next: Next<Array<Infer<T>>>): this;
     /**
      * Member values are unique — only for primitive subtypes.
      *

package/lib/private/ArrayType.js

@@ -40,7 +40,7 @@ export default class ArrayType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    derive(_next) {
+    with(_next) {
         const Constructor = this.constructor;
         return new Constructor(this.#item, this[Loose], [...this.#validators, ..._next.validators ?? []]);
     }
@@ -54,27 +54,27 @@ export default class ArrayType extends GenericType {
         if (!isPrimitive(this.#item)) {
             throw S.unique_subtype_not_primitive(this.#item.name);
         }
-        return this.derive({ validators: [unique] });
+        return this.with({ validators: [unique] });
     }
     uniqueBy(select) {
-        return this.derive({ validators: [uniqueBy(select)] });
+        return this.with({ validators: [uniqueBy(select)] });
     }
     min(limit) {
         if (limit < 0)
             throw S.min_negative(limit);
-        return this.derive({ validators: [min(limit)] });
+        return this.with({ validators: [min(limit)] });
     }
     max(limit) {
         if (limit < 0)
             throw S.max_negative(limit);
-        return this.derive({ validators: [max(limit)] });
+        return this.with({ validators: [max(limit)] });
     }
     length(from, to) {
-        return this.derive({ validators: [length(from, to)] });
+        return this.with({ validators: [length(from, to)] });
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...options, [Loose]: this[Loose] }
             : options;
         const path = $options[ParsedKey] ?? "";

package/lib/private/AsyncType.d.ts

@@ -0,0 +1,18 @@
+import type Mode from "#Mode";
+import type ObjectType from "#ObjectType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type { Dict, MaybePromise } from "@rcompat/type";
+type Derive<Input, Output> = (value: Input) => MaybePromise<Output>;
+export default class AsyncType<P extends Dict<Parsed<unknown>> = Dict<Parsed<unknown>>, M extends Mode = undefined, I = ObjectType<P, M>["infer"], Output = I> {
+    #private;
+    constructor(schema: ObjectType<P, M, I>, derive?: Derive<I, Output>);
+    get infer(): Output;
+    get input(): import("./InferInputSchema.js").default<P>;
+    get schema(): ObjectType<P, M, I>;
+    get properties(): P;
+    derive<Next>(derive: Derive<Output, Next>): AsyncType<P, M, I, Awaited<Next>>;
+    parse(u: unknown, options?: ParseOptions): Promise<Output>;
+}
+export {};
+//# sourceMappingURL=AsyncType.d.ts.map

package/lib/private/AsyncType.js

@@ -0,0 +1,28 @@
+export default class AsyncType {
+    #schema;
+    #derive;
+    constructor(schema, derive = value => value) {
+        this.#schema = schema;
+        this.#derive = derive;
+    }
+    get infer() {
+        return undefined;
+    }
+    get input() {
+        return this.#schema.input;
+    }
+    get schema() {
+        return this.#schema;
+    }
+    get properties() {
+        return this.#schema.properties;
+    }
+    derive(derive) {
+        const next = async (value) => await derive(await this.#derive(value));
+        return new AsyncType(this.#schema, next);
+    }
+    async parse(u, options) {
+        return this.#derive(this.#schema.parse(u, options));
+    }
+}
+//# sourceMappingURL=AsyncType.js.map

package/lib/private/EnumType.d.ts

@@ -1,21 +1,24 @@
 import DefaultType from "#DefaultType";
-import GenericType from "#GenericType";
-import type Infer from "#Infer";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
-import type OptionalTrait from "#trait/Optional";
-type Literal = string;
-export default class EnumType<T extends readonly Literal[]> extends GenericType<T, T[number], "EnumType"> implements OptionalTrait {
+import Storable from "#Storable";
+import type UintType from "#UintType";
+import type { Dict } from "@rcompat/type";
+export default class EnumType<V extends Dict<number>, L extends boolean | undefined = undefined> extends Storable<"u8", V[keyof V]> {
     #private;
-    constructor(values: T);
+    constructor(values: V, inner: UintType<"u8", L>);
     get name(): string;
+    get datatype(): "u8";
+    get values(): V;
+    nameOf(value: V[keyof V]): keyof V;
     optional(): OptionalType<this>;
-    default<D extends T[number]>(value: (() => D) | D): DefaultType<EnumType<T>, D>;
-    parse(u: unknown, options?: ParseOptions): Infer<this>;
+    default<D extends V[keyof V]>(value: (() => D) | D): DefaultType<EnumType<V, L>, D>;
+    parse(u: unknown, options?: ParseOptions): V[keyof V];
     toJSON(): {
         type: "enum";
-        values: T[number][];
+        datatype: "u8";
+        values: V;
     };
 }
-export {};
+export type Enum<V extends Dict<number>, L extends boolean | undefined = undefined> = EnumType<V, L> & V;
 //# sourceMappingURL=EnumType.d.ts.map

package/lib/private/EnumType.js

@@ -1,17 +1,35 @@
 import DefaultType from "#DefaultType";
-import E from "#errors";
-import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import resolve from "#resolve";
-import is from "@rcompat/is";
-export default class EnumType extends GenericType {
+import S from "#schema-errors";
+import Storable from "#Storable";
+const KEY = /^[A-Z][A-Z0-9_]*$/;
+export default class EnumType extends Storable {
     #values;
-    constructor(values) {
+    #reverse;
+    #inner;
+    constructor(values, inner) {
         super();
+        for (const key of Object.keys(values)) {
+            if (!KEY.test(key))
+                throw S.enum_invalid_key(key);
+        }
         this.#values = values;
+        this.#reverse = new Map(Object.entries(values).map(([k, v]) => [v, k]));
+        this.#inner = inner.values(values);
+        Object.assign(this, values);
+        Object.freeze(this);
     }
     get name() {
-        return this.#values.map(v => `"${v}"`).join(" | ");
+        return Object.keys(this.#values).map(k => `"${k}"`).join(" | ");
+    }
+    get datatype() {
+        return "u8";
+    }
+    get values() {
+        return this.#values;
+    }
+    nameOf(value) {
+        return this.#reverse.get(value);
     }
     optional() {
         return new OptionalType(this);
@@ -20,14 +38,14 @@ export default class EnumType extends GenericType {
         return new DefaultType(this, value);
     }
     parse(u, options = {}) {
-        const x = resolve(u);
-        if (!is.string(x) || !this.#values.includes(x)) {
-            throw E.invalid_type(x, this.name, options);
-        }
-        return x;
+        return this.#inner.parse(u, options);
     }
     toJSON() {
-        return { type: "enum", values: [...this.#values] };
+        return {
+            type: "enum",
+            datatype: "u8",
+            values: { ...this.#values },
+        };
     }
 }
 //# sourceMappingURL=EnumType.js.map

package/lib/private/JSONType.js

@@ -24,10 +24,9 @@ export default class JSONType extends Storable {
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        if (this.#inner !== undefined) {
-            // delegate to inner schema for typed validation
+        // delegate to inner schema for typed validation
+        if (is.defined(this.#inner))
             return this.#inner.parse(x, options);
-        }
         if (!is.json(x))
             throw E.invalid_type(x, "json", options);
         return JSON.parse(JSON.stringify(x));
@@ -36,7 +35,7 @@ export default class JSONType extends Storable {
         return {
             type: "json",
             datatype: "json",
-            ...(this.#inner !== undefined && { of: this.#inner.toJSON() }),
+            ...is.defined(this.#inner) && { of: this.#inner.toJSON() },
         };
     }
 }

package/lib/private/LiteralType.d.ts

@@ -2,9 +2,9 @@ import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
-import type Mode from "#Mode";
 type Literal = string | boolean | number;
 export default class LiteralType<T extends Literal, M extends Mode = undefined> extends GenericType<T, T, "LiteralType"> {
     #private;

package/lib/private/NumericType.d.ts

@@ -14,7 +14,7 @@ export default abstract class NumericType<Key extends DataKey, T extends bigint
     #private;
     [Loose]: M;
     constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
-    derive(next: Next<T>): this;
+    with(next: Next<T>): this;
     values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;

package/lib/private/NumericType.js

@@ -12,21 +12,21 @@ export default class NumericType extends PrimitiveType {
         this.#datatype = datatype;
         this[Loose] = mode;
     }
-    derive(next) {
+    with(next) {
         const Constructor = this.constructor;
         return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
     }
     values(anyof) {
-        return this.derive({ validators: [values(anyof)] });
+        return this.with({ validators: [values(anyof)] });
     }
     range(from, to) {
-        return this.derive({ validators: [range(from, to)] });
+        return this.with({ validators: [range(from, to)] });
     }
     min(from) {
-        return this.derive({ validators: [min(from)] });
+        return this.with({ validators: [min(from)] });
     }
     max(to) {
-        return this.derive({ validators: [max(to)] });
+        return this.with({ validators: [max(to)] });
     }
     get datatype() {
         return this.#datatype;

package/lib/private/ObjectType.js

@@ -52,7 +52,7 @@ export default class ObjectType extends GenericType {
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...this.#options, ...options, [Loose]: this[Loose] }
             : { ...this.#options, ...options };
         if (is.defined(x) && !is.dict(x))
@@ -61,7 +61,7 @@ export default class ObjectType extends GenericType {
         const out = {};
         for (const k in this.#properties) {
             const parsed = this.#properties[k].parse(input[k], next(k, $options));
-            if (parsed !== undefined)
+            if (is.defined(parsed))
                 out[k] = parsed;
         }
         return out;

package/lib/private/OmitType.js

@@ -28,12 +28,11 @@ export default class OmitType extends GenericType {
         const props = this.#properties;
         for (const k in props) {
             const field = props[k];
-            const r = field.parse(x[k], {
+            const parsed = field.parse(x[k], {
                 ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
             });
-            if (r !== undefined) {
-                out[k] = r;
-            }
+            if (is.defined(parsed))
+                out[k] = parsed;
         }
         return out;
     }

package/lib/private/Parsed.d.ts

@@ -11,6 +11,7 @@ export default abstract class Parsed<StaticType> implements Serializable {
     [Loose]: boolean | undefined;
     [CoerceKey](x: unknown): unknown;
     abstract get name(): string;
+    derive<Output>(derive: (value: StaticType) => Output): Parsed<Output>;
     /**
     * Parse the given value.
     *

package/lib/private/Parsed.js

@@ -15,5 +15,26 @@ export default class Parsed {
     [CoerceKey](x) {
         return x;
     }
+    derive(derive) {
+        return new DerivedType(this, derive);
+    }
+}
+class DerivedType extends Parsed {
+    #schema;
+    #derive;
+    constructor(schema, derive) {
+        super();
+        this.#schema = schema;
+        this.#derive = derive;
+    }
+    get name() {
+        return this.#schema.name;
+    }
+    parse(u, options) {
+        return this.#derive(this.#schema.parse(u, options));
+    }
+    toJSON() {
+        return this.#schema.toJSON();
+    }
 }
 //# sourceMappingURL=Parsed.js.map

package/lib/private/PartialType.js

@@ -34,11 +34,11 @@ export default class PartialType extends VirtualType {
         const issues = [];
         for (const key of Object.keys(this.#spec)) {
             // skip missing/undefined keys (partial semantics)
-            if (!(key in input) || input[key] === undefined)
+            if (!(key in input) || is.undefined(input[key]))
                 continue;
             try {
                 const parsed = this.#spec[key].parse(input[key], next(key, options));
-                if (parsed !== undefined)
+                if (is.defined(parsed))
                     out[key] = parsed;
             }
             catch (e) {

package/lib/private/PrimitiveType.d.ts

@@ -11,7 +11,7 @@ export default abstract class PrimitiveType<StaticType, Name extends string> ext
     constructor(validators?: Validator<StaticType>[], options?: ParseOptions);
     get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
-    derive(next: Next<StaticType>): this;
+    with(next: Next<StaticType>): this;
     parse(u: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
 export {};

package/lib/private/PrimitiveType.js

@@ -5,6 +5,7 @@ import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import resolve from "#resolve";
 import Type from "#Type";
+import is from "@rcompat/is";
 export default class PrimitiveType extends Type {
     #validators;
     #options;
@@ -19,14 +20,14 @@ export default class PrimitiveType extends Type {
     get validators() {
         return this.#validators;
     }
-    derive(next) {
+    with(next) {
         const Constructor = this.constructor;
         return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
     }
     parse(u, options = {}) {
         const x = resolve(u);
         // hotpath: avoid object spread when possible
-        const has_instance_options = this.#options[ParsedKey] !== undefined;
+        const has_instance_options = is.defined(this.#options[ParsedKey]);
         const $options = has_instance_options
             ? { ...this.#options, ...options }
             : options;

package/lib/private/Serialized.d.ts

@@ -78,7 +78,8 @@ type StructuralSerialized = {
     properties: Dict<Serialized>;
 } | {
     type: "enum";
-    values: string[];
+    datatype: "u8";
+    values: Dict<number>;
 } | {
     type: "pure";
 } | {

package/lib/private/StoreType.js

@@ -24,7 +24,7 @@ export default class StoreType extends ObjectType {
             if (k === this.#pk && !(k in input))
                 continue;
             const parsed = this.properties[k].parse(input[k], next(k, $options));
-            if (parsed !== undefined)
+            if (is.defined(parsed))
                 out[k] = parsed;
         }
         return out;

package/lib/private/StringType.js

@@ -17,32 +17,32 @@ export default class StringType extends PrimitiveType {
         return "string";
     }
     isotime() {
-        return this.derive({ validators: [isotime] });
+        return this.with({ validators: [isotime] });
     }
     regex(pattern) {
-        return this.derive({ validators: [regex(pattern)] });
+        return this.with({ validators: [regex(pattern)] });
     }
     email() {
-        return this.derive({ validators: [email] });
+        return this.with({ validators: [email] });
     }
     startsWith(prefix) {
-        return this.derive({ validators: [starts_with(prefix)] });
+        return this.with({ validators: [starts_with(prefix)] });
     }
     endsWith(suffix) {
-        return this.derive({ validators: [ends_with(suffix)] });
+        return this.with({ validators: [ends_with(suffix)] });
     }
     min(limit) {
         if (limit < 0)
             throw E.min_negative(limit);
-        return this.derive({ validators: [min(limit)] });
+        return this.with({ validators: [min(limit)] });
     }
     max(limit) {
         if (limit < 0)
             throw E.max_negative(limit);
-        return this.derive({ validators: [max(limit)] });
+        return this.with({ validators: [max(limit)] });
     }
     length(from, to) {
-        return this.derive({ validators: [length(from, to)] });
+        return this.with({ validators: [length(from, to)] });
     }
     toJSON() {
         return Storable.serialize(this);

package/lib/private/TupleType.js

@@ -23,7 +23,7 @@ export default class TupleType extends GenericType {
         const x = resolve(u);
         if (!is.array(x))
             throw E.invalid_type(x, "array", options);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...options, [Loose]: this[Loose] }
             : options;
         const items = this.#items;

package/lib/private/UintType.js

@@ -12,7 +12,7 @@ export default class UintType extends NumericType {
     * Value is a non-privileged port number (1000 - 65535).
     */
     port() {
-        return this.derive({ validators: [port] });
+        return this.with({ validators: [port] });
     }
     parse(u, options = {}) {
         return super.parse(u, {

package/lib/private/array.d.ts

@@ -1,10 +1,16 @@
 import ArrayType from "#ArrayType";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
+/**
+* Value is an array of the given type.
+*/
+declare const vanilla: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+declare const loose: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, true>;
+declare const strict: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, false>;
 declare const array: {
-    strict: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, false>;
-    loose: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, true>;
-    vanilla: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+    strict: typeof strict;
+    loose: typeof loose;
+    vanilla: typeof vanilla;
 };
 export default array;
 //# sourceMappingURL=array.d.ts.map

package/lib/private/async.d.ts

@@ -0,0 +1,8 @@
+import AsyncType from "#AsyncType";
+import type { NormalizeSchemaObject } from "#NormalizeSchema";
+import type ObjectType from "#ObjectType";
+import type Schema from "#Schema";
+import type { Dict } from "@rcompat/type";
+declare function async_schema<const S extends Dict<Schema>>(schema: S): AsyncType<NormalizeSchemaObject<S>, undefined, ObjectType<NormalizeSchemaObject<S>>["infer"]>;
+export default async_schema;
+//# sourceMappingURL=async.d.ts.map

package/lib/private/async.js

@@ -0,0 +1,7 @@
+import AsyncType from "#AsyncType";
+import normalize from "#normalize";
+function async_schema(schema) {
+    return new AsyncType(normalize(schema));
+}
+export default async_schema;
+//# sourceMappingURL=async.js.map

package/lib/private/coerce/date.js

@@ -6,16 +6,14 @@ const ISO_DATETIME_TZ = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})
 const INT = /^[+-]?\d+$/;
 function epoch(n, digits) {
     // for strings we use digit-count to choose s vs ms.
-    // for numbers we ALWAYS treat as ms (no digits provided)
-    const ms = digits !== undefined
-        ? (digits >= 13 ? n : n * 1000)
-        : n;
+    // for numbers we always treat as ms (no digits provided)
+    const ms = is.defined(digits) ? (digits >= 13 ? n : n * 1000) : n;
     const date = new Date(ms);
     return Number.isNaN(date.getTime()) ? undefined : date;
 }
 function fromNumber(n) {
     const date = epoch(n);
-    return date !== undefined ? date : n;
+    return is.defined(date) ? date : n;
 }
 function fromString(raw) {
     const s = raw.trim();

package/lib/private/constructor.d.ts

@@ -1,9 +1,15 @@
 import ConstructorType from "#ConstructorType";
 import type { AbstractNewable } from "@rcompat/type";
+/**
+ * Value is a constructed instance of the given class.
+ */
+declare const vanilla: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+declare const loose: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+declare const strict: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
 declare const constructor: {
-    vanilla: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
-    loose: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
-    strict: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
 };
 export default constructor;
 //# sourceMappingURL=constructor.d.ts.map

package/lib/private/enum.d.ts

@@ -1,11 +1,12 @@
-import EnumType from "#EnumType";
-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>;
+import { type Enum } from "#EnumType";
+import type { Dict } from "@rcompat/type";
+declare function vanilla<const V extends Dict<number>>(values: V): Enum<V, undefined>;
+declare function loose<const V extends Dict<number>>(values: V): Enum<V, true>;
+declare function strict<const V extends Dict<number>>(values: V): Enum<V, false>;
 declare const _default: {
+    vanilla: typeof vanilla;
     loose: typeof loose;
     strict: typeof strict;
-    vanilla: typeof vanilla;
 };
 export default _default;
 //# sourceMappingURL=enum.d.ts.map

package/lib/private/enum.js

@@ -1,12 +1,13 @@
 import EnumType from "#EnumType";
+import u8 from "#u8";
 function vanilla(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.vanilla);
 }
 function loose(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.loose);
 }
 function strict(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.strict);
 }
-export default { loose, strict, vanilla };
+export default { vanilla, loose, strict };
 //# sourceMappingURL=enum.js.map

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";
 /**
@@ -49,6 +51,7 @@ declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 declare namespace schema {
     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>;
@@ -66,7 +69,7 @@ declare namespace schema {
         <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value>;
     };
     export { _h as dict };
-    export var _j: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
+    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 };
@@ -146,7 +149,113 @@ declare namespace schema {
     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>;
+declare const 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: <const V extends import("@rcompat/type").Dict<number>>(values: V) => import("#EnumType").Enum<V, true>;
+    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 const 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: <const V extends import("@rcompat/type").Dict<number>>(values: V) => import("#EnumType").Enum<V, false>;
+    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

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";
@@ -50,17 +51,106 @@ import uuid from "#uuid";
 function schema(s) {
     return normalize(s);
 }
-function loose(s) {
+const loose = Object.assign(function loose(s) {
     const i = normalize(s);
     i[Loose] = true;
     return i;
-}
-function strict(s) {
+}, {
+    array: array.loose,
+    bigint: bigint.loose,
+    biguint: biguint.loose,
+    blob: blob.loose,
+    boolean: boolean.loose,
+    constructor: constructor.loose,
+    date: date.loose,
+    dict: dict.loose,
+    enum: enum$.loose,
+    f32: f32.loose,
+    f64: f64.loose,
+    file: file.loose,
+    function: function$.loose,
+    i128: i128.loose,
+    i16: i16.loose,
+    i32: i32.loose,
+    i64: i64.loose,
+    i8: i8.loose,
+    int: int.loose,
+    is: is.loose,
+    json: json.loose,
+    literal: literal.loose,
+    null: null$.loose,
+    number: number.loose,
+    object: object.loose,
+    omit: omit.loose,
+    record: record.loose,
+    partial: partial.loose,
+    pure: pure.loose,
+    string: string.loose,
+    symbol: symbol.loose,
+    tuple: tuple.loose,
+    u128: u128.loose,
+    u16: u16.loose,
+    u32: u32.loose,
+    u64: u64.loose,
+    u8: u8.loose,
+    uint: uint.loose,
+    undefined: undefined$.loose,
+    union: union.loose,
+    unknown: unknown.loose,
+    url: url.loose,
+    uuid: uuid.loose,
+});
+const strict = Object.assign(function strict(s) {
     const i = normalize(s);
     i[Loose] = false;
     return i;
-}
+}, {
+    array: array.strict,
+    bigint: bigint.strict,
+    biguint: biguint.strict,
+    blob: blob.strict,
+    boolean: boolean.strict,
+    constructor: constructor.strict,
+    date: date.strict,
+    dict: dict.strict,
+    enum: enum$.strict,
+    f32: f32.strict,
+    f64: f64.strict,
+    file: file.strict,
+    function: function$.strict,
+    i128: i128.strict,
+    i16: i16.strict,
+    i32: i32.strict,
+    i64: i64.strict,
+    i8: i8.strict,
+    int: int.strict,
+    is: is.strict,
+    json: json.strict,
+    literal: literal.strict,
+    null: null$.strict,
+    number: number.strict,
+    object: object.strict,
+    omit: omit.strict,
+    record: record.strict,
+    partial: partial.strict,
+    pure: pure.strict,
+    string: string.strict,
+    symbol: symbol.strict,
+    tuple: tuple.strict,
+    u128: u128.strict,
+    u16: u16.strict,
+    u32: u32.strict,
+    u64: u64.strict,
+    u8: u8.strict,
+    uint: uint.strict,
+    undefined: undefined$.strict,
+    union: union.strict,
+    unknown: unknown.strict,
+    url: url.strict,
+    uuid: uuid.strict,
+});
 schema.array = array.vanilla;
+schema.async = async_schema;
 schema.bigint = bigint.vanilla;
 schema.biguint = biguint.vanilla;
 schema.blob = blob.vanilla;
@@ -104,92 +194,6 @@ schema.unknown = unknown.vanilla;
 schema.url = url.vanilla;
 schema.uuid = uuid.vanilla;
 schema.error = E.field;
-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;

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/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/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.3",
+  "version": "0.9.1",
   "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",