pema 0.6.1 → 0.8.0

package/lib/private/TupleType.js

@@ -1,12 +1,17 @@
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import next from "#path/next";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class TupleType extends GenericType {
     #items;
-    constructor(items) {
+    [Loose];
+    constructor(items, mode) {
         super();
         this.#items = items;
+        this[Loose] = mode;
     }
     get name() {
         return "tuple";
@@ -14,19 +19,23 @@ export default class TupleType extends GenericType {
     optional() {
         return new OptionalType(this);
     }
-    parse(x, options = {}) {
-        if (!Array.isArray(x))
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.array(x))
             throw E.invalid_type(x, "array", options);
+        const $options = this[Loose] !== undefined
+            ? { ...options, [Loose]: this[Loose] }
+            : options;
         const items = this.#items;
         const n = items.length;
         const out = new Array(n);
         // validate each expected item
         for (let i = 0; i < n; i++) {
-            out[i] = items[i].parse(x[i], next(i, options));
+            out[i] = items[i].parse(x[i], next(i, $options));
         }
         // reject extra items
         if (x.length > n)
-            throw E.invalid_type(x[n], "undefined", next(n, options));
+            throw E.invalid_type(x[n], "undefined", next(n, $options));
         return out;
     }
     toJSON() {

package/lib/private/URLType.d.ts

@@ -1,6 +1,10 @@
 import BuiltinType from "#BuiltinType";
+import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
-export default class URLType extends BuiltinType<URL, "URLType"> implements Storable<"url"> {
+export default class URLType<M extends boolean | undefined = undefined> extends BuiltinType<URL, "URLType"> implements Storable<"url"> {
+    [Loose]: M;
+    constructor(mode?: M);
     get Type(): {
         new (url: string | URL, base?: string | URL): URL;
         prototype: URL;
@@ -11,6 +15,7 @@ export default class URLType extends BuiltinType<URL, "URLType"> implements Stor
     };
     get name(): "url";
     get datatype(): "url";
+    [CoerceKey](x: unknown): unknown;
     toJSON(): {
         type: "url";
         datatype: "url";

package/lib/private/URLType.js

@@ -1,6 +1,17 @@
 import BuiltinType from "#BuiltinType";
+import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
+import is from "@rcompat/is";
 export default class URLType extends BuiltinType {
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
+    /*get [as.out](): L extends true ? "text" : never {
+      return (this[Loose] === true ? as.$("text") : as.$()) as never;
+    }*/
     get Type() {
         return URL;
     }
@@ -10,6 +21,16 @@ export default class URLType extends BuiltinType {
     get datatype() {
         return "url";
     }
+    [CoerceKey](x) {
+        if (!is.string(x))
+            return x;
+        try {
+            return new URL(x);
+        }
+        catch {
+            return x;
+        }
+    }
     toJSON() {
         return Storable.serialize(this);
     }

package/lib/private/UUIDType.d.ts

@@ -6,7 +6,7 @@ import UUIDV7Type from "#UUIDV7Type";
 export default class UUIDType extends PrimitiveType<string, "UUIDType"> implements Storable<"uuid"> {
     get name(): "string";
     get datatype(): "uuid";
-    parse(x: unknown): Infer<this>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid";

package/lib/private/UUIDType.js

@@ -3,6 +3,7 @@ import Storable from "#Storable";
 import UUIDV4Type from "#UUIDV4Type";
 import UUIDV7Type from "#UUIDV7Type";
 import E from "#errors";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 const re = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
 const v4 = new UUIDV4Type();
@@ -14,7 +15,8 @@ export default class UUIDType extends PrimitiveType {
     get datatype() {
         return "uuid";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID`);
         }

package/lib/private/UUIDV4Type.d.ts

@@ -4,7 +4,7 @@ import Storable from "#Storable";
 export default class UUIDV4Type extends PrimitiveType<string, "UUIDV4Type"> implements Storable<"uuid_v4"> {
     get name(): "string";
     get datatype(): "uuid_v4";
-    parse(x: unknown): Infer<this>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid_v4";

package/lib/private/UUIDV4Type.js

@@ -1,6 +1,7 @@
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import E from "#errors";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 const re = /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
 export default class UUIDV4Type extends PrimitiveType {
@@ -10,7 +11,8 @@ export default class UUIDV4Type extends PrimitiveType {
     get datatype() {
         return "uuid_v4";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID v4`);
         }

package/lib/private/UUIDV7Type.d.ts

@@ -4,7 +4,7 @@ import Storable from "#Storable";
 export default class UUIDV7Type extends PrimitiveType<string, "UUIDV7Type"> implements Storable<"uuid_v7"> {
     get name(): "string";
     get datatype(): "uuid_v7";
-    parse(x: unknown): Infer<this>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid_v7";

package/lib/private/UUIDV7Type.js

@@ -1,6 +1,7 @@
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import E from "#errors";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 const re = /^[\da-f]{8}-[\da-f]{4}-7[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
 export default class UUIDV7Type extends PrimitiveType {
@@ -10,7 +11,8 @@ export default class UUIDV7Type extends PrimitiveType {
     get datatype() {
         return "uuid_v7";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID v7`);
         }

package/lib/private/UintType.d.ts

@@ -4,13 +4,13 @@ import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
 import type Storable from "#Storable";
 import type UintDataType from "#UintDataType";
-export default class UintType<T extends UintDataType> extends NumericType<T, number, "UintType"> implements Storable<T> {
+export default class UintType<T extends UintDataType, L extends boolean | undefined = undefined> extends NumericType<T, number, "UintType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     /**
     * Value is a non-privileged port number (1000 - 65535).
     */
     port(): this;
-    parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
+    parse(u: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
 //# sourceMappingURL=UintType.d.ts.map

package/lib/private/UintType.js

@@ -14,8 +14,8 @@ export default class UintType extends NumericType {
     port() {
         return this.derive({ validators: [port] });
     }
-    parse(x, options = {}) {
-        return super.parse(x, {
+    parse(u, options = {}) {
+        return super.parse(u, {
             ...options,
             validators: [integer],
         });

package/lib/private/UnionType.d.ts

@@ -1,4 +1,5 @@
 import DefaultType from "#DefaultType";
+import type Mode from "#Mode";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type NormalizeSchema from "#NormalizeSchema";
@@ -9,17 +10,19 @@ import type Schema from "#Schema";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
 import type { TupleToUnion } from "@rcompat/type";
+import Loose from "#Loose";
 type InferUnion<T extends Schema[]> = TupleToUnion<{
     [K in keyof T]: T[K] extends Schema ? NormalizeSchema<T[K]>["infer"] : "union-never";
 }>;
-export default class UnionType<T extends Parsed<unknown>[]> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
+export default class UnionType<T extends Parsed<unknown>[], M extends Mode = undefined> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
     #private;
-    constructor(of: T);
+    [Loose]: M;
+    constructor(of: T, mode?: M);
     get name(): "union";
     get schema(): T;
     optional(): OptionalType<this>;
     default(value: (() => InferUnion<T>) | InferUnion<T>): DefaultType<this, InferUnion<T>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "union";
         of: import("./Serialized.js").default[];

package/lib/private/UnionType.js

@@ -1,13 +1,15 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
-import isParsedType from "#is-parsed-type";
+import is_parsed from "#is-parsed";
 import OptionalType from "#OptionalType";
 import ParseError from "#ParseError";
+import resolve from "#resolve";
 import S from "#schema-errors";
 import assert from "@rcompat/assert";
+import Loose from "#Loose";
 const print = (type) => {
-    const parsed = isParsedType(type);
+    const parsed = is_parsed(type);
     if (parsed) {
         return type.name;
     }
@@ -25,13 +27,15 @@ const print = (type) => {
     }
     return type;
 };
-const union_error = (types) => `\`${types.map(t => isParsedType(t) ? t.name : print(t)).join(" | ")}\``;
+const union_error = (types) => `\`${types.map(t => is_parsed(t) ? t.name : print(t)).join(" | ")}\``;
 export default class UnionType extends GenericType {
     #of;
-    constructor(of) {
+    [Loose];
+    constructor(of, mode) {
         assert.true(of.length > 1, S.union_at_least_two_members());
         super();
         this.#of = of;
+        this[Loose] = mode;
     }
     get name() {
         return "union";
@@ -45,7 +49,8 @@ export default class UnionType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         for (const type of this.#of) {
             try {
                 type.parse(x, options);

package/lib/private/VirtualType.js

@@ -1,8 +1,8 @@
 import GenericType from "#GenericType";
-const storable = (x) => !!x && typeof x === "object" && "datatype" in x;
+import Storable from "#Storable";
 export default class VirtualType extends GenericType {
     get datatype() {
-        if (storable(this.schema))
+        if (Storable.is(this.schema))
             return this.schema.datatype;
         throw new Error("cannot be used in a store");
     }

package/lib/private/array.d.ts

@@ -1,8 +1,10 @@
 import ArrayType from "#ArrayType";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
-/**
-* Value is an array of the given type.
-*/
-export default function array<const S extends Schema>(of: S): ArrayType<NormalizeSchema<S>>;
+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>>;
+};
+export default array;
 //# sourceMappingURL=array.d.ts.map

package/lib/private/array.js

@@ -3,7 +3,15 @@ import normalize from "#normalize";
 /**
 * Value is an array of the given type.
 */
-export default function array(of) {
+const vanilla = function array(of) {
     return new ArrayType(normalize(of));
-}
+};
+const loose = function array(of) {
+    return new ArrayType(normalize(of), true);
+};
+const strict = function array(of) {
+    return new ArrayType(normalize(of), false);
+};
+const array = { strict, loose, vanilla };
+export default array;
 //# sourceMappingURL=array.js.map

package/lib/private/blob.d.ts

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

package/lib/private/blob.js

@@ -1,3 +1,7 @@
 import BlobType from "#BlobType";
-export default new BlobType();
+const vanilla = new BlobType();
+const loose = new BlobType();
+const strict = new BlobType();
+const blob = { vanilla, loose, strict };
+export default blob;
 //# sourceMappingURL=blob.js.map

package/lib/private/boolean.d.ts

@@ -1,7 +1,8 @@
 import BooleanType from "#BooleanType";
-/**
-* Value is a boolean.
-*/
-declare const _default: BooleanType;
+declare const _default: {
+    strict: BooleanType<false>;
+    loose: BooleanType<true>;
+    vanilla: BooleanType<undefined>;
+};
 export default _default;
 //# sourceMappingURL=boolean.d.ts.map

package/lib/private/boolean.js

@@ -1,6 +1,7 @@
 import BooleanType from "#BooleanType";
-/**
-* Value is a boolean.
-*/
-export default new BooleanType();
+export default {
+    strict: new BooleanType(false),
+    loose: new BooleanType(true),
+    vanilla: new BooleanType(),
+};
 //# sourceMappingURL=boolean.js.map

package/lib/private/coerce/date.js

@@ -1,3 +1,4 @@
+import is from "@rcompat/is";
 const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 // time with optional :ss and .ms, but TZ is REQUIRED (Z or ±HH:MM)
 const ISO_DATETIME_TZ = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})$/;
@@ -44,13 +45,10 @@ export default function coerceDate(x) {
     if (x instanceof Date)
         return x;
     // numbers are treated as epochs
-    if (typeof x === "number" && Number.isFinite(x)) {
+    if (is.finite(x))
         return fromNumber(x);
-    }
-    // strings
-    if (typeof x === "string") {
+    if (is.string(x))
         return fromString(x);
-    }
     return x;
 }
 //# sourceMappingURL=date.js.map

package/lib/private/coerce/int.js

@@ -3,7 +3,7 @@ export default function coerce_int(x) {
     // normalize from string to number; other types unaffected
     const n = is.numeric(x) ? Number(x) : x;
     // if is integer, return it
-    if (typeof n === "number" && is.int(n))
+    if (is.int(n))
         return n;
     return x;
 }

package/lib/private/constructor.d.ts

@@ -1,8 +1,9 @@
 import ConstructorType from "#ConstructorType";
 import type { AbstractNewable } from "@rcompat/type";
-/**
- * Value is a constructed instance of the given class.
- */
-declare const _default: <const C extends AbstractNewable>(constructor: C) => ConstructorType<C>;
-export default _default;
+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>;
+};
+export default constructor;
 //# sourceMappingURL=constructor.d.ts.map

package/lib/private/constructor.js

@@ -2,5 +2,15 @@ import ConstructorType from "#ConstructorType";
 /**
  * Value is a constructed instance of the given class.
  */
-export default (constructor) => new ConstructorType(constructor);
+const vanilla = function constructor(c) {
+    return new ConstructorType(c);
+};
+const loose = function constructor(c) {
+    return new ConstructorType(c);
+};
+const strict = function constructor(c) {
+    return new ConstructorType(c);
+};
+const constructor = { vanilla, loose, strict };
+export default constructor;
 //# sourceMappingURL=constructor.js.map

package/lib/private/date.d.ts

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

package/lib/private/date.js

@@ -1,3 +1,7 @@
 import DateType from "#DateType";
-export default new DateType();
+const vanilla = new DateType();
+const loose = new DateType(true);
+const strict = new DateType(false);
+const date = { vanilla, loose, strict };
+export default date;
 //# sourceMappingURL=date.js.map

package/lib/private/dict.d.ts

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

package/lib/private/dict.js

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

package/lib/private/enum.d.ts

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

package/lib/private/enum.js

@@ -1,5 +1,12 @@
 import EnumType from "#EnumType";
-export default function _enum(values) {
+function vanilla(values) {
     return new EnumType(values);
 }
+function loose(values) {
+    return new EnumType(values);
+}
+function strict(values) {
+    return new EnumType(values);
+}
+export default { loose, strict, vanilla };
 //# 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", undefined>;
+    loose: NumberType<"f32", true>;
+    strict: NumberType<"f32", false>;
+};
+export default f32$;
 //# sourceMappingURL=f32.d.ts.map

package/lib/private/f32.js

@@ -1,4 +1,8 @@
 import NumberType from "#NumberType";
 import f32 from "#validator/f32";
-export default new NumberType("f32", [f32]);
+const vanilla = new NumberType("f32", undefined, [f32]);
+const strict = new NumberType("f32", false, [f32]);
+const loose = new NumberType("f32", true, [f32]);
+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", false>;
+    loose: NumberType<"f64", true>;
+    vanilla: NumberType<"f64", undefined>;
+};
+export default f64;
 //# sourceMappingURL=f64.d.ts.map

package/lib/private/f64.js

@@ -1,3 +1,7 @@
 import NumberType from "#NumberType";
-export default new NumberType("f64");
+const vanilla = new NumberType("f64");
+const loose = new NumberType("f64", true);
+const strict = new NumberType("f64", false);
+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,7 @@
 import FileType from "#FileType";
-export default new FileType();
+const vanilla = new FileType();
+const loose = new FileType();
+const strict = new FileType();
+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