pema 0.1.0 → 0.2.1

package/lib/private/optional.d.ts

@@ -1,5 +1,5 @@
 import OptionalType from "#OptionalType";
-import type Validated from "#Validated";
-declare const _default: <const T extends Validated<unknown>>(type: T) => OptionalType<T>;
+import type Parsed from "#Parsed";
+declare const _default: <const T extends Parsed<unknown>>(type: T) => OptionalType<T>;
 export default _default;
 //# sourceMappingURL=optional.d.ts.map

package/lib/private/partial.d.ts

@@ -0,0 +1,9 @@
+import ObjectType from "#ObjectType";
+import type Partialable from "#Partialable";
+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 {};
+//# sourceMappingURL=partial.d.ts.map

package/lib/private/partial.js

@@ -0,0 +1,8 @@
+// partial.ts
+import ObjectType from "#ObjectType";
+import PartialType from "#PartialType";
+export default function partial(input) {
+    const dict = input instanceof ObjectType ? input.properties : input;
+    return new PartialType(dict);
+}
+//# sourceMappingURL=partial.js.map

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

@@ -0,0 +1,3 @@
+import type JSONPointer from "@rcompat/type/JSONPointer";
+export default function join(base: JSONPointer, ...tokens: (number | string)[]): JSONPointer;
+//# sourceMappingURL=join.d.ts.map

package/lib/private/path/join.js

