{"version":3,"file":"vendor.msgpack-22da7cec.ae5d21d74530b253.bundle.js","mappings":"wIAcO,SAASA,EAAOC,EAAQC,GAE3B,OADc,IAAI,IAAQA,GACXF,OAAOC,EAC1B,C,2DC0EWE,EAAqB,CAC5BC,MAzFwB,EA0FxBC,OA3CG,SAAkCC,GAEjC,IAZAC,EACAC,EACAC,EAEAC,EAOJ,OAAIJ,aAAkBK,KA7CnB,SAAmCC,GACtC,IA0BQC,EA1BJL,EAAMI,EAAGJ,IAAKC,EAAOG,EAAGH,KAC5B,GAAID,GAAO,GAAKC,GAAQ,GAAKD,GAHP,YAGmC,CAErD,GAAa,IAATC,GAAcD,GANA,WAM4B,CAE1C,IAAIM,EAAK,IAAIC,WAAW,GAGxB,OAFIF,EAAO,IAAIG,SAASF,EAAGb,SACtBgB,UAAU,EAAGT,GACXM,CACX,CAGI,IAAII,EAAUV,EAAM,WAChBW,EAAe,WAANX,EAOb,OANIM,EAAK,IAAIC,WAAW,IACpBF,EAAO,IAAIG,SAASF,EAAGb,SAEtBgB,UAAU,EAAIR,GAAQ,EAAgB,EAAVS,GAEjCL,EAAKI,UAAU,EAAGE,GACXL,CAEf,CAOI,OAJIA,EAAK,IAAIC,WAAW,KACpBF,EAAO,IAAIG,SAASF,EAAGb,SACtBgB,UAAU,EAAGR,IAClB,QAASI,EAAM,EAAGL,GACXM,CAEf,CAeeM,EAXPX,EAA4B,MAF5BF,EAYoCD,EAZxBe,WAES,KADrBb,EAAMc,KAAKC,MAAMhB,EAAO,OAIrB,CACHC,IAAKA,GAFLE,EAAYY,KAAKC,MAAMd,EAAO,MAG9BA,KAAMA,EAAmB,IAAZC,KASN,IAEf,EAoCIV,OAPG,SAAkCwB,GACrC,IAAIC,EA7BD,SAAmCD,GACtC,IAAIX,EAAO,IAAIG,SAASQ,EAAKvB,OAAQuB,EAAKE,WAAYF,EAAKG,YAE3D,OAAQH,EAAKG,YACT,KAAK,EAID,MAAO,CAAEnB,IAFCK,EAAKe,UAAU,GAENnB,KADR,GAGf,KAAK,EAED,IAAIoB,EAAoBhB,EAAKe,UAAU,GAIvC,MAAO,CAAEpB,IAF6B,YAAP,EAApBqB,GADIhB,EAAKe,UAAU,GAGXnB,KADRoB,IAAsB,GAGrC,KAAK,GAID,MAAO,CAAErB,KAFC,QAASK,EAAM,GAENJ,KADRI,EAAKe,UAAU,IAG9B,QACI,MAAM,IAAI,IAAY,gEAAgEE,OAAON,EAAKO,SAE9G,CAEmBC,CAA0BR,GACzC,OAAO,IAAIb,KAAoB,IAAfc,EAASjB,IAAYiB,EAAShB,KAAO,IACzD,E,8DCzFO,IAAIwB,EAAa,WASjB,SAASC,EAASrB,EAAMsB,EAAQC,GACnC,IAAIC,EAAOf,KAAKC,MAAMa,EAAQ,YAC1BE,EAAMF,EACVvB,EAAKI,UAAUkB,EAAQE,GACvBxB,EAAKI,UAAUkB,EAAS,EAAGG,EAC/B,CACO,SAASC,EAAS1B,EAAMsB,GAG3B,OAAc,WAFHtB,EAAK2B,SAASL,GACftB,EAAKe,UAAUO,EAAS,EAEtC,CACO,SAASM,EAAU5B,EAAMsB,GAG5B,OAAc,WAFHtB,EAAKe,UAAUO,GAChBtB,EAAKe,UAAUO,EAAS,EAEtC,C,gBCzBO,SAASO,EAAWC,GACvB,MAAO,GAAGb,OAAOa,EAAO,EAAI,IAAM,GAAI,MAAMb,OAAOR,KAAKsB,IAAID,GAAME,SAAS,IAAIC,SAAS,EAAG,KAC/F,C,iCCFO,SAASC,EAAiB9C,GAC7B,OAAIA,aAAkBc,WACXd,EAEF+C,YAAYC,OAAOhD,GACjB,IAAIc,WAAWd,EAAOA,OAAQA,EAAOyB,WAAYzB,EAAO0B,YAE1D1B,aAAkB+C,YAChB,IAAIjC,WAAWd,GAIfc,WAAWmC,KAAKjD,EAE/B,CACO,SAASkD,EAAelD,GAC3B,GAAIA,aAAkB+C,YAClB,OAAO,IAAIhC,SAASf,GAExB,IAAImD,EAAaL,EAAiB9C,GAClC,OAAO,IAAIe,SAASoC,EAAWnD,OAAQmD,EAAW1B,WAAY0B,EAAWzB,WAC7E,C,oECkEwB,IAAI0B,YAe5B,IAAIC,EAAa,KACV,SAASC,EAAaC,EAAOC,EAAa9B,GAK7C,IAJA,IAAIQ,EAASsB,EACTC,EAAMvB,EAASR,EACfgC,EAAQ,GACRC,EAAS,GACNzB,EAASuB,GAAK,CACjB,IAAIG,EAAQL,EAAMrB,KAClB,GAAuB,IAAV,IAAR0B,GAEDF,EAAMG,KAAKD,QAEV,GAAuB,MAAV,IAARA,GAAwB,CAE9B,IAAIE,EAA0B,GAAlBP,EAAMrB,KAClBwB,EAAMG,MAAe,GAARD,IAAiB,EAAKE,EACvC,MACK,GAAuB,MAAV,IAARF,GAAwB,CAE1BE,EAA0B,GAAlBP,EAAMrB,KAAlB,IACI6B,EAA0B,GAAlBR,EAAMrB,KAClBwB,EAAMG,MAAe,GAARD,IAAiB,GAAOE,GAAS,EAAKC,EACvD,MACK,GAAuB,MAAV,IAARH,GAAwB,CAE9B,IAGII,GAAiB,EAARJ,IAAiB,IAH1BE,EAA0B,GAAlBP,EAAMrB,OAG8B,IAF5C6B,EAA0B,GAAlBR,EAAMrB,OAEgD,EADpC,GAAlBqB,EAAMrB,KAEd8B,EAAO,QACPA,GAAQ,MACRN,EAAMG,KAAOG,IAAS,GAAM,KAAS,OACrCA,EAAO,MAAiB,KAAPA,GAErBN,EAAMG,KAAKG,EACf,MAEIN,EAAMG,KAAKD,GAEXF,EAAM5B,QAAUuB,IAChBM,GAAUM,OAAOC,aAAaC,MAAMF,OAAQP,GAC5CA,EAAM5B,OAAS,EAEvB,CAIA,OAHI4B,EAAM5B,OAAS,IACf6B,GAAUM,OAAOC,aAAaC,MAAMF,OAAQP,IAEzCC,CACX,CACA,IAAIS,EAAoB,IAAIC,YAGxBC,EAAyB,IAKtB,SAASC,EAAWhB,EAAOC,EAAa9B,GAC3C,OAAIA,EAAa4C,EALd,SAAsBf,EAAOC,EAAa9B,GAC7C,IAAI8C,EAAcjB,EAAMkB,SAASjB,EAAaA,EAAc9B,GAC5D,OAAO0C,EAAkBrE,OAAOyE,EACpC,CAGeE,CAAanB,EAAOC,EAAa9B,GAGjC4B,EAAaC,EAAOC,EAAa9B,EAEhD,C","sources":["webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs"],"sourcesContent":["import { Decoder } from \"./Decoder.mjs\";\n/**\n * @deprecated No longer supported.\n */\nexport var defaultDecodeOptions = undefined;\n/**\n * It decodes a single MessagePack object in a buffer.\n *\n * This is a synchronous decoding function.\n * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.\n *\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\nexport function decode(buffer, options) {\n    var decoder = new Decoder(options);\n    return decoder.decode(buffer);\n}\n/**\n * It decodes multiple MessagePack objects in a buffer.\n * This is corresponding to {@link decodeMultiStream()}.\n *\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\nexport function decodeMulti(buffer, options) {\n    var decoder = new Decoder(options);\n    return decoder.decodeMulti(buffer);\n}\n//# sourceMappingURL=decode.mjs.map","// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type\nimport { DecodeError } from \"./DecodeError.mjs\";\nimport { getInt64, setInt64 } from \"./utils/int.mjs\";\nexport var EXT_TIMESTAMP = -1;\nvar TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int\nvar TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int\nexport function encodeTimeSpecToTimestamp(_a) {\n    var sec = _a.sec, nsec = _a.nsec;\n    if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {\n        // Here sec >= 0 && nsec >= 0\n        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {\n            // timestamp 32 = { sec32 (unsigned) }\n            var rv = new Uint8Array(4);\n            var view = new DataView(rv.buffer);\n            view.setUint32(0, sec);\n            return rv;\n        }\n        else {\n            // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }\n            var secHigh = sec / 0x100000000;\n            var secLow = sec & 0xffffffff;\n            var rv = new Uint8Array(8);\n            var view = new DataView(rv.buffer);\n            // nsec30 | secHigh2\n            view.setUint32(0, (nsec << 2) | (secHigh & 0x3));\n            // secLow32\n            view.setUint32(4, secLow);\n            return rv;\n        }\n    }\n    else {\n        // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }\n        var rv = new Uint8Array(12);\n        var view = new DataView(rv.buffer);\n        view.setUint32(0, nsec);\n        setInt64(view, 4, sec);\n        return rv;\n    }\n}\nexport function encodeDateToTimeSpec(date) {\n    var msec = date.getTime();\n    var sec = Math.floor(msec / 1e3);\n    var nsec = (msec - sec * 1e3) * 1e6;\n    // Normalizes { sec, nsec } to ensure nsec is unsigned.\n    var nsecInSec = Math.floor(nsec / 1e9);\n    return {\n        sec: sec + nsecInSec,\n        nsec: nsec - nsecInSec * 1e9,\n    };\n}\nexport function encodeTimestampExtension(object) {\n    if (object instanceof Date) {\n        var timeSpec = encodeDateToTimeSpec(object);\n        return encodeTimeSpecToTimestamp(timeSpec);\n    }\n    else {\n        return null;\n    }\n}\nexport function decodeTimestampToTimeSpec(data) {\n    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n    // data may be 32, 64, or 96 bits\n    switch (data.byteLength) {\n        case 4: {\n            // timestamp 32 = { sec32 }\n            var sec = view.getUint32(0);\n            var nsec = 0;\n            return { sec: sec, nsec: nsec };\n        }\n        case 8: {\n            // timestamp 64 = { nsec30, sec34 }\n            var nsec30AndSecHigh2 = view.getUint32(0);\n            var secLow32 = view.getUint32(4);\n            var sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;\n            var nsec = nsec30AndSecHigh2 >>> 2;\n            return { sec: sec, nsec: nsec };\n        }\n        case 12: {\n            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }\n            var sec = getInt64(view, 4);\n            var nsec = view.getUint32(0);\n            return { sec: sec, nsec: nsec };\n        }\n        default:\n            throw new DecodeError(\"Unrecognized data size for timestamp (expected 4, 8, or 12): \".concat(data.length));\n    }\n}\nexport function decodeTimestampExtension(data) {\n    var timeSpec = decodeTimestampToTimeSpec(data);\n    return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);\n}\nexport var timestampExtension = {\n    type: EXT_TIMESTAMP,\n    encode: encodeTimestampExtension,\n    decode: decodeTimestampExtension,\n};\n//# sourceMappingURL=timestamp.mjs.map","// Integer Utility\nexport var UINT32_MAX = 4294967295;\n// DataView extension to handle int64 / uint64,\n// where the actual range is 53-bits integer (a.k.a. safe integer)\nexport function setUint64(view, offset, value) {\n    var high = value / 4294967296;\n    var low = value; // high bits are truncated by DataView\n    view.setUint32(offset, high);\n    view.setUint32(offset + 4, low);\n}\nexport function setInt64(view, offset, value) {\n    var high = Math.floor(value / 4294967296);\n    var low = value; // high bits are truncated by DataView\n    view.setUint32(offset, high);\n    view.setUint32(offset + 4, low);\n}\nexport function getInt64(view, offset) {\n    var high = view.getInt32(offset);\n    var low = view.getUint32(offset + 4);\n    return high * 4294967296 + low;\n}\nexport function getUint64(view, offset) {\n    var high = view.getUint32(offset);\n    var low = view.getUint32(offset + 4);\n    return high * 4294967296 + low;\n}\n//# sourceMappingURL=int.mjs.map","export function prettyByte(byte) {\n    return \"\".concat(byte < 0 ? \"-\" : \"\", \"0x\").concat(Math.abs(byte).toString(16).padStart(2, \"0\"));\n}\n//# sourceMappingURL=prettyByte.mjs.map","export function ensureUint8Array(buffer) {\n    if (buffer instanceof Uint8Array) {\n        return buffer;\n    }\n    else if (ArrayBuffer.isView(buffer)) {\n        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n    }\n    else if (buffer instanceof ArrayBuffer) {\n        return new Uint8Array(buffer);\n    }\n    else {\n        // ArrayLike<number>\n        return Uint8Array.from(buffer);\n    }\n}\nexport function createDataView(buffer) {\n    if (buffer instanceof ArrayBuffer) {\n        return new DataView(buffer);\n    }\n    var bufferView = ensureUint8Array(buffer);\n    return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);\n}\n//# sourceMappingURL=typedArrays.mjs.map","export function utf8Count(str) {\n    var strLength = str.length;\n    var byteLength = 0;\n    var pos = 0;\n    while (pos < strLength) {\n        var value = str.charCodeAt(pos++);\n        if ((value & 0xffffff80) === 0) {\n            // 1-byte\n            byteLength++;\n            continue;\n        }\n        else if ((value & 0xfffff800) === 0) {\n            // 2-bytes\n            byteLength += 2;\n        }\n        else {\n            // handle surrogate pair\n            if (value >= 0xd800 && value <= 0xdbff) {\n                // high surrogate\n                if (pos < strLength) {\n                    var extra = str.charCodeAt(pos);\n                    if ((extra & 0xfc00) === 0xdc00) {\n                        ++pos;\n                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;\n                    }\n                }\n            }\n            if ((value & 0xffff0000) === 0) {\n                // 3-byte\n                byteLength += 3;\n            }\n            else {\n                // 4-byte\n                byteLength += 4;\n            }\n        }\n    }\n    return byteLength;\n}\nexport function utf8EncodeJs(str, output, outputOffset) {\n    var strLength = str.length;\n    var offset = outputOffset;\n    var pos = 0;\n    while (pos < strLength) {\n        var value = str.charCodeAt(pos++);\n        if ((value & 0xffffff80) === 0) {\n            // 1-byte\n            output[offset++] = value;\n            continue;\n        }\n        else if ((value & 0xfffff800) === 0) {\n            // 2-bytes\n            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;\n        }\n        else {\n            // handle surrogate pair\n            if (value >= 0xd800 && value <= 0xdbff) {\n                // high surrogate\n                if (pos < strLength) {\n                    var extra = str.charCodeAt(pos);\n                    if ((extra & 0xfc00) === 0xdc00) {\n                        ++pos;\n                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;\n                    }\n                }\n            }\n            if ((value & 0xffff0000) === 0) {\n                // 3-byte\n                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;\n                output[offset++] = ((value >> 6) & 0x3f) | 0x80;\n            }\n            else {\n                // 4-byte\n                output[offset++] = ((value >> 18) & 0x07) | 0xf0;\n                output[offset++] = ((value >> 12) & 0x3f) | 0x80;\n                output[offset++] = ((value >> 6) & 0x3f) | 0x80;\n            }\n        }\n        output[offset++] = (value & 0x3f) | 0x80;\n    }\n}\n// TextEncoder and TextDecoder are standardized in whatwg encoding:\n// https://encoding.spec.whatwg.org/\n// and available in all the modern browsers:\n// https://caniuse.com/textencoder\n// They are available in Node.js since v12 LTS as well:\n// https://nodejs.org/api/globals.html#textencoder\nvar sharedTextEncoder = new TextEncoder();\n// This threshold should be determined by benchmarking, which might vary in engines and input data.\n// Run `npx ts-node benchmark/encode-string.ts` for details.\nvar TEXT_ENCODER_THRESHOLD = 50;\nexport function utf8EncodeTE(str, output, outputOffset) {\n    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));\n}\nexport function utf8Encode(str, output, outputOffset) {\n    if (str.length > TEXT_ENCODER_THRESHOLD) {\n        utf8EncodeTE(str, output, outputOffset);\n    }\n    else {\n        utf8EncodeJs(str, output, outputOffset);\n    }\n}\nvar CHUNK_SIZE = 4096;\nexport function utf8DecodeJs(bytes, inputOffset, byteLength) {\n    var offset = inputOffset;\n    var end = offset + byteLength;\n    var units = [];\n    var result = \"\";\n    while (offset < end) {\n        var byte1 = bytes[offset++];\n        if ((byte1 & 0x80) === 0) {\n            // 1 byte\n            units.push(byte1);\n        }\n        else if ((byte1 & 0xe0) === 0xc0) {\n            // 2 bytes\n            var byte2 = bytes[offset++] & 0x3f;\n            units.push(((byte1 & 0x1f) << 6) | byte2);\n        }\n        else if ((byte1 & 0xf0) === 0xe0) {\n            // 3 bytes\n            var byte2 = bytes[offset++] & 0x3f;\n            var byte3 = bytes[offset++] & 0x3f;\n            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);\n        }\n        else if ((byte1 & 0xf8) === 0xf0) {\n            // 4 bytes\n            var byte2 = bytes[offset++] & 0x3f;\n            var byte3 = bytes[offset++] & 0x3f;\n            var byte4 = bytes[offset++] & 0x3f;\n            var unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;\n            if (unit > 0xffff) {\n                unit -= 0x10000;\n                units.push(((unit >>> 10) & 0x3ff) | 0xd800);\n                unit = 0xdc00 | (unit & 0x3ff);\n            }\n            units.push(unit);\n        }\n        else {\n            units.push(byte1);\n        }\n        if (units.length >= CHUNK_SIZE) {\n            result += String.fromCharCode.apply(String, units);\n            units.length = 0;\n        }\n    }\n    if (units.length > 0) {\n        result += String.fromCharCode.apply(String, units);\n    }\n    return result;\n}\nvar sharedTextDecoder = new TextDecoder();\n// This threshold should be determined by benchmarking, which might vary in engines and input data.\n// Run `npx ts-node benchmark/decode-string.ts` for details.\nvar TEXT_DECODER_THRESHOLD = 200;\nexport function utf8DecodeTD(bytes, inputOffset, byteLength) {\n    var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);\n    return sharedTextDecoder.decode(stringBytes);\n}\nexport function utf8Decode(bytes, inputOffset, byteLength) {\n    if (byteLength > TEXT_DECODER_THRESHOLD) {\n        return utf8DecodeTD(bytes, inputOffset, byteLength);\n    }\n    else {\n        return utf8DecodeJs(bytes, inputOffset, byteLength);\n    }\n}\n//# sourceMappingURL=utf8.mjs.map"],"names":["decode","buffer","options","timestampExtension","type","encode","object","msec","sec","nsec","nsecInSec","Date","_a","view","rv","Uint8Array","DataView","setUint32","secHigh","secLow","encodeTimeSpecToTimestamp","getTime","Math","floor","data","timeSpec","byteOffset","byteLength","getUint32","nsec30AndSecHigh2","concat","length","decodeTimestampToTimeSpec","UINT32_MAX","setInt64","offset","value","high","low","getInt64","getInt32","getUint64","prettyByte","byte","abs","toString","padStart","ensureUint8Array","ArrayBuffer","isView","from","createDataView","bufferView","TextEncoder","CHUNK_SIZE","utf8DecodeJs","bytes","inputOffset","end","units","result","byte1","push","byte2","byte3","unit","String","fromCharCode","apply","sharedTextDecoder","TextDecoder","TEXT_DECODER_THRESHOLD","utf8Decode","stringBytes","subarray","utf8DecodeTD"],"sourceRoot":""}