typia 7.0.0-dev.20241001 → 7.0.0-dev.20241002-2

package/lib/factories/MetadataCommentTagFactory.js

@@ -41,220 +41,270 @@ var Writable_1 = require("../typings/Writable");
 var FormatCheatSheet_1 = require("../tags/internal/FormatCheatSheet");
 var MetadataTypeTagFactory_1 = require("./MetadataTypeTagFactory");
 /**
- * Extremely hard coded, but no reason to maintain.
- *
  * @internal
  */
 var MetadataCommentTagFactory;
 (function (MetadataCommentTagFactory) {
-    MetadataCommentTagFactory.analyze = function (errors) {
-        return function (metadata) {
-            return function (commentList, explore) {
-                var e_1, _a, e_2, _b;
-                var _c, _d;
-                // PREPARE MESSAGE CONTAINER
-                var messages = [];
-                var report = function (msg) {
-                    messages.push(msg);
-                    return null;
-                };
-                var validateReport = function (property) {
-                    return function (msg) {
-                        messages.push("the property ".concat(property === null ? "[\"typia.tag\"]" : "[\"typia.tag.".concat(property, "\"]"), " ").concat(msg, "."));
-                        return false;
-                    };
-                };
-                try {
-                    // VALIDATE AND CONSTRUCT COMMENT TAGS
-                    for (var commentList_1 = __values(commentList), commentList_1_1 = commentList_1.next(); !commentList_1_1.done; commentList_1_1 = commentList_1.next()) {
-                        var comment = commentList_1_1.value;
-                        var tagger = parse(report)(comment);
-                        if (tagger === null)
-                            continue;
-                        var _loop_1 = function (key, value) {
-                            var e_3, _h, e_4, _j, e_5, _k;
-                            var filtered = value.filter(function (v) { return v.validate !== null; });
-                            if (key === "array") {
-                                if (metadata.arrays.length === 0) {
-                                    report("requires array type");
-                                    return "continue";
-                                }
-                                try {
-                                    for (var _l = (e_3 = void 0, __values(metadata.arrays)), _m = _l.next(); !_m.done; _m = _l.next()) {
-                                        var a = _m.value;
-                                        (0, Writable_1.Writable)(a).tags = a.tags.filter(function (x) {
-                                            return MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate(validateReport)("array")(__spreadArray(__spreadArray([], __read(x), false), __read(filtered), false));
-                                        });
-                                        if (a.tags.length === 0)
-                                            a.tags.push(filtered);
-                                        else
-                                            try {
-                                                for (var _o = (e_4 = void 0, __values(a.tags)), _p = _o.next(); !_p.done; _p = _o.next()) {
-                                                    var tags = _p.value;
-                                                    tags.push.apply(tags, __spreadArray([], __read(filtered), false));
-                                                }
-                                            }
-                                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                            finally {
-                                                try {
-                                                    if (_p && !_p.done && (_j = _o.return)) _j.call(_o);
-                                                }
-                                                finally { if (e_4) throw e_4.error; }
-                                            }
-                                    }
-                                }
-                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                finally {
+    MetadataCommentTagFactory.analyze = function (props) {
+        var e_1, _a, e_2, _b;
+        var _c, _d;
+        // PREPARE MESSAGE CONTAINER
+        var messages = [];
+        var report = function (msg) {
+            messages.push(msg);
+            return null;
+        };
+        var validateReport = function (next) {
+            messages.push("the property ".concat(next.property === null
+                ? "[\"typia.tag\"]"
+                : "[\"typia.tag.".concat(next.property, "\"]"), " ").concat(next.message, "."));
+            return false;
+        };
+        try {
+            // VALIDATE AND CONSTRUCT COMMENT TAGS
+            for (var _e = __values(props.tags), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var tag = _f.value;
+                var tagger = parse({
+                    report: report,
+                    tag: tag,
+                });
+                if (tagger === null)
+                    continue;
+                var _loop_1 = function (key, value) {
+                    var e_3, _k, e_4, _l, e_5, _m;
+                    var filtered = value.filter(function (v) { return v.validate !== null; });
+                    if (key === "array") {
+                        if (props.metadata.arrays.length === 0) {
+                            report("requires array type");
+                            return "continue";
+                        }
+                        try {
+                            for (var _o = (e_3 = void 0, __values(props.metadata.arrays)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                                var a = _p.value;
+                                (0, Writable_1.Writable)(a).tags = a.tags.filter(function (x) {
+                                    return MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate({
+                                        report: validateReport,
+                                        type: "array",
+                                        tags: __spreadArray(__spreadArray([], __read(x), false), __read(filtered), false),
+                                    });
+                                });
+                                if (a.tags.length === 0)
+                                    a.tags.push(filtered);
+                                else
                                     try {
-                                        if (_m && !_m.done && (_h = _l.return)) _h.call(_l);
-                                    }
-                                    finally { if (e_3) throw e_3.error; }
-                                }
-                            }
-                            else {
-                                var atomic = metadata.atomics.find(function (a) { return a.type == key; });
-                                if (atomic === undefined)
-                                    if (key === "bigint" || key === "number") {
-                                        var opposite_1 = key === "bigint" ? "number" : "bigint";
-                                        if (tagger[opposite_1] !== undefined &&
-                                            metadata.atomics.some(function (a) { return a.type === opposite_1; }))
-                                            return "continue";
+                                        for (var _q = (e_4 = void 0, __values(a.tags)), _r = _q.next(); !_r.done; _r = _q.next()) {
+                                            var tags = _r.value;
+                                            tags.push.apply(tags, __spreadArray([], __read(filtered), false));
+                                        }
                                     }
-                                    else if (key === "string" &&
-                                        ((_c = value[0]) === null || _c === void 0 ? void 0 : _c.kind) === "format" &&
-                                        ((_d = value[0]) === null || _d === void 0 ? void 0 : _d.value) === "date-time")
-                                        return "continue";
-                                    else
-                                        report("requires ".concat(key, " type"));
-                                else {
-                                    (0, Writable_1.Writable)(atomic).tags = atomic.tags.filter(function (x) {
-                                        return MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate(validateReport)(key)(__spreadArray(__spreadArray([], __read(x), false), __read(filtered), false));
-                                    });
-                                    if (atomic.tags.length === 0)
-                                        atomic.tags.push(filtered);
-                                    else
+                                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                    finally {
                                         try {
-                                            for (var _q = (e_5 = void 0, __values(atomic.tags)), _r = _q.next(); !_r.done; _r = _q.next()) {
-                                                var tags = _r.value;
-                                                tags.push.apply(tags, __spreadArray([], __read(filtered), false));
-                                            }
-                                        }
-                                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                                        finally {
-                                            try {
-                                                if (_r && !_r.done && (_k = _q.return)) _k.call(_q);
-                                            }
-                                            finally { if (e_5) throw e_5.error; }
+                                            if (_r && !_r.done && (_l = _q.return)) _l.call(_q);
                                         }
-                                }
-                            }
-                        };
-                        try {
-                            for (var _e = (e_2 = void 0, __values(Object.entries(tagger))), _f = _e.next(); !_f.done; _f = _e.next()) {
-                                var _g = __read(_f.value, 2), key = _g[0], value = _g[1];
-                                _loop_1(key, value);
+                                        finally { if (e_4) throw e_4.error; }
+                                    }
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
                         finally {
                             try {
-                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                if (_p && !_p.done && (_k = _o.return)) _k.call(_o);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_3) throw e_3.error; }
                         }
                     }
+                    else {
+                        var atomic = props.metadata.atomics.find(function (a) { return a.type == key; });
+                        if (atomic === undefined)
+                            if (key === "bigint" || key === "number") {
+                                var opposite_1 = key === "bigint" ? "number" : "bigint";
+                                if (tagger[opposite_1] !== undefined &&
+                                    props.metadata.atomics.some(function (a) { return a.type === opposite_1; }))
+                                    return "continue";
+                            }
+                            else if (key === "string" &&
+                                ((_c = value[0]) === null || _c === void 0 ? void 0 : _c.kind) === "format" &&
+                                ((_d = value[0]) === null || _d === void 0 ? void 0 : _d.value) === "date-time")
+                                return "continue";
+                            else
+                                report("requires ".concat(key, " type"));
+                        else {
+                            (0, Writable_1.Writable)(atomic).tags = atomic.tags.filter(function (x) {
+                                return MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate({
+                                    report: validateReport,
+                                    type: key,
+                                    tags: __spreadArray(__spreadArray([], __read(x), false), __read(filtered), false),
+                                });
+                            });
+                            if (atomic.tags.length === 0)
+                                atomic.tags.push(filtered);
+                            else
+                                try {
+                                    for (var _s = (e_5 = void 0, __values(atomic.tags)), _t = _s.next(); !_t.done; _t = _s.next()) {
+                                        var tags = _t.value;
+                                        tags.push.apply(tags, __spreadArray([], __read(filtered), false));
+                                    }
+                                }
+                                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                finally {
+                                    try {
+                                        if (_t && !_t.done && (_m = _s.return)) _m.call(_s);
+                                    }
+                                    finally { if (e_5) throw e_5.error; }
+                                }
+                        }
+                    }
+                };
+                try {
+                    for (var _g = (e_2 = void 0, __values(Object.entries(tagger))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var _j = __read(_h.value, 2), key = _j[0], value = _j[1];
+                        _loop_1(key, value);
+                    }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
                 finally {
                     try {
-                        if (commentList_1_1 && !commentList_1_1.done && (_a = commentList_1.return)) _a.call(commentList_1);
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
                     }
-                    finally { if (e_1) throw e_1.error; }
+                    finally { if (e_2) throw e_2.error; }
                 }
-                // DO REPORT
-                if (messages.length !== 0)
-                    errors.push({
-                        name: "comment tag(s)",
-                        explore: explore,
-                        messages: messages,
-                    });
-            };
-        };
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // DO REPORT
+        if (messages.length !== 0)
+            props.errors.push({
+                name: "comment tag(s)",
+                explore: props.explore,
+                messages: messages,
+            });
     };
-    var parse = function (report) {
-        return function (comment) {
-            var _a;
-            var parser = PARSER[comment.name];
-            if (parser === undefined)
-                return {};
-            var text = (_a = (comment.text || [])[0]) === null || _a === void 0 ? void 0 : _a.text;
-            if (text === undefined && comment.name !== "uniqueItems")
-                return report("no comment tag value");
-            return parser(report)(text);
-        };
+    var parse = function (props) {
+        var _a;
+        var next = PARSER[props.tag.name];
+        if (next === undefined)
+            return {};
+        var value = (_a = (props.tag.text || [])[0]) === null || _a === void 0 ? void 0 : _a.text;
+        if (value === undefined && props.tag.name !== "uniqueItems")
+            return props.report("no comment tag value");
+        return next({
+            report: props.report,
+            value: value,
+        });
     };
 })(MetadataCommentTagFactory || (exports.MetadataCommentTagFactory = MetadataCommentTagFactory = {}));
+/**
+ * @internal
+ */
 var PARSER = {
     /* -----------------------------------------------------------
           ARRAY
       ----------------------------------------------------------- */
-    items: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MinItems<".concat(Value, ">"),
-                target: "array",
-                kind: "minItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minItems: parse_integer(report)(true)(Value),
+    items: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MinItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "minItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-            {
-                name: "MaxItems<".concat(Value, ">"),
-                target: "array",
-                kind: "maxItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxItems: parse_integer(report)(true)(Value),
+                {
+                    name: "MaxItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "maxItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxItems: parse_integer({
+                            report: report,
+                            unsigned: true,
+                            value: value,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    minItems: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MinItems<".concat(Value, ">"),
-                target: "array",
-                kind: "minItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minItems: parse_integer(report)(true)(Value),
+            ],
+        });
+    },
+    minItems: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MinItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "minItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    maxItems: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MaxItems<".concat(Value, ">"),
-                target: "array",
-                kind: "maxItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxItems: parse_integer(report)(true)(Value),
+            ],
+        });
+    },
+    maxItems: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MaxItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "maxItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    uniqueItems: function () { return function () { return ({
+            ],
+        });
+    },
+    uniqueItems: function () { return ({
         array: [
             {
                 name: "UniqueItems",
@@ -268,212 +318,234 @@ var PARSER = {
                 },
             },
         ],
-    }); }; },
+    }); },
     /* -----------------------------------------------------------
           NUMBER
       ----------------------------------------------------------- */