@@ -0,0 +1,13 @@
+// RFC 6901 escaping
+function escapeToken(token) {
+    return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+export default function join(base, ...tokens) {
+    if (tokens.length === 0)
+        return base;
+    const tail = tokens.map(t => escapeToken(String(t))).join("/");
+    if (base === "")
+        return ("/" + tail);
+    return (base + "/" + tail);
+}
+//# sourceMappingURL=join.js.map

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

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

package/lib/private/path/next.js

@@ -0,0 +1,9 @@
+import ParsedKey from "#ParsedKey";
+import join from "#path/join";
+export default function next(s, options) {
+    const base = options?.[ParsedKey] ?? "";
+    return options === undefined
+        ? { [ParsedKey]: join("", String(s)) }
+        : { ...options, [ParsedKey]: join(base, String(s)) };
+}
+//# sourceMappingURL=next.js.map

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

@@ -0,0 +1,3 @@
+import type JSONPointer from "@rcompat/type/JSONPointer";
+export default function rebase(base: JSONPointer, rel: JSONPointer): JSONPointer;
+//# sourceMappingURL=rebase.d.ts.map

package/lib/private/path/rebase.js

@@ -0,0 +1,9 @@
+// Rebase a relative pointer under a base (rel must be "" or start with "/")
+export default function rebase(base, rel) {
+    if (base === "")
+        return rel;
+    if (rel === "")
+        return base;
+    return (base + rel);
+}
+//# sourceMappingURL=rebase.js.map

package/lib/private/primary.d.ts

@@ -0,0 +1,4 @@
+import PrimaryType from "#PrimaryType";
+declare const _default: PrimaryType;
+export default _default;
+//# sourceMappingURL=primary.d.ts.map

package/lib/private/primary.js

@@ -0,0 +1,3 @@
+import PrimaryType from "#PrimaryType";
+export default new PrimaryType();
+//# sourceMappingURL=primary.js.map

package/lib/private/pure.d.ts

@@ -0,0 +1,3 @@
+import PureType from "#PureType";
+export default function <T>(): PureType<T, "PureType">;
+//# sourceMappingURL=pure.d.ts.map

package/lib/private/pure.js

@@ -0,0 +1,5 @@
+import PureType from "#PureType";
+export default function () {
+    return new PureType();
+}
+//# sourceMappingURL=pure.js.map

package/lib/private/record.d.ts

@@ -1,6 +1,9 @@
+import type Parsed from "#Parsed";
 import RecordType from "#RecordType";
 import type RecordTypeKey from "#RecordTypeKey";
-import type Validated from "#Validated";
-declare const _default: <const Key extends RecordTypeKey, const Value extends Validated<unknown>>(k: Key, v: Value) => RecordType<Key, Value>;
+/**
+* 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;
 //# sourceMappingURL=record.d.ts.map

package/lib/private/record.js

@@ -1,3 +1,6 @@
 import RecordType from "#RecordType";
+/**
+* Value is a record of the given key and value types.
+*/
 export default (k, v) => new RecordType(k, v);
 //# sourceMappingURL=record.js.map

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

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

package/lib/private/spec/bigint.js

@@ -0,0 +1,73 @@
+import expect from "#expect";
+import test from "@rcompat/test";
+export default (i, min, max) => {
+    test.case("fail", assert => {
+        assert(() => i.parse("1")).throws(expect("bi", "1"));
+        assert(() => i.parse(1.1)).throws(expect("bi", 1.1));
+        assert(() => i.parse(-1.1)).throws(expect("bi", -1.1));
+        assert(() => i.parse(0)).throws(expect("bi", 0));
+        assert(() => i.parse(1)).throws(expect("bi", 1));
+    });
+    test.case("pass", assert => {
+        assert(i).type();
+        assert(i.parse(0n)).equals(0n).type();
+        assert(i.parse(1n)).equals(1n).type();
+    });
+    test.case("range", assert => {
+        assert(i.parse(min)).equals(min).type();
+        assert(i.parse(max)).equals(max).type();
+        assert(() => i.parse(min - 1n)).throws(`${min - 1n} is out of range`);
+        assert(() => i.parse(max + 1n)).throws(`${max + 1n} is out of range`);
+    });
+    test.case("coerced", assert => {
+        const coerced = i.coerce;
+        assert(coerced.parse(0n)).equals(0n).type();
+        assert(coerced.parse(1n)).equals(1n).type();
+        assert(coerced.parse(0)).equals(0n).type();
+        assert(coerced.parse(1)).equals(1n).type();
+        assert(coerced.parse("1")).equals(1n).type();
+        assert(coerced.parse("1.0")).equals(1n).type();
+        assert(coerced.parse("1.")).equals(1n).type();
+        assert(() => coerced.parse("0.1")).throws(expect("bi", "0.1"));
+        assert(() => coerced.parse(".1")).throws(expect("bi", ".1"));
+        assert(coerced.parse(-1)).equals(-1n).type();
+        assert(coerced.parse("-1")).equals(-1n).type();
+        assert(coerced.parse("-1.0")).equals(-1n).type();
+        assert(coerced.parse("-1.")).equals(-1n).type();
+        assert(() => coerced.parse("-0.1")).throws(expect("bi", "-0.1"));
+        assert(() => coerced.parse("-.1")).throws(expect("bi", "-.1"));
+    });
+    test.case("default", assert => {
+        [i.default(1n), i.default(() => 1n)].forEach(d => {
+            assert(d).type();
+            assert(d.parse(undefined)).equals(1n).type();
+            assert(d.parse(1n)).equals(1n).type();
+            assert(d.parse(0n)).equals(0n).type();
+            assert(() => d.parse(1.2)).throws(expect("bi", 1.2));
+            assert(() => d.parse(-1.2)).throws(expect("bi", -1.2));
+        });
+    });
+    test.case("validator - range", assert => {
+        const r = i.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.parse(-11n)).throws("-11 is out of range");
+        assert(() => r.parse(11n)).throws("11 is out of range");
+    });
+    test.case("validator - min", assert => {
+        const r = i.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.parse(-11n)).throws("-11 is lower than min (-10)");
+    });
+    test.case("validator - max", assert => {
+        const r = i.max(10n);
+        assert(r.parse(-10n)).equals(-10n).type();
+        assert(r.parse(0n)).equals(0n).type();
+        assert(r.parse(10n)).equals(10n).type();
+        assert(() => r.parse(11n)).throws("11 is greater than max (10)");
+    });
+};
+//# sourceMappingURL=bigint.js.map

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

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

package/lib/private/spec/biguint.js

