pema 0.6.1 → 0.7.0

package/lib/private/is.d.ts

@@ -1,4 +1,8 @@
 import IsType from "#IsType";
-declare const _default: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
-export default _default;
+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>;
+};
+export default is;
 //# sourceMappingURL=is.d.ts.map

package/lib/private/is.js

@@ -1,3 +1,16 @@
 import IsType from "#IsType";
-export default (predicate) => new IsType(predicate);
+import Loose from "#Loose";
+const vanilla = (predicate) => new IsType(predicate);
+const loose = (predicate) => {
+    const i = new IsType(predicate);
+    i[Loose] = true;
+    return i;
+};
+const strict = (predicate) => {
+    const i = new IsType(predicate);
+    i[Loose] = false;
+    return i;
+};
+const is = { vanilla, loose, strict };
+export default is;
 //# sourceMappingURL=is.js.map

package/lib/private/json.d.ts

@@ -1,5 +1,15 @@
 import type { ParsedJSON } from "#JSONType";
 import JSONType from "#JSONType";
-export default function json(): JSONType<undefined>;
-export default function json<S extends ParsedJSON>(inner: S): JSONType<S>;
+declare function vanilla(): JSONType<undefined>;
+declare function vanilla<S extends ParsedJSON>(inner: S): JSONType<S>;
+declare function loose(): JSONType<undefined>;
+declare function loose<S extends ParsedJSON>(inner: S): JSONType<S>;
+declare function strict(): JSONType<undefined>;
+declare function strict<S extends ParsedJSON>(inner: S): JSONType<S>;
+declare const json: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default json;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/json.js

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

package/lib/private/literal.d.ts

@@ -1,4 +1,12 @@
 import LiteralType from "#LiteralType";
-declare const _default: typeof LiteralType.new;
-export default _default;
+type Literal = string | boolean | number;
+declare function vanilla<T extends Literal>(literal: T): LiteralType<T>;
+declare function loose<T extends Literal>(literal: T): LiteralType<T>;
+declare function strict<T extends Literal>(literal: T): LiteralType<T>;
+declare const literal: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default literal;
 //# sourceMappingURL=literal.d.ts.map

package/lib/private/literal.js

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

package/lib/private/normalize.js

@@ -1,27 +1,20 @@
 import ArrayType from "#ArrayType";
 import ConstructorType from "#ConstructorType";
+import is_parsed from "#is-parsed";
 import LiteralType from "#LiteralType";
 import NullType from "#NullType";
 import ObjectType from "#ObjectType";
-import ParsedKey from "#ParsedKey";
 import TupleType from "#TupleType";
 import UndefinedType from "#UndefinedType";
 import is from "@rcompat/is";
