typia 7.0.0-dev.20241005 → 7.0.0-dev.20241007

package/lib/index.mjs

@@ -1,1275 +1,3 @@
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var lib$1 = {exports: {}};
-
-var util$1 = {};
-
-var types$4 = {
-  ROOT       : 0,
-  GROUP      : 1,
-  POSITION   : 2,
-  SET        : 3,
-  RANGE      : 4,
-  REPETITION : 5,
-  REFERENCE  : 6,
-  CHAR       : 7,
-};
-
-var sets$1 = {};
-
-const types$3 = types$4;
-
-const INTS = () => [{ type: types$3.RANGE , from: 48, to: 57 }];
-
-const WORDS = () => {
-  return [
-    { type: types$3.CHAR, value: 95 },
-    { type: types$3.RANGE, from: 97, to: 122 },
-    { type: types$3.RANGE, from: 65, to: 90 }
-  ].concat(INTS());
-};
-
-const WHITESPACE = () => {
-  return [
-    { type: types$3.CHAR, value: 9 },
-    { type: types$3.CHAR, value: 10 },
-    { type: types$3.CHAR, value: 11 },
-    { type: types$3.CHAR, value: 12 },
-    { type: types$3.CHAR, value: 13 },
-    { type: types$3.CHAR, value: 32 },
-    { type: types$3.CHAR, value: 160 },
-    { type: types$3.CHAR, value: 5760 },
-    { type: types$3.RANGE, from: 8192, to: 8202 },
-    { type: types$3.CHAR, value: 8232 },
-    { type: types$3.CHAR, value: 8233 },
-    { type: types$3.CHAR, value: 8239 },
-    { type: types$3.CHAR, value: 8287 },
-    { type: types$3.CHAR, value: 12288 },
-    { type: types$3.CHAR, value: 65279 }
-  ];
-};
-
-const NOTANYCHAR = () => {
-  return [
-    { type: types$3.CHAR, value: 10 },
-    { type: types$3.CHAR, value: 13 },
-    { type: types$3.CHAR, value: 8232 },
-    { type: types$3.CHAR, value: 8233 },
-  ];
-};
-
-// Predefined class objects.
-sets$1.words = () => ({ type: types$3.SET, set: WORDS(), not: false });
-sets$1.notWords = () => ({ type: types$3.SET, set: WORDS(), not: true });
-sets$1.ints = () => ({ type: types$3.SET, set: INTS(), not: false });
-sets$1.notInts = () => ({ type: types$3.SET, set: INTS(), not: true });
-sets$1.whitespace = () => ({ type: types$3.SET, set: WHITESPACE(), not: false });
-sets$1.notWhitespace = () => ({ type: types$3.SET, set: WHITESPACE(), not: true });
-sets$1.anyChar = () => ({ type: types$3.SET, set: NOTANYCHAR(), not: true });
-
-(function (exports) {
-	const types = types$4;
-	const sets  = sets$1;
-
-
-	const CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?';
-	const SLSH = { '0': 0, 't': 9, 'n': 10, 'v': 11, 'f': 12, 'r': 13 };
-
-	/**
-	 * Finds character representations in str and convert all to
-	 * their respective characters
-	 *
-	 * @param {String} str
-	 * @return {String}
-	 */
-	exports.strToChars = function(str) {
-	  /* jshint maxlen: false */
-	  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);
-
-	    // Escape special regex characters.
-	    if (/[[\]{}^$.|?*+()]/.test(c)) {
-	      c = '\\' + c;
-	    }
-
-	    return c;
-	  });
-
-	  return str;
-	};
-
-
-	/**
-	 * turns class into tokens
-	 * reads str until it encounters a ] not preceeded by a \
-	 *
-	 * @param {String} str
-	 * @param {String} regexpStr
-	 * @return {Array.<Array.<Object>, Number>}
-	 */
-	exports.tokenizeClass = (str, regexpStr) => {
-	  /* jshint maxlen: false */
-	  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');
-	};
-
-
-	/**
-	 * Shortcut to throw errors.
-	 *
-	 * @param {String} regexp
-	 * @param {String} msg
-	 */
-	exports.error = (regexp, msg) => {
-	  throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg);
-	}; 
-} (util$1));
-
-var positions$1 = {};
-
-const types$2 = types$4;
-positions$1.wordBoundary = () => ({ type: types$2.POSITION, value: 'b' });
-positions$1.nonWordBoundary = () => ({ type: types$2.POSITION, value: 'B' });
-positions$1.begin = () => ({ type: types$2.POSITION, value: '^' });
-positions$1.end = () => ({ type: types$2.POSITION, value: '$' });
-
-const util      = util$1;
-const types$1     = types$4;
-const sets      = sets$1;
-const positions = positions$1;
-
-
-lib$1.exports = (regexpStr) => {
-  var i = 0, l, c,
-    start = { type: types$1.ROOT, stack: []},
-
-    // Keep track of last clause/group and stack.
-    lastGroup = start,
-    last = start.stack,
-    groupStack = [];
-
-
-  var repeatErr = (i) => {
-    util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);
-  };
-
-  // Decode a few escaped characters.
-  var str = util.strToChars(regexpStr);
-  l = str.length;
-
-  // Iterate through each character in string.
-  while (i < l) {
-    c = str[i++];
-
-    switch (c) {
-      // Handle escaped characters, inclues a few sets.
-      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:
-            // Check if c is integer.
-            // In which case it's a reference.
-            if (/\d/.test(c)) {
-              last.push({ type: types$1.REFERENCE, value: parseInt(c, 10) });
-
-            // Escaped character.
-            } else {
-              last.push({ type: types$1.CHAR, value: c.charCodeAt(0) });
-            }
-        }
-
-        break;
-
-
-      // Positionals.
-      case '^':
-        last.push(positions.begin());
-        break;
-
-      case '$':
-        last.push(positions.end());
-        break;
-
-
-      // Handle custom sets.
-      case '[':
-        // Check if this class is 'anti' i.e. [^abc].
-        var not;
-        if (str[i] === '^') {
-          not = true;
-          i++;
-        } else {
-          not = false;
-        }
-
-        // Get all the characters in class.
-        var classTokens = util.tokenizeClass(str.slice(i), regexpStr);
-
-        // Increase index by length of class.
-        i += classTokens[1];
-        last.push({
-          type: types$1.SET,
-          set: classTokens[0],
-          not,
-        });
-
-        break;
-
-
-      // Class of any character except \n.
-      case '.':
-        last.push(sets.anyChar());
-        break;
-
-
-      // Push group onto stack.
-      case '(':
-        // Create group.
-        var group = {
-          type: types$1.GROUP,
-          stack: [],
-          remember: true,
-        };
-
-        c = str[i];
-
-        // If if this is a special kind of group.
-        if (c === '?') {
-          c = str[i + 1];
-          i += 2;
-
-          // Match if followed by.
-          if (c === '=') {
-            group.followedBy = true;
-
-          // Match if not followed by.
-          } else if (c === '!') {
-            group.notFollowedBy = true;
-
-          } else if (c !== ':') {
-            util.error(regexpStr,
-              `Invalid group, character '${c}'` +
-              ` after '?' at column ${i - 1}`);
-          }
-
-          group.remember = false;
-        }
-
-        // Insert subgroup into current group stack.
-        last.push(group);
-
-        // Remember the current group for when the group closes.
-        groupStack.push(lastGroup);
-
-        // Make this new group the current group.
-        lastGroup = group;
-        last = group.stack;
-        break;
-
-
-      // Pop group out of stack.
-      case ')':
-        if (groupStack.length === 0) {
-          util.error(regexpStr, `Unmatched ) at column ${i - 1}`);
-        }
-        lastGroup = groupStack.pop();
-
-        // Check if this group has a PIPE.
-        // To get back the correct last stack.
-        last = lastGroup.options ?
-          lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
-        break;
-
-
-      // Use pipe character to give more choices.
-      case '|':
-        // Create array where options are if this is the first PIPE
-        // in this clause.
-        if (!lastGroup.options) {
-          lastGroup.options = [lastGroup.stack];
-          delete lastGroup.stack;
-        }
-
-        // Create a new stack and add to options for rest of clause.
-        var stack = [];
-        lastGroup.options.push(stack);
-        last = stack;
-        break;
-
-
-      // Repetition.
-      // For every repetition, remove last element from last stack
-      // then insert back a RANGE object.
-      // This design is chosen because there could be more than
-      // one repetition symbols in a regex i.e. `a?+{2,3}`.
-      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$1.REPETITION,
-            min,
-            max,
-            value: last.pop(),
-          });
-        } else {
-          last.push({
-            type: types$1.CHAR,
-            value: 123,
-          });
-        }
-        break;
-
-      case '?':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-        last.push({
-          type: types$1.REPETITION,
-          min: 0,
-          max: 1,
-          value: last.pop(),
-        });
-        break;
-
-      case '+':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-        last.push({
-          type: types$1.REPETITION,
-          min: 1,
-          max: Infinity,
-          value: last.pop(),
-        });
-        break;
-
-      case '*':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-        last.push({
-          type: types$1.REPETITION,
-          min: 0,
-          max: Infinity,
-          value: last.pop(),
-        });
-        break;
-
-
-      // Default is a character that is not `\[](){}?+*^$`.
-      default:
-        last.push({
-          type: types$1.CHAR,
-          value: c.charCodeAt(0),
-        });
-    }
-
-  }
-
-  // Check if any groups have not been closed.
-  if (groupStack.length !== 0) {
-    util.error(regexpStr, 'Unterminated group');
-  }
-
-  return start;
-};
-
-lib$1.exports.types = types$1;
-
-var libExports = lib$1.exports;
-
-/* eslint indent: 4 */
-
-
-// Private helper class
-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;
-    }
-}
-
-
-let DRange$1 = 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
-        }));
-    }
-};
-
-var lib = DRange$1;
-
-const ret    = libExports;
-const DRange = lib;
-const types  = ret.types;
-
-
-var randexp = 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) {
-    // When a repetitional token has its max set to Infinite,
-    // randexp won't actually generate a random amount between min and Infinite
-    // instead it will see Infinite as min + 100.
-    this.max = regexp.max != null ? regexp.max :
-      RandExp.prototype.max != null ? RandExp.prototype.max : 100;
-
-    // This allows expanding to include additional characters
-    // for instance: RandExp.defaultRange.add(0, 65535);
-    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:
-        // Ignore lookaheads for now.
-        if (token.followedBy || token.notFollowedBy) { return ''; }
-
-        // Insert placeholder until group string is generated.
-        if (token.remember && token.groupNumber === undefined) {
-          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:
-        // Do nothing for now.
-        return '';
-
-      case types.SET:
-        var expandedSet = this._expand(token);
-        if (!expandedSet.length) { return ''; }
-        return String.fromCharCode(this._randSelect(expandedSet));
-
-      case types.REPETITION:
-        // Randomly generate number between min and max.
-        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 === undefined) {
-      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() {
-    /* eshint freeze:false */
-    RegExp.prototype.gen = function() {
-      return RandExp.randexp(this);
-    };
-  }
-};
-
-var RandExp = /*@__PURE__*/getDefaultExportFromCjs(randexp);
-
-const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
-/* -----------------------------------------------------------
-  REGULAR
------------------------------------------------------------ */
-const boolean = () => Math.random() < 0.5;
-const integer = (min, max) => {
-    min ??= 0;
-    max ??= 100;
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-};
-const bigint = (min, max) => BigInt(integer(Number(min ?? BigInt(0)), Number(max ?? BigInt(100))));
-const number = (min, max) => {
-    min ??= 0;
-    max ??= 100;
-    return Math.random() * (max - min) + min;
-};
-const string = (length) => new Array(length ?? integer(5, 10))
-    .fill(0)
-    .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
-    .join("");
-const array = (closure, count, unique) => {
-    count ??= length();
-    unique ??= false;
-    if (unique === false)
-        return new Array(count ?? length())
-            .fill(0)
-            .map((_e, index) => closure(index));
-    else {
-        const set = new Set();
-        while (set.size < count)
-            set.add(closure(set.size));
-        return Array.from(set);
-    }
-};
-const pick = (array) => array[integer(0, array.length - 1)];
-const length = () => integer(0, 3);
-const pattern = (regex) => {
-    const r = new RandExp(regex);
-    for (let i = 0; i < 10; ++i) {
-        const str = r.gen();
-        if (regex.test(str))
-            return str;
-    }
-    return r.gen();
-};
-/* -----------------------------------------------------------
-  SECIAL FORMATS
------------------------------------------------------------ */
-// SPECIAL CHARACTERS
-const byte = () => "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";
-const password = () => string(integer(4, 16));
-const regex = () => "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/";
-const uuid = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-});
-// ADDRESSES
-const email = () => `${string(10)}@${string(10)}.${string(3)}`;
-const hostname = () => `${string(10)}.${string(3)}`;
-const idnEmail = () => email();
-const idnHostname = () => hostname();
-const iri = () => url();
-const iriReference = () => url();
-const ipv4 = () => array(() => integer(0, 255), 4).join(".");
-const ipv6 = () => array(() => integer(0, 65535).toString(16), 8).join(":");
-const uri = () => url();
-const uriReference = () => url();
-const uriTemplate = () => url();
-const url = () => `https://${string(10)}.${string(3)}`;
-// TIMESTAMPS
-const datetime = (min, max) => new Date(number(min ?? Date.now() - 30 * DAY, max ?? Date.now() + 7 * DAY)).toISOString();
-const date = (min, max) => new Date(number(min ?? 0, max ?? Date.now() * 2))
-    .toISOString()
-    .substring(0, 10);
-const time = () => new Date(number(0, DAY)).toISOString().substring(11);
-const duration = () => {
-    const period = durate([
-        ["Y", integer(0, 100)],
-        ["M", integer(0, 12)],
-        ["D", integer(0, 31)],
-    ]);
-    const time = durate([
-        ["H", integer(0, 24)],
-        ["M", integer(0, 60)],
-        ["S", integer(0, 60)],
-    ]);
-    if (period.length + time.length === 0)
-        return "PT0S";
-    return `P${period}${time.length ? "T" : ""}${time}`;
-};
-// POINTERS
-const jsonPointer = () => `/components/schemas/${string(10)}`;
-const relativeJsonPointer = () => `${integer(0, 10)}#`;
-const DAY = 86400000;
-const durate = (elements) => elements
-    .filter(([_unit, value]) => value !== 0)
-    .map(([unit, value]) => `${value}${unit}`)
-    .join("");
-
-var RandomGenerator = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	array: array,
-	bigint: bigint,
-	boolean: boolean,
-	byte: byte,
-	date: date,
-	datetime: datetime,
-	duration: duration,
-	email: email,
-	hostname: hostname,
-	idnEmail: idnEmail,
-	idnHostname: idnHostname,
-	integer: integer,
-	ipv4: ipv4,
-	ipv6: ipv6,
-	iri: iri,
-	iriReference: iriReference,
-	jsonPointer: jsonPointer,
-	length: length,
-	number: number,
-	password: password,
-	pattern: pattern,
-	pick: pick,
-	regex: regex,
-	relativeJsonPointer: relativeJsonPointer,
-	string: string,
-	time: time,
-	uri: uri,
-	uriReference: uriReference,
-	uriTemplate: uriTemplate,
-	url: url,
-	uuid: uuid
-});
-
-class TypeGuardError extends Error {
-    method;
-    path;
-    expected;
-    value;
-    fake_expected_typed_value_;
-    constructor(props) {
-        // MESSAGE CONSTRUCTION
-        super(props.message ||
-            `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
-        // INHERITANCE POLYFILL
-        const proto = new.target.prototype;
-        if (Object.setPrototypeOf)
-            Object.setPrototypeOf(this, proto);
-        else
-            this.__proto__ = proto;
-        // ASSIGN MEMBERS
-        this.method = props.method;
-        this.path = props.path;
-        this.expected = props.expected;
-        this.value = props.value;
-    }
-}
-
-var StringUtil;
-(function (StringUtil) {
-    StringUtil.capitalize = (str) => str.length ? str[0].toUpperCase() + str.slice(1).toLowerCase() : str;
-    StringUtil.escapeDuplicate = (props) => props.keep.includes(props.input)
-        ? StringUtil.escapeDuplicate({
-            keep: props.keep,
-            input: (props.escape ?? ((str) => `_${str}`))(props.input),
-        })
-        : props.input;
-})(StringUtil || (StringUtil = {}));
-
-var NamingConvention;
-(function (NamingConvention) {
-    const unsnake = (props) => (str) => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        let prefix = "";
-        for (let i = 0; i < str.length; i++) {
-            if (str[i] === "_")
-                prefix += "_";
-            else
-                break;
-        }
-        if (prefix.length !== 0)
-            str = str.substring(prefix.length);
-        const out = (s) => `${prefix}${s}`;
-        if (str.length === 0)
-            return out("");
-        const items = str.split("_").filter((s) => s.length !== 0);
-        return items.length === 0
-            ? out("")
-            : items.length === 1
-                ? out(props.plain(items[0]))
-                : out(items.map(props.snake).join(""));
-    };
-    function snake(str) {
-        if (str.length === 0)
-            return str;
-        // PREFIX
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        let prefix = "";
-        for (let i = 0; i < str.length; i++) {
-            if (str[i] === "_")
-                prefix += "_";
-            else
-                break;
-        }
-        if (prefix.length !== 0)
-            str = str.substring(prefix.length);
-        const out = (s) => `${prefix}${s}`;
-        // SNAKE CASE
-        const items = str.split("_");
-        if (items.length > 1)
-            return out(items.map((s) => s.toLowerCase()).join("_"));
-        // CAMEL OR PASCAL CASE
-        const indexes = [];
-        for (let i = 0; i < str.length; i++) {
-            const code = str.charCodeAt(i);
-            if (65 <= code && code <= 90)
-                indexes.push(i);
-        }
-        for (let i = indexes.length - 1; i > 0; --i) {
-            const now = indexes[i];
-            const prev = indexes[i - 1];
-            if (now - prev === 1)
-                indexes.splice(i, 1);
-        }
-        if (indexes.length !== 0 && indexes[0] === 0)
-            indexes.splice(0, 1);
-        if (indexes.length === 0)
-            return str.toLowerCase();
-        let ret = "";
-        for (let i = 0; i < indexes.length; i++) {
-            const first = i === 0 ? 0 : indexes[i - 1];
-            const last = indexes[i];
-            ret += str.substring(first, last).toLowerCase();
-            ret += "_";
-        }
-        ret += str.substring(indexes[indexes.length - 1]).toLowerCase();
-        return out(ret);
-    }
-    NamingConvention.snake = snake;
-    function camel(str) {
-        return unsnake({
-            plain: (str) => str.length
-                ? str === str.toUpperCase()
-                    ? str.toLocaleLowerCase()
-                    : `${str[0].toLowerCase()}${str.substring(1)}`
-                : str,
-            snake: (str, i) => i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
-        })(str);
-    }
-    NamingConvention.camel = camel;
-    function pascal(str) {
-        return unsnake({
-            plain: (str) => str.length ? `${str[0].toUpperCase()}${str.substring(1)}` : str,
-            snake: StringUtil.capitalize,
-        })(str);
-    }
-    NamingConvention.pascal = pascal;
-})(NamingConvention || (NamingConvention = {}));
-
-var LlmTypeChecker;
-
-(function(LlmTypeChecker) {
-    LlmTypeChecker.visit = (schema, callback) => {
-        callback(schema);
-        if (LlmTypeChecker.isOneOf(schema)) schema.oneOf.forEach((s => LlmTypeChecker.visit(s, callback))); else if (LlmTypeChecker.isObject(schema)) {
-            for (const [_, s] of Object.entries(schema.properties ?? {})) LlmTypeChecker.visit(s, callback);
-            if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) LlmTypeChecker.visit(schema.additionalProperties, callback);
-        } else if (LlmTypeChecker.isArray(schema)) LlmTypeChecker.visit(schema.items, callback);
-    };
-    LlmTypeChecker.isOneOf = schema => schema.oneOf !== undefined;
-    LlmTypeChecker.isObject = schema => schema.type === "object";
-    LlmTypeChecker.isArray = schema => schema.type === "array";
-    LlmTypeChecker.isBoolean = schema => schema.type === "boolean";
-    LlmTypeChecker.isInteger = schema => schema.type === "integer";
-    LlmTypeChecker.isNumber = schema => schema.type === "number";
-    LlmTypeChecker.isString = schema => schema.type === "string";
-    LlmTypeChecker.isNullOnly = schema => schema.type === "null";
-    LlmTypeChecker.isNullable = schema => !LlmTypeChecker.isUnknown(schema) && (LlmTypeChecker.isNullOnly(schema) || (LlmTypeChecker.isOneOf(schema) ? schema.oneOf.some(LlmTypeChecker.isNullable) : schema.nullable === true));
-    LlmTypeChecker.isUnknown = schema => !LlmTypeChecker.isOneOf(schema) && schema.type === undefined;
-})(LlmTypeChecker || (LlmTypeChecker = {}));
-
-var LlmSchemaSeparator;
-
-(function(LlmSchemaSeparator) {
-    LlmSchemaSeparator.parameters = props => {
-        const indexes = props.parameters.map(LlmSchemaSeparator.schema(props.predicator));
-        return {
-            llm: indexes.map((([llm], index) => ({
-                index,
-                schema: llm
-            }))).filter((({schema}) => schema !== null)),
-            human: indexes.map((([, human], index) => ({
-                index,
-                schema: human
-            }))).filter((({schema}) => schema !== null))
-        };
-    };
-    LlmSchemaSeparator.schema = predicator => input => {
-        if (predicator(input) === true) return [ null, input ]; else if (LlmTypeChecker.isUnknown(input) || LlmTypeChecker.isOneOf(input)) return [ input, null ]; else if (LlmTypeChecker.isObject(input)) return separateObject(predicator)(input); else if (LlmTypeChecker.isArray(input)) return separateArray(predicator)(input);
-        return [ input, null ];
-    };
-    const separateArray = predicator => input => {
-        const [x, y] = LlmSchemaSeparator.schema(predicator)(input.items);
-        return [ x !== null ? {
-            ...input,
-            items: x
-        } : null, y !== null ? {
-            ...input,
-            items: y
-        } : null ];
-    };
-    const separateObject = predicator => input => {
-        if (!!input.additionalProperties || Object.keys(input.properties ?? {}).length === 0) return [ input, null ];
-        const llm = {
-            ...input,
-            properties: {}
-        };
-        const human = {
-            ...input,
-            properties: {}
-        };
-        for (const [key, value] of Object.entries(input.properties ?? {})) {
-            const [x, y] = LlmSchemaSeparator.schema(predicator)(value);
-            if (x !== null) llm.properties[key] = x;
-            if (y !== null) human.properties[key] = y;
-        }
-        return [ Object.keys(llm.properties).length === 0 ? null : shrinkRequired(llm), Object.keys(human.properties).length === 0 ? null : shrinkRequired(human) ];
-    };
-    const shrinkRequired = input => {
-        if (input.required !== undefined) input.required = input.required.filter((key => input.properties?.[key] !== undefined));
-        return input;
-    };
-})(LlmSchemaSeparator || (LlmSchemaSeparator = {}));
-
-const application$2 = () => ({
-    finalize: (app, options) => {
-        app.options = {
-            separate: options?.separate ?? null,
-        };
-        if (app.options.separate === null)
-            return;
-        for (const func of app.functions)
-            func.separated = LlmSchemaSeparator.parameters({
-                parameters: func.parameters,
-                predicator: app.options.separate,
-            });
-    },
-});
-
-const random$1 = () => ({
-    generator: RandomGenerator,
-    pick: pick,
-});
-
 /**
  * @internal
  */
@@ -1389,25 +117,25 @@ function halt$8(name) {
 }
 
 var functional = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	assertEqualsFunction: assertEqualsFunction,
-	assertEqualsParameters: assertEqualsParameters,
-	assertEqualsReturn: assertEqualsReturn,
-	assertFunction: assertFunction,
-	assertParameters: assertParameters,
-	assertReturn: assertReturn,
-	equalsFunction: equalsFunction,
-	equalsParameters: equalsParameters,
-	equalsReturn: equalsReturn,
-	isFunction: isFunction,
-	isParameters: isParameters,
-	isReturn: isReturn,
-	validateEqualsFunction: validateEqualsFunction,
-	validateEqualsParameters: validateEqualsParameters,
-	validateEqualsReturn: validateEqualsReturn,
-	validateFunction: validateFunction,
-	validateParameters: validateParameters,
-	validateReturn: validateReturn
+  __proto__: null,
+  assertEqualsFunction: assertEqualsFunction,
+  assertEqualsParameters: assertEqualsParameters,
+  assertEqualsReturn: assertEqualsReturn,
+  assertFunction: assertFunction,
+  assertParameters: assertParameters,
+  assertReturn: assertReturn,
+  equalsFunction: equalsFunction,
+  equalsParameters: equalsParameters,
+  equalsReturn: equalsReturn,
+  isFunction: isFunction,
+  isParameters: isParameters,
+  isReturn: isReturn,
+  validateEqualsFunction: validateEqualsFunction,
+  validateEqualsParameters: validateEqualsParameters,
+  validateEqualsReturn: validateEqualsReturn,
+  validateFunction: validateFunction,
+  validateParameters: validateParameters,
+  validateReturn: validateReturn
 });
 
 /**
@@ -1574,33 +302,33 @@ function halt$7(name) {
 }
 
 var http = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	assertFormData: assertFormData,
-	assertHeaders: assertHeaders,
-	assertQuery: assertQuery,
-	createAssertFormData: createAssertFormData,
-	createAssertHeaders: createAssertHeaders,
-	createAssertQuery: createAssertQuery,
-	createFormData: createFormData,
-	createHeaders: createHeaders,
-	createIsFormData: createIsFormData,
-	createIsHeaders: createIsHeaders,
-	createIsQuery: createIsQuery,
-	createParameter: createParameter,
-	createQuery: createQuery,
-	createValidateFormData: createValidateFormData,
-	createValidateHeaders: createValidateHeaders,
-	createValidateQuery: createValidateQuery,
-	formData: formData,
-	headers: headers,
-	isFormData: isFormData,
-	isHeaders: isHeaders,
-	isQuery: isQuery,
-	parameter: parameter,
-	query: query,
-	validateFormData: validateFormData,
-	validateHeaders: validateHeaders,
-	validateQuery: validateQuery
+  __proto__: null,
+  assertFormData: assertFormData,
+  assertHeaders: assertHeaders,
+  assertQuery: assertQuery,
+  createAssertFormData: createAssertFormData,
+  createAssertHeaders: createAssertHeaders,
+  createAssertQuery: createAssertQuery,
+  createFormData: createFormData,
+  createHeaders: createHeaders,
+  createIsFormData: createIsFormData,
+  createIsHeaders: createIsHeaders,
+  createIsQuery: createIsQuery,
+  createParameter: createParameter,
+  createQuery: createQuery,
+  createValidateFormData: createValidateFormData,
+  createValidateHeaders: createValidateHeaders,
+  createValidateQuery: createValidateQuery,
+  formData: formData,
+  headers: headers,
+  isFormData: isFormData,
+  isHeaders: isHeaders,
+  isQuery: isQuery,
+  parameter: parameter,
+  query: query,
+  validateFormData: validateFormData,
+  validateHeaders: validateHeaders,
+  validateQuery: validateQuery
 });
 
 /**
@@ -1609,8 +337,6 @@ var http = /*#__PURE__*/Object.freeze({
 function application$1() {
     halt$6("application");
 }
-const applicationPure = /** @__PURE__ */ Object.assign(application$1, 
-/** @__PURE__ */ application$2());
 /**
  * @internal
  */
@@ -1625,9 +351,9 @@ function halt$6(name) {
 }
 
 var llm = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	application: applicationPure,
-	schema: schema
+  __proto__: null,
+  application: application$1,
+  schema: schema
 });
 
 /**
@@ -1728,22 +454,22 @@ function halt$5(name) {
 }
 
 var json = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	application: application,
-	assertParse: assertParse,
-	assertStringify: assertStringify,
-	createAssertParse: createAssertParse,
-	createAssertStringify: createAssertStringify,
-	createIsParse: createIsParse,
-	createIsStringify: createIsStringify,
-	createStringify: createStringify,
-	createValidateParse: createValidateParse,
-	createValidateStringify: createValidateStringify,
-	isParse: isParse,
-	isStringify: isStringify,
-	stringify: stringify,
-	validateParse: validateParse,
-	validateStringify: validateStringify
+  __proto__: null,
+  application: application,
+  assertParse: assertParse,
+  assertStringify: assertStringify,
+  createAssertParse: createAssertParse,
+  createAssertStringify: createAssertStringify,
+  createIsParse: createIsParse,
+  createIsStringify: createIsStringify,
+  createStringify: createStringify,
+  createValidateParse: createValidateParse,
+  createValidateStringify: createValidateStringify,
+  isParse: isParse,
+  isStringify: isStringify,
+  stringify: stringify,
+  validateParse: validateParse,
+  validateStringify: validateStringify
 });
 
 /**
@@ -1856,24 +582,24 @@ function halt$4(name) {
 }
 
 var misc = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	assertClone: assertClone,
-	assertPrune: assertPrune,
-	clone: clone,
-	createAssertClone: createAssertClone,
-	createAssertPrune: createAssertPrune,
-	createClone: createClone,
-	createIsClone: createIsClone,
-	createIsPrune: createIsPrune,
-	createPrune: createPrune,
-	createValidateClone: createValidateClone,
-	createValidatePrune: createValidatePrune,
-	isClone: isClone,
-	isPrune: isPrune,
-	literals: literals,
-	prune: prune,
-	validateClone: validateClone,
-	validatePrune: validatePrune
+  __proto__: null,
+  assertClone: assertClone,
+  assertPrune: assertPrune,
+  clone: clone,
+  createAssertClone: createAssertClone,
+  createAssertPrune: createAssertPrune,
+  createClone: createClone,
+  createIsClone: createIsClone,
+  createIsPrune: createIsPrune,
+  createPrune: createPrune,
+  createValidateClone: createValidateClone,
+  createValidatePrune: createValidatePrune,
+  isClone: isClone,
+  isPrune: isPrune,
+  literals: literals,
+  prune: prune,
+  validateClone: validateClone,
+  validatePrune: validatePrune
 });
 
 /**
@@ -2028,31 +754,31 @@ function halt$3(name) {
 }
 
 var notations = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	assertCamel: assertCamel,
-	assertPascal: assertPascal,
-	assertSnake: assertSnake,
-	camel: camel,
-	createAssertCamel: createAssertCamel,
-	createAssertPascal: createAssertPascal,
-	createAssertSnake: createAssertSnake,
-	createCamel: createCamel,
-	createIsCamel: createIsCamel,
-	createIsPascal: createIsPascal,
-	createIsSnake: createIsSnake,
-	createPascal: createPascal,
-	createSnake: createSnake,
-	createValidateCamel: createValidateCamel,
-	createValidatePascal: createValidatePascal,
-	createValidateSnake: createValidateSnake,
-	isCamel: isCamel,
-	isPascal: isPascal,
-	isSnake: isSnake,
-	pascal: pascal,
-	snake: snake,
-	validateCamel: validateCamel,
-	validatePascal: validatePascal,
-	validateSnake: validateSnake
+  __proto__: null,
+  assertCamel: assertCamel,
+  assertPascal: assertPascal,
+  assertSnake: assertSnake,
+  camel: camel,
+  createAssertCamel: createAssertCamel,
+  createAssertPascal: createAssertPascal,
+  createAssertSnake: createAssertSnake,
+  createCamel: createCamel,
+  createIsCamel: createIsCamel,
+  createIsPascal: createIsPascal,
+  createIsSnake: createIsSnake,
+  createPascal: createPascal,
+  createSnake: createSnake,
+  createValidateCamel: createValidateCamel,
+  createValidatePascal: createValidatePascal,
+  createValidateSnake: createValidateSnake,
+  isCamel: isCamel,
+  isPascal: isPascal,
+  isSnake: isSnake,
+  pascal: pascal,
+  snake: snake,
+  validateCamel: validateCamel,
+  validatePascal: validatePascal,
+  validateSnake: validateSnake
 });
 
 /**
@@ -2165,24 +891,24 @@ function halt$2(name) {
 }
 
 var protobuf = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	assertDecode: assertDecode,
-	assertEncode: assertEncode,
-	createAssertDecode: createAssertDecode,
-	createAssertEncode: createAssertEncode,
-	createDecode: createDecode,
-	createEncode: createEncode,
-	createIsDecode: createIsDecode,
-	createIsEncode: createIsEncode,
-	createValidateDecode: createValidateDecode,
-	createValidateEncode: createValidateEncode,
-	decode: decode,
-	encode: encode,
-	isDecode: isDecode,
-	isEncode: isEncode,
-	message: message,
-	validateDecode: validateDecode,
-	validateEncode: validateEncode
+  __proto__: null,
+  assertDecode: assertDecode,
+  assertEncode: assertEncode,
+  createAssertDecode: createAssertDecode,
+  createAssertEncode: createAssertEncode,
+  createDecode: createDecode,
+  createEncode: createEncode,
+  createIsDecode: createIsDecode,
+  createIsEncode: createIsEncode,
+  createValidateDecode: createValidateDecode,
+  createValidateEncode: createValidateEncode,
+  decode: decode,
+  encode: encode,
+  isDecode: isDecode,
+  isEncode: isEncode,
+  message: message,
+  validateDecode: validateDecode,
+  validateEncode: validateEncode
 });
 
 /**
@@ -2202,15 +928,39 @@ function halt$1(name) {
 }
 
 var reflect = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	metadata: metadata,
-	name: name
+  __proto__: null,
+  metadata: metadata,
+  name: name
 });
 
 var index = /*#__PURE__*/Object.freeze({
-	__proto__: null
+  __proto__: null
 });
 
+class TypeGuardError extends Error {
+    method;
+    path;
+    expected;
+    value;
+    fake_expected_typed_value_;
+    constructor(props) {
+        // MESSAGE CONSTRUCTION
+        super(props.message ||
+            `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf)
+            Object.setPrototypeOf(this, proto);
+        else
+            this.__proto__ = proto;
+        // ASSIGN MEMBERS
+        this.method = props.method;
+        this.path = props.path;
+        this.expected = props.expected;
+        this.value = props.value;
+    }
+}
+
 /**
  * @internal
  */
