pema 0.13.0 → 0.14.1

package/lib/private/BigUintType.d.ts

@@ -3,11 +3,8 @@ import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 import type Storable from "#Storable";
-export default class BigUintType<T extends BigUintDataType = "u64", L extends boolean | undefined = undefined, G extends boolean = false> extends NumericType<T, bigint, "BigUintType", L, G> implements Storable<T> {
+export default class BigUintType<T extends BigUintDataType = "u64", L extends boolean | undefined = undefined> extends NumericType<T, bigint, "BigUintType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
-    sequence(): BigUintType<T, L, true>;
-    default<S extends bigint>(value: (() => S) | S): import("./DefaultType.js").default<this, S>;
-    optional(): import("./OptionalType.js").default<this>;
     get name(): string;
 }
 //# sourceMappingURL=BigUintType.d.ts.map

package/lib/private/BigUintType.js

@@ -3,21 +3,6 @@ import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 export default class BigUintType extends NumericType {
     [CoerceKey] = coerce;
-    sequence() {
-        return this.with({ sequence: true });
-    }
-    default(value) {
-        if (this.generated === "sequence") {
-            throw new TypeError("a sequence cannot also have a default value");
-        }
-        return super.default(value);
-    }
-    optional() {
-        if (this.generated === "sequence") {
-            throw new TypeError("a sequence cannot be optional in stored output");
-        }
-        return super.optional();
-    }
     get name() {
         return "bigint";
     }

package/lib/private/NumericType.d.ts

@@ -8,24 +8,21 @@ import type Validator from "#Validator";
 import type { Dict } from "@rcompat/type";
 type Next<T> = {
     options?: ParseOptions;
-    sequence?: boolean;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined, G extends boolean = false> extends PrimitiveType<T, Name> implements Storable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
     [Loose]: M;
-    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions, sequence?: G);
+    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
     with(next: Next<T>): this;
     values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;
     max(to: T): this;
     get datatype(): Key;
-    get generated(): G extends true ? "sequence" : undefined;
     toJSON(): {
         type: "number" | "bigint";
         datatype: Key;
-        sequence?: true | undefined;
     };
 }
 export {};

package/lib/private/NumericType.js