-function isParsed(x) {
-    return !!x && typeof x === "object" && ParsedKey in x;
-}
-function isPlain(x) {
-    return !!x && typeof x === "object" &&
-        Object.getPrototypeOf(x) === Object.prototype;
-}
 export default function normalize(x) {
-    if (isParsed(x))
+    if (is_parsed(x))
         return x;
     if (x === null)
         return new NullType();
     if (x === undefined)
         return new UndefinedType();
-    if (typeof x === "string" || typeof x === "number" || typeof x === "boolean")
+    if (is.string(x) || is.number(x) || is.boolean(x))
         return new LiteralType(x);
     if (is.newable(x))
         return new ConstructorType(x);
@@ -30,7 +23,7 @@ export default function normalize(x) {
             ? new ArrayType(normalize(x[0]))
             : new TupleType(x.map(normalize));
     }
-    if (isPlain(x)) {
+    if (is.dict(x)) {
         const props = {};
         for (const [k, v] of Object.entries(x))
             props[k] = normalize(v);

package/lib/private/null.d.ts

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

package/lib/private/null.js

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

package/lib/private/object.d.ts

@@ -1,10 +1,17 @@
 import type NormalizeSchema from "#NormalizeSchema";
 import ObjectType from "#ObjectType";
 import type Schema from "#Schema";
-import type { Dict, EmptyObject } from "@rcompat/type";
-type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EmptyObject : {
+import type { Dict, EmptyDict } from "@rcompat/type";
+type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EmptyDict : {
     [K in keyof S]: NormalizeSchema<S[K]>;
 };
-export default function object<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
-export {};
+declare function vanilla<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+declare function loose<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+declare function strict<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+declare const object: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default object;
 //# sourceMappingURL=object.d.ts.map

package/lib/private/object.js

@@ -1,10 +1,31 @@
+import Loose from "#Loose";
 import normalize from "#normalize";
 import ObjectType from "#ObjectType";
-export default function object(properties) {
+function vanilla(properties) {
     const props = {};
     for (const [k, v] of Object.entries(properties)) {
         props[k] = normalize(v);
     }
     return new ObjectType(props);
 }
+function loose(properties) {
+    const props = {};
+    for (const [k, v] of Object.entries(properties)) {
+        props[k] = normalize(v);
+    }
+    const i = new ObjectType(props);
+    i[Loose] = true;
+    return i;
+}
+function strict(properties) {
+    const props = {};
+    for (const [k, v] of Object.entries(properties)) {
+        props[k] = normalize(v);
+    }
+    const i = new ObjectType(props);
+    i[Loose] = false;
+    return i;
+}
+const object = { vanilla, loose, strict };
+export default object;
 //# sourceMappingURL=object.js.map

package/lib/private/omit.d.ts

@@ -2,5 +2,13 @@ import type ObjectType from "#ObjectType";
 import OmitType from "#OmitType";
 import type Parsed from "#Parsed";
 import type { Dict } from "@rcompat/type";
-export default function omit<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+declare function vanilla<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+declare function loose<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+declare function strict<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+declare const omit: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default omit;
 //# sourceMappingURL=omit.d.ts.map

package/lib/private/omit.js

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

package/lib/private/partial.d.ts

@@ -4,6 +4,13 @@ import PartialType from "#PartialType";
 type StripReadonly<T> = {
     -readonly [K in keyof T]: T[K];
 };
-export default function partial<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
-export {};
+declare function vanilla<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
+declare function loose<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
+declare function strict<const D extends Partialable>(input: D | ObjectType<D>): PartialType<StripReadonly<D>>;
+declare const partial: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default partial;
 //# sourceMappingURL=partial.d.ts.map

package/lib/private/partial.js

@@ -1,8 +1,22 @@
-// partial.ts
+import Loose from "#Loose";
 import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
-export default function partial(input) {
+function vanilla(input) {
     const dict = input instanceof ObjectType ? input.properties : input;
     return new PartialType(dict);
 }
+function loose(input) {
+    const dict = input instanceof ObjectType ? input.properties : input;
+    const i = new PartialType(dict);
+    i[Loose] = true;
+    return i;
+}
+function strict(input) {
+    const dict = input instanceof ObjectType ? input.properties : input;
+    const i = new PartialType(dict);
+    i[Loose] = false;
+    return i;
+}
+const partial = { vanilla, loose, strict };
+export default partial;
 //# sourceMappingURL=partial.js.map

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

@@ -1,9 +1,3 @@
-import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
-export default function next(s: number | string, options?: ParseOptions): {
-    [ParsedKey]: import("@rcompat/type").JSONPointer;
-    coerce?: boolean;
-    partial?: boolean;
-    validators?: import("../Validator.js").default<unknown>[] | undefined;
-};
+export default function next(s: number | string, options?: ParseOptions): ParseOptions;
 //# sourceMappingURL=next.d.ts.map

package/lib/private/pure.d.ts

@@ -1,3 +1,11 @@
 import PureType from "#PureType";
-export default function <T>(): PureType<T, "PureType">;
+declare function vanilla<T>(): PureType<T, "PureType">;
+declare function loose<T>(): PureType<T, "PureType">;
+declare function strict<T>(): PureType<T, "PureType">;
+declare const pure: {
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
+};
+export default pure;
 //# sourceMappingURL=pure.d.ts.map

package/lib/private/pure.js

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

package/lib/private/record.d.ts

@@ -1,9 +1,10 @@
 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 _default: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
-export default _default;
+declare const record: {
+    vanilla: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
+    loose: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
+    strict: <const Key extends RecordTypeKey, const Value extends Parsed<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
+};
+export default record;
 //# sourceMappingURL=record.d.ts.map

package/lib/private/record.js

@@ -1,6 +1,19 @@
+import Loose from "#Loose";
 import RecordType from "#RecordType";
 /**
 * Value is a record of the given key and value types.
 */
-export default (k, v) => new RecordType(k, v);
+const vanilla = (k, v) => new RecordType(k, v);
+const loose = (k, v) => {
+    const i = new RecordType(k, v);
+    i[Loose] = true;
+    return i;
+};
+const strict = (k, v) => {
+    const i = new RecordType(k, v);
+    i[Loose] = false;
+    return i;
+};
+const record = { vanilla, loose, strict };
+export default record;
 //# sourceMappingURL=record.js.map

package/lib/private/resolve.d.ts

@@ -0,0 +1,2 @@
+export default function resolve(x: unknown): unknown;
+//# sourceMappingURL=resolve.d.ts.map

package/lib/private/resolve.js

@@ -0,0 +1,7 @@
+import is from "@rcompat/is";
+import symbol from "@rcompat/symbol";
+const { parse } = symbol;
+export default function resolve(x) {
+    return is.object(x) && parse in x ? x[parse]() : x;
+}
+//# sourceMappingURL=resolve.js.map

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

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

package/lib/private/spec/bigint.js

@@ -1,35 +1,36 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 1.1, -1.1, 0, 1]);
+        assert(strict).invalid_type(["1", 1.1, -1.1, 0, 1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(0n)).equals(0n).type();
-        assert(t.parse(1n)).equals(1n).type();
+        assert(strict).type();
+        assert(strict.parse(0n)).equals(0n).type();
+        assert(strict.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        assert(t.parse(min)).equals(min).type();
-        assert(t.parse(max)).equals(max).type();
-        assert(t).out_of_range([min - 1n, max + 1n]);
-    });
-    test.case("coerced", assert => {
-        assert(t.coerce(0n)).equals(0n).type();
-        assert(t.coerce(1n)).equals(1n).type();
-        assert(t.coerce(0)).equals(0n).type();
-        assert(t.coerce(1)).equals(1n).type();
-        assert(t.coerce("1")).equals(1n).type();
-        assert(t.coerce("1.0")).equals(1n).type();
-        assert(t.coerce("1.")).equals(1n).type();
-        assert(t).coerce_invalid_type(["0.1", ".1"]);
-        assert(t.coerce(-1)).equals(-1n).type();
-        assert(t.coerce("-1")).equals(-1n).type();
-        assert(t.coerce("-1.0")).equals(-1n).type();
-        assert(t.coerce("-1.")).equals(-1n).type();
-        assert(t).coerce_invalid_type(["-0.1", "-.1"]);
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([min - 1n, max + 1n]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0n)).equals(0n).type();
+        assert(loose.parse(1n)).equals(1n).type();
+        assert(loose.parse(0)).equals(0n).type();
+        assert(loose.parse(1)).equals(1n).type();
+        assert(loose.parse("1")).equals(1n).type();
+        assert(loose.parse("1.0")).equals(1n).type();
+        assert(loose.parse("1.")).equals(1n).type();
+        assert(loose).invalid_type(["0.1", ".1"]);
+        assert(loose.parse(-1)).equals(-1n).type();
+        assert(loose.parse("-1")).equals(-1n).type();
+        assert(loose.parse("-1.0")).equals(-1n).type();
+        assert(loose.parse("-1.")).equals(-1n).type();
+        assert(loose).invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [t.default(1n), t.default(() => 1n)].forEach(d => {
+        [strict.default(1n), strict.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
@@ -38,21 +39,21 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(-10n, 10n);
+        const r = strict.range(-10n, 10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(-10n);
+        const r = strict.min(-10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).too_small([-11n]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10n);
+        const r = strict.max(10n);
         assert(r.parse(-10n)).equals(-10n).type();
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();

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

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

package/lib/private/spec/biguint.js

@@ -1,31 +1,32 @@
 import test from "#test";
 export default (t, min, max) => {
+    const { strict, loose } = t;
     test.case("fail", assert => {
-        assert(t).invalid_type(["1", 0, 1, 1.1, -1.1]);
+        assert(strict).invalid_type(["1", 0, 1, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(t).type();
-        assert(t.parse(0n)).equals(0n).type();
-        assert(t.parse(1n)).equals(1n).type();
+        assert(strict).type();
+        assert(strict.parse(0n)).equals(0n).type();
+        assert(strict.parse(1n)).equals(1n).type();
     });
     test.case("range", assert => {
-        assert(t.parse(min)).equals(min).type();
-        assert(t.parse(max)).equals(max).type();
-        assert(t).out_of_range([-1n, min - 1n, max + 1n]);
-    });
-    test.case("coerced", assert => {
-        assert(t.coerce(0n)).equals(0n).type();
-        assert(t.coerce(1n)).equals(1n).type();
-        assert(t.coerce(0)).equals(0n).type();
-        assert(t.coerce(1)).equals(1n).type();
-        assert(t.coerce("1")).equals(1n).type();
-        assert(t.coerce("1.0")).equals(1n).type();
-        assert(t.coerce("1.")).equals(1n).type();
-        assert(t).coerce_invalid_type(["0.1", .1, "-0.1", "-.1"]);
-        assert(t).coerce_out_of_range([-1, "-1", "-1.0", "-1."]);
+        assert(strict.parse(min)).equals(min).type();
+        assert(strict.parse(max)).equals(max).type();
+        assert(strict).out_of_range([-1n, min - 1n, max + 1n]);
+    });
+    test.case("loose", assert => {
+        assert(loose.parse(0n)).equals(0n).type();
+        assert(loose.parse(1n)).equals(1n).type();
+        assert(loose.parse(0)).equals(0n).type();
+        assert(loose.parse(1)).equals(1n).type();
+        assert(loose.parse("1")).equals(1n).type();
+        assert(loose.parse("1.0")).equals(1n).type();
+        assert(loose.parse("1.")).equals(1n).type();
+        assert(loose).invalid_type(["0.1", .1, "-0.1", "-.1"]);
+        assert(loose).out_of_range([-1, "-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [t.default(1n), t.default(() => 1n)].forEach(d => {
+        [strict.default(1n), strict.default(() => 1n)].forEach(d => {
             assert(d).type();
             assert(d.parse(undefined)).equals(1n).type();
             assert(d.parse(1n)).equals(1n).type();
@@ -34,20 +35,20 @@ export default (t, min, max) => {
         });
     });
     test.case("validator - range", assert => {
-        const r = t.range(0n, 10n);
+        const r = strict.range(0n, 10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n, -11n, 11n]);
     });
     test.case("validator - min", assert => {
-        const r = t.min(10n);
+        const r = strict.min(10n);
         assert(r.parse(20n)).equals(20n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n]);
         assert(r).too_small([0n]);
     });
     test.case("validator - max", assert => {
-        const r = t.max(10n);
+        const r = strict.max(10n);
         assert(r.parse(0n)).equals(0n).type();
         assert(r.parse(10n)).equals(10n).type();
         assert(r).out_of_range([-1n]);

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

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