@@ -0,0 +1,73 @@
+import expect from "#expect";
+import test from "@rcompat/test";
+export default (i, min, max) => {
+    test.case("fail", assert => {
+        assert(() => i.parse("1")).throws(expect("bi", "1"));
+        assert(() => i.parse(1.1)).throws(expect("bi", 1.1));
+        assert(() => i.parse(-1.1)).throws(expect("bi", -1.1));
+        assert(() => i.parse(-1n)).throws("-1 is out of range");
+        assert(() => i.parse(0)).throws(expect("bi", 0));
+        assert(() => i.parse(1)).throws(expect("bi", 1));
+    });
+    test.case("pass", assert => {
+        assert(i).type();
+        assert(i.parse(0n)).equals(0n).type();
+        assert(i.parse(1n)).equals(1n).type();
+    });
+    test.case("range", assert => {
+        assert(i.parse(min)).equals(min).type();
+        assert(i.parse(max)).equals(max).type();
+        assert(() => i.parse(min - 1n)).throws(`${min - 1n} is out of range`);
+        assert(() => i.parse(max + 1n)).throws(`${max + 1n} is out of range`);
+    });
+    test.case("coerced", assert => {
+        const coerced = i.coerce;
+        assert(coerced.parse(0n)).equals(0n).type();
+        assert(coerced.parse(1n)).equals(1n).type();
+        assert(coerced.parse(0)).equals(0n).type();
+        assert(coerced.parse(1)).equals(1n).type();
+        assert(coerced.parse("1")).equals(1n).type();
+        assert(coerced.parse("1.0")).equals(1n).type();
+        assert(coerced.parse("1.")).equals(1n).type();
+        assert(() => coerced.parse("0.1")).throws(expect("bi", "0.1"));
+        assert(() => coerced.parse(".1")).throws(expect("bi", ".1"));
+        assert(() => coerced.parse(-1)).throws("-1 is out of range");
+        assert(() => coerced.parse("-1")).throws("-1 is out of range");
+        assert(() => coerced.parse("-1.0")).throws("-1 is out of range");
+        assert(() => coerced.parse("-1.")).throws("-1 is out of range");
+        assert(() => coerced.parse("-0.1")).throws(expect("bi", "-0.1"));
+        assert(() => coerced.parse("-.1")).throws(expect("bi", "-.1"));
+    });
+    test.case("default", assert => {
+        [i.default(1n), i.default(() => 1n)].forEach(d => {
+            assert(d).type();
+            assert(d.parse(undefined)).equals(1n).type();
+            assert(d.parse(1n)).equals(1n).type();
+            assert(d.parse(0n)).equals(0n).type();
+            assert(() => d.parse(1.2)).throws(expect("bi", 1.2));
+            assert(() => d.parse(-1.2)).throws(expect("bi", -1.2));
+        });
+    });
+    test.case("validator - range", assert => {
+        const r = i.range(0n, 10n);
+        assert(r.parse(0n)).equals(0n).type();
+        assert(r.parse(10n)).equals(10n).type();
+        assert(() => r.parse(-1n)).throws("-1 is out of range");
+        assert(() => r.parse(-11n)).throws("-11 is out of range");
+        assert(() => r.parse(11n)).throws("11 is out of range");
+    });
+    test.case("validator - min", assert => {
+        const r = i.min(0n);
+        assert(r.parse(0n)).equals(0n).type();
+        assert(r.parse(10n)).equals(10n).type();
+        assert(() => r.parse(-1n)).throws("-1 is out of range");
+    });
+    test.case("validator - max", assert => {
+        const r = i.max(10n);
+        assert(r.parse(0n)).equals(0n).type();
+        assert(r.parse(10n)).equals(10n).type();
+        assert(() => r.parse(-1n)).throws("-1 is out of range");
+        assert(() => r.parse(11n)).throws("11 is greater than max (10)");
+    });
+};
+//# sourceMappingURL=biguint.js.map

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

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

package/lib/private/spec/int.js

