pema 0.5.0 → 0.6.1

package/lib/private/spec/int.js

@@ -1,70 +1,59 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, 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));
+        assert(t).invalid_type(["1", 0n, 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(0)).equals(0).type();
-        assert(i.parse(1)).equals(1).type();
+        assert(t).type();
+        assert(t.parse(0)).equals(0).type();
+        assert(t.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`);
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([min - 1, max + 1]);
     });
     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");
+        assert(t.coerce(0)).equals(0).type();
+        assert(t.coerce(1)).equals(1).type();
+        assert(t.coerce("1")).equals(1).type();
+        assert(t.coerce("1.0")).equals(1).type();
+        assert(t.coerce("1.")).equals(1).type();
+        assert(t).invalid_type(["0.1", ".1"]);
+        assert(t.coerce("-1")).equals(-1).type();
+        assert(t.coerce("-1.0")).equals(-1).type();
+        assert(t.coerce("-1.")).equals(-1).type();
+        assert(t).invalid_type(["-0.1", "-.1"]);
     });
     test.case("default", assert => {
-        [i.default(1), i.default(() => 1)].forEach(d => {
+        [t.default(1), t.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");
+            assert(d).invalid_type(["1.2", "-1.2"]);
         });
     });
     test.case("validator - range", assert => {
-        const r = i.range(-10, 10);
+        const r = t.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");
+        assert(r).out_of_range([-11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(-10);
+        const r = t.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)");
+        assert(r).too_small([-11]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10);
+        const r = t.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)");
+        assert(r).too_large([11]);
     });
 };
 //# sourceMappingURL=int.js.map

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

@@ -1,5 +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;
+declare const _default: <T extends UintDataType>(t: UintType<T>, min: number, max: number) => void;
 export default _default;
 //# sourceMappingURL=uint.d.ts.map

package/lib/private/spec/uint.js

@@ -1,73 +1,61 @@
-import expect from "#expect";
-import test from "@rcompat/test";
-export default (i, min, max) => {
+import test from "#test";
+export default (t, 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));
+        assert(t).invalid_type(["1", 1n, 1.1, -1.1]);
     });
     test.case("pass", assert => {
-        assert(i).type();
-        assert(i.parse(1)).equals(1).type();
+        assert(t).type();
+        assert(t.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");
+        assert(t.parse(0)).equals(0).type();
+        assert(t.parse(min)).equals(min).type();
+        assert(t.parse(max)).equals(max).type();
+        assert(t).out_of_range([-1, min - 1, max + 1]);
+    });
+    test.case("coerce", assert => {
+        assert(t.coerce(0)).equals(0).type();
+        assert(t.coerce(1)).equals(1).type();
+        assert(t.coerce("1")).equals(1).type();
+        assert(t.coerce("1.0")).equals(1).type();
+        assert(t.coerce("1.")).equals(1).type();
+        assert(t).coerce_invalid_type(["0.1", ".1"]);
+        assert(t).coerce_out_of_range(["-1", "-1.0", "-1."]);
     });
     test.case("default", assert => {
-        [i.default(1), i.default(() => 1)].forEach(d => {
+        [t.default(1), t.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");
+            assert(d).invalid_type(["1.2", "-1.2"]);
         });
-        [i.default(-1), i.default(() => -1)].forEach(d => {
+        [t.default(-1), t.default(() => -1)].forEach(d => {
             assert(d).type();
-            assert(() => d.parse(undefined)).throws("-1 is out of range");
+            assert(d).out_of_range([undefined]);
             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);
+        const r = t.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");
+        assert(r).out_of_range([-1, -11, 11]);
     });
     test.case("validator - min", assert => {
-        const r = i.min(0);
-        assert(r.parse(0)).equals(0).type();
+        const r = t.min(10);
+        assert(r.parse(20)).equals(20).type();
         assert(r.parse(10)).equals(10).type();
-        assert(() => r.parse(-1)).throws("-1 is out of range");
+        assert(r).out_of_range([-1]);
+        assert(r).too_small([0]);
     });
     test.case("validator - max", assert => {
-        const r = i.max(10);
+        const r = t.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)");
+        assert(r).out_of_range([-1]);
+        assert(r).too_large([11]);
     });
 };
 //# sourceMappingURL=uint.js.map

package/lib/private/test.d.ts

@@ -0,0 +1,34 @@
+import type IssueType from "#IssueType";
+import type { JSONPointer } from "@rcompat/type";
+type Input = [unknown, string?];
+type IssueMatcher = {
+    type: IssueType;
+    path?: string;
+    message?: string;
+};
+declare const _default: import("@rcompat/test/index").ExtendedTest<{
+    parse_issue: (type: IssueType, inputs: Input[]) => void;
+    coerce_issue: (type: IssueType, inputs: Input[]) => void;
+    parse_issues(input: unknown, matchers: IssueMatcher[]): void;
+    coerce_issues(input: unknown, matchers: IssueMatcher[]): void;
+} & {
+    invalid_type: (inputs: unknown[], path?: JSONPointer) => void;
+    invalid_format: (inputs: unknown[], path?: JSONPointer) => void;
+    too_small: (inputs: unknown[], path?: JSONPointer) => void;
+    too_large: (inputs: unknown[], path?: JSONPointer) => void;
+    out_of_range: (inputs: unknown[], path?: JSONPointer) => void;
+    not_in_set: (inputs: unknown[], path?: JSONPointer) => void;
+    duplicate: (inputs: unknown[], path?: JSONPointer) => void;
+    network_error: (inputs: unknown[], path?: JSONPointer) => void;
+} & {
+    coerce_invalid_type: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_invalid_format: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_too_small: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_too_large: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_out_of_range: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_not_in_set: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_duplicate: (inputs: unknown[], path?: JSONPointer) => void;
+    coerce_network_error: (inputs: unknown[], path?: JSONPointer) => void;
+}>;
+export default _default;
+//# sourceMappingURL=test.d.ts.map

package/lib/private/test.js

@@ -0,0 +1,107 @@
+import ParseError from "#ParseError";
+import test from "@rcompat/test";
+const issue_types = [
+    "invalid_type",
+    "invalid_format",
+    "too_small",
+    "too_large",
+    "out_of_range",
+    "not_in_set",
+    "duplicate",
+];
+export default test.extend((assert, subject) => {
+    const parse_issue = (type, inputs) => {
+        for (const [input, path] of inputs) {
+            try {
+                subject.parse(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    const issue = e.issues[0];
+                    assert(issue.type).equals(type);
+                    if (path !== undefined)
+                        assert(issue.path).equals(path);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    };
+    const coerce_issue = (type, inputs) => {
+        for (const [input, path] of inputs) {
+            try {
+                subject.coerce(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    const issue = e.issues[0];
+                    assert(issue.type).equals(type);
+                    if (path !== undefined)
+                        assert(issue.path).equals(path);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    };
+    const shortcuts = Object.fromEntries(issue_types.flatMap(type => [
+        [type, (inputs, path = "") => parse_issue(type, inputs.map(input => [input, path]))],
+        [`coerce_${type}`, (inputs, path = "") => coerce_issue(type, inputs.map(input => [input, path]))],
+    ]));
+    return {
+        parse_issue,
+        coerce_issue,
+        parse_issues(input, matchers) {
+            try {
+                subject.parse(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    assert(e.issues.length).equals(matchers.length);
+                    for (let i = 0; i < matchers.length; i++) {
+                        assert(e.issues[i].type).equals(matchers[i].type);
+                        if (matchers[i].path !== undefined) {
+                            assert(e.issues[i].path).equals(matchers[i].path);
+                        }
+                        if (matchers[i].message !== undefined) {
+                            assert(e.issues[i].message).equals(matchers[i].message);
+                        }
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+        },
+        coerce_issues(input, matchers) {
+            try {
+                subject.coerce(input);
+                assert("[did not throw]").equals("[threw]");
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    assert(e.issues.length).equals(matchers.length);
+                    for (let i = 0; i < matchers.length; i++) {
+                        assert(e.issues[i].type).equals(matchers[i].type);
+                        if (matchers[i].path !== undefined) {
+                            assert(e.issues[i].path).equals(matchers[i].path);
+                        }
+                        if (matchers[i].message !== undefined) {
+                            assert(e.issues[i].message).equals(matchers[i].message);
+                        }
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+        },
+        ...shortcuts,
+    };
+});
+//# sourceMappingURL=test.js.map

package/lib/private/uuid.d.ts

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

package/lib/private/uuid.js

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

package/lib/private/validator/ends-with.d.ts

@@ -1,4 +1,3 @@
 import type Validator from "#Validator";
-declare const _default: (suffix: string) => Validator<string>;
-export default _default;
+export default function ends_with(suffix: string): Validator<string>;
 //# sourceMappingURL=ends-with.d.ts.map

package/lib/private/validator/ends-with.js

@@ -1,11 +1,9 @@
-import ParseError from "#ParseError";
-export default (suffix) => (x) => {
-    if (!x.endsWith(suffix)) {
-        throw new ParseError([{
-                input: x,
-                message: `"${x}" does not end with "${suffix}"`,
-                path: "",
-            }]);
-    }
-};
+import E from "#errors";
+export default function ends_with(suffix) {
+    return (x) => {
+        if (!x.endsWith(suffix)) {
+            throw E.invalid_format(x, `"${x}" does not end with "${suffix}"`);
+        }
+    };
+}
 //# sourceMappingURL=ends-with.js.map

package/lib/private/validator/f32.js

@@ -1,11 +1,6 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 export default function f32(x) {
-    if (x !== new Float32Array([x])[0]) {
-        throw new ParseError([{
-                input: x,
-                message: `${x} is not a 32-bit float`,
-                path: "",
-            }]);
-    }
+    if (x !== new Float32Array([x])[0])
+        throw E.out_of_range(x, `${x} is not a 32-bit float`);
 }
 //# sourceMappingURL=f32.js.map

package/lib/private/validator/integer.d.ts

@@ -1,3 +1,2 @@
-declare const _default: (x: bigint | number) => void;
-export default _default;
+export default function integer(x: bigint | number): void;
 //# sourceMappingURL=integer.d.ts.map

package/lib/private/validator/integer.js

@@ -1,12 +1,8 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 import is from "@rcompat/is";
-export default (x) => {
-    if (!is.int(x)) {
-        throw new ParseError([{
-                input: x,
-                message: `${x} is not an integer`,
-                path: "",
-            }]);
-    }
-};
+export default function integer(x) {
+    if (!is.int(x))
+        throw E.invalid_type(x, `${x} is not an integer`);
+}
+;
 //# sourceMappingURL=integer.js.map

package/lib/private/validator/isotime.js

@@ -1,4 +1,4 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 import regex from "#validator/regex";
 const ISOTIME = /^T?(?<hour>\d{2}):?(?<minute>\d{2}):?(?<second>\d{2})$/u;
 const RANGE = {
@@ -6,25 +6,23 @@ const RANGE = {
     minute: { max: 59, min: 0 },
     second: { max: 60, min: 0 },
 };
+function validator(s) {
+    return `"${s}" is not a valid ISO time`;
+}
 export default function isotime(x) {
     // check format
-    regex(ISOTIME, y => `"${y}" is not a valid ISO time`)(x);
+    regex(ISOTIME, validator)(x);
     // check range
     const match = ISOTIME.exec(x);
     const g = match.groups;
     const h = Number(g.hour);
     const m = Number(g.minute);
     const s = Number(g.second);
-    const inRange = h >= RANGE.hour.min && h <= RANGE.hour.max &&
+    const in_range = h >= RANGE.hour.min && h <= RANGE.hour.max &&
         m >= RANGE.minute.min && m <= RANGE.minute.max &&
         s >= RANGE.second.min && s <= RANGE.second.max;
-    if (!inRange) {
-        throw new ParseError([{
-                input: x,
-                message: `"${x}" is not a valid ISO time`,
-                path: "",
-            }]);
-    }
+    if (!in_range)
+        throw E.out_of_range(x, validator(x));
 }
 ;
 //# sourceMappingURL=isotime.js.map

package/lib/private/validator/length.js

@@ -1,27 +1,19 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
-import ParseError from "#ParseError";
+import E from "#errors";
+import S from "#schema-errors";
 import is from "@rcompat/is";
 export default function length(from, to) {
-    if (!is.finite(from) || !is.finite(to)) {
-        throw schemafail("length: {0} and {1} must be finite numbers", from, to);
-    }
-    if (from < 0 || to < 0) {
-        throw schemafail("length: {0} and {1} must be positive", from, to);
-    }
-    if (from > to) {
-        throw schemafail("length: {0} must be lower than {1}", from, to);
-    }
+    if (!is.finite(from) || !is.finite(to))
+        throw S.length_not_finite(from, to);
+    if (from < 0 || to < 0)
+        throw S.length_not_positive(from, to);
+    if (from > to)
+        throw S.length_from_exceeds_to(from, to);
     return (x) => {
-        if (typeof x !== "string" && !Array.isArray(x)) {
-            throw fail(x, "invalid type");
+        if (!is.string(x) && !is.array(x)) {
+            throw E.invalid_type(x, "string or array");
         }
         if (x.length < from || x.length > to) {
-            throw new ParseError([{
-                    input: x,
-                    message: "length out of range",
-                    path: "",
-                }]);
+            throw E.out_of_range(x, "length out of range");
         }
     };
 }

package/lib/private/validator/max.js

@@ -1,36 +1,35 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
+import E from "#errors";
+import S from "#schema-errors";
 import is from "@rcompat/is";
 export default function max(limit) {
     // validate limit once
-    if (typeof limit === "number") {
-        if (!is.finite(limit)) {
-            throw schemafail("max: limit {0} must be a finite number", limit);
-        }
+    if (is.number(limit)) {
+        if (!is.finite(limit))
+            throw S.max_limit_not_finite(limit);
         return (x) => {
-            if (typeof x === "number") {
+            if (is.number(x)) {
                 if (x > limit)
-                    throw fail(x, `${x} is greater than max (${limit})`);
+                    throw E.too_large(x, `${x} is greater than ${limit}`);
             }
-            else if (typeof x === "string" || Array.isArray(x)) {
+            else if (is.string(x) || is.array(x)) {
                 if (x.length > limit) {
-                    const unit = typeof x === "string" ? "characters" : "items";
-                    throw fail(x, `max ${limit} ${unit}`);
+                    const unit = is.string(x) ? "characters" : "items";
+                    throw E.too_large(x, `max ${limit} ${unit}`);
                 }
             }
             else {
-                throw fail(x, "invalid type");
+                throw E.invalid_type(x, "number");
             }
         };
     }
     // bigint
     return (x) => {
-        if (typeof x === "bigint") {
+        if (is.bigint(x)) {
             if (x > limit)
-                throw fail(x, `${x} is greater than max (${limit})`);
+                throw E.too_large(x, `${x} is greater than ${limit}`);
         }
         else {
-            throw fail(x, "invalid type");
+            throw E.invalid_type(x, "bigint");
         }
     };
 }

package/lib/private/validator/min.js

@@ -1,36 +1,35 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
+import E from "#errors";
+import S from "#schema-errors";
 import is from "@rcompat/is";
 export default function min(limit) {
     // validate limit once
-    if (typeof limit === "number") {
-        if (!is.finite(limit)) {
-            throw schemafail("max: limit {0} must be a finite number", limit);
-        }
+    if (is.number(limit)) {
+        if (!is.finite(limit))
+            throw S.min_limit_not_finite(limit);
         return (x) => {
-            if (typeof x === "number") {
+            if (is.number(x)) {
                 if (x < limit)
-                    throw fail(x, `${x} is lower than min (${limit})`);
+                    throw E.too_small(x, `${x} is lower than ${limit}`);
             }
-            else if (typeof x === "string" || Array.isArray(x)) {
+            else if (is.string(x) || is.array(x)) {
                 if (x.length < limit) {
-                    const unit = typeof x === "string" ? "characters" : "items";
-                    throw fail(x, `min ${limit} ${unit}`);
+                    const unit = is.string(x) ? "characters" : "items";
+                    throw E.too_small(x, `min ${limit} ${unit}`);
                 }
             }
             else {
-                throw fail(x, "invalid type");
+                throw E.invalid_type(x, "number");
             }
         };
     }
     // bigint
     return (x) => {
-        if (typeof x === "bigint") {
+        if (is.bigint(x)) {
             if (x < limit)
-                throw fail(x, `${x} is lower than min (${limit})`);
+                throw E.too_small(x, `${x} is lower than ${limit}`);
         }
         else {
-            throw fail(x, "invalid type");
+            throw E.invalid_type(x, "bigint");
         }
     };
 }

package/lib/private/validator/port.d.ts

@@ -1,3 +1,2 @@
-declare const _default: (port: number) => void;
-export default _default;
+export default function port(given: number): void;
 //# sourceMappingURL=port.d.ts.map

package/lib/private/validator/port.js

@@ -1,15 +1,12 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 // 1000
 const min = 2 ** 10;
 // 65535
 const max = 2 ** 16 - 1;
-export default (port) => {
-    if (port < min || port > max) {
-        throw new ParseError([{
-                input: port,
-                message: `${port} out of port range (${min} - ${max})`,
-                path: "",
-            }]);
+export default function port(given) {
+    if (given < min || given > max) {
+        throw E.out_of_range(given, `${given} out of port range (${min} - ${max})`);
     }
-};
+}
+;
 //# sourceMappingURL=port.js.map