-    type: function () { return function (Value) {
+    type: function (_a) {
+        var value = _a.value;
         // EMENDATIONS
-        if (Value.startsWith("{") && Value.endsWith("}"))
-            Value = Value.substring(1, Value.length - 1);
-        if (Value === "int")
-            Value = "int32";
-        else if (Value === "uint")
-            Value = "uint32";
+        if (value.startsWith("{") && value.endsWith("}"))
+            value = value.substring(1, value.length - 1);
+        if (value === "int")
+            value = "int32";
+        else if (value === "uint")
+            value = "uint32";
         // MUST BE ONE OF THEM
-        if (["int32", "uint32", "int64", "uint64", "float", "double"].includes(Value) === false)
+        if (["int32", "uint32", "int64", "uint64", "float", "double"].includes(value) === false)
             return {};
         return {
             number: [
                 {
-                    name: "Type<".concat(JSON.stringify(Value), ">"),
+                    name: "Type<".concat(JSON.stringify(value), ">"),
                     target: "number",
                     kind: "type",
-                    value: Value,
-                    validate: Value === "int32"
+                    value: value,
+                    validate: value === "int32"
                         ? "Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647"
-                        : Value === "uint32"
+                        : value === "uint32"
                             ? "Math.floor($input) === $input && 0 <= $input && $input <= 4294967295"
-                            : Value === "int64"
+                            : value === "int64"
                                 ? "Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807"
-                                : Value === "uint64"
+                                : value === "uint64"
                                     ? "Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615"
-                                    : Value === "float"
+                                    : value === "float"
                                         ? "-1.175494351e38 <= $input && $input <= 3.4028235e38"
                                         : "true",
                     exclusive: true,
-                    schema: ["int32", "uint32", "int64", "uint64"].includes(Value)
+                    schema: ["int32", "uint32", "int64", "uint64"].includes(value)
                         ? { type: "integer" }
                         : undefined,
                 },
             ],
-            bigint: Value === "int64" || "uint64"
+            bigint: value === "int64" || "uint64"
                 ? [
                     {
-                        name: "Type<".concat(JSON.stringify(Value), ">"),
+                        name: "Type<".concat(JSON.stringify(value), ">"),
                         target: "bigint",
                         kind: "type",
-                        value: Value,
-                        validate: Value === "int64" ? "true" : "BigInt(0) <= $input",
+                        value: value,
+                        validate: value === "int64" ? "true" : "BigInt(0) <= $input",
                         exclusive: true,
                         schema: undefined,
                     },
                 ]
                 : [],
         };
-    }; },
-    minimum: function (report) { return function (Value) { return ({
+    },
+    minimum: function (props) { return ({
         number: [
             {
-                name: "Minimum<".concat(Value, ">"),
+                name: "Minimum<".concat(props.value, ">"),
                 target: "number",
                 kind: "minimum",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " <= $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
-                    minimum: parse_number(report)(Value),
+                    minimum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "Minimum<".concat(Value, "n>"),
+                name: "Minimum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "minimum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(Value, " <= $input"),
+                validate: "".concat(props.value, " <= $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    maximum: function (report) { return function (Value) { return ({
+    }); },
+    maximum: function (props) { return ({
         number: [
             {
-                name: "Maximum<".concat(Value, ">"),
+                name: "Maximum<".concat(props.value, ">"),
                 target: "number",
                 kind: "maximum",
-                value: parse_number(report)(Value),
-                validate: "$input <= ".concat(Value),
+                value: parse_number(props),
+                validate: "$input <= ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
-                    maximum: parse_number(report)(Value),
+                    maximum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "Maximum<".concat(Value, "n>"),
+                name: "Maximum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "maximum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input <= ".concat(Value),
+                validate: "$input <= ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    exclusiveMinimum: function (report) { return function (Value) { return ({
+    }); },
+    exclusiveMinimum: function (props) { return ({
         number: [
             {
-                name: "ExclusiveMinimum<".concat(Value, ">"),
+                name: "ExclusiveMinimum<".concat(props.value, ">"),
                 target: "number",
                 kind: "exclusiveMinimum",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " < $input"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " < $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     exclusiveMinimum: true,
-                    minimum: parse_number(report)(Value),
+                    minimum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "ExclusiveMinimum<".concat(Value, "n>"),
+                name: "ExclusiveMinimum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "exclusiveMinimum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(Value, " < $input"),
+                validate: "".concat(props.value, " < $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    exclusiveMaximum: function (report) { return function (Value) { return ({
+    }); },
+    exclusiveMaximum: function (props) { return ({
         number: [
             {
-                name: "ExclusiveMaximum<".concat(Value, ">"),
+                name: "ExclusiveMaximum<".concat(props.value, ">"),
                 target: "number",
                 kind: "exclusiveMaximum",
-                value: parse_number(report)(Value),
-                validate: "$input < ".concat(Value),
+                value: parse_number(props),
+                validate: "$input < ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     exclusiveMaximum: true,
-                    maximum: parse_number(report)(Value),
+                    maximum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "ExclusiveMaximum<".concat(Value, "n>"),
+                name: "ExclusiveMaximum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "exclusiveMaximum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input < ".concat(Value),
+                validate: "$input < ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    multipleOf: function (report) { return function (Value) { return ({
+    }); },
+    multipleOf: function (props) { return ({
         number: [
             {
-                name: "MultipleOf<".concat(Value, ">"),
+                name: "MultipleOf<".concat(props.value, ">"),
                 target: "number",
                 kind: "multipleOf",
-                value: parse_number(report)(Value),
-                validate: "$input % ".concat(Value, " === 0"),
+                value: parse_number(props),
+                validate: "$input % ".concat(props.value, " === 0"),
                 exclusive: true,
                 schema: {
-                    multipleOf: parse_number(report)(Value),
+                    multipleOf: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "MultipleOf<".concat(Value, "n>"),
+                name: "MultipleOf<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "multipleOf",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input % ".concat(Value, "n === 0n"),
+                validate: "$input % ".concat(props.value, "n === 0n"),
                 exclusive: true,
                 schema: undefined,
             },
         ],
-    }); }; },
+    }); },
     /* -----------------------------------------------------------
           STRING
       ----------------------------------------------------------- */
-    format: function () { return function (Value) {
-        var matched = FORMATS.get(Value);
+    format: function (_a) {
+        var value = _a.value;
+        var matched = FORMATS.get(value);
         if (matched === undefined)
             return {};
         return {
@@ -491,101 +563,113 @@ var PARSER = {
                 },
             ],
         };
-    }; },
-    pattern: function () { return function (Value) { return ({
-        string: [
-            {
-                name: "Pattern<".concat(JSON.stringify(Value), ">"),
-                target: "string",
-                kind: "pattern",
-                value: Value,
-                validate: "RegExp(".concat(JSON.stringify(Value), ").test($input)"),
-                exclusive: ["format"],
-                schema: {
-                    pattern: Value,
+    },
+    pattern: function (_a) {
+        var value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "Pattern<".concat(JSON.stringify(value), ">"),
+                    target: "string",
+                    kind: "pattern",
+                    value: value,
+                    validate: "RegExp(".concat(JSON.stringify(value), ").test($input)"),
+                    exclusive: ["format"],
+                    schema: {
+                        pattern: value,
+                    },
                 },
-            },
-        ],
-    }); }; },
-    length: function (report) { return function (Value) { return ({
+            ],
+        });
+    },
+    length: function (props) { return ({
         string: [
             {
-                name: "MinLength<".concat(Value, ">"),
+                name: "MinLength<".concat(props.value, ">"),
                 target: "string",
                 kind: "minLength",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input.length"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " <= $input.length"),
                 exclusive: true,
                 schema: {
-                    minLength: parse_number(report)(Value),
+                    minLength: parse_number(props),
                 },
             },
             {
-                name: "MaxLength<".concat(Value, ">"),
+                name: "MaxLength<".concat(props.value, ">"),
                 target: "string",
                 kind: "maxLength",
-                value: parse_number(report)(Value),
-                validate: "$input.length <= ".concat(Value),
+                value: parse_number(props),
+                validate: "$input.length <= ".concat(props.value),
                 exclusive: true,
                 schema: {
-                    maxLength: parse_number(report)(Value),
+                    maxLength: parse_number(props),
                 },
             },
         ],
-    }); }; },
-    minLength: function (report) { return function (Value) { return ({
-        string: [
-            {
-                name: "MinLength<".concat(Value, ">"),
-                target: "string",
-                kind: "minLength",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minLength: parse_number(report)(Value),
+    }); },
+    minLength: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "MinLength<".concat(value, ">"),
+                    target: "string",
+                    kind: "minLength",
+                    value: parse_number({ report: report, value: value }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minLength: parse_number({ report: report, value: value }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    maxLength: function (report) { return function (Value) { return ({
-        string: [
-            {
-                name: "MaxLength<".concat(Value, ">"),
-                target: "string",
-                kind: "maxLength",
-                value: parse_number(report)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxLength: parse_number(report)(Value),
+            ],
+        });
+    },
+    maxLength: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "MaxLength<".concat(value, ">"),
+                    target: "string",
+                    kind: "maxLength",
+                    value: parse_number({ report: report, value: value }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxLength: parse_number({ report: report, value: value }),
+                    },
                 },
-            },
-        ],
-    }); }; },
+            ],
+        });
+    },
 };
-var parse_number = function (report) {
-    return function (str) {
-        var value = Number(str);
-        if (isNaN(value) === true)
-            return report("invalid number");
-        return value;
-    };
+/**
+ * @internal
+ */
+var parse_number = function (props) {
+    var parsed = Number(props.value);
+    if (isNaN(parsed) === true)
+        return props.report("invalid number");
+    return parsed;
 };
-var parse_integer = function (report) {
-    return function (unsigned) {
-        return function (str) {
-            var value = parse_number(report)(str);
-            if (value === null)
-                return null;
-            else if (Math.floor(value) !== value)
-                return report("invalid integer");
-            else if (unsigned === true && value < 0)
-                return report("invalid unsigned integer");
-            return value;
-        };
-    };
+/**
+ * @internal
+ */
+var parse_integer = function (props) {
+    var parsed = parse_number(props);
+    if (parsed === null)
+        return null;
+    else if (Math.floor(parsed) !== parsed)
+        return props.report("invalid integer");
+    else if (props.unsigned === true && parsed < 0)
+        return props.report("invalid unsigned integer");
+    return parsed;
 };
+/**
+ * @internal
+ */
 var FORMATS = new Map(__spreadArray(__spreadArray([], __read(Object.entries(FormatCheatSheet_1.FormatCheatSheet).map(function (_a) {
     var _b = __read(_a, 2), key = _b[0], value = _b[1];
     return [key, [key, value]];