@@ -0,0 +1,70 @@
+import expect from "#expect";
+import test from "@rcompat/test";
+export default (i, min, max) => {
+    test.case("fail", assert => {
+        assert(() => i.parse("1")).throws(expect("n", "1"));
+        assert(() => i.parse(1.1)).throws("1.1 is not an integer");
+        assert(() => i.parse(-1.1)).throws("-1.1 is not an integer");
+        assert(() => i.parse(0n)).throws(expect("n", 0n));
+        assert(() => i.parse(1n)).throws(expect("n", 1n));
+    });
+    test.case("pass", assert => {
+        assert(i).type();
+        assert(i.parse(0)).equals(0).type();
+        assert(i.parse(1)).equals(1).type();
+    });
+    test.case("range", assert => {
+        assert(i.parse(min)).equals(min).type();
+        assert(i.parse(max)).equals(max).type();
+        assert(() => i.parse(min - 1)).throws(`${min - 1} is out of range`);
+        assert(() => i.parse(max + 1)).throws(`${max + 1} is out of range`);
+    });
+    test.case("coerced", assert => {
+        const coerced = i.coerce;
+        assert(coerced.parse(0)).equals(0).type();
+        assert(coerced.parse(1)).equals(1).type();
+        assert(coerced.parse("1")).equals(1).type();
+        assert(coerced.parse("1.0")).equals(1).type();
+        assert(coerced.parse("1.")).equals(1).type();
+        assert(() => coerced.parse("0.1")).throws("0.1 is not an integer");
+        assert(() => coerced.parse(".1")).throws("0.1 is not an integer");
+        assert(coerced.parse("-1")).equals(-1).type();
+        assert(coerced.parse("-1.0")).equals(-1).type();
+        assert(coerced.parse("-1.")).equals(-1).type();
+        assert(() => coerced.parse("-0.1")).throws("-0.1 is not an integer");
+        assert(() => coerced.parse("-.1")).throws("-0.1 is not an integer");
+    });
+    test.case("default", assert => {
+        [i.default(1), i.default(() => 1)].forEach(d => {
+            assert(d).type();
+            assert(d.parse(undefined)).equals(1).type();
+            assert(d.parse(1)).equals(1).type();
+            assert(d.parse(0)).equals(0).type();
+            assert(() => d.parse(1.2)).throws("1.2 is not an integer");
+            assert(() => d.parse(-1.2)).throws("-1.2 is not an integer");
+        });
+    });
+    test.case("validator - range", assert => {
+        const r = i.range(-10, 10);
+        assert(r.parse(-10)).equals(-10).type();
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(-11)).throws("-11 is out of range");
+        assert(() => r.parse(11)).throws("11 is out of range");
+    });
+    test.case("validator - min", assert => {
+        const r = i.min(-10);
+        assert(r.parse(-10)).equals(-10).type();
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(-11)).throws("-11 is lower than min (-10)");
+    });
+    test.case("validator - max", assert => {
+        const r = i.max(10);
+        assert(r.parse(-10)).equals(-10).type();
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(11)).throws("11 is greater than max (10)");
+    });
+};
+//# sourceMappingURL=int.js.map

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

@@ -0,0 +1,5 @@
+import type UintDataType from "#UintDataType";
+import type UintType from "#UintType";
+declare const _default: <T extends UintDataType>(i: UintType<T>, min: number, max: number) => void;
+export default _default;
+//# sourceMappingURL=uint.d.ts.map

package/lib/private/spec/uint.js

@@ -0,0 +1,73 @@
+import expect from "#expect";
+import test from "@rcompat/test";
+export default (i, min, max) => {
+    test.case("fail", assert => {
+        assert(() => i.parse("1")).throws(expect("n", "1"));
+        assert(() => i.parse(1.1)).throws("1.1 is not an integer");
+        assert(() => i.parse(-1.1)).throws("-1.1 is not an integer");
+        assert(() => i.parse(-1)).throws("-1 is out of range");
+        assert(() => i.parse(1n)).throws(expect("n", 1n));
+    });
+    test.case("pass", assert => {
+        assert(i).type();
+        assert(i.parse(1)).equals(1).type();
+    });
+    test.case("range", assert => {
+        assert(i.parse(0)).equals(0).type();
+        assert(i.parse(min)).equals(min).type();
+        assert(i.parse(max)).equals(max).type();
+        assert(() => i.parse(min - 1)).throws(`${min - 1} is out of range`);
+        assert(() => i.parse(max + 1)).throws(`${max + 1} is out of range`);
+    });
+    test.case("coerced", assert => {
+        const coerced = i.coerce;
+        assert(coerced.parse(0)).equals(0).type();
+        assert(coerced.parse(1)).equals(1).type();
+        assert(coerced.parse("1")).equals(1).type();
+        assert(coerced.parse("1.0")).equals(1).type();
+        assert(coerced.parse("1.")).equals(1).type();
+        assert(() => coerced.parse("0.1")).throws("0.1 is not an integer");
+        assert(() => coerced.parse(".1")).throws("0.1 is not an integer");
+        assert(() => coerced.parse("-1")).throws("-1 is out of range");
+        assert(() => coerced.parse("-1.0")).throws("-1 is out of range");
+        assert(() => coerced.parse("-1.")).throws("-1 is out of range");
+    });
+    test.case("default", assert => {
+        [i.default(1), i.default(() => 1)].forEach(d => {
+            assert(d).type();
+            assert(d.parse(undefined)).equals(1).type();
+            assert(d.parse(1)).equals(1).type();
+            assert(d.parse(0)).equals(0).type();
+            assert(() => d.parse(1.2)).throws("1.2 is not an integer");
+            assert(() => d.parse(-1.2)).throws("-1.2 is not an integer");
+        });
+        [i.default(-1), i.default(() => -1)].forEach(d => {
+            assert(d).type();
+            assert(() => d.parse(undefined)).throws("-1 is out of range");
+            assert(d.parse(1)).equals(1).type();
+            assert(d.parse(0)).equals(0).type();
+        });
+    });
+    test.case("validator - range", assert => {
+        const r = i.range(0, 10);
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(-1)).throws("-1 is out of range");
+        assert(() => r.parse(-11)).throws("-11 is out of range");
+        assert(() => r.parse(11)).throws("11 is out of range");
+    });
+    test.case("validator - min", assert => {
+        const r = i.min(0);
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(-1)).throws("-1 is out of range");
+    });
+    test.case("validator - max", assert => {
+        const r = i.max(10);
+        assert(r.parse(0)).equals(0).type();
+        assert(r.parse(10)).equals(10).type();
+        assert(() => r.parse(-1)).throws("-1 is out of range");
+        assert(() => r.parse(11)).throws("11 is greater than max (10)");
+    });
+};
+//# sourceMappingURL=uint.js.map

