pema 0.4.0 → 0.5.0

package/lib/private/ArrayType.d.ts

@@ -7,7 +7,7 @@ import type ParseOptions from "#ParseOptions";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
 import type Validator from "#Validator";
-import type Primitive from "@rcompat/type/Primitive";
+import type { Primitive } from "@rcompat/type";
 type Next<T> = {
     validators?: Validator<T>[];
 };

package/lib/private/ArrayType.js

@@ -1,6 +1,7 @@
 import DefaultType from "#DefaultType";
 import error from "#error";
 import schemafail from "#error/schemafail";
+import fail from "#fail";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
@@ -16,7 +17,6 @@ import unique from "#validator/unique";
 function isPrimitive(x) {
     return x instanceof PrimitiveType;
 }
-const is = (x, validator) => validator(x);
 export default class ArrayType extends GenericType {
     #item;
     #validators;
@@ -66,38 +66,30 @@ export default class ArrayType extends GenericType {
         return this.derive({ validators: [length(from, to)] });
     }
     parse(x, options = {}) {
-        if (!is(x, _ => !!x && Array.isArray(x))) {
-            throw new ParseError(error("array", x, options));
-        }
+        if (!Array.isArray(x))
+            throw fail("array", x, options);
         const base = options[ParsedKey] ?? "";
-        let last = 0;
-        x.forEach((v, i) => {
+        const item = this.#item;
+        const len = x.length;
+        for (let i = 0; i < len; i++) {
             // sparse array check
-            if (i > last) {
+            if (!(i in x)) {
                 throw new ParseError([{
-                        ...error(this.#item.name, undefined, options)[0],
-                        path: join(base, last),
+                        ...error(item.name, undefined, options)[0],
+                        path: join(base, i),
                     }]);
             }
-            const validator = this.#item;
-            validator.parse(v, next(i, options));
-            last++;
-        });
-        // sparse array with end slots
-        if (x.length > last) {
-            throw new ParseError([{
-                    ...error(this.#item.name, undefined, options)[0],
-                    path: join(base, last),
-                }]);
+            item.parse(x[i], next(i, options));
         }
-        for (const v of this.#validators) {
+        const validators = this.#validators;
+        for (let i = 0; i < validators.length; i++) {
             try {
-                v(x);
+                validators[i](x);
             }
             catch (e) {
                 if (e instanceof ParseError) {
                     const rebased = (e.issues ?? [])
-                        .map(i => ({ ...i, path: rebase(base, i.path) }));
+                        .map(issue => ({ ...issue, path: rebase(base, issue.path) }));
                     throw new ParseError(rebased);
                 }
                 throw e;

package/lib/private/BigIntType.d.ts

@@ -2,8 +2,8 @@ import type BigIntDataType from "#BigIntDataType";
 import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
-import type Storeable from "#Storeable";
-export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BigUintType.d.ts

@@ -2,8 +2,8 @@ import type BigUintDataType from "#BigUintDataType";
 import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
-import type Storeable from "#Storeable";
-export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BlobType.d.ts

@@ -1,6 +1,6 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
-export default class BlobType extends BuiltinType<Blob, "BlobType"> implements Storeable<"blob"> {
+import Storable from "#Storable";
+export default class BlobType extends BuiltinType<Blob, "BlobType"> implements Storable<"blob"> {
     get Type(): {
         new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
         prototype: Blob;

package/lib/private/BlobType.js

@@ -1,5 +1,5 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class BlobType extends BuiltinType {
     get Type() {
         return Blob;
@@ -11,7 +11,7 @@ export default class BlobType extends BuiltinType {
         return "blob";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=BlobType.js.map

package/lib/private/BooleanType.d.ts

@@ -1,7 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storeable<"boolean"> {
+import Storable from "#Storable";
+export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
     get name(): "boolean";
     get datatype(): "boolean";
     [CoerceKey](x: unknown): unknown;

package/lib/private/BooleanType.js

@@ -1,7 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-import boolish from "@rcompat/is/boolish";
+import Storable from "#Storable";
+import is from "@rcompat/is";
 export default class BooleanType extends PrimitiveType {
     get name() {
         return "boolean";
@@ -10,10 +10,10 @@ export default class BooleanType extends PrimitiveType {
         return "boolean";
     }
     [CoerceKey](x) {
-        return boolish(x) ? x === "true" : x;
+        return is.boolish(x) ? x === "true" : x;
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=BooleanType.js.map

package/lib/private/BuiltinType.d.ts

@@ -1,7 +1,7 @@
 import type Infer from "#Infer";
 import type ParseOptions from "#ParseOptions";
 import Type from "#Type";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 export default abstract class BuiltinType<StaticType, Name extends string> extends Type<StaticType, Name> {
     #private;
     abstract get Type(): AbstractNewable;

package/lib/private/BuiltinType.js

@@ -1,6 +1,5 @@
 import CoerceKey from "#CoerceKey";
-import error from "#error";
-import ParseError from "#ParseError";
+import fail from "#fail";
 import Type from "#Type";
 export default class BuiltinType extends Type {
     #options;
@@ -18,9 +17,8 @@ export default class BuiltinType extends Type {
     parse(x, options = {}) {
         const $options = { ...this.#options, ...options };
         const $x = $options.coerce === true ? this[CoerceKey](x) : x;
-        if (!($x instanceof this.Type)) {
-            throw new ParseError(error(this.name, $x, $options));
-        }
+        if (!($x instanceof this.Type))
+            throw fail(this.name, $x, $options);
         return $x;
     }
 }

package/lib/private/ConstructorType.d.ts

@@ -3,7 +3,7 @@ import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type ParseOptions from "#ParseOptions";
 import type DefaultTrait from "#trait/Default";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements DefaultTrait<InstanceType<C>> {
     #private;
     constructor(t: C);

package/lib/private/ConstructorType.js

@@ -1,7 +1,6 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import fail from "#fail";
 import GenericType from "#GenericType";
-import ParseError from "#ParseError";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
@@ -15,9 +14,8 @@ export default class ConstructorType extends GenericType {
         return new DefaultType(this, value);
     }
     parse(x, options = {}) {
-        if (!(x instanceof this.#type)) {
-            throw new ParseError(error(this.name, x, options));
-        }
+        if (!(x instanceof this.#type))
+            throw fail(this.name, x, options);
         return x;
     }
     toJSON() {

package/lib/private/DataType.d.ts

@@ -9,7 +9,6 @@ type DataType = {
     i32: number;
     i64: bigint;
     i8: number;
-    primary: string;
     string: string;
     time: string;
     u128: bigint;

package/lib/private/DateType.d.ts

@@ -1,8 +1,8 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
-import Storeable from "#Storeable";
-export default class DateType extends BuiltinType<Date, "DateType"> implements Storeable<"datetime"> {
+import Storable from "#Storable";
+export default class DateType extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
     [CoerceKey]: typeof coerce;
     get Type(): DateConstructor;
     get name(): "date";

package/lib/private/DateType.js

@@ -1,7 +1,7 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class DateType extends BuiltinType {
     [CoerceKey] = coerce;
     get Type() {
@@ -14,7 +14,7 @@ export default class DateType extends BuiltinType {
         return "datetime";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=DateType.js.map

package/lib/private/FileType.d.ts

@@ -1,6 +1,6 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
-export default class FileType extends BuiltinType<File, "FileType"> implements Storeable<"blob"> {
+import Storable from "#Storable";
+export default class FileType extends BuiltinType<File, "FileType"> implements Storable<"blob"> {
     get Type(): {
         new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
         prototype: File;

package/lib/private/FileType.js

@@ -1,5 +1,5 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class FileType extends BuiltinType {
     get Type() {
         return File;
@@ -11,7 +11,7 @@ export default class FileType extends BuiltinType {
         return "blob";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=FileType.js.map

package/lib/private/GenericType.d.ts

@@ -1,5 +1,5 @@
 import Parsed from "#Parsed";
-import type PrintableGeneric from "@rcompat/type/PrintableGeneric";
+import type { PrintableGeneric } from "@rcompat/type";
 export default abstract class GenericType<Type, Inferred, Name extends string> extends Parsed<Inferred> implements PrintableGeneric<Type> {
     get Name(): Name;
     get Type(): Type;

package/lib/private/InferInputSchema.d.ts

@@ -1,26 +1,16 @@
-import type ArrayType from "#ArrayType";
-import type DecrementDepth from "#DecrementDepth";
 import type DefaultType from "#DefaultType";
-import type Infer from "#Infer";
-import type NullType from "#NullType";
+import type NormalizeSchema from "#NormalizeSchema";
 import type ObjectType from "#ObjectType";
 import type OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type Schema from "#Schema";
-import type TupleType from "#TupleType";
-import type UndefinedType from "#UndefinedType";
-import type ImpliedOptional from "@rcompat/type/ImpliedOptional";
-import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
-type InferInputSchema<S, Depth extends number = 3> = [
-    Depth
-] extends [never] ? never : S extends DefaultType<infer T, unknown> ? Infer<T> | undefined : S extends OptionalType<infer T> ? Infer<T> | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
-    [K in keyof P]: InferInputSchema<P[K], DecrementDepth[Depth]>;
-}>> : S extends Parsed<unknown> ? Infer<S> : S extends null ? Infer<NullType> : S extends undefined ? Infer<UndefinedType> : S extends [infer Only] ? Only extends Parsed<unknown> ? Infer<ArrayType<Only>> : never : S extends Schema[] ? InferInputSchema<TupleType<{
-    [K in keyof S]: S[K] extends Parsed<unknown> ? InferInputSchema<S[K], DecrementDepth[Depth]> : never;
-}>> : S extends {
+import type { ImpliedOptional, UndefinedToOptional } from "@rcompat/type";
+type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? T["infer"] | undefined : S extends OptionalType<infer T> ? T["infer"] | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
+    [K in keyof P]: InferInputSchema<P[K]>;
+}>> : S extends Parsed<unknown> ? S["infer"] : S extends {
     [key: string]: Schema;
 } ? ImpliedOptional<UndefinedToOptional<{
-    [K in keyof S]: InferInputSchema<S[K], DecrementDepth[Depth]>;
-}>> : never;
+    [K in keyof S]: InferInputSchema<S[K]>;
+}>> : NormalizeSchema<S>["infer"];
 export type { InferInputSchema as default };
 //# sourceMappingURL=InferInputSchema.d.ts.map

package/lib/private/InferStore.d.ts

@@ -1,6 +1,6 @@
 import type Parsed from "#Parsed";
 import type StoreSchema from "#StoreSchema";
-import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
+import type { UndefinedToOptional } from "@rcompat/type";
 type StoreValue<T> = T extends Parsed<infer U> ? U : never;
 type InferStore<T extends StoreSchema> = UndefinedToOptional<{
     [K in keyof T]: StoreValue<T[K]>;

package/lib/private/IntType.d.ts

@@ -3,8 +3,8 @@ import CoerceKey from "#CoerceKey";
 import type IntDataType from "#IntDataType";
 import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
-import type Storeable from "#Storeable";
-export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;

package/lib/private/Issue.d.ts

@@ -1,4 +1,4 @@
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 export default interface Issue {
     readonly message: string;
     readonly path: JSONPointer;

package/lib/private/LiteralType.d.ts

@@ -2,8 +2,7 @@ import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type ParseOptions from "#ParseOptions";
 type Literal = string | boolean | number;
-type InferLiteral<T extends Literal> = T;
-export default class LiteralType<T extends Literal> extends GenericType<T, InferLiteral<T>, "LiteralType"> {
+export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
     #private;
     constructor(literal: T);
     static new<T extends Literal>(literal: T): LiteralType<T>;

package/lib/private/LiteralType.js

@@ -1,6 +1,5 @@
-import error from "#error";
+import fail from "#fail";
 import GenericType from "#GenericType";
-import ParseError from "#ParseError";
 export default class LiteralType extends GenericType {
     #literal;
     constructor(literal) {
@@ -17,9 +16,8 @@ export default class LiteralType extends GenericType {
         return JSON.stringify(this.#literal);
     }
     parse(x, options = {}) {
-        if (x !== this.#literal) {
-            throw new ParseError(error(this.name, x, options));
-        }
+        if (x !== this.#literal)
+            throw fail(this.name, x, options);
         return x;
     }
     toJSON() {

package/lib/private/NormalizeSchema.d.ts

@@ -7,15 +7,13 @@ import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
-import type EO from "@rcompat/type/EO";
-type IsEmptyObject<T> = keyof T extends never ? true : false;
+import type { AbstractNewable } from "@rcompat/type";
 type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-type NormalizeSchemaObject<T extends Record<string, unknown>> = IsEmptyObject<T> extends true ? EO : {
-    -readonly [K in keyof T]: T[K] extends Parsed<unknown> ? T[K] : NormalizeSchema<T[K]>;
+type NormalizeSchemaObject<T extends Record<string, unknown>> = {
+    -readonly [K in keyof T]: NormalizeSchema<T[K]>;
 };
-type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string ? LiteralType<S> : S extends number ? LiteralType<S> : S extends boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [infer O] ? O extends Schema ? ArrayType<NormalizeSchema<O>> : never : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
+type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
 export type { NormalizeSchema as default };
 //# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NullType.js

@@ -1,14 +1,12 @@
-import error from "#error";
-import ParseError from "#ParseError";
+import fail from "#fail";
 import PrimitiveType from "#PrimitiveType";
 export default class NullType extends PrimitiveType {
     get name() {
         return "null";
     }
     parse(x, options = {}) {
-        if (x !== null) {
-            throw new ParseError(error(this.name, x, options));
-        }
+        if (x !== null)
+            throw fail(this.name, x, options);
         return x;
     }
     toJSON() {

package/lib/private/NumericType.d.ts

@@ -1,13 +1,13 @@
 import type DataKey from "#DataKey";
 import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
-import type Storeable from "#Storeable";
+import type Storable from "#Storable";
 import type Validator from "#Validator";
 type Next<T> = {
     options?: ParseOptions;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storeable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
     constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
     derive(next: Next<T>): this;

package/lib/private/ObjectType.d.ts

@@ -4,7 +4,7 @@ import type InferInputSchema from "#InferInputSchema";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default class ObjectType<P extends Dict<Parsed<unknown>>> extends GenericType<P, {
     [K in keyof P]: P[K]["infer"];
 }, "ObjectType"> {

package/lib/private/ObjectType.js

@@ -1,5 +1,7 @@
+import fail from "#fail";
 import GenericType from "#GenericType";
 import next from "#path/next";
+import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
     #properties;
     #options;
@@ -20,25 +22,23 @@ export default class ObjectType extends GenericType {
     get input() {
         return undefined;
     }
-    #derive(next) {
+    #derive(options) {
         const Constructor = this.constructor;
-        return new Constructor(this.#properties, { ...this.#options, ...next });
+        return new Constructor(this.#properties, { ...this.#options, ...options });
     }
     get coerce() {
         return this.#derive({ coerce: true });
     }
     parse(x, options = {}) {
         const $options = { ...this.#options, ...options };
-        let _x = x;
-        if (typeof x !== "object" || x === null) {
-            _x = {};
-        }
+        if (x !== undefined && !is.dict(x))
+            throw fail("object", x, $options);
+        const input = x ?? {};
         const out = {};
         for (const k in this.#properties) {
-            const parsed = this.#properties[k].parse(_x[k], next(k, $options));
-            if (parsed !== undefined) {
+            const parsed = this.#properties[k].parse(input[k], next(k, $options));
+            if (parsed !== undefined)
                 out[k] = parsed;
-            }
         }
         return out;
     }

package/lib/private/OmitType.d.ts

@@ -4,7 +4,7 @@ import type ObjectType from "#ObjectType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P> extends GenericType<Omit<P, K>, Omit<{
     [Key in keyof P]: Infer<P[Key]>;
 }, K>, "OmitType"> {

package/lib/private/OmitType.js

@@ -1,3 +1,4 @@
+import fail from "#fail";
 import GenericType from "#GenericType";
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
@@ -15,10 +16,9 @@ export default class OmitType extends GenericType {
         return "omit";
     }
     parse(x, options = {}) {
-        if (typeof x !== "object" || x === null) {
-            throw new Error("Expected object");
-        }
-        const result = {};
+        if (typeof x !== "object" || x === null)
+            throw fail("object", x, options);
+        const out = {};
         const props = this.#properties;
         for (const k in props) {
             const field = props[k];
@@ -26,10 +26,10 @@ export default class OmitType extends GenericType {
                 ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
             });
             if (r !== undefined) {
-                result[k] = r;
+                out[k] = r;
             }
         }
-        return result;
+        return out;
     }
     toJSON() {
         const properties = {};

package/lib/private/ParseError.d.ts

@@ -1,6 +1,6 @@
 import type JSONPayload from "#json/JSONPayload";
 import type ParseIssue from "#ParseIssue";
-import type Serializable from "@rcompat/type/Serializable";
+import type { Serializable } from "@rcompat/type";
 export default class ParseError extends Error implements Serializable {
     #private;
     constructor(issues: ParseIssue[]);

package/lib/private/ParseError.js

@@ -30,8 +30,8 @@ export default class ParseError extends Error {
         if (issues.length === 0) {
             return { message: "Parsing failed", messages: ["Parsing failed"] };
         }
-        const isForm = issues.some(i => i.path !== "");
-        if (!isForm) {
+        const is_form = issues.some(i => i.path !== "");
+        if (!is_form) {
             const messages = issues.map(i => i.message);
             return { message: messages[0], messages };
         }

package/lib/private/ParseOptions.d.ts

@@ -1,6 +1,6 @@
 import type ParsedKey from "#ParsedKey";
 import type Validator from "#Validator";
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 export default interface ParseOptions<T = unknown> {
     coerce?: boolean;
     [ParsedKey]?: JSONPointer;

package/lib/private/Parsed.d.ts

@@ -2,7 +2,7 @@ import CoerceKey from "#CoerceKey";
 import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type Serializable from "@rcompat/type/Serializable";
+import type { Serializable } from "@rcompat/type";
 export default abstract class Parsed<StaticType> implements Serializable {
     get [ParsedKey](): "ParsedKey";
     get infer(): StaticType;