@@ -2265,8 +1015,6 @@ function validateEquals() {
 function random() {
     halt("random");
 }
-const randomPure = /** @__PURE__ */ Object.assign(random, 
-/** @__PURE__ */ random$1());
 /**
  * @internal
  */
@@ -2321,7 +1069,6 @@ function createValidateEquals() {
 function createRandom() {
     halt("createRandom");
 }
-const createRandomPure = /** @__PURE__ */ Object.assign(createRandom, randomPure);
 /**
  * @internal
  */
@@ -2330,36 +1077,36 @@ function halt(name) {
 }
 
 var typia = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	TypeGuardError: TypeGuardError,
-	assert: assert,
-	assertEquals: assertEquals,
-	assertGuard: assertGuard,
-	assertGuardEquals: assertGuardEquals,
-	createAssert: createAssert,
-	createAssertEquals: createAssertEquals,
-	createAssertGuard: createAssertGuard,
-	createAssertGuardEquals: createAssertGuardEquals,
-	createEquals: createEquals,
-	createIs: createIs,
-	createRandom: createRandomPure,
-	createValidate: createValidate,
-	createValidateEquals: createValidateEquals,
-	equals: equals,
-	functional: functional,
-	http: http,
-	is: is,
-	json: json,
-	llm: llm,
-	misc: misc,
-	notations: notations,
-	protobuf: protobuf,
-	random: randomPure,
-	reflect: reflect,
-	tags: index,
-	validate: validate,
-	validateEquals: validateEquals
+  __proto__: null,
+  TypeGuardError: TypeGuardError,
+  assert: assert,
+  assertEquals: assertEquals,
+  assertGuard: assertGuard,
+  assertGuardEquals: assertGuardEquals,
+  createAssert: createAssert,
+  createAssertEquals: createAssertEquals,
+  createAssertGuard: createAssertGuard,
+  createAssertGuardEquals: createAssertGuardEquals,
+  createEquals: createEquals,
+  createIs: createIs,
+  createRandom: createRandom,
+  createValidate: createValidate,
+  createValidateEquals: createValidateEquals,
+  equals: equals,
+  functional: functional,
+  http: http,
+  is: is,
+  json: json,
+  llm: llm,
+  misc: misc,
+  notations: notations,
+  protobuf: protobuf,
+  random: random,
+  reflect: reflect,
+  tags: index,
+  validate: validate,
+  validateEquals: validateEquals
 });
 
-export { TypeGuardError, assert, assertEquals, assertGuard, assertGuardEquals, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandomPure as createRandom, createValidate, createValidateEquals, typia as default, equals, functional, http, is, json, llm, misc, notations, protobuf, randomPure as random, reflect, index as tags, validate, validateEquals };
+export { TypeGuardError, assert, assertEquals, assertGuard, assertGuardEquals, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandom, createValidate, createValidateEquals, typia as default, equals, functional, http, is, json, llm, misc, notations, protobuf, random, reflect, index as tags, validate, validateEquals };
 //# sourceMappingURL=index.mjs.map