package/lib/private/string.d.ts

@@ -1,4 +1,7 @@
 import StringType from "#StringType";
+/**
+* Value is a string.
+*/
 declare const _default: StringType;
 export default _default;
 //# sourceMappingURL=string.d.ts.map

package/lib/private/string.js

@@ -1,3 +1,6 @@
 import StringType from "#StringType";
+/**
+* Value is a string.
+*/
 export default new StringType();
 //# sourceMappingURL=string.js.map

package/lib/private/test/messages-of.d.ts

@@ -0,0 +1,3 @@
+import type ParseIssue from "#ParseIssue";
+export default function messagesOf(issues: ParseIssue[]): string[];
+//# sourceMappingURL=messages-of.d.ts.map

package/lib/private/test/messages-of.js

@@ -0,0 +1,4 @@
+export default function messagesOf(issues) {
+    return issues.map(i => i.message);
+}
+//# sourceMappingURL=messages-of.js.map

package/lib/private/test/paths-of.d.ts

@@ -0,0 +1,3 @@
+import type ParseIssue from "#ParseIssue";
+export default function pathsOf(issues: ParseIssue[]): import("@rcompat/type/JSONPointer").default[];
+//# sourceMappingURL=paths-of.d.ts.map

package/lib/private/test/paths-of.js

@@ -0,0 +1,4 @@
+export default function pathsOf(issues) {
+    return issues.map(i => i.path);
+}
+//# sourceMappingURL=paths-of.js.map

package/lib/private/test/throws-issues.d.ts

@@ -0,0 +1,4 @@
+import type ParseIssue from "#ParseIssue";
+import type Asserter from "@rcompat/test/Asserter";
+export default function throwsIssues(assert: Asserter, fn: () => unknown): ParseIssue[];
+//# sourceMappingURL=throws-issues.d.ts.map

package/lib/private/test/throws-issues.js

@@ -0,0 +1,13 @@
+export default function throwsIssues(assert, fn) {
+    try {
+        fn();
+        // fail if nothing was thrown
+        assert().fail();
+        return []; // unreachable
+    }
+    catch (error) {
+        const e = error;
+        return e.issues ?? [];
+    }
+}
+//# sourceMappingURL=throws-issues.js.map

package/lib/private/trait/Default.d.ts

@@ -0,0 +1,9 @@
+import type DefaultType from "#DefaultType";
+import Parsed from "#Parsed";
+export default abstract class DefaultTrait<T> extends Parsed<unknown> {
+    /**
+    * Use the given default if value is missing.
+    */
+    abstract default(value: (() => T) | T): DefaultType<this, T>;
+}
+//# sourceMappingURL=Default.d.ts.map

