typia 6.0.5 → 6.0.6-dev.20240604

package/lib/index.mjs

@@ -0,0 +1,1921 @@
+import RandExp from "randexp";
+
+const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+
+const boolean$4 = () => Math.random() < .5;
+
+const integer = (min, max) => {
+    min ?? (min = 0);
+    max ?? (max = 100);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+const bigint$4 = (min, max) => BigInt(integer(Number(min ?? BigInt(0)), Number(max ?? BigInt(100))));
+
+const number$4 = (min, max) => {
+    min ?? (min = 0);
+    max ?? (max = 100);
+    return Math.random() * (max - min) + min;
+};
+
+const string$4 = length => new Array(length ?? integer(5, 10)).fill(0).map((() => ALPHABETS[integer(0, ALPHABETS.length - 1)])).join("");
+
+const array$2 = (closure, count) => new Array(count ?? length()).fill(0).map(((_e, index) => closure(index)));
+
+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();
+};
+
+const byte = () => "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";
+
+const password = () => string$4(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 & 3 | 8;
+    return v.toString(16);
+}));
+
+const email = () => `${string$4(10)}@${string$4(10)}.${string$4(3)}`;
+
+const hostname = () => `${string$4(10)}.${string$4(3)}`;
+
+const idnEmail = () => email();
+
+const idnHostname = () => hostname();
+
+const iri = () => url();
+
+const iriReference = () => url();
+
+const ipv4 = () => array$2((() => integer(0, 255)), 4).join(".");
+
+const ipv6 = () => array$2((() => integer(0, 65535).toString(16)), 8).join(":");
+
+const uri = () => url();
+
+const uriReference = () => url();
+
+const uriTemplate = () => url();
+
+const url = () => `https://${string$4(10)}.${string$4(3)}`;
+
+const datetime = (min, max) => new Date(number$4(min ?? Date.now() - 30 * DAY, max ?? Date.now() + 7 * DAY)).toISOString();
+
+const date = (min, max) => new Date(number$4(min ?? 0, max ?? Date.now() * 2)).toISOString().substring(0, 10);
+
+const time = () => new Date(number$4(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}`;
+};
+
+const jsonPointer = () => `/components/schemas/${string$4(10)}`;
+
+const relativeJsonPointer = () => `${integer(0, 10)}#`;
+
+const DAY = 864e5;
+
+const durate = elements => elements.filter((([_unit, value]) => value !== 0)).map((([unit, value]) => `${value}${unit}`)).join("");
+
+var RandomGenerator = Object.freeze({
+    __proto__: null,
+    array: array$2,
+    bigint: bigint$4,
+    boolean: boolean$4,
+    byte,
+    date,
+    datetime,
+    duration,
+    email,
+    hostname,
+    idnEmail,
+    idnHostname,
+    integer,
+    ipv4,
+    ipv6,
+    iri,
+    iriReference,
+    jsonPointer,
+    length,
+    number: number$4,
+    password,
+    pattern,
+    pick,
+    regex,
+    relativeJsonPointer,
+    string: string$4,
+    time,
+    uri,
+    uriReference,
+    uriTemplate,
+    url,
+    uuid
+});
+
+const $every = (array, pred) => {
+    let error = null;
+    for (let i = 0; i < array.length; ++i) if (null !== (error = pred(array[i], i))) return error;
+    return null;
+};
+
+class TypeGuardError extends Error {
+    constructor(props) {
+        super(props.message || `Error on ${props.method}(): invalid type${props.path ? ` on ${props.path}` : ""}, expect to be ${props.expected}`);
+        const proto = new.target.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;
+    }
+}
+
+const $guard = method => (exceptionable, props, factory) => {
+    if (exceptionable === true) throw (factory ?? (props => new TypeGuardError(props)))({
+        method,
+        path: props.path,
+        expected: props.expected,
+        value: props.value
+    });
+    return false;
+};
+
+const $join = str => variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`;
+
+const variable = str => reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+
+const reserved = str => RESERVED.has(str);
+
+const RESERVED = 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" ]);
+
+const $report = array => {
+    const reportable = path => {
+        if (array.length === 0) return true;
+        const last = array[array.length - 1].path;
+        return path.length > last.length || last.substring(0, path.length) !== path;
+    };
+    return (exceptable, error) => {
+        if (exceptable && reportable(error.path)) array.push(error);
+        return false;
+    };
+};
+
+const $is_between = (value, minimum, maximum) => minimum <= value && value <= maximum;
+
+const $is_bigint_string = str => {
+    try {
+        BigInt(str);
+        return true;
+    } catch {
+        return false;
+    }
+};
+
+const is$1 = () => ({
+    is_between: $is_between,
+    is_bigint_string: $is_bigint_string
+});
+
+const functionalAssert = () => ({
+    errorFactory: p => new TypeGuardError(p)
+});
+
+const $number = value => {
+    if (isFinite(value) === false) throw new TypeGuardError({
+        method: "typia.json.stringify",
+        expected: "number",
+        value,
+        message: "Error on typia.json.stringify(): infinite or not a number."
+    });
+    return value;
+};
+
+const $rest = str => str.length === 2 ? "" : "," + str.substring(1, str.length - 1);
+
+const $string = str => {
+    const len = str.length;
+    let result = "";
+    let last = -1;
+    let point = 255;
+    for (var i = 0; i < len; 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) + '"';
+};
+
+const $tail = str => str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
+
+const $throws = method => props => {
+    throw new TypeGuardError({
+        ...props,
+        method: `typia.${method}`
+    });
+};
+
+const stringify$1 = method => ({
+    ...is$1(),
+    number: $number,
+    string: $string,
+    tail: $tail,
+    rest: $rest,
+    throws: $throws(`json.${method}`)
+});
+
+const boolean$3 = input => input instanceof File ? input : input === null ? undefined : input === "null" ? null : input.length === 0 ? true : input === "true" || input === "1" ? true : input === "false" || input === "0" ? false : input;
+
+const number$3 = input => input instanceof File ? input : !!input?.length ? input === "null" ? null : toNumber$3(input) : undefined;
+
+const bigint$3 = input => input instanceof File ? input : !!input?.length ? input === "null" ? null : toBigint$3(input) : undefined;
+
+const string$3 = input => input instanceof File ? input : input === null ? undefined : input === "null" ? null : input;
+
+const array$1 = (input, alternative) => input.length ? input : alternative;
+
+const blob = input => input instanceof Blob ? input : input === null ? undefined : input === "null" ? null : input;
+
+const file = input => input instanceof File ? input : input === null ? undefined : input === "null" ? null : input;
+
+const toNumber$3 = str => {
+    const value = Number(str);
+    return isNaN(value) ? str : value;
+};
+
+const toBigint$3 = str => {
+    try {
+        return BigInt(str);
+    } catch {
+        return str;
+    }
+};
+
+var $FormDataReader = Object.freeze({
+    __proto__: null,
+    array: array$1,
+    bigint: bigint$3,
+    blob,
+    boolean: boolean$3,
+    file,
+    number: number$3,
+    string: string$3
+});
+
+const boolean$2 = value => value !== undefined ? value === "true" ? true : value === "false" ? false : value : undefined;
+
+const bigint$2 = value => value !== undefined ? toBigint$2(value) : undefined;
+
+const number$2 = value => value !== undefined ? toNumber$2(value) : undefined;
+
+const string$2 = value => value;
+
+const toBigint$2 = str => {
+    try {
+        return BigInt(str);
+    } catch {
+        return str;
+    }
+};
+
+const toNumber$2 = str => {
+    const value = Number(str);
+    return isNaN(value) ? str : value;
+};
+
+var $HeadersReader = Object.freeze({
+    __proto__: null,
+    bigint: bigint$2,
+    boolean: boolean$2,
+    number: number$2,
+    string: string$2
+});
+
+const boolean$1 = value => value !== "null" ? value === "true" || value === "1" ? true : value === "false" || value === "0" ? false : value : null;
+
+const bigint$1 = value => value !== "null" ? toBigint$1(value) : null;
+
+const number$1 = value => value !== "null" ? toNumber$1(value) : null;
+
+const string$1 = value => value !== "null" ? value : null;
+
+const toNumber$1 = str => {
+    const value = Number(str);
+    return isNaN(value) ? str : value;
+};
+
+const toBigint$1 = str => {
+    try {
+        return BigInt(str);
+    } catch {
+        return str;
+    }
+};
+
+var $ParameterReader = Object.freeze({
+    __proto__: null,
+    bigint: bigint$1,
+    boolean: boolean$1,
+    number: number$1,
+    string: string$1
+});
+
+const boolean = str => str === null ? undefined : str === "null" ? null : str.length === 0 ? true : str === "true" || str === "1" ? true : str === "false" || str === "0" ? false : str;
+
+const number = str => !!str?.length ? str === "null" ? null : toNumber(str) : undefined;
+
+const bigint = str => !!str?.length ? str === "null" ? null : toBigint(str) : undefined;
+
+const string = str => str === null ? undefined : str === "null" ? null : str;
+
+const params = input => {
+    if (typeof input === "string") {
+        const index = input.indexOf("?");
+        input = index === -1 ? "" : input.substring(index + 1);
+        return new URLSearchParams(input);
+    }
+    return input;
+};
+
+const array = (input, alternative) => input.length ? input : alternative;
+
+const toNumber = str => {
+    const value = Number(str);
+    return isNaN(value) ? str : value;
+};
+
+const toBigint = str => {
+    try {
+        return BigInt(str);
+    } catch {
+        return str;
+    }
+};
+
+var $QueryReader = Object.freeze({
+    __proto__: null,
+    array,
+    bigint,
+    boolean,
+    number,
+    params,
+    string
+});
+
+const formData$1 = () => $FormDataReader;
+
+const headers$1 = () => $HeadersReader;
+
+const parameter$1 = () => $ParameterReader;
+
+const query$1 = () => $QueryReader;
+
+const capitalize = str => str.length ? str[0].toUpperCase() + str.slice(1) : str;
+
+function snake$2(str) {
+    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 ret;
+}
+
+function camel$2(str) {
+    return unsnake((str => {
+        if (str.length === 0) return str; else if (str[0] === str[0].toUpperCase()) return str[0].toLowerCase() + str.substring(1); else return str;
+    }))(str);
+}
+
+function pascal$2(str) {
+    return unsnake((str => {
+        if (str.length === 0) return str; else if (str[0] === str[0].toLowerCase()) return str[0].toUpperCase() + str.substring(1); else return str;
+    }))(str);
+}
+
+const unsnake = escaper => str => {
+    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 indexes = [];
+    for (let i = 0; i < str.length; i++) {
+        const ch = str[i];
+        if (ch !== "_") continue;
+        const last = indexes[indexes.length - 1];
+        if (last === undefined || last[0] + last[1] !== i) indexes.push([ i, 1 ]); else ++last[1];
+    }
+    if (indexes.length === 0) return prefix + escaper(str);
+    let ret = "";
+    for (let i = 0; i < indexes.length; i++) {
+        const [first] = indexes[i];
+        if (i === 0) if (first === 0) ret += "_"; else ret += str.substring(0, first); else {
+            const [prevFirst, prevLength] = indexes[i - 1];
+            const piece = str.substring(prevFirst + prevLength, first);
+            if (piece.length) ret += capitalize(piece);
+        }
+    }
+    const last = indexes[indexes.length - 1];
+    const piece = str.substring(last[0] + last[1]);
+    if (last.length) ret += capitalize(piece);
+    return prefix + escaper(ret);
+};
+
+const $convention = rename => {
+    const main = input => {
+        if (typeof input === "object") if (input === null) return null; else if (Array.isArray(input)) return input.map(main); else if (input instanceof Boolean || input instanceof BigInt || input instanceof Number || input instanceof String) return input.valueOf(); else if (input instanceof Date) return new Date(input); else if (input instanceof Uint8Array || input instanceof Uint8ClampedArray || input instanceof Uint16Array || input instanceof Uint32Array || input instanceof BigUint64Array || input instanceof Int8Array || input instanceof Int16Array || input instanceof Int32Array || input instanceof BigInt64Array || input instanceof Float32Array || input instanceof Float64Array || input instanceof DataView) return input; else return object(input);
+        return input;
+    };
+    const object = input => Object.fromEntries(Object.entries(input).map((([key, value]) => [ rename(key), main(value) ])));
+    return main;
+};
+
+const camel$1 = method => ({
+    ...base(method),
+    any: $convention(camel$2)
+});
+
+const pascal$1 = method => ({
+    ...base(method),
+    any: $convention(pascal$2)
+});
+
+const snake$1 = method => ({
+    ...base(method),
+    any: $convention(snake$2)
+});
+
+const base = method => ({
+    ...is$1(),
+    throws: $throws(`notations.${method}`)
+});
+
+const $clone = value => JSON.parse(JSON.stringify(value));
+
+const $any = val => val !== undefined ? $clone(val) : undefined;
+
+const clone$1 = method => ({
+    ...is$1(),
+    throws: $throws(`misc.${method}`),
+    any: $any
+});
+
+const prune$1 = method => ({
+    ...is$1(),
+    throws: $throws(`misc.${method}`)
+});
+
+class $ProtobufReader {
+    constructor(buf) {
+        this.buf = buf;
+        this.ptr = 0;
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    index() {
+        return this.ptr;
+    }
+    size() {
+        return this.buf.length;
+    }
+    uint32() {
+        return this.varint32();
+    }
+    int32() {
+        return this.varint32();
+    }
+    sint32() {
+        const value = this.varint32();
+        return value >>> 1 ^ -(value & 1);
+    }
+    uint64() {
+        return this.varint64();
+    }
+    int64() {
+        return this.varint64();
+    }
+    sint64() {
+        const value = this.varint64();
+        return value >> N01 ^ -(value & N01);
+    }
+    bool() {
+        return this.varint32() !== 0;
+    }
+    float() {
+        const value = this.view.getFloat32(this.ptr, true);
+        this.ptr += 4;
+        return value;
+    }
+    double() {
+        const value = this.view.getFloat64(this.ptr, true);
+        this.ptr += 8;
+        return value;
+    }
+    bytes() {
+        const length = this.uint32();
+        const from = this.ptr;
+        this.ptr += length;
+        return this.buf.subarray(from, from + length);
+    }
+    string() {
+        return utf8$1.decode(this.bytes());
+    }
+    skip(length) {
+        if (length === 0) while (this.u8() & 128) ; else {
+            if (this.index() + length > this.size()) throw new Error("Error on typia.protobuf.decode(): buffer overflow.");
+            this.ptr += length;
+        }
+    }
+    skipType(wireType) {
+        switch (wireType) {
+          case 0:
+            this.skip(0);
+            break;
+
+          case 1:
+            this.skip(8);
+            break;
+
+          case 2:
+            this.skip(this.uint32());
+            break;
+
+          case 3:
+            while ((wireType = this.uint32() & 7) !== 4) this.skipType(wireType);
+            break;
+
+          case 5:
+            this.skip(4);
+            break;
+
+          default:
+            throw new Error(`Invalid wire type ${wireType} at offset ${this.ptr}.`);
+        }
+    }
+    varint32() {
+        let loaded;
+        let value;
+        value = (loaded = this.u8()) & 127;
+        if (loaded < 128) return value;
+        value |= ((loaded = this.u8()) & 127) << 7;
+        if (loaded < 128) return value;
+        value |= ((loaded = this.u8()) & 127) << 14;
+        if (loaded < 128) return value;
+        value |= ((loaded = this.u8()) & 127) << 21;
+        if (loaded < 128) return value;
+        value |= ((loaded = this.u8()) & 15) << 28;
+        if (loaded < 128) return value;
+        if (this.u8() < 128) return value;
+        if (this.u8() < 128) return value;
+        if (this.u8() < 128) return value;
+        if (this.u8() < 128) return value;
+        if (this.u8() < 128) return value;
+        return value;
+    }
+    varint64() {
+        let loaded;
+        let value;
+        value = (loaded = this.u8n()) & N7F;
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(7);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(14);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(21);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(28);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(35);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(42);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(49);
+        if (loaded < N80) return value;
+        value |= ((loaded = this.u8n()) & N7F) << BigInt(56);
+        if (loaded < N80) return value;
+        value |= (this.u8n() & N01) << BigInt(63);
+        return BigInt.asIntN(64, value);
+    }
+    u8() {
+        return this.view.getUint8(this.ptr++);
+    }
+    u8n() {
+        return BigInt(this.u8());
+    }
+}
+
+const utf8$1 = new TextDecoder;
+
+const N01 = BigInt(1);
+
+const N7F = BigInt(127);
+
+const N80 = BigInt(128);
+
+const $strlen = s => {
+    let b;
+    let i;
+    let c;
+    for (b = i = 0; c = s.charCodeAt(i++); b += c >> 11 ? 3 : c >> 7 ? 2 : 1) ;
+    return b;
+};
+
+class $ProtobufSizer {
+    constructor(length = 0) {
+        this.len = length;
+        this.pos = [];
+        this.varlen = [];
+        this.varlenidx = [];
+    }
+    bool() {
+        this.len += 1;
+    }
+    int32(value) {
+        if (value < 0) {
+            this.len += 10;
+        } else {
+            this.varint32(value);
+        }
+    }
+    sint32(value) {
+        this.varint32(value << 1 ^ value >> 31);
+    }
+    uint32(value) {
+        this.varint32(value);
+    }
+    int64(value) {
+        this.varint64(typeof value === "number" ? BigInt(value) : value);
+    }
+    sint64(value) {
+        if (typeof value === "number") value = BigInt(value);
+        this.varint64(value << BigInt(1) ^ value >> BigInt(63));
+    }
+    uint64(value) {
+        this.varint64(typeof value === "number" ? BigInt(value) : value);
+    }
+    float(_value) {
+        this.len += 4;
+    }
+    double(_value) {
+        this.len += 8;
+    }
+    bytes(value) {
+        this.uint32(value.byteLength);
+        this.len += value.byteLength;
+    }
+    string(value) {
+        const len = $strlen(value);
+        this.varlen.push(len);
+        this.uint32(len);
+        this.len += len;
+    }
+    fork() {
+        this.pos.push(this.len);
+        this.varlenidx.push(this.varlen.length);
+        this.varlen.push(0);
+    }
+    ldelim() {
+        if (!(this.pos.length && this.varlenidx.length)) throw new Error("Error on typia.protobuf.encode(): missing fork() before ldelim() call.");
+        const endPos = this.len;
+        const startPos = this.pos.pop();
+        const idx = this.varlenidx.pop();
+        const len = endPos - startPos;
+        this.varlen[idx] = len;
+        this.uint32(len);
+    }
+    reset() {
+        this.len = 0;
+        this.pos.length = 0;
+        this.varlen.length = 0;
+        this.varlenidx.length = 0;
+    }
+    varint32(value) {
+        this.len += value < 0 ? 10 : value < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5;
+    }
+    varint64(val) {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F$1) {
+            ++this.len;
+            val = val >> ND07$1;
+        }
+        ++this.len;
+    }
+}
+
+const ND07$1 = BigInt(7);
+
+const NX7F$1 = BigInt(127);
+
+class $ProtobufWriter {
+    constructor(sizer) {
+        this.sizer = sizer;
+        this.buf = new Uint8Array(sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+    buffer() {
+        return this.buf;
+    }
+    bool(value) {
+        this.byte(value ? 1 : 0);
+    }
+    byte(value) {
+        this.buf[this.ptr++] = value & 255;
+    }
+    int32(value) {
+        if (value < 0) this.int64(value); else this.variant32(value >>> 0);
+    }
+    sint32(value) {
+        this.variant32(value << 1 ^ value >> 31);
+    }
+    uint32(value) {
+        this.variant32(value);
+    }
+    sint64(value) {
+        value = BigInt(value);
+        this.variant64(value << ND01 ^ value >> ND63);
+    }
+    int64(value) {
+        this.variant64(BigInt(value));
+    }
+    uint64(value) {
+        this.variant64(BigInt(value));
+    }
+    float(val) {
+        this.view.setFloat32(this.ptr, val, true);
+        this.ptr += 4;
+    }
+    double(val) {
+        this.view.setFloat64(this.ptr, val, true);
+        this.ptr += 8;
+    }
+    bytes(value) {
+        this.uint32(value.byteLength);
+        for (let i = 0; i < value.byteLength; i++) this.buf[this.ptr++] = value[i];
+    }
+    string(value) {
+        const len = this.varlen();
+        this.uint32(len);
+        const binary = utf8.encode(value);
+        for (let i = 0; i < binary.byteLength; i++) this.buf[this.ptr++] = binary[i];
+    }
+    fork() {
+        this.uint32(this.varlen());
+    }
+    ldelim() {}
+    finish() {
+        return this.buf;
+    }
+    reset() {
+        this.buf = new Uint8Array(this.sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+    variant32(val) {
+        while (val > 127) {
+            this.buf[this.ptr++] = val & 127 | 128;
+            val = val >>> 7;
+        }
+        this.buf[this.ptr++] = val;
+    }
+    variant64(val) {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F) {
+            this.buf[this.ptr++] = Number(val & NX7F | NX80);
+            val = val >> ND07;
+        }
+        this.buf[this.ptr++] = Number(val);
+    }
+    varlen() {
+        return this.varlenidx >= this.sizer.varlen.length ? 0 : this.sizer.varlen[this.varlenidx++];
+    }
+}
+
+const utf8 = new TextEncoder;
+
+const ND01 = BigInt(1);
+
+const ND07 = BigInt(7);
+
+const ND63 = BigInt(63);
+
+const NX7F = BigInt(127);
+
+const NX80 = BigInt(128);
+
+const decode$1 = method => ({
+    ...is$1(),
+    Reader: $ProtobufReader,
+    throws: $throws(`protobuf.${method}`)
+});
+
+const encode$1 = method => ({
+    ...is$1(),
+    Sizer: $ProtobufSizer,
+    Writer: $ProtobufWriter,
+    strlen: $strlen,
+    throws: $throws(method)
+});
+
+const assert$1 = method => ({
+    ...is$1(),
+    join: $join,
+    every: $every,
+    guard: $guard(`typia.${method}`),
+    predicate: (matched, exceptionable, closure) => {
+        if (matched === false && exceptionable === true) throw new TypeGuardError({
+            ...closure(),
+            method: `typia.${method}`
+        });
+        return matched;
+    }
+});
+
+const validate$1 = () => ({
+    ...is$1(),
+    join: $join,
+    report: $report,
+    predicate: res => (matched, exceptionable, closure) => {
+        if (matched === false && exceptionable === true) (() => {
+            res.success && (res.success = false);
+            const errorList = res.errors;
+            const error = closure();
+            if (errorList.length) {
+                const 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;
+    }
+});
+
+const random$1 = () => ({
+    generator: RandomGenerator,
+    pick
+});
+
+function assertFunction() {
+    halt$7("assertFunction");
+}
+
+const assertFunctionPure = Object.assign(assertFunction, assert$1("functional.assertFunction"), functionalAssert());
+
+const assertParametersPure = Object.assign(assertFunction, assert$1("functional.assertFunction"), functionalAssert());
+
+function assertReturn() {
+    halt$7("assertReturn");
+}
+
+const assertReturnPure = Object.assign(assertReturn, assert$1("functional.assertReturn"), functionalAssert());
+
+function assertEqualsFunction() {
+    halt$7("assertEqualsFunction");
+}
+
+const assertEqualsFunctionPure = Object.assign(assertEqualsFunction, assert$1("functional.assertEqualsFunction"), functionalAssert());
+
+function assertEqualsParameters() {
+    halt$7("assertEqualsParameters");
+}
+
+const assertEqualsParametersPure = Object.assign(assertEqualsParameters, assert$1("functional.assertEqualsParameters"), functionalAssert());
+
+function assertEqualsReturn() {
+    halt$7("assertEqualsReturn");
+}
+
+const assertEqualsReturnPure = Object.assign(assertEqualsReturn, assert$1("functional.assertEqualsReturn"), functionalAssert());
+
+function isFunction() {
+    halt$7("isFunction");
+}
+
+const isFunctionPure = Object.assign(isFunction, is$1());
+
+function isParameters() {
+    halt$7("isParameters");
+}
+
+const isParametersPure = Object.assign(isParameters, is$1());
+
+function isReturn() {
+    halt$7("isReturn");
+}
+
+const isReturnPure = Object.assign(isReturn, is$1());
+
+function equalsFunction() {
+    halt$7("equalsFunction");
+}
+
+const equalsFunctionPure = Object.assign(equalsFunction, is$1());
+
+function equalsParameters() {
+    halt$7("equalsParameters");
+}
+
+const equalsParametersPure = Object.assign(equalsParameters, is$1());
+
+function equalsReturn() {
+    halt$7("equalsReturn");
+}
+
+const equalsReturnPure = Object.assign(equalsReturn, is$1());
+
+function validateFunction() {
+    halt$7("validateFunction");
+}
+
+const validateFunctionPure = Object.assign(validateFunction, validate$1());
+
+function validateParameters() {
+    halt$7("validateReturn");
+}
+
+const validateParametersPure = Object.assign(validateParameters, validate$1());
+
+function validateReturn() {
+    halt$7("validateReturn");
+}
+
+const validateReturnPure = Object.assign(validateReturn, validate$1());
+
+function validateEqualsFunction() {
+    halt$7("validateEqualsFunction");
+}
+
+const validateEqualsFunctionPure = Object.assign(validateEqualsFunction, validate$1());
+
+function validateEqualsParameters() {
+    halt$7("validateEqualsParameters");
+}
+
+const validateEqualsParametersPure = Object.assign(validateEqualsParameters, validate$1());
+
+function validateEqualsReturn() {
+    halt$7("validateEqualsReturn");
+}
+
+const validateEqualsReturnPure = Object.assign(validateEqualsReturn, validate$1());
+
+function halt$7(name) {
+    throw new Error(`Error on typia.functional.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var functional = Object.freeze({
+    __proto__: null,
+    assertEqualsFunction: assertEqualsFunctionPure,
+    assertEqualsParameters: assertEqualsParametersPure,
+    assertEqualsReturn: assertEqualsReturnPure,
+    assertFunction: assertFunctionPure,
+    assertParameters: assertParametersPure,
+    assertReturn: assertReturnPure,
+    equalsFunction: equalsFunctionPure,
+    equalsParameters: equalsParametersPure,
+    equalsReturn: equalsReturnPure,
+    isFunction: isFunctionPure,
+    isParameters: isParametersPure,
+    isReturn: isReturnPure,
+    validateEqualsFunction: validateEqualsFunctionPure,
+    validateEqualsParameters: validateEqualsParametersPure,
+    validateEqualsReturn: validateEqualsReturnPure,
+    validateFunction: validateFunctionPure,
+    validateParameters: validateParametersPure,
+    validateReturn: validateReturnPure
+});
+
+function formData() {
+    halt$6("formData");
+}
+
+const formDataPure = Object.assign(formData, formData$1());
+
+function assertFormData() {
+    halt$6("assertFormData");
+}
+
+const assertFormDataPure = Object.assign(assertFormData, formData$1(), assert$1("http.assertFormData"));
+
+function isFormData() {
+    halt$6("isFormData");
+}
+
+const isFormDataPure = Object.assign(isFormData, formData$1(), is$1());
+
+function validateFormData() {
+    halt$6("validateFormData");
+}
+
+const validateFormDataPure = Object.assign(validateFormData, formData$1(), validate$1());
+
+function query() {
+    halt$6("query");
+}
+
+const queryPure = Object.assign(query, query$1());
+
+function assertQuery() {
+    halt$6("assertQuery");
+}
+
+const assertQueryPure = Object.assign(assertQuery, query$1(), assert$1("http.assertQuery"));
+
+function isQuery() {
+    halt$6("isQuery");
+}
+
+const isQueryPure = Object.assign(isQuery, query$1(), is$1());
+
+function validateQuery() {
+    halt$6("validateQuery");
+}
+
+const validateQueryPure = Object.assign(validateQuery, query$1(), validate$1());
+
+function headers() {
+    halt$6("headers");
+}
+
+const headersPure = Object.assign(headers, headers$1());
+
+function assertHeaders() {
+    halt$6("assertHeaders");
+}
+
+const assertHeadersPure = Object.assign(assertHeaders, headers$1(), assert$1("http.assertHeaders"));
+
+function isHeaders() {
+    halt$6("isHeaders");
+}
+
+const isHeadersPure = Object.assign(isHeaders, headers$1(), is$1());
+
+function validateHeaders() {
+    halt$6("validateHeaders");
+}
+
+const validateHeadersPure = Object.assign(validateHeaders, headers$1(), validate$1());
+
+function parameter() {
+    halt$6("parameter");
+}
+
+const parameterPure = Object.assign(parameter, parameter$1(), assert$1("http.parameter"));
+
+function createFormData() {
+    halt$6("createFormData");
+}
+
+const createFormDataPure = Object.assign(createFormData, formData$1());
+
+function createAssertFormData() {
+    halt$6("createAssertFormData");
+}
+
+const createAssertFormDataPure = Object.assign(createAssertFormData, formData$1(), assert$1("http.createAssertFormData"));
+
+function createIsFormData() {
+    halt$6("createIsFormData");
+}
+
+const createIsFormDataPure = Object.assign(createIsFormData, formData$1(), is$1());
+
+function createValidateFormData() {
+    halt$6("createValidateFormData");
+}
+
+const createValidateFormDataPure = Object.assign(createValidateFormData, formData$1(), validate$1());
+
+function createQuery() {
+    halt$6("createQuery");
+}
+
+const createQueryPure = Object.assign(createQuery, query$1());
+
+function createAssertQuery() {
+    halt$6("createAssertQuery");
+}
+
+const createAssertQueryPure = Object.assign(createAssertQuery, query$1(), assert$1("http.createAssertQuery"));
+
+function createIsQuery() {
+    halt$6("createIsQuery");
+}
+
+const createIsQueryPure = Object.assign(createIsQuery, query$1(), is$1());
+
+function createValidateQuery() {
+    halt$6("createValidateQuery");
+}
+
+const createValidateQueryPure = Object.assign(createValidateQuery, query$1(), validate$1());
+
+function createHeaders() {
+    halt$6("createHeaders");
+}
+
+const createHeadersPure = Object.assign(createHeaders, headers$1());
+
+function createAssertHeaders() {
+    halt$6("createAssertHeaders");
+}
+
+const createAssertHeadersPure = Object.assign(createAssertHeaders, headers$1(), assert$1("http.createAssertHeaders"));
+
+function createIsHeaders() {
+    halt$6("createIsHeaders");
+}
+
+const createIsHeadersPure = Object.assign(createIsHeaders, headers$1(), is$1());
+
+function createValidateHeaders() {
+    halt$6("createValidateHeaders");
+}
+
+const createValidateHeadersPure = Object.assign(createValidateHeaders, headers$1(), validate$1());
+
+function createParameter() {
+    halt$6("createParameter");
+}
+
+const createParameterPure = Object.assign(createParameter, parameter$1(), assert$1("http.createParameter"));
+
+function halt$6(name) {
+    throw new Error(`Error on typia.http.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var http = Object.freeze({
+    __proto__: null,
+    assertFormData: assertFormDataPure,
+    assertHeaders: assertHeadersPure,
+    assertQuery: assertQueryPure,
+    createAssertFormData: createAssertFormDataPure,
+    createAssertHeaders: createAssertHeadersPure,
+    createAssertQuery: createAssertQueryPure,
+    createFormData: createFormDataPure,
+    createHeaders: createHeadersPure,
+    createIsFormData: createIsFormDataPure,
+    createIsHeaders: createIsHeadersPure,
+    createIsQuery: createIsQueryPure,
+    createParameter: createParameterPure,
+    createQuery: createQueryPure,
+    createValidateFormData: createValidateFormDataPure,
+    createValidateHeaders: createValidateHeadersPure,
+    createValidateQuery: createValidateQueryPure,
+    formData: formDataPure,
+    headers: headersPure,
+    isFormData: isFormDataPure,
+    isHeaders: isHeadersPure,
+    isQuery: isQueryPure,
+    parameter: parameterPure,
+    query: queryPure,
+    validateFormData: validateFormDataPure,
+    validateHeaders: validateHeadersPure,
+    validateQuery: validateQueryPure
+});
+
+function application() {
+    halt$5("application");
+}
+
+function assertParse() {
+    halt$5("assertParse");
+}
+
+const assertParsePure = Object.assign(assertParse, assert$1("json.assertParse"));
+
+function isParse() {
+    halt$5("isParse");
+}
+
+const isParsePure = Object.assign(isParse, is$1());
+
+function validateParse() {
+    halt$5("validateParse");
+}
+
+const validateParsePure = Object.assign(validateParse, validate$1());
+
+function stringify() {
+    halt$5("stringify");
+}
+
+const stringifyPure = Object.assign(stringify, stringify$1("stringify"));
+
+function assertStringify() {
+    halt$5("assertStringify");
+}
+
+const assertStringifyPure = Object.assign(assertStringify, assert$1("json.assertStringify"), stringify$1("assertStringify"));
+
+function isStringify() {
+    halt$5("isStringify");
+}
+
+const isStringifyPure = Object.assign(isStringify, is$1(), stringify$1("isStringify"));
+
+function validateStringify() {
+    halt$5("validateStringify");
+}
+
+const validateStringifyPure = Object.assign(validateStringify, validate$1(), stringify$1("validateStringify"));
+
+function createIsParse() {
+    halt$5("createIsParse");
+}
+
+const createIsParsePure = Object.assign(createIsParse, isParsePure);
+
+function createAssertParse() {
+    halt$5("createAssertParse");
+}
+
+const createAssertParsePure = Object.assign(createAssertParse, assertParsePure);
+
+function createValidateParse() {
+    halt$5("createValidateParse");
+}
+
+const createValidateParsePure = Object.assign(createValidateParse, validateParsePure);
+
+function createStringify() {
+    halt$5("createStringify");
+}
+
+const createStringifyPure = Object.assign(createStringify, stringifyPure);
+
+function createAssertStringify() {
+    halt$5("createAssertStringify");
+}
+
+const createAssertStringifyPure = Object.assign(createAssertStringify, assertStringifyPure);
+
+function createIsStringify() {
+    halt$5("createIsStringify");
+}
+
+const createIsStringifyPure = Object.assign(createIsStringify, isStringifyPure);
+
+function createValidateStringify() {
+    halt$5("createValidateStringify");
+}
+
+const createValidateStringifyPure = Object.assign(createValidateStringify, validateStringifyPure);
+
+function halt$5(name) {
+    throw new Error(`Error on typia.json.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var json = Object.freeze({
+    __proto__: null,
+    application,
+    assertParse: assertParsePure,
+    assertStringify: assertStringifyPure,
+    createAssertParse: createAssertParsePure,
+    createAssertStringify: createAssertStringifyPure,
+    createIsParse: createIsParsePure,
+    createIsStringify: createIsStringifyPure,
+    createStringify: createStringifyPure,
+    createValidateParse: createValidateParsePure,
+    createValidateStringify: createValidateStringifyPure,
+    isParse: isParsePure,
+    isStringify: isStringifyPure,
+    stringify: stringifyPure,
+    validateParse: validateParsePure,
+    validateStringify: validateStringifyPure
+});
+
+function literals() {
+    halt$4("literals");
+}
+
+function clone() {
+    halt$4("clone");
+}
+
+const clonePure = Object.assign(clone, clone$1("clone"));
+
+function assertClone() {
+    halt$4("assertClone");
+}
+
+const assertClonePure = Object.assign(assertClone, assert$1("misc.assertClone"), clone$1("assertClone"));
+
+function isClone() {
+    halt$4("isClone");
+}
+
+const isClonePure = Object.assign(isClone, is$1(), clone$1("isClone"));
+
+function validateClone() {
+    halt$4("validateClone");
+}
+
+const validateClonePure = Object.assign(validateClone, validate$1(), clone$1("validateClone"));
+
+function prune() {
+    halt$4("prune");
+}
+
+const prunePure = Object.assign(prune, prune$1("prune"));
+
+function assertPrune() {
+    halt$4("assertPrune");
+}
+
+const assertPrunePure = Object.assign(assertPrune, assert$1("misc.assertPrune"), prune$1("assertPrune"));
+
+function isPrune() {
+    halt$4("isPrune");
+}
+
+const isPrunePure = Object.assign(isPrune, is$1(), prune$1("isPrune"));
+
+function validatePrune() {
+    halt$4("validatePrune");
+}
+
+const validatePrunePure = Object.assign(validatePrune, prune$1("validatePrune"), validate$1());
+
+function createClone() {
+    halt$4("createClone");
+}
+
+const createClonePure = Object.assign(createClone, clonePure);
+
+function createAssertClone() {
+    halt$4("createAssertClone");
+}
+
+const createAssertClonePure = Object.assign(createAssertClone, assertClonePure);
+
+function createIsClone() {
+    halt$4("createIsClone");
+}
+
+const createIsClonePure = Object.assign(createIsClone, isClonePure);
+
+function createValidateClone() {
+    halt$4("createValidateClone");
+}
+
+const createValidateClonePure = Object.assign(createValidateClone, validateClonePure);
+
+function createPrune() {
+    halt$4("createPrune");
+}
+
+const createPrunePure = Object.assign(createPrune, prunePure);
+
+function createAssertPrune() {
+    halt$4("createAssertPrune");
+}
+
+const createAssertPrunePure = Object.assign(createAssertPrune, assertPrunePure);
+
+function createIsPrune() {
+    halt$4("createIsPrune");
+}
+
+const createIsPrunePure = Object.assign(createIsPrune, isPrunePure);
+
+function createValidatePrune() {
+    halt$4("createValidatePrune");
+}
+
+const createValidatePrunePure = Object.assign(createValidatePrune, validatePrunePure);
+
+function halt$4(name) {
+    throw new Error(`Error on typia.misc.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var misc = Object.freeze({
+    __proto__: null,
+    assertClone: assertClonePure,
+    assertPrune: assertPrunePure,
+    clone: clonePure,
+    createAssertClone: createAssertClonePure,
+    createAssertPrune: createAssertPrunePure,
+    createClone: createClonePure,
+    createIsClone: createIsClonePure,
+    createIsPrune: createIsPrunePure,
+    createPrune: createPrunePure,
+    createValidateClone: createValidateClonePure,
+    createValidatePrune: createValidatePrunePure,
+    isClone: isClonePure,
+    isPrune: isPrunePure,
+    literals,
+    prune: prunePure,
+    validateClone: validateClonePure,
+    validatePrune: validatePrunePure
+});
+
+function camel() {
+    return halt$3("camel");
+}
+
+const camelPure = Object.assign(camel, camel$1("camel"));
+
+function assertCamel() {
+    return halt$3("assertCamel");
+}
+
+const assertCamelPure = Object.assign(assertCamel, camel$1("assertCamel"), assert$1("notations.assertCamel"));
+
+function isCamel() {
+    return halt$3("isCamel");
+}
+
+const isCamelPure = Object.assign(isCamel, camel$1("isCamel"), is$1());
+
+function validateCamel() {
+    return halt$3("validateCamel");
+}
+
+const validateCamelPure = Object.assign(validateCamel, camel$1("validateCamel"), validate$1());
+
+function pascal() {
+    return halt$3("pascal");
+}
+
+const pascalPure = Object.assign(pascal, pascal$1("pascal"));
+
+function assertPascal() {
+    return halt$3("assertPascal");
+}
+
+const assertPascalPure = Object.assign(assertPascal, pascal$1("assertPascal"), assert$1("notations.assertPascal"));
+
+function isPascal() {
+    return halt$3("isPascal");
+}
+
+const isPascalPure = Object.assign(isPascal, pascal$1("isPascal"), is$1());
+
+function validatePascal() {
+    return halt$3("validatePascal");
+}
+
+const validatePascalPure = Object.assign(validatePascal, pascal$1("validatePascal"), validate$1());
+
+function snake() {
+    return halt$3("snake");
+}
+
+const snakePure = Object.assign(snake, snake$1("snake"));
+
+function assertSnake() {
+    return halt$3("assertSnake");
+}
+
+const assertSnakePure = Object.assign(assertSnake, snake$1("assertSnake"), assert$1("notations.assertSnake"));
+
+function isSnake() {
+    return halt$3("isSnake");
+}
+
+const isSnakePure = Object.assign(isSnake, snake$1("isSnake"), is$1());
+
+function validateSnake() {
+    return halt$3("validateSnake");
+}
+
+const validateSnakePure = Object.assign(validateSnake, snake$1("validateSnake"), validate$1());
+
+function createCamel() {
+    halt$3("createCamel");
+}
+
+const createCamelPure = Object.assign(createCamel, camel$1("createCamel"));
+
+function createAssertCamel() {
+    halt$3("createAssertCamel");
+}
+
+const createAssertCamelPure = Object.assign(createAssertCamel, camel$1("createAssertCamel"), assert$1("notations.createAssertCamel"));
+
+function createIsCamel() {
+    halt$3("createIsCamel");
+}
+
+const createIsCamelPure = Object.assign(createIsCamel, camel$1("createIsCamel"), is$1());
+
+function createValidateCamel() {
+    halt$3("createValidateCamel");
+}
+
+const createValidateCamelPure = Object.assign(createValidateCamel, camel$1("createValidateCamel"), validate$1());
+
+function createPascal() {
+    halt$3("createPascal");
+}
+
+const createPascalPure = Object.assign(createPascal, pascal$1("createPascal"));
+
+function createAssertPascal() {
+    halt$3("createAssertPascal");
+}
+
+const createAssertPascalPure = Object.assign(createAssertPascal, pascal$1("createAssertPascal"), assert$1("notations.createAssertPascal"));
+
+function createIsPascal() {
+    halt$3("createIsPascal");
+}
+
+const createIsPascalPure = Object.assign(createIsPascal, pascal$1("createIsPascal"), is$1());
+
+function createValidatePascal() {
+    halt$3("createValidatePascal");
+}
+
+const createValidatePascalPure = Object.assign(createValidatePascal, pascal$1("createValidatePascal"), validate$1());
+
+function createSnake() {
+    halt$3("createSnake");
+}
+
+const createSnakePure = Object.assign(createSnake, snake$1("createSnake"));
+
+function createAssertSnake() {
+    halt$3("createAssertSnake");
+}
+
+const createAssertSnakePure = Object.assign(createAssertSnake, snake$1("createAssertSnake"), assert$1("notations.createAssertSnake"));
+
+function createIsSnake() {
+    halt$3("createIsSnake");
+}
+
+const createIsSnakePure = Object.assign(createIsSnake, snake$1("createIsSnake"), is$1());
+
+function createValidateSnake() {
+    halt$3("createValidateSnake");
+}
+
+const createValidateSnakePure = Object.assign(createValidateSnake, snake$1("createValidateSnake"), validate$1());
+
+function halt$3(name) {
+    throw new Error(`Error on typia.notations.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var notations = Object.freeze({
+    __proto__: null,
+    assertCamel: assertCamelPure,
+    assertPascal: assertPascalPure,
+    assertSnake: assertSnakePure,
+    camel: camelPure,
+    createAssertCamel: createAssertCamelPure,
+    createAssertPascal: createAssertPascalPure,
+    createAssertSnake: createAssertSnakePure,
+    createCamel: createCamelPure,
+    createIsCamel: createIsCamelPure,
+    createIsPascal: createIsPascalPure,
+    createIsSnake: createIsSnakePure,
+    createPascal: createPascalPure,
+    createSnake: createSnakePure,
+    createValidateCamel: createValidateCamelPure,
+    createValidatePascal: createValidatePascalPure,
+    createValidateSnake: createValidateSnakePure,
+    isCamel: isCamelPure,
+    isPascal: isPascalPure,
+    isSnake: isSnakePure,
+    pascal: pascalPure,
+    snake: snakePure,
+    validateCamel: validateCamelPure,
+    validatePascal: validatePascalPure,
+    validateSnake: validateSnakePure
+});
+
+function message() {
+    halt$2("message");
+}
+
+function decode() {
+    halt$2("decode");
+}
+
+const decodePure = Object.assign(decode, decode$1("decode"));
+
+function assertDecode() {
+    halt$2("assertDecode");
+}
+
+const assertDecodePure = Object.assign(assertDecode, assert$1("protobuf.assertDecode"), decode$1("assertDecode"));
+
+function isDecode() {
+    halt$2("isDecode");
+}
+
+const isDecodePure = Object.assign(isDecode, is$1(), decode$1("isDecode"));
+
+function validateDecode() {
+    halt$2("validateDecode");
+}
+
+const validateDecodePure = Object.assign(validateDecode, validate$1(), decode$1("validateDecode"));
+
+function encode() {
+    halt$2("encode");
+}
+
+const encodePure = Object.assign(encode, encode$1("encode"));
+
+function assertEncode() {
+    halt$2("assertEncode");
+}
+
+const assertEncodePure = Object.assign(assertEncode, assert$1("protobuf.assertEncode"), encode$1("assertEncode"));
+
+function isEncode() {
+    halt$2("isEncode");
+}
+
+const isEncodePure = Object.assign(isEncode, is$1(), encode$1("isEncode"));
+
+function validateEncode() {
+    halt$2("validateEncode");
+}
+
+const validateEncodePure = Object.assign(validateEncode, validate$1(), encode$1("validateEncode"));
+
+function createDecode() {
+    halt$2("createDecode");
+}
+
+const createDecodePure = Object.assign(createDecode, decode$1("createDecode"));
+
+function createIsDecode() {
+    halt$2("createIsDecode");
+}
+
+const createIsDecodePure = Object.assign(createIsDecode, is$1(), decode$1("createIsDecode"));
+
+function createAssertDecode() {
+    halt$2("createAssertDecode");
+}
+
+const createAssertDecodePure = Object.assign(createAssertDecode, assert$1("protobuf.createAssertDecode"), decode$1("createAssertDecode"));
+
+function createValidateDecode() {
+    halt$2("createValidateDecode");
+}
+
+const createValidateDecodePure = Object.assign(createValidateDecode, validate$1(), decode$1("createValidateDecode"));
+
+function createEncode() {
+    halt$2("createEncode");
+}
+
+const createEncodePure = Object.assign(createEncode, encode$1("createEncode"));
+
+function createIsEncode() {
+    halt$2("createIsEncode");
+}
+
+const createIsEncodePure = Object.assign(createIsEncode, is$1(), encode$1("createIsEncode"));
+
+function createAssertEncode() {
+    halt$2("createAssertEncode");
+}
+
+const createAssertEncodePure = Object.assign(createAssertEncode, assert$1("protobuf.createAssertEncode"), encode$1("createAssertEncode"));
+
+function createValidateEncode() {
+    halt$2("createValidateEncode");
+}
+
+const createValidateEncodePure = Object.assign(createValidateEncode, validate$1(), encode$1("createValidateEncode"));
+
+function halt$2(name) {
+    throw new Error(`Error on typia.protobuf.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var protobuf = Object.freeze({
+    __proto__: null,
+    assertDecode: assertDecodePure,
+    assertEncode: assertEncodePure,
+    createAssertDecode: createAssertDecodePure,
+    createAssertEncode: createAssertEncodePure,
+    createDecode: createDecodePure,
+    createEncode: createEncodePure,
+    createIsDecode: createIsDecodePure,
+    createIsEncode: createIsEncodePure,
+    createValidateDecode: createValidateDecodePure,
+    createValidateEncode: createValidateEncodePure,
+    decode: decodePure,
+    encode: encodePure,
+    isDecode: isDecodePure,
+    isEncode: isEncodePure,
+    message,
+    validateDecode: validateDecodePure,
+    validateEncode: validateEncodePure
+});
+
+function metadata() {
+    halt$1("metadata");
+}
+
+const metadataPure = Object.assign(metadata, {
+    from: input => input
+});
+
+function halt$1(name) {
+    throw new Error(`Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var reflect = Object.freeze({
+    __proto__: null,
+    metadata: metadataPure
+});
+
+var index = Object.freeze({
+    __proto__: null
+});
+
+function assert() {
+    halt("assert");
+}
+
+const assertPure = Object.assign(assert, assert$1("assert"));
+
+function assertGuard() {
+    halt("assertGuard");
+}
+
+const assertGuardPure = Object.assign(assertGuard, assert$1("assertGuard"));
+
+function is() {
+    halt("is");
+}
+
+const isPure = Object.assign(is, assert$1("is"));
+
+function validate() {
+    halt("validate");
+}
+
+const validatePure = Object.assign(validate, validate$1());
+
+function assertEquals() {
+    halt("assertEquals");
+}
+
+const assertEqualsPure = Object.assign(assertEquals, assert$1("assertEquals"));
+
+function assertGuardEquals() {
+    halt("assertGuardEquals");
+}
+
+const assertGuardEqualsPure = Object.assign(assertGuardEquals, assert$1("assertGuardEquals"));
+
+function equals() {
+    halt("equals");
+}
+
+const equalsPure = Object.assign(equals, is$1());
+
+function validateEquals() {
+    halt("validateEquals");
+}
+
+const validateEqualsPure = Object.assign(validateEquals, validate$1());
+
+function random() {
+    halt("random");
+}
+
+const randomPure = Object.assign(random, random$1());
+
+function createAssert() {
+    halt("createAssert");
+}
+
+const createAssertPure = Object.assign(createAssert, assertPure);
+
+function createAssertGuard() {
+    halt("createAssertGuard");
+}
+
+const createAssertGuardPure = Object.assign(createAssertGuard, assertGuardPure);
+
+function createIs() {
+    halt("createIs");
+}
+
+const createIsPure = Object.assign(createIs, isPure);
+
+function createValidate() {
+    halt("createValidate");
+}
+
+const createValidatePure = Object.assign(createValidate, validatePure);
+
+function createAssertEquals() {
+    halt("createAssertEquals");
+}
+
+const createAssertEqualsPure = Object.assign(createAssertEquals, assertEqualsPure);
+
+function createAssertGuardEquals() {
+    halt("createAssertGuardEquals");
+}
+
+const createAssertGuardEqualsPure = Object.assign(createAssertGuardEquals, assertGuardEqualsPure);
+
+function createEquals() {
+    halt("createEquals");
+}
+
+const createEqualsPure = Object.assign(createEquals, equalsPure);
+
+function createValidateEquals() {
+    halt("createValidateEquals");
+}
+
+const createValidateEqualsPure = Object.assign(createValidateEquals, validateEqualsPure);
+
+function createRandom() {
+    halt("createRandom");
+}
+
+const createRandomPure = Object.assign(createRandom, randomPure);
+
+function halt(name) {
+    throw new Error(`Error on typia.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`);
+}
+
+var typia = Object.freeze({
+    __proto__: null,
+    TypeGuardError,
+    assert: assertPure,
+    assertEquals: assertEqualsPure,
+    assertGuard: assertGuardPure,
+    assertGuardEquals: assertGuardEqualsPure,
+    createAssert: createAssertPure,
+    createAssertEquals: createAssertEqualsPure,
+    createAssertGuard: createAssertGuardPure,
+    createAssertGuardEquals: createAssertGuardEqualsPure,
+    createEquals: createEqualsPure,
+    createIs: createIsPure,
+    createRandom: createRandomPure,
+    createValidate: createValidatePure,
+    createValidateEquals: createValidateEqualsPure,
+    equals: equalsPure,
+    functional,
+    http,
+    is: isPure,
+    json,
+    misc,
+    notations,
+    protobuf,
+    random: randomPure,
+    reflect,
+    tags: index,
+    validate: validatePure,
+    validateEquals: validateEqualsPure
+});
+
+export { TypeGuardError, assertPure as assert, assertEqualsPure as assertEquals, assertGuardPure as assertGuard, assertGuardEqualsPure as assertGuardEquals, createAssertPure as createAssert, createAssertEqualsPure as createAssertEquals, createAssertGuardPure as createAssertGuard, createAssertGuardEqualsPure as createAssertGuardEquals, createEqualsPure as createEquals, createIsPure as createIs, createRandomPure as createRandom, createValidatePure as createValidate, createValidateEqualsPure as createValidateEquals, typia as default, equalsPure as equals, functional, http, isPure as is, json, misc, notations, protobuf, randomPure as random, reflect, index as tags, validatePure as validate, validateEqualsPure as validateEquals };
+//# sourceMappingURL=index.mjs.map