pema 0.6.0 → 0.7.0

package/lib/private/index.js

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

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

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

package/lib/private/is-parsed.js

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

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