package/lib/private/trait/Default.js

@@ -0,0 +1,4 @@
+import Parsed from "#Parsed";
+export default class DefaultTrait extends Parsed {
+}
+//# sourceMappingURL=Default.js.map

package/lib/private/trait/Optional.d.ts

@@ -0,0 +1,11 @@
+import type OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+export default abstract class OptionalTrait extends Parsed<unknown> {
+    /**
+    * Value is optional.
+    *
+    * @returns OptionalType<T>
+    */
+    abstract optional(): OptionalType<this>;
+}
+//# sourceMappingURL=Optional.d.ts.map

package/lib/private/trait/Optional.js

@@ -0,0 +1,4 @@
+import Parsed from "#Parsed";
+export default class OptionalTrait extends Parsed {
+}
+//# sourceMappingURL=Optional.js.map

package/lib/private/tuple.d.ts

@@ -1,5 +1,9 @@
+import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
 import TupleType from "#TupleType";
-declare const _default: <const T extends Schema[]>(...types: T) => TupleType<T>;
-export default _default;
+type NormalizeSchemaArray<T extends Schema[]> = {
+    [K in keyof T]: NormalizeSchema<T[K]>;
+};
+export default function tuple<const T extends Schema[]>(...items: T): TupleType<NormalizeSchemaArray<T>>;
+export {};
 //# sourceMappingURL=tuple.d.ts.map

package/lib/private/tuple.js

@@ -1,3 +1,8 @@
 import TupleType from "#TupleType";
-export default (...types) => new TupleType(types);
+import normalize from "#normalize";
+export default function tuple(...items) {
+    // normalize each item so the class only sees Parsed
+    const parsed = items.map(normalize);
+    return new TupleType(parsed);
+}
 //# sourceMappingURL=tuple.js.map

package/lib/private/u128.d.ts

@@ -0,0 +1,4 @@
+import BigUintType from "#BigUintType";
+declare const _default: BigUintType<"u128">;
+export default _default;
+//# sourceMappingURL=u128.d.ts.map

package/lib/private/u128.js

@@ -0,0 +1,6 @@
+import BigUintType from "#BigUintType";
+import range from "#validator/range";
+const from = 0n;
+const to = 2n ** 128n - 1n;
+export default new BigUintType("u128", [range(from, to)]);
+//# sourceMappingURL=u128.js.map

package/lib/private/u16.d.ts

@@ -0,0 +1,4 @@
+import UintType from "#UintType";
+declare const _default: UintType<"u16">;
+export default _default;
+//# sourceMappingURL=u16.d.ts.map

package/lib/private/u16.js

@@ -0,0 +1,6 @@
+import UintType from "#UintType";
+import range from "#validator/range";
+const from = 0;
+const to = 2 ** 16 - 1;
+export default new UintType("u16", [range(from, to)]);
+//# sourceMappingURL=u16.js.map

package/lib/private/u32.d.ts

@@ -0,0 +1,7 @@
+import UintType from "#UintType";
+/**
+* Value is an unsigned integer.
+*/
+declare const _default: UintType<"u32">;
+export default _default;
+//# sourceMappingURL=u32.d.ts.map

package/lib/private/u32.js

@@ -0,0 +1,9 @@
+import UintType from "#UintType";
+import range from "#validator/range";
+const from = 0;
+const to = 2 ** 32 - 1;
+/**
+* Value is an unsigned integer.
+*/
+export default new UintType("u32", [range(from, to)]);
+//# sourceMappingURL=u32.js.map

package/lib/private/u64.d.ts

@@ -0,0 +1,4 @@
+import BigUintType from "#BigUintType";
+declare const _default: BigUintType<"u64">;
+export default _default;
+//# sourceMappingURL=u64.d.ts.map

package/lib/private/u64.js

@@ -0,0 +1,6 @@
+import BigUintType from "#BigUintType";
+import range from "#validator/range";
+const from = 0n;
+const to = 2n ** 64n - 1n;
+export default new BigUintType("u64", [range(from, to)]);
+//# sourceMappingURL=u64.js.map

package/lib/private/u8.d.ts

@@ -0,0 +1,4 @@
+import UintType from "#UintType";
+declare const _default: UintType<"u8">;
+export default _default;
+//# sourceMappingURL=u8.d.ts.map