@@ -6,17 +6,15 @@ import range from "#validator/range";
 import values from "#validator/values";
 export default class NumericType extends PrimitiveType {
     #datatype;
-    #sequence;
     [Loose];
-    constructor(datatype, mode = undefined, validators = [], options = {}, sequence = false) {
+    constructor(datatype, mode = undefined, validators = [], options = {}) {
         super(validators, options);
         this.#datatype = datatype;
-        this.#sequence = sequence;
         this[Loose] = mode;
     }
     with(next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} }, (next.sequence ?? this.#sequence));
+        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
     }
     values(anyof) {
         return this.with({ validators: [values(anyof)] });
@@ -33,14 +31,10 @@ export default class NumericType extends PrimitiveType {
     get datatype() {
         return this.#datatype;
     }
-    get generated() {
-        return (this.#sequence ? "sequence" : undefined);
-    }
     toJSON() {
         return {
             type: this.name,
             datatype: this.#datatype,
-            ...this.#sequence ? { sequence: true } : {},
         };
     }
 }

package/lib/private/RecordType.d.ts

@@ -22,7 +22,6 @@ export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<
         } | {
             type: "number" | "bigint";
             datatype: "f64";
-            sequence?: true | undefined;
         } | {
             type: "symbol";
         };

package/lib/private/Serialized.d.ts

@@ -31,11 +31,9 @@ type PrimitiveSerialized = ({
 };
 type NumberSerialized = {
     type: "number";
-    sequence?: true;
 } & DT;
 type BigIntSerialized = {
     type: "bigint";
-    sequence?: true;
 } & DT;
 type StructuralSerialized = {
     type: "newable";

package/lib/private/StoreType.d.ts

@@ -5,7 +5,7 @@ import PartialType from "#PartialType";
 import type StoreSchema from "#StoreSchema";
 export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
     #private;
-    constructor(properties: S, pk?: string | null, sequences?: readonly string[]);
+    constructor(properties: S, pk?: string | null);
     get name(): string;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
     partial(): PartialType<any, undefined>;

package/lib/private/StoreType.js

@@ -6,11 +6,9 @@ import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class StoreType extends ObjectType {
     #pk;
-    #sequences;
-    constructor(properties, pk = null, sequences = []) {
+    constructor(properties, pk = null) {
         super(properties);
         this.#pk = pk;
-        this.#sequences = new Set(sequences);
     }
     get name() {
         return "store";
@@ -23,7 +21,7 @@ export default class StoreType extends ObjectType {
         const input = x ?? {};
         const out = {};
         for (const k in this.properties) {
-            const generated = k === this.#pk || this.#sequences.has(k);
+            const generated = k === this.#pk;
             if (generated && !(k in input))
                 continue;
             const parsed = this.properties[k].parse(input[k], next(k, $options));

package/lib/private/UintType.d.ts

@@ -4,11 +4,8 @@ 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, L extends boolean | undefined = undefined, G extends boolean = false> extends NumericType<T, number, "UintType", L, G> 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;
-    sequence(): UintType<T, L, true>;
-    default<S extends number>(value: (() => S) | S): import("./DefaultType.js").default<this, S>;
-    optional(): import("./OptionalType.js").default<this>;
     get name(): string;
     /**
     * Value is a non-privileged port number (1000 - 65535).

package/lib/private/UintType.js

@@ -5,21 +5,6 @@ import integer from "#validator/integer";
 import port from "#validator/port";
 export default class UintType extends NumericType {
     [CoerceKey] = coerce;
-    sequence() {
-        return this.with({ sequence: true });
-    }
-    default(value) {
-        if (this.generated === "sequence") {
-            throw new TypeError("a sequence cannot also have a default value");
-        }
-        return super.default(value);
-    }
-    optional() {
-        if (this.generated === "sequence") {
-            throw new TypeError("a sequence cannot be optional in stored output");
-        }
-        return super.optional();
-    }
     get name() {
         return "number";
     }

package/lib/private/index.d.ts

@@ -27,7 +27,6 @@ export type { default as PartialType } from "#PartialType";
 export type { default as PureType } from "#PureType";
 export type { default as RecordType } from "#RecordType";
 export type { default as Schema } from "#Schema";
-export type { default as Sequence } from "#Sequence";
 export type { default as Serialized } from "#Serialized";
 export type { default as Storable } from "#Storable";
 export type { default as StoreId } from "#StoreId";
@@ -56,7 +55,7 @@ declare namespace schema {
     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, false>;
+    export var _c: import("./BigUintType.js").default<"u64", undefined>;
     export { _c as biguint };
     export var _d: import("#BlobType").default;
     export { _d as blob };
@@ -122,17 +121,17 @@ declare namespace schema {
     export { _6 as symbol };
     export var _7: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
     export { _7 as tuple };
-    export var _8: import("./BigUintType.js").default<"u128", undefined, false>;
+    export var _8: import("./BigUintType.js").default<"u128", undefined>;
     export { _8 as u128 };
-    export var _9: import("#UintType").default<"u16", undefined, false>;
+    export var _9: import("#UintType").default<"u16", undefined>;
     export { _9 as u16 };
-    export var _10: import("#UintType").default<"u32", undefined, false>;
+    export var _10: import("#UintType").default<"u32", undefined>;
     export { _10 as u32 };
-    export var _11: import("./BigUintType.js").default<"u64", undefined, false>;
+    export var _11: import("./BigUintType.js").default<"u64", undefined>;
     export { _11 as u64 };
-    export var _12: import("#UintType").default<"u8", undefined, false>;
+    export var _12: import("#UintType").default<"u8", undefined>;
     export { _12 as u8 };
-    export var _13: import("#UintType").default<"u32", undefined, false>;
+    export var _13: import("#UintType").default<"u32", undefined>;
     export { _13 as uint };
     export var _14: import("#UndefinedType").default;
     export { _14 as undefined };
@@ -155,7 +154,7 @@ declare namespace schema {
 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, false>;
+    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>;
@@ -191,12 +190,12 @@ declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     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, false>;
-    u16: import("#UintType").default<"u16", true, false>;
-    u32: import("#UintType").default<"u32", true, false>;
-    u64: import("./BigUintType.js").default<"u64", true, false>;
-    u8: import("#UintType").default<"u8", true, false>;
-    uint: import("#UintType").default<"u32", true, false>;
+    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>;
@@ -209,7 +208,7 @@ declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
 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, 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>;
@@ -245,12 +244,12 @@ declare const strict: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     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, false>;
-    u16: import("#UintType").default<"u16", false, false>;
-    u32: import("#UintType").default<"u32", false, false>;
-    u64: import("./BigUintType.js").default<"u64", false, false>;
-    u8: import("#UintType").default<"u8", false, false>;
-    uint: import("#UintType").default<"u32", false, 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>;

package/lib/private/schema-errors.d.ts

@@ -15,6 +15,38 @@ declare const errors: {
     enum_invalid_key: (key: string) => import("@rcompat/error").CodeError<"enum_invalid_key">;
 };
 export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
-export default errors;
+declare const schema_errors: {
+    unique_subtype_not_primitive: (subtype: string) => import("@rcompat/error").CodeError<"unique_subtype_not_primitive">;
+    min_negative: (limit: number) => import("@rcompat/error").CodeError<"min_negative">;
+    max_negative: (limit: number) => import("@rcompat/error").CodeError<"max_negative">;
+    length_not_finite: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_finite">;
+    length_not_positive: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_positive">;
+    length_not_integer: (from: number, to: number) => import("@rcompat/error").CodeError<"length_not_integer">;
+    length_from_exceeds_to: (from: number, to: number) => import("@rcompat/error").CodeError<"length_from_exceeds_to">;
+    min_limit_not_finite: (limit: number) => import("@rcompat/error").CodeError<"min_limit_not_finite">;
+    min_limit_not_integer: (limit: number) => import("@rcompat/error").CodeError<"min_limit_not_integer">;
+    max_limit_not_finite: (limit: number) => import("@rcompat/error").CodeError<"max_limit_not_finite">;
+    max_limit_not_integer: (limit: number) => import("@rcompat/error").CodeError<"max_limit_not_integer">;
+    extend_key_collision: (key: string) => import("@rcompat/error").CodeError<"extend_key_collision">;
+    union_at_least_two_members: () => import("@rcompat/error").CodeError<"union_at_least_two_members">;
+    enum_invalid_key: (key: string) => import("@rcompat/error").CodeError<"enum_invalid_key">;
+} & {
+    Code: {
+        enum_invalid_key: "enum_invalid_key";
+        extend_key_collision: "extend_key_collision";
+        length_from_exceeds_to: "length_from_exceeds_to";
+        length_not_finite: "length_not_finite";
+        length_not_integer: "length_not_integer";
+        length_not_positive: "length_not_positive";
+        max_limit_not_finite: "max_limit_not_finite";
+        max_limit_not_integer: "max_limit_not_integer";
+        max_negative: "max_negative";
+        min_limit_not_finite: "min_limit_not_finite";
+        min_limit_not_integer: "min_limit_not_integer";
+        min_negative: "min_negative";
+        union_at_least_two_members: "union_at_least_two_members";
+        unique_subtype_not_primitive: "unique_subtype_not_primitive";
+    };
+};
+export default schema_errors;
 //# sourceMappingURL=schema-errors.d.ts.map

package/lib/private/schema-errors.js

@@ -16,6 +16,7 @@ const errors = error.coded({
     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;
+const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+const schema_errors = Object.assign(errors, { Code });
+export default schema_errors;
 //# sourceMappingURL=schema-errors.js.map

package/lib/private/u128.d.ts

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

package/lib/private/u16.d.ts

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

package/lib/private/u32.d.ts

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

package/lib/private/u64.d.ts

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

package/lib/private/u8.d.ts

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

package/lib/private/validator/email.js

@@ -1,5 +1,7 @@
 import regex from "#validator/regex";
-const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+// Choose the first dot after the domain's first character. Keeping dots out
+// of the preceding repetition avoids quadratic backtracking on hostile input.
+const re = /^[^\s@]+@[^\s@][^\s@.]*\.[^\s@]+$/u;
 export default function email(options) {
     return regex(re, options ?? (x => `"${x}" is not a valid email`));
 }

package/lib/public/ParseError.d.ts

@@ -1,2 +1,3 @@
-export { default } from "#ParseError";
+import ParseError from "#ParseError";
+export default ParseError;
 //# sourceMappingURL=ParseError.d.ts.map

package/lib/public/ParseError.js

@@ -1,2 +1,3 @@
-export { default } from "#ParseError";
+import ParseError from "#ParseError";
+export default ParseError;
 //# sourceMappingURL=ParseError.js.map

package/lib/public/StoreType.d.ts

@@ -1,3 +1,4 @@
 export type { default as Serialized } from "#Serialized";
-export { default } from "#StoreType";
+import StoreType from "#StoreType";
+export default StoreType;
 //# sourceMappingURL=StoreType.d.ts.map

package/lib/public/StoreType.js

@@ -1,2 +1,3 @@
-export { default } from "#StoreType";
+import StoreType from "#StoreType";
+export default StoreType;
 //# sourceMappingURL=StoreType.js.map

package/lib/public/index.d.ts

@@ -1,3 +1,4 @@
 export type * from "#index";
-export { default } from "#index";
+import pema from "#index";
+export default pema;
 //# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -1,2 +1,3 @@
-export { default } from "#index";
+import pema from "#index";
+export default pema;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -48,5 +48,5 @@
     "test": "proby"
   },
   "type": "module",
-  "version": "0.13.0"
+  "version": "0.14.1"
 }

package/lib/private/Sequence.d.ts

@@ -1,5 +0,0 @@
-type Sequence = {
-    readonly generated: "sequence";
-};
-export type { Sequence as default };
-//# sourceMappingURL=Sequence.d.ts.map

package/lib/private/Sequence.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Sequence.js.map