@sjcrh/proteinpaint-types 2.86.0 → 2.87.1

package/dist/chunk-Z6B6IQIY.js

@@ -0,0 +1,1785 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/typia/lib/functional/$dictionary.js
+var require_dictionary = __commonJS({
+  "../../node_modules/typia/lib/functional/$dictionary.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$dictionary = void 0;
+    var blackhole = {};
+    exports.$dictionary = function() {
+      var _a;
+      var glob = typeof global === "object" && typeof global.process === "object" && typeof global.process.versions === "object" && typeof global.process.versions.node !== "undefined" ? global !== null && global !== void 0 ? global : blackhole : self !== null && self !== void 0 ? self : blackhole;
+      return (_a = glob.__typia_custom_validator) !== null && _a !== void 0 ? _a : glob.__typia_custom_validator = /* @__PURE__ */ new Map();
+    }();
+  }
+});
+
+// ../../node_modules/ret/lib/types.js
+var require_types = __commonJS({
+  "../../node_modules/ret/lib/types.js"(exports, module) {
+    module.exports = {
+      ROOT: 0,
+      GROUP: 1,
+      POSITION: 2,
+      SET: 3,
+      RANGE: 4,
+      REPETITION: 5,
+      REFERENCE: 6,
+      CHAR: 7
+    };
+  }
+});
+
+// ../../node_modules/ret/lib/sets.js
+var require_sets = __commonJS({
+  "../../node_modules/ret/lib/sets.js"(exports) {
+    var types = require_types();
+    var INTS = () => [{ type: types.RANGE, from: 48, to: 57 }];
+    var WORDS = () => {
+      return [
+        { type: types.CHAR, value: 95 },
+        { type: types.RANGE, from: 97, to: 122 },
+        { type: types.RANGE, from: 65, to: 90 }
+      ].concat(INTS());
+    };
+    var WHITESPACE = () => {
+      return [
+        { type: types.CHAR, value: 9 },
+        { type: types.CHAR, value: 10 },
+        { type: types.CHAR, value: 11 },
+        { type: types.CHAR, value: 12 },
+        { type: types.CHAR, value: 13 },
+        { type: types.CHAR, value: 32 },
+        { type: types.CHAR, value: 160 },
+        { type: types.CHAR, value: 5760 },
+        { type: types.RANGE, from: 8192, to: 8202 },
+        { type: types.CHAR, value: 8232 },
+        { type: types.CHAR, value: 8233 },
+        { type: types.CHAR, value: 8239 },
+        { type: types.CHAR, value: 8287 },
+        { type: types.CHAR, value: 12288 },
+        { type: types.CHAR, value: 65279 }
+      ];
+    };
+    var NOTANYCHAR = () => {
+      return [
+        { type: types.CHAR, value: 10 },
+        { type: types.CHAR, value: 13 },
+        { type: types.CHAR, value: 8232 },
+        { type: types.CHAR, value: 8233 }
+      ];
+    };
+    exports.words = () => ({ type: types.SET, set: WORDS(), not: false });
+    exports.notWords = () => ({ type: types.SET, set: WORDS(), not: true });
+    exports.ints = () => ({ type: types.SET, set: INTS(), not: false });
+    exports.notInts = () => ({ type: types.SET, set: INTS(), not: true });
+    exports.whitespace = () => ({ type: types.SET, set: WHITESPACE(), not: false });
+    exports.notWhitespace = () => ({ type: types.SET, set: WHITESPACE(), not: true });
+    exports.anyChar = () => ({ type: types.SET, set: NOTANYCHAR(), not: true });
+  }
+});
+
+// ../../node_modules/ret/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/ret/lib/util.js"(exports) {
+    var types = require_types();
+    var sets = require_sets();
+    var CTRL = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?";
+    var SLSH = { "0": 0, "t": 9, "n": 10, "v": 11, "f": 12, "r": 13 };
+    exports.strToChars = function(str) {
+      var chars_regex = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g;
+      str = str.replace(chars_regex, function(s, b, lbs, a16, b16, c8, dctrl, eslsh) {
+        if (lbs) {
+          return s;
+        }
+        var code = b ? 8 : a16 ? parseInt(a16, 16) : b16 ? parseInt(b16, 16) : c8 ? parseInt(c8, 8) : dctrl ? CTRL.indexOf(dctrl) : SLSH[eslsh];
+        var c = String.fromCharCode(code);
+        if (/[[\]{}^$.|?*+()]/.test(c)) {
+          c = "\\" + c;
+        }
+        return c;
+      });
+      return str;
+    };
+    exports.tokenizeClass = (str, regexpStr) => {
+      var tokens = [];
+      var regexp = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?([^])/g;
+      var rs, c;
+      while ((rs = regexp.exec(str)) != null) {
+        if (rs[1]) {
+          tokens.push(sets.words());
+        } else if (rs[2]) {
+          tokens.push(sets.ints());
+        } else if (rs[3]) {
+          tokens.push(sets.whitespace());
+        } else if (rs[4]) {
+          tokens.push(sets.notWords());
+        } else if (rs[5]) {
+          tokens.push(sets.notInts());
+        } else if (rs[6]) {
+          tokens.push(sets.notWhitespace());
+        } else if (rs[7]) {
+          tokens.push({
+            type: types.RANGE,
+            from: (rs[8] || rs[9]).charCodeAt(0),
+            to: rs[10].charCodeAt(0)
+          });
+        } else if (c = rs[12]) {
+          tokens.push({
+            type: types.CHAR,
+            value: c.charCodeAt(0)
+          });
+        } else {
+          return [tokens, regexp.lastIndex];
+        }
+      }
+      exports.error(regexpStr, "Unterminated character class");
+    };
+    exports.error = (regexp, msg) => {
+      throw new SyntaxError("Invalid regular expression: /" + regexp + "/: " + msg);
+    };
+  }
+});
+
+// ../../node_modules/ret/lib/positions.js
+var require_positions = __commonJS({
+  "../../node_modules/ret/lib/positions.js"(exports) {
+    var types = require_types();
+    exports.wordBoundary = () => ({ type: types.POSITION, value: "b" });
+    exports.nonWordBoundary = () => ({ type: types.POSITION, value: "B" });
+    exports.begin = () => ({ type: types.POSITION, value: "^" });
+    exports.end = () => ({ type: types.POSITION, value: "$" });
+  }
+});
+
+// ../../node_modules/ret/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/ret/lib/index.js"(exports, module) {
+    var util = require_util();
+    var types = require_types();
+    var sets = require_sets();
+    var positions = require_positions();
+    module.exports = (regexpStr) => {
+      var i = 0, l, c, start = { type: types.ROOT, stack: [] }, lastGroup = start, last = start.stack, groupStack = [];
+      var repeatErr = (i2) => {
+        util.error(regexpStr, `Nothing to repeat at column ${i2 - 1}`);
+      };
+      var str = util.strToChars(regexpStr);
+      l = str.length;
+      while (i < l) {
+        c = str[i++];
+        switch (c) {
+          case "\\":
+            c = str[i++];
+            switch (c) {
+              case "b":
+                last.push(positions.wordBoundary());
+                break;
+              case "B":
+                last.push(positions.nonWordBoundary());
+                break;
+              case "w":
+                last.push(sets.words());
+                break;
+              case "W":
+                last.push(sets.notWords());
+                break;
+              case "d":
+                last.push(sets.ints());
+                break;
+              case "D":
+                last.push(sets.notInts());
+                break;
+              case "s":
+                last.push(sets.whitespace());
+                break;
+              case "S":
+                last.push(sets.notWhitespace());
+                break;
+              default:
+                if (/\d/.test(c)) {
+                  last.push({ type: types.REFERENCE, value: parseInt(c, 10) });
+                } else {
+                  last.push({ type: types.CHAR, value: c.charCodeAt(0) });
+                }
+            }
+            break;
+          case "^":
+            last.push(positions.begin());
+            break;
+          case "$":
+            last.push(positions.end());
+            break;
+          case "[":
+            var not;
+            if (str[i] === "^") {
+              not = true;
+              i++;
+            } else {
+              not = false;
+            }
+            var classTokens = util.tokenizeClass(str.slice(i), regexpStr);
+            i += classTokens[1];
+            last.push({
+              type: types.SET,
+              set: classTokens[0],
+              not
+            });
+            break;
+          case ".":
+            last.push(sets.anyChar());
+            break;
+          case "(":
+            var group = {
+              type: types.GROUP,
+              stack: [],
+              remember: true
+            };
+            c = str[i];
+            if (c === "?") {
+              c = str[i + 1];
+              i += 2;
+              if (c === "=") {
+                group.followedBy = true;
+              } else if (c === "!") {
+                group.notFollowedBy = true;
+              } else if (c !== ":") {
+                util.error(
+                  regexpStr,
+                  `Invalid group, character '${c}' after '?' at column ${i - 1}`
+                );
+              }
+              group.remember = false;
+            }
+            last.push(group);
+            groupStack.push(lastGroup);
+            lastGroup = group;
+            last = group.stack;
+            break;
+          case ")":
+            if (groupStack.length === 0) {
+              util.error(regexpStr, `Unmatched ) at column ${i - 1}`);
+            }
+            lastGroup = groupStack.pop();
+            last = lastGroup.options ? lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
+            break;
+          case "|":
+            if (!lastGroup.options) {
+              lastGroup.options = [lastGroup.stack];
+              delete lastGroup.stack;
+            }
+            var stack = [];
+            lastGroup.options.push(stack);
+            last = stack;
+            break;
+          case "{":
+            var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), min, max;
+            if (rs !== null) {
+              if (last.length === 0) {
+                repeatErr(i);
+              }
+              min = parseInt(rs[1], 10);
+              max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
+              i += rs[0].length;
+              last.push({
+                type: types.REPETITION,
+                min,
+                max,
+                value: last.pop()
+              });
+            } else {
+              last.push({
+                type: types.CHAR,
+                value: 123
+              });
+            }
+            break;
+          case "?":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types.REPETITION,
+              min: 0,
+              max: 1,
+              value: last.pop()
+            });
+            break;
+          case "+":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types.REPETITION,
+              min: 1,
+              max: Infinity,
+              value: last.pop()
+            });
+            break;
+          case "*":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types.REPETITION,
+              min: 0,
+              max: Infinity,
+              value: last.pop()
+            });
+            break;
+          default:
+            last.push({
+              type: types.CHAR,
+              value: c.charCodeAt(0)
+            });
+        }
+      }
+      if (groupStack.length !== 0) {
+        util.error(regexpStr, "Unterminated group");
+      }
+      return start;
+    };
+    module.exports.types = types;
+  }
+});
+
+// ../../node_modules/drange/lib/index.js
+var require_lib2 = __commonJS({
+  "../../node_modules/drange/lib/index.js"(exports, module) {
+    "use strict";
+    var SubRange = class _SubRange {
+      constructor(low, high) {
+        this.low = low;
+        this.high = high;
+        this.length = 1 + high - low;
+      }
+      overlaps(range) {
+        return !(this.high < range.low || this.low > range.high);
+      }
+      touches(range) {
+        return !(this.high + 1 < range.low || this.low - 1 > range.high);
+      }
+      // Returns inclusive combination of SubRanges as a SubRange.
+      add(range) {
+        return new _SubRange(
+          Math.min(this.low, range.low),
+          Math.max(this.high, range.high)
+        );
+      }
+      // Returns subtraction of SubRanges as an array of SubRanges.
+      // (There's a case where subtraction divides it in 2)
+      subtract(range) {
+        if (range.low <= this.low && range.high >= this.high) {
+          return [];
+        } else if (range.low > this.low && range.high < this.high) {
+          return [
+            new _SubRange(this.low, range.low - 1),
+            new _SubRange(range.high + 1, this.high)
+          ];
+        } else if (range.low <= this.low) {
+          return [new _SubRange(range.high + 1, this.high)];
+        } else {
+          return [new _SubRange(this.low, range.low - 1)];
+        }
+      }
+      toString() {
+        return this.low == this.high ? this.low.toString() : this.low + "-" + this.high;
+      }
+    };
+    var DRange = class _DRange {
+      constructor(a, b) {
+        this.ranges = [];
+        this.length = 0;
+        if (a != null)
+          this.add(a, b);
+      }
+      _update_length() {
+        this.length = this.ranges.reduce((previous, range) => {
+          return previous + range.length;
+        }, 0);
+      }
+      add(a, b) {
+        var _add = (subrange) => {
+          var i = 0;
+          while (i < this.ranges.length && !subrange.touches(this.ranges[i])) {
+            i++;
+          }
+          var newRanges = this.ranges.slice(0, i);
+          while (i < this.ranges.length && subrange.touches(this.ranges[i])) {
+            subrange = subrange.add(this.ranges[i]);
+            i++;
+          }
+          newRanges.push(subrange);
+          this.ranges = newRanges.concat(this.ranges.slice(i));
+          this._update_length();
+        };
+        if (a instanceof _DRange) {
+          a.ranges.forEach(_add);
+        } else {
+          if (b == null)
+            b = a;
+          _add(new SubRange(a, b));
+        }
+        return this;
+      }
+      subtract(a, b) {
+        var _subtract = (subrange) => {
+          var i = 0;
+          while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) {
+            i++;
+          }
+          var newRanges = this.ranges.slice(0, i);
+          while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) {
+            newRanges = newRanges.concat(this.ranges[i].subtract(subrange));
+            i++;
+          }
+          this.ranges = newRanges.concat(this.ranges.slice(i));
+          this._update_length();
+        };
+        if (a instanceof _DRange) {
+          a.ranges.forEach(_subtract);
+        } else {
+          if (b == null)
+            b = a;
+          _subtract(new SubRange(a, b));
+        }
+        return this;
+      }
+      intersect(a, b) {
+        var newRanges = [];
+        var _intersect = (subrange) => {
+          var i = 0;
+          while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) {
+            i++;
+          }
+          while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) {
+            var low = Math.max(this.ranges[i].low, subrange.low);
+            var high = Math.min(this.ranges[i].high, subrange.high);
+            newRanges.push(new SubRange(low, high));
+            i++;
+          }
+        };
+        if (a instanceof _DRange) {
+          a.ranges.forEach(_intersect);
+        } else {
+          if (b == null)
+            b = a;
+          _intersect(new SubRange(a, b));
+        }
+        this.ranges = newRanges;
+        this._update_length();
+        return this;
+      }
+      index(index) {
+        var i = 0;
+        while (i < this.ranges.length && this.ranges[i].length <= index) {
+          index -= this.ranges[i].length;
+          i++;
+        }
+        return this.ranges[i].low + index;
+      }
+      toString() {
+        return "[ " + this.ranges.join(", ") + " ]";
+      }
+      clone() {
+        return new _DRange(this);
+      }
+      numbers() {
+        return this.ranges.reduce((result, subrange) => {
+          var i = subrange.low;
+          while (i <= subrange.high) {
+            result.push(i);
+            i++;
+          }
+          return result;
+        }, []);
+      }
+      subranges() {
+        return this.ranges.map((subrange) => ({
+          low: subrange.low,
+          high: subrange.high,
+          length: 1 + subrange.high - subrange.low
+        }));
+      }
+    };
+    module.exports = DRange;
+  }
+});
+
+// ../../node_modules/randexp/lib/randexp.js
+var require_randexp = __commonJS({
+  "../../node_modules/randexp/lib/randexp.js"(exports, module) {
+    var ret = require_lib();
+    var DRange = require_lib2();
+    var types = ret.types;
+    module.exports = class RandExp {
+      /**
+       * @constructor
+       * @param {RegExp|String} regexp
+       * @param {String} m
+       */
+      constructor(regexp, m) {
+        this._setDefaults(regexp);
+        if (regexp instanceof RegExp) {
+          this.ignoreCase = regexp.ignoreCase;
+          this.multiline = regexp.multiline;
+          regexp = regexp.source;
+        } else if (typeof regexp === "string") {
+          this.ignoreCase = m && m.indexOf("i") !== -1;
+          this.multiline = m && m.indexOf("m") !== -1;
+        } else {
+          throw new Error("Expected a regexp or string");
+        }
+        this.tokens = ret(regexp);
+      }
+      /**
+       * Checks if some custom properties have been set for this regexp.
+       *
+       * @param {RandExp} randexp
+       * @param {RegExp} regexp
+       */
+      _setDefaults(regexp) {
+        this.max = regexp.max != null ? regexp.max : RandExp.prototype.max != null ? RandExp.prototype.max : 100;
+        this.defaultRange = regexp.defaultRange ? regexp.defaultRange : this.defaultRange.clone();
+        if (regexp.randInt) {
+          this.randInt = regexp.randInt;
+        }
+      }
+      /**
+       * Generates the random string.
+       *
+       * @return {String}
+       */
+      gen() {
+        return this._gen(this.tokens, []);
+      }
+      /**
+       * Generate random string modeled after given tokens.
+       *
+       * @param {Object} token
+       * @param {Array.<String>} groups
+       * @return {String}
+       */
+      _gen(token, groups) {
+        var stack, str, n, i, l;
+        switch (token.type) {
+          case types.ROOT:
+          case types.GROUP:
+            if (token.followedBy || token.notFollowedBy) {
+              return "";
+            }
+            if (token.remember && token.groupNumber === void 0) {
+              token.groupNumber = groups.push(null) - 1;
+            }
+            stack = token.options ? this._randSelect(token.options) : token.stack;
+            str = "";
+            for (i = 0, l = stack.length; i < l; i++) {
+              str += this._gen(stack[i], groups);
+            }
+            if (token.remember) {
+              groups[token.groupNumber] = str;
+            }
+            return str;
+          case types.POSITION:
+            return "";
+          case types.SET:
+            var expandedSet = this._expand(token);
+            if (!expandedSet.length) {
+              return "";
+            }
+            return String.fromCharCode(this._randSelect(expandedSet));
+          case types.REPETITION:
+            n = this.randInt(
+              token.min,
+              token.max === Infinity ? token.min + this.max : token.max
+            );
+            str = "";
+            for (i = 0; i < n; i++) {
+              str += this._gen(token.value, groups);
+            }
+            return str;
+          case types.REFERENCE:
+            return groups[token.value - 1] || "";
+          case types.CHAR:
+            var code = this.ignoreCase && this._randBool() ? this._toOtherCase(token.value) : token.value;
+            return String.fromCharCode(code);
+        }
+      }
+      /**
+       * If code is alphabetic, converts to other case.
+       * If not alphabetic, returns back code.
+       *
+       * @param {Number} code
+       * @return {Number}
+       */
+      _toOtherCase(code) {
+        return code + (97 <= code && code <= 122 ? -32 : 65 <= code && code <= 90 ? 32 : 0);
+      }
+      /**
+       * Randomly returns a true or false value.
+       *
+       * @return {Boolean}
+       */
+      _randBool() {
+        return !this.randInt(0, 1);
+      }
+      /**
+       * Randomly selects and returns a value from the array.
+       *
+       * @param {Array.<Object>} arr
+       * @return {Object}
+       */
+      _randSelect(arr) {
+        if (arr instanceof DRange) {
+          return arr.index(this.randInt(0, arr.length - 1));
+        }
+        return arr[this.randInt(0, arr.length - 1)];
+      }
+      /**
+       * expands a token to a DiscontinuousRange of characters which has a
+       * length and an index function (for random selecting)
+       *
+       * @param {Object} token
+       * @return {DiscontinuousRange}
+       */
+      _expand(token) {
+        if (token.type === ret.types.CHAR) {
+          return new DRange(token.value);
+        } else if (token.type === ret.types.RANGE) {
+          return new DRange(token.from, token.to);
+        } else {
+          let drange = new DRange();
+          for (let i = 0; i < token.set.length; i++) {
+            let subrange = this._expand(token.set[i]);
+            drange.add(subrange);
+            if (this.ignoreCase) {
+              for (let j = 0; j < subrange.length; j++) {
+                let code = subrange.index(j);
+                let otherCaseCode = this._toOtherCase(code);
+                if (code !== otherCaseCode) {
+                  drange.add(otherCaseCode);
+                }
+              }
+            }
+          }
+          if (token.not) {
+            return this.defaultRange.clone().subtract(drange);
+          } else {
+            return this.defaultRange.clone().intersect(drange);
+          }
+        }
+      }
+      /**
+       * Randomly generates and returns a number between a and b (inclusive).
+       *
+       * @param {Number} a
+       * @param {Number} b
+       * @return {Number}
+       */
+      randInt(a, b) {
+        return a + Math.floor(Math.random() * (1 + b - a));
+      }
+      /**
+       * Default range of characters to generate from.
+       */
+      get defaultRange() {
+        return this._range = this._range || new DRange(32, 126);
+      }
+      set defaultRange(range) {
+        this._range = range;
+      }
+      /**
+       *
+       * Enables use of randexp with a shorter call.
+       *
+       * @param {RegExp|String| regexp}
+       * @param {String} m
+       * @return {String}
+       */
+      static randexp(regexp, m) {
+        var randexp;
+        if (typeof regexp === "string") {
+          regexp = new RegExp(regexp, m);
+        }
+        if (regexp._randexp === void 0) {
+          randexp = new RandExp(regexp, m);
+          regexp._randexp = randexp;
+        } else {
+          randexp = regexp._randexp;
+          randexp._setDefaults(regexp);
+        }
+        return randexp.gen();
+      }
+      /**
+       * Enables sugary /regexp/.gen syntax.
+       */
+      static sugar() {
+        RegExp.prototype.gen = function() {
+          return RandExp.randexp(this);
+        };
+      }
+    };
+  }
+});
+
+// ../../node_modules/typia/lib/utils/RandomGenerator.js
+var require_RandomGenerator = __commonJS({
+  "../../node_modules/typia/lib/utils/RandomGenerator.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RandomGenerator = void 0;
+    var randexp_1 = __importDefault(require_randexp());
+    var RandomGenerator;
+    (function(RandomGenerator2) {
+      var ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+      RandomGenerator2.boolean = function() {
+        return Math.random() < 0.5;
+      };
+      RandomGenerator2.integer = function(min, max) {
+        min !== null && min !== void 0 ? min : min = 0;
+        max !== null && max !== void 0 ? max : max = 100;
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+      };
+      RandomGenerator2.bigint = function(min, max) {
+        min !== null && min !== void 0 ? min : min = BigInt(0);
+        max !== null && max !== void 0 ? max : max = BigInt(100);
+        return BigInt(RandomGenerator2.integer(Number(min), Number(max)));
+      };
+      RandomGenerator2.number = function(min, max) {
+        min !== null && min !== void 0 ? min : min = 0;
+        max !== null && max !== void 0 ? max : max = 100;
+        return Math.random() * (max - min) + min;
+      };
+      RandomGenerator2.string = function(length) {
+        return new Array(length !== null && length !== void 0 ? length : RandomGenerator2.integer(5, 10)).fill(0).map(function() {
+          return ALPHABETS[RandomGenerator2.integer(0, ALPHABETS.length - 1)];
+        }).join("");
+      };
+      RandomGenerator2.array = function(closure, count) {
+        return new Array(count !== null && count !== void 0 ? count : RandomGenerator2.length()).fill(0).map(function(_e, index) {
+          return closure(index);
+        });
+      };
+      RandomGenerator2.pick = function(array) {
+        return array[RandomGenerator2.integer(0, array.length - 1)];
+      };
+      RandomGenerator2.length = function() {
+        return RandomGenerator2.integer(0, 3);
+      };
+      RandomGenerator2.uuid = function() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+          var r = Math.random() * 16 | 0;
+          var v = c === "x" ? r : r & 3 | 8;
+          return v.toString(16);
+        });
+      };
+      RandomGenerator2.email = function() {
+        return "".concat(RandomGenerator2.string(10), "@").concat(RandomGenerator2.string(10), ".").concat(RandomGenerator2.string(3));
+      };
+      RandomGenerator2.url = function() {
+        return "https://".concat(RandomGenerator2.string(10), ".").concat(RandomGenerator2.string(3));
+      };
+      RandomGenerator2.ipv4 = function() {
+        return RandomGenerator2.array(function() {
+          return RandomGenerator2.integer(0, 255);
+        }, 4).join(".");
+      };
+      RandomGenerator2.ipv6 = function() {
+        return RandomGenerator2.array(function() {
+          return RandomGenerator2.integer(0, 65535).toString(16);
+        }, 8).join(":");
+      };
+      RandomGenerator2.pattern = function(regex) {
+        return new randexp_1.default(regex).gen();
+      };
+      RandomGenerator2.date = function(min, max) {
+        min !== null && min !== void 0 ? min : min = 0;
+        max !== null && max !== void 0 ? max : max = Date.now() * 2;
+        return new Date(RandomGenerator2.number(min, max)).toISOString().substring(0, 10);
+      };
+      RandomGenerator2.datetime = function(min, max) {
+        min !== null && min !== void 0 ? min : min = 0;
+        max !== null && max !== void 0 ? max : max = Date.now() * 2;
+        return new Date(RandomGenerator2.number(min, max)).toISOString();
+      };
+    })(RandomGenerator || (exports.RandomGenerator = RandomGenerator = {}));
+  }
+});
+
+// ../../node_modules/typia/lib/TypeGuardError.js
+var require_TypeGuardError = __commonJS({
+  "../../node_modules/typia/lib/TypeGuardError.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (Object.prototype.hasOwnProperty.call(b2, p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeGuardError = void 0;
+    var TypeGuardError = function(_super) {
+      __extends(TypeGuardError2, _super);
+      function TypeGuardError2(props) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, props.message || "Error on ".concat(props.method, "(): invalid type").concat(props.path ? " on ".concat(props.path) : "", ", expect to be ").concat(props.expected)) || this;
+        var proto = _newTarget.prototype;
+        if (Object.setPrototypeOf)
+          Object.setPrototypeOf(_this, proto);
+        else
+          _this.__proto__ = proto;
+        _this.method = props.method;
+        _this.path = props.path;
+        _this.expected = props.expected;
+        _this.value = props.value;
+        return _this;
+      }
+      return TypeGuardError2;
+    }(Error);
+    exports.TypeGuardError = TypeGuardError;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$any.js
+var require_any = __commonJS({
+  "../../node_modules/typia/lib/functional/$any.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$any = void 0;
+    var $any = function(val) {
+      return val !== void 0 ? JSON.parse(JSON.stringify(val)) : void 0;
+    };
+    exports.$any = $any;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$every.js
+var require_every = __commonJS({
+  "../../node_modules/typia/lib/functional/$every.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$every = void 0;
+    var $every = function(array, pred) {
+      var error = null;
+      for (var i = 0; i < array.length; ++i)
+        if (null !== (error = pred(array[i], i)))
+          return error;
+      return null;
+    };
+    exports.$every = $every;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$guard.js
+var require_guard = __commonJS({
+  "../../node_modules/typia/lib/functional/$guard.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$guard = void 0;
+    var TypeGuardError_1 = require_TypeGuardError();
+    var $guard = function(method) {
+      return function(exceptionable, props) {
+        if (exceptionable === true)
+          throw new TypeGuardError_1.TypeGuardError({
+            method,
+            path: props.path,
+            expected: props.expected,
+            value: props.value
+          });
+        return false;
+      };
+    };
+    exports.$guard = $guard;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_between.js
+var require_is_between = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_between.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_between = void 0;
+    var $is_between = function(value, minimum, maximum) {
+      return minimum <= value && value <= maximum;
+    };
+    exports.$is_between = $is_between;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_custom.js
+var require_is_custom = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_custom.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_custom = void 0;
+    var _dictionary_1 = require_dictionary();
+    var $is_custom = function(name, type, text, value) {
+      var _a;
+      var validator = (_a = _dictionary_1.$dictionary.get(name)) === null || _a === void 0 ? void 0 : _a.get(type);
+      if (validator === void 0)
+        return true;
+      return validator(text)(value);
+    };
+    exports.$is_custom = $is_custom;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_date.js
+var require_is_date = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_date.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_date = void 0;
+    var $is_date = function(value) {
+      return REGEX.test(value);
+    };
+    exports.$is_date = $is_date;
+    var REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_datetime.js
+var require_is_datetime = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_datetime.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_datetime = void 0;
+    var $is_datetime = function(value) {
+      return !isNaN(new Date(value).getTime());
+    };
+    exports.$is_datetime = $is_datetime;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_email.js
+var require_is_email = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_email.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_email = void 0;
+    var $is_email = function(str) {
+      return REGEX.test(str);
+    };
+    exports.$is_email = $is_email;
+    var REGEX = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_ipv4.js
+var require_is_ipv4 = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_ipv4.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_ipv4 = void 0;
+    var $is_ipv4 = function(str) {
+      return REGEX.test(str);
+    };
+    exports.$is_ipv4 = $is_ipv4;
+    var REGEX = /^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_ipv6.js
+var require_is_ipv6 = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_ipv6.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_ipv6 = void 0;
+    var $is_ipv6 = function(str) {
+      return REGEX.test(str);
+    };
+    exports.$is_ipv6 = $is_ipv6;
+    var REGEX = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_url.js
+var require_is_url = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_url.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_url = void 0;
+    var $is_url = function(str) {
+      return REGEX.test(str);
+    };
+    exports.$is_url = $is_url;
+    var REGEX = /^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$is_uuid.js
+var require_is_uuid = __commonJS({
+  "../../node_modules/typia/lib/functional/$is_uuid.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$is_uuid = void 0;
+    var $is_uuid = function(str) {
+      return REGEX.test(str);
+    };
+    exports.$is_uuid = $is_uuid;
+    var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$join.js
+var require_join = __commonJS({
+  "../../node_modules/typia/lib/functional/$join.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$join = void 0;
+    var $join = function(str) {
+      return variable(str) ? ".".concat(str) : "[".concat(JSON.stringify(str), "]");
+    };
+    exports.$join = $join;
+    var variable = function(str) {
+      return reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+    };
+    var reserved = function(str) {
+      return RESERVED.has(str);
+    };
+    var RESERVED = /* @__PURE__ */ new Set([
+      "break",
+      "case",
+      "catch",
+      "class",
+      "const",
+      "continue",
+      "debugger",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "enum",
+      "export",
+      "extends",
+      "false",
+      "finally",
+      "for",
+      "function",
+      "if",
+      "import",
+      "in",
+      "instanceof",
+      "new",
+      "null",
+      "return",
+      "super",
+      "switch",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typeof",
+      "var",
+      "void",
+      "while",
+      "with"
+    ]);
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$number.js
+var require_number = __commonJS({
+  "../../node_modules/typia/lib/functional/$number.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$number = void 0;
+    var TypeGuardError_1 = require_TypeGuardError();
+    var $number = function(value) {
+      if (isFinite(value) === false)
+        throw new TypeGuardError_1.TypeGuardError({
+          method: "typia.stringify",
+          expected: "number",
+          value,
+          message: "Error on typia.stringify(): infinite or not a number."
+        });
+      return value;
+    };
+    exports.$number = $number;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$report.js
+var require_report = __commonJS({
+  "../../node_modules/typia/lib/functional/$report.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$report = void 0;
+    var $report = function(array) {
+      var reportable = function(path) {
+        if (array.length === 0)
+          return true;
+        var last = array[array.length - 1].path;
+        return path.length > last.length || last.substring(0, path.length) !== path;
+      };
+      return function(exceptable, error) {
+        if (exceptable && reportable(error.path))
+          array.push(error);
+        return false;
+      };
+    };
+    exports.$report = $report;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$rest.js
+var require_rest = __commonJS({
+  "../../node_modules/typia/lib/functional/$rest.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$rest = void 0;
+    var $rest = function(str) {
+      return str.length === 2 ? "" : "," + str.substring(1, str.length - 1);
+    };
+    exports.$rest = $rest;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$string.js
+var require_string = __commonJS({
+  "../../node_modules/typia/lib/functional/$string.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$string = void 0;
+    var $string = function(str) {
+      if (STR_ESCAPE.test(str) === false)
+        return '"'.concat(str, '"');
+      var length = str.length;
+      if (length > 41)
+        return JSON.stringify(str);
+      var result = "";
+      var last = -1;
+      var point = 255;
+      for (var i = 0; i < length; ++i) {
+        point = str.charCodeAt(i);
+        if (point < 32) {
+          return JSON.stringify(str);
+        }
+        if (point >= 55296 && point <= 57343) {
+          return JSON.stringify(str);
+        }
+        if (point === 34 || point === 92) {
+          last === -1 && (last = 0);
+          result += str.slice(last, i) + "\\";
+          last = i;
+        }
+      }
+      return last === -1 && '"' + str + '"' || '"' + result + str.slice(last) + '"';
+    };
+    exports.$string = $string;
+    var STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/$tail.js
+var require_tail = __commonJS({
+  "../../node_modules/typia/lib/functional/$tail.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.$tail = void 0;
+    var $tail = function(str) {
+      return str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
+    };
+    exports.$tail = $tail;
+  }
+});
+
+// ../../node_modules/typia/lib/functional/Namespace.js
+var require_Namespace = __commonJS({
+  "../../node_modules/typia/lib/functional/Namespace.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Namespace = void 0;
+    var RandomGenerator_1 = require_RandomGenerator();
+    var TypeGuardError_1 = require_TypeGuardError();
+    var _any_1 = require_any();
+    var _every_1 = require_every();
+    var _guard_1 = require_guard();
+    var _is_between_1 = require_is_between();
+    var _is_custom_1 = require_is_custom();
+    var _is_date_1 = require_is_date();
+    var _is_datetime_1 = require_is_datetime();
+    var _is_email_1 = require_is_email();
+    var _is_ipv4_1 = require_is_ipv4();
+    var _is_ipv6_1 = require_is_ipv6();
+    var _is_url_1 = require_is_url();
+    var _is_uuid_1 = require_is_uuid();
+    var _join_1 = require_join();
+    var _number_1 = require_number();
+    var _report_1 = require_report();
+    var _rest_1 = require_rest();
+    var _string_1 = require_string();
+    var _tail_1 = require_tail();
+    var Namespace;
+    (function(Namespace2) {
+      Namespace2.is = function() {
+        return {
+          is_uuid: _is_uuid_1.$is_uuid,
+          is_email: _is_email_1.$is_email,
+          is_url: _is_url_1.$is_url,
+          is_ipv4: _is_ipv4_1.$is_ipv4,
+          is_ipv6: _is_ipv6_1.$is_ipv6,
+          is_between: _is_between_1.$is_between,
+          is_date: _is_date_1.$is_date,
+          is_datetime: _is_datetime_1.$is_datetime,
+          is_custom: _is_custom_1.$is_custom
+        };
+      };
+      Namespace2.assert = function(method) {
+        return __assign(__assign({}, Namespace2.is()), { join: _join_1.$join, every: _every_1.$every, guard: (0, _guard_1.$guard)("typia.".concat(method)), predicate: function(matched, exceptionable, closure) {
+          if (matched === false && exceptionable === true)
+            throw new TypeGuardError_1.TypeGuardError(__assign(__assign({}, closure()), { method: "typia.".concat(method) }));
+          return matched;
+        } });
+      };
+      Namespace2.validate = function() {
+        return __assign(__assign({}, Namespace2.is()), { join: _join_1.$join, report: _report_1.$report, predicate: function(res) {
+          return function(matched, exceptionable, closure) {
+            if (matched === false && exceptionable === true)
+              (function() {
+                res.success && (res.success = false);
+                var errorList = res.errors;
+                var error = closure();
+                if (errorList.length) {
+                  var last = errorList[errorList.length - 1].path;
+                  if (last.length >= error.path.length && last.substring(0, error.path.length) === error.path)
+                    return;
+                }
+                errorList.push(error);
+                return;
+              })();
+            return matched;
+          };
+        } });
+      };
+      Namespace2.stringify = function(method) {
+        return __assign(__assign({}, Namespace2.is()), { number: _number_1.$number, string: _string_1.$string, tail: _tail_1.$tail, rest: _rest_1.$rest, throws: $throws(method) });
+      };
+      Namespace2.clone = function(method) {
+        return __assign(__assign({}, Namespace2.is()), { throws: $throws(method), any: _any_1.$any });
+      };
+      Namespace2.prune = function(method) {
+        return __assign(__assign({}, Namespace2.is()), { throws: $throws(method) });
+      };
+      Namespace2.random = function() {
+        return {
+          generator: RandomGenerator_1.RandomGenerator,
+          pick: RandomGenerator_1.RandomGenerator.pick
+        };
+      };
+      var $throws = function(method) {
+        return function(props) {
+          throw new TypeGuardError_1.TypeGuardError(__assign(__assign({}, props), { method: "typia.".concat(method) }));
+        };
+      };
+    })(Namespace || (exports.Namespace = Namespace = {}));
+  }
+});
+
+// ../../node_modules/typia/lib/utils/MapUtil.js
+var require_MapUtil = __commonJS({
+  "../../node_modules/typia/lib/utils/MapUtil.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MapUtil = void 0;
+    var MapUtil;
+    (function(MapUtil2) {
+      MapUtil2.take = function(dict) {
+        return function(key, generator) {
+          var oldbie = dict.get(key);
+          if (oldbie)
+            return oldbie;
+          var value = generator();
+          dict.set(key, value);
+          return value;
+        };
+      };
+    })(MapUtil || (exports.MapUtil = MapUtil = {}));
+  }
+});
+
+// ../../node_modules/typia/lib/schemas/IJsonApplication.js
+var require_IJsonApplication = __commonJS({
+  "../../node_modules/typia/lib/schemas/IJsonApplication.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/schemas/IJsonComponents.js
+var require_IJsonComponents = __commonJS({
+  "../../node_modules/typia/lib/schemas/IJsonComponents.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/schemas/IJsonSchema.js
+var require_IJsonSchema = __commonJS({
+  "../../node_modules/typia/lib/schemas/IJsonSchema.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/IRandomGenerator.js
+var require_IRandomGenerator = __commonJS({
+  "../../node_modules/typia/lib/IRandomGenerator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/IValidation.js
+var require_IValidation = __commonJS({
+  "../../node_modules/typia/lib/IValidation.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/Primitive.js
+var require_Primitive = __commonJS({
+  "../../node_modules/typia/lib/Primitive.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/typia/lib/module.js
+var require_module = __commonJS({
+  "../../node_modules/typia/lib/module.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createValidatePrune = exports.createIsPrune = exports.createAssertPrune = exports.createPrune = exports.createValidateClone = exports.createIsClone = exports.createAssertClone = exports.createClone = exports.createRandom = exports.createValidateStringify = exports.createIsStringify = exports.createAssertStringify = exports.createStringify = exports.createValidateParse = exports.createAssertParse = exports.createIsParse = exports.createValidateEquals = exports.createEquals = exports.createAssertEquals = exports.createValidate = exports.createIs = exports.createAssertType = exports.createAssert = exports.validatePrune = exports.isPrune = exports.assertPrune = exports.prune = exports.validateClone = exports.isClone = exports.assertClone = exports.clone = exports.literals = exports.random = exports.metadata = exports.validateStringify = exports.isStringify = exports.assertStringify = exports.stringify = exports.validateParse = exports.isParse = exports.assertParse = exports.application = exports.customValidators = exports.validateEquals = exports.equals = exports.assertEquals = exports.validate = exports.is = exports.assertType = exports.assert = void 0;
+    var _dictionary_1 = require_dictionary();
+    var Namespace_1 = require_Namespace();
+    var MapUtil_1 = require_MapUtil();
+    __exportStar(require_IJsonApplication(), exports);
+    __exportStar(require_IJsonComponents(), exports);
+    __exportStar(require_IJsonSchema(), exports);
+    __exportStar(require_IRandomGenerator(), exports);
+    __exportStar(require_IValidation(), exports);
+    __exportStar(require_Primitive(), exports);
+    __exportStar(require_TypeGuardError(), exports);
+    function assert() {
+      halt("assert");
+    }
+    exports.assert = assert;
+    Object.assign(assert, Namespace_1.Namespace.assert("assert"));
+    function assertType() {
+      halt("assertType");
+    }
+    exports.assertType = assertType;
+    Object.assign(assertType, Namespace_1.Namespace.assert("assertType"));
+    function is() {
+      halt("is");
+    }
+    exports.is = is;
+    Object.assign(is, Namespace_1.Namespace.assert("is"));
+    function validate() {
+      halt("validate");
+    }
+    exports.validate = validate;
+    Object.assign(validate, Namespace_1.Namespace.validate());
+    function assertEquals() {
+      halt("assertEquals");
+    }
+    exports.assertEquals = assertEquals;
+    Object.assign(assertEquals, Namespace_1.Namespace.assert("assertEquals"));
+    function equals() {
+      halt("equals");
+    }
+    exports.equals = equals;
+    Object.assign(equals, Namespace_1.Namespace.is());
+    function validateEquals() {
+      halt("validateEquals");
+    }
+    exports.validateEquals = validateEquals;
+    Object.assign(validateEquals, Namespace_1.Namespace.validate());
+    exports.customValidators = {
+      size: function(name) {
+        var _a, _b;
+        return name ? (_b = (_a = _dictionary_1.$dictionary.get(name)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0 : _dictionary_1.$dictionary.size;
+      },
+      has: function(name) {
+        return function(type) {
+          var _a, _b;
+          return (_b = (_a = _dictionary_1.$dictionary.get(name)) === null || _a === void 0 ? void 0 : _a.has(type)) !== null && _b !== void 0 ? _b : false;
+        };
+      },
+      get: function(name) {
+        return function(type) {
+          var _a;
+          return (_a = _dictionary_1.$dictionary.get(name)) === null || _a === void 0 ? void 0 : _a.get(type);
+        };
+      },
+      insert: function(name) {
+        return function(type) {
+          return function(closure) {
+            var internal = MapUtil_1.MapUtil.take(_dictionary_1.$dictionary)(name, function() {
+              return /* @__PURE__ */ new Map();
+            });
+            if (internal.has(type))
+              return false;
+            internal.set(type, closure);
+            return true;
+          };
+        };
+      },
+      erase: function(name) {
+        return function(type) {
+          var _a, _b;
+          return (_b = (_a = _dictionary_1.$dictionary.get(name)) === null || _a === void 0 ? void 0 : _a.delete(type)) !== null && _b !== void 0 ? _b : false;
+        };
+      }
+    };
+    function application() {
+      halt("application");
+    }
+    exports.application = application;
+    function assertParse() {
+      halt("assertParse");
+    }
+    exports.assertParse = assertParse;
+    Object.assign(assertParse, Namespace_1.Namespace.assert("assertParse"));
+    function isParse() {
+      halt("isParse");
+    }
+    exports.isParse = isParse;
+    Object.assign(isParse, is);
+    function validateParse() {
+      halt("validateParse");
+    }
+    exports.validateParse = validateParse;
+    Object.assign(validateParse, validate);
+    function stringify() {
+      halt("stringify");
+    }
+    exports.stringify = stringify;
+    Object.assign(stringify, Namespace_1.Namespace.stringify("stringify"));
+    function assertStringify() {
+      halt("assertStringify");
+    }
+    exports.assertStringify = assertStringify;
+    Object.assign(assertStringify, Namespace_1.Namespace.assert("assertStringify"));
+    Object.assign(assertStringify, Namespace_1.Namespace.stringify("assertStringify"));
+    function isStringify() {
+      halt("isStringify");
+    }
+    exports.isStringify = isStringify;
+    Object.assign(isStringify, Namespace_1.Namespace.is());
+    Object.assign(isStringify, Namespace_1.Namespace.stringify("isStringify"));
+    function validateStringify() {
+      halt("validateStringify");
+    }
+    exports.validateStringify = validateStringify;
+    Object.assign(validateStringify, Namespace_1.Namespace.validate());
+    Object.assign(validateStringify, Namespace_1.Namespace.stringify("validateStringify"));
+    function metadata() {
+      halt("metadata");
+    }
+    exports.metadata = metadata;
+    function random() {
+      halt("random");
+    }
+    exports.random = random;
+    Object.assign(random, Namespace_1.Namespace.random());
+    function literals() {
+      halt("literals");
+    }
+    exports.literals = literals;
+    function clone() {
+      halt("clone");
+    }
+    exports.clone = clone;
+    Object.assign(clone, Namespace_1.Namespace.clone("clone"));
+    function assertClone() {
+      halt("assertClone");
+    }
+    exports.assertClone = assertClone;
+    Object.assign(assertClone, Namespace_1.Namespace.assert("assertClone"));
+    Object.assign(assertClone, Namespace_1.Namespace.clone("assertClone"));
+    function isClone() {
+      halt("isClone");
+    }
+    exports.isClone = isClone;
+    Object.assign(isClone, Namespace_1.Namespace.is());
+    Object.assign(isClone, Namespace_1.Namespace.clone("isClone"));
+    function validateClone() {
+      halt("validateClone");
+    }
+    exports.validateClone = validateClone;
+    Object.assign(validateClone, Namespace_1.Namespace.validate());
+    Object.assign(validateClone, Namespace_1.Namespace.clone("validateClone"));
+    function prune() {
+      halt("prune");
+    }
+    exports.prune = prune;
+    Object.assign(prune, Namespace_1.Namespace.prune("prune"));
+    function assertPrune() {
+      halt("assertPrune");
+    }
+    exports.assertPrune = assertPrune;
+    Object.assign(assertPrune, Namespace_1.Namespace.assert("assertPrune"));
+    Object.assign(assertPrune, Namespace_1.Namespace.prune("assertPrune"));
+    function isPrune() {
+      halt("isPrune");
+    }
+    exports.isPrune = isPrune;
+    Object.assign(isPrune, Namespace_1.Namespace.is());
+    Object.assign(isPrune, Namespace_1.Namespace.prune("isPrune"));
+    function validatePrune() {
+      halt("validatePrune");
+    }
+    exports.validatePrune = validatePrune;
+    Object.assign(validatePrune, Namespace_1.Namespace.prune("validatePrune"));
+    Object.assign(validatePrune, Namespace_1.Namespace.validate());
+    function createAssert() {
+      halt("createAssert");
+    }
+    exports.createAssert = createAssert;
+    Object.assign(createAssert, assert);
+    function createAssertType() {
+      halt("createAssertType");
+    }
+    exports.createAssertType = createAssertType;
+    Object.assign(createAssertType, assertType);
+    function createIs() {
+      halt("createIs");
+    }
+    exports.createIs = createIs;
+    Object.assign(createIs, is);
+    function createValidate() {
+      halt("createValidate");
+    }
+    exports.createValidate = createValidate;
+    Object.assign(createValidate, validate);
+    function createAssertEquals() {
+      halt("createAssertEquals");
+    }
+    exports.createAssertEquals = createAssertEquals;
+    Object.assign(createAssertEquals, assertEquals);
+    function createEquals() {
+      halt("createEquals");
+    }
+    exports.createEquals = createEquals;
+    Object.assign(createEquals, equals);
+    function createValidateEquals() {
+      halt("createValidateEquals");
+    }
+    exports.createValidateEquals = createValidateEquals;
+    Object.assign(createValidateEquals, validateEquals);
+    function createIsParse() {
+      halt("createIsParse");
+    }
+    exports.createIsParse = createIsParse;
+    Object.assign(createIsParse, isParse);
+    function createAssertParse() {
+      halt("createAssertParse");
+    }
+    exports.createAssertParse = createAssertParse;
+    Object.assign(createAssertParse, assertParse);
+    function createValidateParse() {
+      halt("createValidateParse");
+    }
+    exports.createValidateParse = createValidateParse;
+    Object.assign(createValidateParse, validateParse);
+    function createStringify() {
+      halt("createStringify");
+    }
+    exports.createStringify = createStringify;
+    Object.assign(createStringify, stringify);
+    function createAssertStringify() {
+      halt("createAssertStringify");
+    }
+    exports.createAssertStringify = createAssertStringify;
+    Object.assign(createAssertStringify, assertStringify);
+    function createIsStringify() {
+      halt("createIsStringify");
+    }
+    exports.createIsStringify = createIsStringify;
+    Object.assign(createIsStringify, isStringify);
+    function createValidateStringify() {
+      halt("createValidateStringify");
+    }
+    exports.createValidateStringify = createValidateStringify;
+    Object.assign(createValidateStringify, validateStringify);
+    function createRandom() {
+      halt("createRandom");
+    }
+    exports.createRandom = createRandom;
+    Object.assign(createRandom, random);
+    function createClone() {
+      halt("createClone");
+    }
+    exports.createClone = createClone;
+    Object.assign(createClone, clone);
+    function createAssertClone() {
+      halt("createAssertClone");
+    }
+    exports.createAssertClone = createAssertClone;
+    Object.assign(createAssertClone, assertClone);
+    function createIsClone() {
+      halt("createIsClone");
+    }
+    exports.createIsClone = createIsClone;
+    Object.assign(createIsClone, isClone);
+    function createValidateClone() {
+      halt("createValidateClone");
+    }
+    exports.createValidateClone = createValidateClone;
+    Object.assign(createValidateClone, validateClone);
+    function createPrune() {
+      halt("createPrune");
+    }
+    exports.createPrune = createPrune;
+    Object.assign(createPrune, prune);
+    function createAssertPrune() {
+      halt("createAssertPrune");
+    }
+    exports.createAssertPrune = createAssertPrune;
+    Object.assign(createAssertPrune, assertPrune);
+    function createIsPrune() {
+      halt("createIsPrune");
+    }
+    exports.createIsPrune = createIsPrune;
+    Object.assign(createIsPrune, isPrune);
+    function createValidatePrune() {
+      halt("createValidatePrune");
+    }
+    exports.createValidatePrune = createValidatePrune;
+    Object.assign(createValidatePrune, validatePrune);
+    function halt(name) {
+      throw new Error("Error on typia.".concat(name, "(): no transform has been configured. Read and follow https://typia.io/docs/setup please."));
+    }
+  }
+});
+
+// ../../node_modules/typia/lib/index.js
+var require_lib3 = __commonJS({
+  "../../node_modules/typia/lib/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var typia = __importStar(require_module());
+    exports.default = typia;
+    __exportStar(require_module(), exports);
+  }
+});
+
+export {
+  __toESM,
+  require_lib3 as require_lib
+};