typia 7.0.0-dev.20241112 → 7.0.0-dev.20241114

package/lib/factories/MetadataCommentTagFactory.js

@@ -1,339 +1,232 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataCommentTagFactory = void 0;
-var Writable_1 = require("../typings/Writable");
-var FormatCheatSheet_1 = require("../tags/internal/FormatCheatSheet");
-var MetadataTypeTagFactory_1 = require("./MetadataTypeTagFactory");
+const Writable_1 = require("../typings/Writable");
+const FormatCheatSheet_1 = require("../tags/internal/FormatCheatSheet");
+const MetadataTypeTagFactory_1 = require("./MetadataTypeTagFactory");
 /**
  * @internal
  */
 var MetadataCommentTagFactory;
 (function (MetadataCommentTagFactory) {
-    MetadataCommentTagFactory.analyze = function (props) {
-        var e_1, _a, e_2, _b;
-        var _c, _d;
+    MetadataCommentTagFactory.analyze = (props) => {
+        var _a, _b;
         // PREPARE MESSAGE CONTAINER
-        var messages = [];
-        var report = function (msg) {
+        const messages = [];
+        const report = (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, "."));
+        const validateReport = (next) => {
+            messages.push(`the property ${next.property === null
+                ? `["typia.tag"]`
+                : `["typia.tag.${next.property}"]`} ${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 {
-                                        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));
-                                        }
-                                    }
-                                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                    finally {
-                                        try {
-                                            if (_r && !_r.done && (_l = _q.return)) _l.call(_q);
-                                        }
-                                        finally { if (e_4) throw e_4.error; }
-                                    }
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_p && !_p.done && (_k = _o.return)) _k.call(_o);
-                            }
-                            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; }
-                                }
-                        }
+        // VALIDATE AND CONSTRUCT COMMENT TAGS
+        for (const tag of props.tags) {
+            const tagger = parse({
+                report,
+                tag,
+            });
+            if (tagger === null)
+                continue;
+            for (const [key, value] of Object.entries(tagger)) {
+                const filtered = value.filter((v) => v.validate !== null);
+                if (key === "array") {
+                    if (props.metadata.arrays.length === 0) {
+                        report(`requires array type`);
+                        continue;
                     }
-                };
-                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);
+                    for (const a of props.metadata.arrays) {
+                        (0, Writable_1.Writable)(a).tags = a.tags.filter((x) => MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate({
+                            report: validateReport,
+                            type: "array",
+                            tags: [...x, ...filtered],
+                        }));
+                        if (a.tags.length === 0)
+                            a.tags.push(filtered);
+                        else
+                            for (const tags of a.tags)
+                                tags.push(...filtered);
                     }
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                else {
+                    const atomic = props.metadata.atomics.find((a) => a.type == key);
+                    if (atomic === undefined)
+                        if (key === "bigint" || key === "number") {
+                            const opposite = key === "bigint" ? "number" : "bigint";
+                            if (tagger[opposite] !== undefined &&
+                                props.metadata.atomics.some((a) => a.type === opposite))
+                                continue;
+                        }
+                        else if (key === "string" &&
+                            ((_a = value[0]) === null || _a === void 0 ? void 0 : _a.kind) === "format" &&
+                            ((_b = value[0]) === null || _b === void 0 ? void 0 : _b.value) === "date-time")
+                            continue;
+                        else
+                            report(`requires ${key} type`);
+                    else {
+                        (0, Writable_1.Writable)(atomic).tags = atomic.tags.filter((x) => MetadataTypeTagFactory_1.MetadataTypeTagFactory.validate({
+                            report: validateReport,
+                            type: key,
+                            tags: [...x, ...filtered],
+                        }));
+                        if (atomic.tags.length === 0)
+                            atomic.tags.push(filtered);
+                        else
+                            for (const tags of atomic.tags)
+                                tags.push(...filtered);
                     }
-                    finally { if (e_2) throw e_2.error; }
                 }
             }
         }
-        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,
+                messages,
             });
     };
-    var parse = function (props) {
+    const parse = (props) => {
         var _a;
-        var next = PARSER[props.tag.name];
+        const next = PARSER[props.tag.name];
         if (next === undefined)
             return {};
-        var value = (_a = (props.tag.text || [])[0]) === null || _a === void 0 ? void 0 : _a.text;
+        const 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 props.report(`no comment tag value`);
         return next({
             report: props.report,
             value: value,
         });
     };
-    MetadataCommentTagFactory.get = function (props) {
+    MetadataCommentTagFactory.get = (props) => {
         var _a, _b;
-        var output = (_b = (_a = PARSER[props.kind]) === null || _a === void 0 ? void 0 : _a.call(PARSER, {
-            report: function () { return null; },
+        const output = (_b = (_a = PARSER[props.kind]) === null || _a === void 0 ? void 0 : _a.call(PARSER, {
+            report: () => null,
             value: props.value,
         })) === null || _b === void 0 ? void 0 : _b[props.type];
         if (output === undefined)
-            throw new Error("no tag found for (kind: ".concat(props.kind, ", type: ").concat(props.type, ")."));
+            throw new Error(`no tag found for (kind: ${props.kind}, type: ${props.type}).`);
         return output;
     };
 })(MetadataCommentTagFactory || (exports.MetadataCommentTagFactory = MetadataCommentTagFactory = {}));
 /**
  * @internal
  */
-var PARSER = {
+const PARSER = {
     /* -----------------------------------------------------------
           ARRAY
       ----------------------------------------------------------- */
-    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,
+    items: ({ report, value }) => ({
+        array: [
+            {
+                name: `MinItems<${value}>`,
+                target: "array",
+                kind: "minItems",
+                value: parse_integer({
+                    report,
+                    value,
+                    unsigned: true,
+                }),
+                validate: `${value} <= $input.length`,
+                exclusive: true,
+                schema: {
+                    minItems: parse_integer({
+                        report,
+                        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: report,
-                        value: value,
+            },
+            {
+                name: `MaxItems<${value}>`,
+                target: "array",
+                kind: "maxItems",
+                value: parse_integer({
+                    report,
+                    value,
+                    unsigned: true,
+                }),
+                validate: `$input.length <= ${value}`,
+                exclusive: true,
+                schema: {
+                    maxItems: parse_integer({
+                        report,
                         unsigned: true,
+                        value,
                     }),
-                    validate: "$input.length <= ".concat(value),
-                    exclusive: true,
-                    schema: {
-                        maxItems: parse_integer({
-                            report: report,
-                            unsigned: true,
-                            value: 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,
+            },
+        ],
+    }),
+    minItems: ({ report, value }) => ({
+        array: [
+            {
+                name: `MinItems<${value}>`,
+                target: "array",
+                kind: "minItems",
+                value: parse_integer({
+                    report,
+                    value,
+                    unsigned: true,
+                }),
+                validate: `${value} <= $input.length`,
+                exclusive: true,
+                schema: {
+                    minItems: parse_integer({
+                        report,
+                        value,
                         unsigned: true,
                     }),
-                    validate: "".concat(value, " <= $input.length"),
-                    exclusive: true,
-                    schema: {
-                        minItems: parse_integer({
-                            report: report,
-                            value: value,
-                            unsigned: true,
-                        }),
-                    },
                 },
-            ],
-        });
-    },
-    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,
+            },
+        ],
+    }),
+    maxItems: ({ report, value }) => ({
+        array: [
+            {
+                name: `MaxItems<${value}>`,
+                target: "array",
+                kind: "maxItems",
+                value: parse_integer({
+                    report,
+                    value,
+                    unsigned: true,
+                }),
+                validate: `$input.length <= ${value}`,
+                exclusive: true,
+                schema: {
+                    maxItems: parse_integer({
+                        report,
+                        value,
                         unsigned: true,
                     }),
-                    validate: "$input.length <= ".concat(value),
-                    exclusive: true,
-                    schema: {
-                        maxItems: parse_integer({
-                            report: report,
-                            value: value,
-                            unsigned: true,
-                        }),
-                    },
                 },
-            ],
-        });
-    },
-    uniqueItems: function () { return ({
+            },
+        ],
+    }),
+    uniqueItems: () => ({
         array: [
             {
-                name: "UniqueItems",
+                name: `UniqueItems`,
                 target: "array",
                 kind: "uniqueItems",
                 value: true,
-                validate: "$input.length <= 1 || (new Set($input).size === $input.length)",
+                validate: `$input.length <= 1 || (new Set($input).size === $input.length)`,
                 exclusive: true,
                 schema: {
                     uniqueItems: true,
                 },
             },
         ],
-    }); },
+    }),
     /* -----------------------------------------------------------
           NUMBER
       ----------------------------------------------------------- */
-    type: function (_a) {
-        var value = _a.value;
+    type: ({ value }) => {
         // EMENDATIONS
         if (value.startsWith("{") && value.endsWith("}"))
             value = value.substring(1, value.length - 1);
@@ -347,21 +240,21 @@ var PARSER = {
         return {
             number: [
                 {
-                    name: "Type<".concat(JSON.stringify(value), ">"),
+                    name: `Type<${JSON.stringify(value)}>`,
                     target: "number",
                     kind: "type",
                     value: value,
                     validate: value === "int32"
-                        ? "Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647"
+                        ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
                         : value === "uint32"
-                            ? "Math.floor($input) === $input && 0 <= $input && $input <= 4294967295"
+                            ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
                             : value === "int64"
-                                ? "Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807"
+                                ? `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`
                                 : value === "uint64"
-                                    ? "Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615"
+                                    ? `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`
                                     : value === "float"
-                                        ? "-1.175494351e38 <= $input && $input <= 3.4028235e38"
-                                        : "true",
+                                        ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+                                        : `true`,
                     exclusive: true,
                     schema: ["int32", "uint32", "int64", "uint64"].includes(value)
                         ? { type: "integer" }
@@ -371,7 +264,7 @@ var PARSER = {
             bigint: value === "int64" || "uint64"
                 ? [
                     {
-                        name: "Type<".concat(JSON.stringify(value), ">"),
+                        name: `Type<${JSON.stringify(value)}>`,
                         target: "bigint",
                         kind: "type",
                         value: value,
@@ -383,14 +276,14 @@ var PARSER = {
                 : [],
         };
     },
-    minimum: function (props) { return ({
+    minimum: (props) => ({
         number: [
             {
-                name: "Minimum<".concat(props.value, ">"),
+                name: `Minimum<${props.value}>`,
                 target: "number",
                 kind: "minimum",
                 value: parse_number(props),
-                validate: "".concat(props.value, " <= $input"),
+                validate: `${props.value} <= $input`,
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     minimum: parse_number(props),
@@ -399,33 +292,33 @@ var PARSER = {
         ],
         bigint: [
             {
-                name: "Minimum<".concat(props.value, "n>"),
+                name: `Minimum<${props.value}n>`,
                 target: "bigint",
                 kind: "minimum",
-                value: (function () {
-                    var parsed = parse_integer({
+                value: (() => {
+                    const parsed = parse_integer({
                         report: props.report,
                         value: props.value,
                         unsigned: false,
                     });
                     return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(props.value, " <= $input"),
+                validate: `${props.value} <= $input`,
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     minimum: parse_number(props),
                 },
             },
         ],
-    }); },
-    maximum: function (props) { return ({
+    }),
+    maximum: (props) => ({
         number: [
             {
-                name: "Maximum<".concat(props.value, ">"),
+                name: `Maximum<${props.value}>`,
                 target: "number",
                 kind: "maximum",
                 value: parse_number(props),
-                validate: "$input <= ".concat(props.value),
+                validate: `$input <= ${props.value}`,
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     maximum: parse_number(props),
@@ -434,33 +327,33 @@ var PARSER = {
         ],
         bigint: [
             {
-                name: "Maximum<".concat(props.value, "n>"),
+                name: `Maximum<${props.value}n>`,
                 target: "bigint",
                 kind: "maximum",
-                value: (function () {
-                    var parsed = parse_integer({
+                value: (() => {
+                    const parsed = parse_integer({
                         report: props.report,
                         value: props.value,
                         unsigned: false,
                     });
                     return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input <= ".concat(props.value),
+                validate: `$input <= ${props.value}`,
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     maximum: parse_number(props),
                 },
             },
         ],
-    }); },
-    exclusiveMinimum: function (props) { return ({
+    }),
+    exclusiveMinimum: (props) => ({
         number: [
             {
-                name: "ExclusiveMinimum<".concat(props.value, ">"),
+                name: `ExclusiveMinimum<${props.value}>`,
                 target: "number",
                 kind: "exclusiveMinimum",
                 value: parse_number(props),
-                validate: "".concat(props.value, " < $input"),
+                validate: `${props.value} < $input`,
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     exclusiveMinimum: true,
@@ -470,18 +363,18 @@ var PARSER = {
         ],
         bigint: [
             {
-                name: "ExclusiveMinimum<".concat(props.value, "n>"),
+                name: `ExclusiveMinimum<${props.value}n>`,
                 target: "bigint",
                 kind: "exclusiveMinimum",
-                value: (function () {
-                    var parsed = parse_integer({
+                value: (() => {
+                    const parsed = parse_integer({
                         report: props.report,
                         value: props.value,
                         unsigned: false,
                     });
                     return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(props.value, " < $input"),
+                validate: `${props.value} < $input`,
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     exclusiveMinimum: true,
@@ -489,15 +382,15 @@ var PARSER = {
                 },
             },
         ],
-    }); },
-    exclusiveMaximum: function (props) { return ({
+    }),
+    exclusiveMaximum: (props) => ({
         number: [
             {
-                name: "ExclusiveMaximum<".concat(props.value, ">"),
+                name: `ExclusiveMaximum<${props.value}>`,
                 target: "number",
                 kind: "exclusiveMaximum",
                 value: parse_number(props),
-                validate: "$input < ".concat(props.value),
+                validate: `$input < ${props.value}`,
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     exclusiveMaximum: true,
@@ -507,18 +400,18 @@ var PARSER = {
         ],
         bigint: [
             {
-                name: "ExclusiveMaximum<".concat(props.value, "n>"),
+                name: `ExclusiveMaximum<${props.value}n>`,
                 target: "bigint",
                 kind: "exclusiveMaximum",
-                value: (function () {
-                    var parsed = parse_integer({
+                value: (() => {
+                    const parsed = parse_integer({
                         report: props.report,
                         value: props.value,
                         unsigned: false,
                     });
                     return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input < ".concat(props.value),
+                validate: `$input < ${props.value}`,
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     exclusiveMaximum: true,
@@ -526,15 +419,15 @@ var PARSER = {
                 },
             },
         ],
-    }); },
-    multipleOf: function (props) { return ({
+    }),
+    multipleOf: (props) => ({
         number: [
             {
-                name: "MultipleOf<".concat(props.value, ">"),
+                name: `MultipleOf<${props.value}>`,
                 target: "number",
                 kind: "multipleOf",
                 value: parse_number(props),
-                validate: "$input % ".concat(props.value, " === 0"),
+                validate: `$input % ${props.value} === 0`,
                 exclusive: true,
                 schema: {
                     multipleOf: parse_number(props),
@@ -543,37 +436,36 @@ var PARSER = {
         ],
         bigint: [
             {
-                name: "MultipleOf<".concat(props.value, "n>"),
+                name: `MultipleOf<${props.value}n>`,
                 target: "bigint",
                 kind: "multipleOf",
-                value: (function () {
-                    var parsed = parse_integer({
+                value: (() => {
+                    const parsed = parse_integer({
                         report: props.report,
                         value: props.value,
                         unsigned: false,
                     });
                     return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input % ".concat(props.value, "n === 0n"),
+                validate: `$input % ${props.value}n === 0n`,
                 exclusive: true,
                 schema: {
                     multipleOf: parse_number(props),
                 },
             },
         ],
-    }); },
+    }),
     /* -----------------------------------------------------------
           STRING
       ----------------------------------------------------------- */
-    format: function (_a) {
-        var value = _a.value;
-        var matched = FORMATS.get(value);
+    format: ({ value }) => {
+        const matched = FORMATS.get(value);
         if (matched === undefined)
             return {};
         return {
             string: [
                 {
-                    name: "Format<".concat(JSON.stringify(matched[0]), ">"),
+                    name: `Format<${JSON.stringify(matched[0])}>`,
                     target: "string",
                     kind: "format",
                     value: matched[0],
@@ -586,117 +478,106 @@ var PARSER = {
             ],
         };
     },
-    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,
-                    },
+    pattern: ({ value }) => ({
+        string: [
+            {
+                name: `Pattern<${JSON.stringify(value)}>`,
+                target: "string",
+                kind: "pattern",
+                value: value,
+                validate: `RegExp(${JSON.stringify(value)}).test($input)`,
+                exclusive: ["format"],
+                schema: {
+                    pattern: value,
                 },
-            ],
-        });
-    },
-    length: function (props) { return ({
+            },
+        ],
+    }),
+    length: (props) => ({
         string: [
             {
-                name: "MinLength<".concat(props.value, ">"),
+                name: `MinLength<${props.value}>`,
                 target: "string",
                 kind: "minLength",
                 value: parse_number(props),
-                validate: "".concat(props.value, " <= $input.length"),
+                validate: `${props.value} <= $input.length`,
                 exclusive: true,
                 schema: {
                     minLength: parse_number(props),
                 },
             },
             {
-                name: "MaxLength<".concat(props.value, ">"),
+                name: `MaxLength<${props.value}>`,
                 target: "string",
                 kind: "maxLength",
                 value: parse_number(props),
-                validate: "$input.length <= ".concat(props.value),
+                validate: `$input.length <= ${props.value}`,
                 exclusive: true,
                 schema: {
                     maxLength: parse_number(props),
                 },
             },
         ],
-    }); },
-    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 }),
-                    },
+    }),
+    minLength: ({ report, value }) => ({
+        string: [
+            {
+                name: `MinLength<${value}>`,
+                target: "string",
+                kind: "minLength",
+                value: parse_number({ report, value }),
+                validate: `${value} <= $input.length`,
+                exclusive: true,
+                schema: {
+                    minLength: 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 }),
-                    },
+            },
+        ],
+    }),
+    maxLength: ({ report, value }) => ({
+        string: [
+            {
+                name: `MaxLength<${value}>`,
+                target: "string",
+                kind: "maxLength",
+                value: parse_number({ report, value }),
+                validate: `$input.length <= ${value}`,
+                exclusive: true,
+                schema: {
+                    maxLength: parse_number({ report, value }),
                 },
-            ],
-        });
-    },
+            },
+        ],
+    }),
 };
 /**
  * @internal
  */
-var parse_number = function (props) {
-    var parsed = Number(props.value);
+const parse_number = (props) => {
+    const parsed = Number(props.value);
     if (isNaN(parsed) === true)
-        return props.report("invalid number");
+        return props.report(`invalid number`);
     return parsed;
 };
 /**
  * @internal
  */
-var parse_integer = function (props) {
-    var parsed = parse_number(props);
+const parse_integer = (props) => {
+    const parsed = parse_number(props);
     if (parsed === null)
         return null;
     else if (Math.floor(parsed) !== parsed)
-        return props.report("invalid integer");
+        return props.report(`invalid integer`);
     else if (props.unsigned === true && parsed < 0)
-        return props.report("invalid unsigned integer");
+        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]];
-})), false), [
-    ["datetime", ["date-time", "!isNaN(new Date($input).getTime())"]],
-    ["dateTime", ["date-time", "!isNaN(new Date($input).getTime())"]],
-], false));
+const FORMATS = new Map([
+    ...Object.entries(FormatCheatSheet_1.FormatCheatSheet).map(([key, value]) => [key, [key, value]]),
+    ["datetime", ["date-time", `!isNaN(new Date($input).getTime())`]],
+    ["dateTime", ["date-time", `!isNaN(new Date($input).getTime())`]],
+]);
 //# sourceMappingURL=MetadataCommentTagFactory.js.map