{"version":3,"file":"vendor.msgpack-ffa3125f.07b33db02a997279.bundle.js","mappings":"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","sources":["webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs","webpack://client-app/./node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs"],"sourcesContent":["var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar DecodeError = /** @class */ (function (_super) {\n    __extends(DecodeError, _super);\n    function DecodeError(message) {\n        var _this = _super.call(this, message) || this;\n        // fix the prototype chain in a cross-platform way\n        var proto = Object.create(DecodeError.prototype);\n        Object.setPrototypeOf(_this, proto);\n        Object.defineProperty(_this, \"name\", {\n            configurable: true,\n            enumerable: false,\n            value: DecodeError.name,\n        });\n        return _this;\n    }\n    return DecodeError;\n}(Error));\nexport { DecodeError };\n//# sourceMappingURL=DecodeError.mjs.map","/**\n * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.\n */\nvar ExtData = /** @class */ (function () {\n    function ExtData(type, data) {\n        this.type = type;\n        this.data = data;\n    }\n    return ExtData;\n}());\nexport { ExtData };\n//# sourceMappingURL=ExtData.mjs.map","// ExtensionCodec to handle MessagePack extensions\nimport { ExtData } from \"./ExtData.mjs\";\nimport { timestampExtension } from \"./timestamp.mjs\";\nexport var ExtensionCodec = /** @class */ (function () {\n    function ExtensionCodec() {\n        // built-in extensions\n        this.builtInEncoders = [];\n        this.builtInDecoders = [];\n        // custom extensions\n        this.encoders = [];\n        this.decoders = [];\n        this.register(timestampExtension);\n    }\n    ExtensionCodec.prototype.register = function (_a) {\n        var type = _a.type, encode = _a.encode, decode = _a.decode;\n        if (type >= 0) {\n            // custom extensions\n            this.encoders[type] = encode;\n            this.decoders[type] = decode;\n        }\n        else {\n            // built-in extensions\n            var index = 1 + type;\n            this.builtInEncoders[index] = encode;\n            this.builtInDecoders[index] = decode;\n        }\n    };\n    ExtensionCodec.prototype.tryToEncode = function (object, context) {\n        // built-in extensions\n        for (var i = 0; i < this.builtInEncoders.length; i++) {\n            var encodeExt = this.builtInEncoders[i];\n            if (encodeExt != null) {\n                var data = encodeExt(object, context);\n                if (data != null) {\n                    var type = -1 - i;\n                    return new ExtData(type, data);\n                }\n            }\n        }\n        // custom extensions\n        for (var i = 0; i < this.encoders.length; i++) {\n            var encodeExt = this.encoders[i];\n            if (encodeExt != null) {\n                var data = encodeExt(object, context);\n                if (data != null) {\n                    var type = i;\n                    return new ExtData(type, data);\n                }\n            }\n        }\n        if (object instanceof ExtData) {\n            // to keep ExtData as is\n            return object;\n        }\n        return null;\n    };\n    ExtensionCodec.prototype.decode = function (data, type, context) {\n        var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];\n        if (decodeExt) {\n            return decodeExt(data, type, context);\n        }\n        else {\n            // decode() does not fail, returns ExtData instead.\n            return new ExtData(type, data);\n        }\n    };\n    ExtensionCodec.defaultCodec = new ExtensionCodec();\n    return ExtensionCodec;\n}());\n//# sourceMappingURL=ExtensionCodec.mjs.map","import { utf8DecodeJs } from \"./utils/utf8.mjs\";\nvar DEFAULT_MAX_KEY_LENGTH = 16;\nvar DEFAULT_MAX_LENGTH_PER_KEY = 16;\nvar CachedKeyDecoder = /** @class */ (function () {\n    function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {\n        if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }\n        if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }\n        this.maxKeyLength = maxKeyLength;\n        this.maxLengthPerKey = maxLengthPerKey;\n        this.hit = 0;\n        this.miss = 0;\n        // avoid `new Array(N)`, which makes a sparse array,\n        // because a sparse array is typically slower than a non-sparse array.\n        this.caches = [];\n        for (var i = 0; i < this.maxKeyLength; i++) {\n            this.caches.push([]);\n        }\n    }\n    CachedKeyDecoder.prototype.canBeCached = function (byteLength) {\n        return byteLength > 0 && byteLength <= this.maxKeyLength;\n    };\n    CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {\n        var records = this.caches[byteLength - 1];\n        FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {\n            var record = records_1[_i];\n            var recordBytes = record.bytes;\n            for (var j = 0; j < byteLength; j++) {\n                if (recordBytes[j] !== bytes[inputOffset + j]) {\n                    continue FIND_CHUNK;\n                }\n            }\n            return record.str;\n        }\n        return null;\n    };\n    CachedKeyDecoder.prototype.store = function (bytes, value) {\n        var records = this.caches[bytes.length - 1];\n        var record = { bytes: bytes, str: value };\n        if (records.length >= this.maxLengthPerKey) {\n            // `records` are full!\n            // Set `record` to an arbitrary position.\n            records[(Math.random() * records.length) | 0] = record;\n        }\n        else {\n            records.push(record);\n        }\n    };\n    CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {\n        var cachedValue = this.find(bytes, inputOffset, byteLength);\n        if (cachedValue != null) {\n            this.hit++;\n            return cachedValue;\n        }\n        this.miss++;\n        var str = utf8DecodeJs(bytes, inputOffset, byteLength);\n        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.\n        var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);\n        this.store(slicedCopyOfBytes, str);\n        return str;\n    };\n    return CachedKeyDecoder;\n}());\nexport { CachedKeyDecoder };\n//# sourceMappingURL=CachedKeyDecoder.mjs.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __asyncValues = (this && this.__asyncValues) || function (o) {\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n    var m = o[Symbol.asyncIterator], i;\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n};\nvar __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }\nvar __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n    function fulfill(value) { resume(\"next\", value); }\n    function reject(value) { resume(\"throw\", value); }\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n};\nimport { prettyByte } from \"./utils/prettyByte.mjs\";\nimport { ExtensionCodec } from \"./ExtensionCodec.mjs\";\nimport { getInt64, getUint64, UINT32_MAX } from \"./utils/int.mjs\";\nimport { utf8Decode } from \"./utils/utf8.mjs\";\nimport { createDataView, ensureUint8Array } from \"./utils/typedArrays.mjs\";\nimport { CachedKeyDecoder } from \"./CachedKeyDecoder.mjs\";\nimport { DecodeError } from \"./DecodeError.mjs\";\nvar STATE_ARRAY = \"array\";\nvar STATE_MAP_KEY = \"map_key\";\nvar STATE_MAP_VALUE = \"map_value\";\nvar isValidMapKeyType = function (key) {\n    return typeof key === \"string\" || typeof key === \"number\";\n};\nvar HEAD_BYTE_REQUIRED = -1;\nvar EMPTY_VIEW = new DataView(new ArrayBuffer(0));\nvar EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);\ntry {\n    // IE11: The spec says it should throw RangeError,\n    // IE11: but in IE11 it throws TypeError.\n    EMPTY_VIEW.getInt8(0);\n}\ncatch (e) {\n    if (!(e instanceof RangeError)) {\n        throw new Error(\"This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access\");\n    }\n}\nexport var DataViewIndexOutOfBoundsError = RangeError;\nvar MORE_DATA = new DataViewIndexOutOfBoundsError(\"Insufficient data\");\nvar sharedCachedKeyDecoder = new CachedKeyDecoder();\nvar Decoder = /** @class */ (function () {\n    function Decoder(options) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        this.totalPos = 0;\n        this.pos = 0;\n        this.view = EMPTY_VIEW;\n        this.bytes = EMPTY_BYTES;\n        this.headByte = HEAD_BYTE_REQUIRED;\n        this.stack = [];\n        this.extensionCodec = (_a = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a !== void 0 ? _a : ExtensionCodec.defaultCodec;\n        this.context = options === null || options === void 0 ? void 0 : options.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined\n        this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;\n        this.maxStrLength = (_c = options === null || options === void 0 ? void 0 : options.maxStrLength) !== null && _c !== void 0 ? _c : UINT32_MAX;\n        this.maxBinLength = (_d = options === null || options === void 0 ? void 0 : options.maxBinLength) !== null && _d !== void 0 ? _d : UINT32_MAX;\n        this.maxArrayLength = (_e = options === null || options === void 0 ? void 0 : options.maxArrayLength) !== null && _e !== void 0 ? _e : UINT32_MAX;\n        this.maxMapLength = (_f = options === null || options === void 0 ? void 0 : options.maxMapLength) !== null && _f !== void 0 ? _f : UINT32_MAX;\n        this.maxExtLength = (_g = options === null || options === void 0 ? void 0 : options.maxExtLength) !== null && _g !== void 0 ? _g : UINT32_MAX;\n        this.keyDecoder = ((options === null || options === void 0 ? void 0 : options.keyDecoder) !== undefined) ? options.keyDecoder : sharedCachedKeyDecoder;\n    }\n    Decoder.prototype.reinitializeState = function () {\n        this.totalPos = 0;\n        this.headByte = HEAD_BYTE_REQUIRED;\n        this.stack.length = 0;\n        // view, bytes, and pos will be re-initialized in setBuffer()\n    };\n    Decoder.prototype.setBuffer = function (buffer) {\n        this.bytes = ensureUint8Array(buffer);\n        this.view = createDataView(this.bytes);\n        this.pos = 0;\n    };\n    Decoder.prototype.appendBuffer = function (buffer) {\n        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {\n            this.setBuffer(buffer);\n        }\n        else {\n            var remainingData = this.bytes.subarray(this.pos);\n            var newData = ensureUint8Array(buffer);\n            // concat remainingData + newData\n            var newBuffer = new Uint8Array(remainingData.length + newData.length);\n            newBuffer.set(remainingData);\n            newBuffer.set(newData, remainingData.length);\n            this.setBuffer(newBuffer);\n        }\n    };\n    Decoder.prototype.hasRemaining = function (size) {\n        return this.view.byteLength - this.pos >= size;\n    };\n    Decoder.prototype.createExtraByteError = function (posToShow) {\n        var _a = this, view = _a.view, pos = _a.pos;\n        return new RangeError(\"Extra \".concat(view.byteLength - pos, \" of \").concat(view.byteLength, \" byte(s) found at buffer[\").concat(posToShow, \"]\"));\n    };\n    /**\n     * @throws {@link DecodeError}\n     * @throws {@link RangeError}\n     */\n    Decoder.prototype.decode = function (buffer) {\n        this.reinitializeState();\n        this.setBuffer(buffer);\n        var object = this.doDecodeSync();\n        if (this.hasRemaining(1)) {\n            throw this.createExtraByteError(this.pos);\n        }\n        return object;\n    };\n    Decoder.prototype.decodeMulti = function (buffer) {\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    this.reinitializeState();\n                    this.setBuffer(buffer);\n                    _a.label = 1;\n                case 1:\n                    if (!this.hasRemaining(1)) return [3 /*break*/, 3];\n                    return [4 /*yield*/, this.doDecodeSync()];\n                case 2:\n                    _a.sent();\n                    return [3 /*break*/, 1];\n                case 3: return [2 /*return*/];\n            }\n        });\n    };\n    Decoder.prototype.decodeAsync = function (stream) {\n        var _a, stream_1, stream_1_1;\n        var _b, e_1, _c, _d;\n        return __awaiter(this, void 0, void 0, function () {\n            var decoded, object, buffer, e_1_1, _e, headByte, pos, totalPos;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        decoded = false;\n                        _f.label = 1;\n                    case 1:\n                        _f.trys.push([1, 6, 7, 12]);\n                        _a = true, stream_1 = __asyncValues(stream);\n                        _f.label = 2;\n                    case 2: return [4 /*yield*/, stream_1.next()];\n                    case 3:\n                        if (!(stream_1_1 = _f.sent(), _b = stream_1_1.done, !_b)) return [3 /*break*/, 5];\n                        _d = stream_1_1.value;\n                        _a = false;\n                        try {\n                            buffer = _d;\n                            if (decoded) {\n                                throw this.createExtraByteError(this.totalPos);\n                            }\n                            this.appendBuffer(buffer);\n                            try {\n                                object = this.doDecodeSync();\n                                decoded = true;\n                            }\n                            catch (e) {\n                                if (!(e instanceof DataViewIndexOutOfBoundsError)) {\n                                    throw e; // rethrow\n                                }\n                                // fallthrough\n                            }\n                            this.totalPos += this.pos;\n                        }\n                        finally {\n                            _a = true;\n                        }\n                        _f.label = 4;\n                    case 4: return [3 /*break*/, 2];\n                    case 5: return [3 /*break*/, 12];\n                    case 6:\n                        e_1_1 = _f.sent();\n                        e_1 = { error: e_1_1 };\n                        return [3 /*break*/, 12];\n                    case 7:\n                        _f.trys.push([7, , 10, 11]);\n                        if (!(!_a && !_b && (_c = stream_1.return))) return [3 /*break*/, 9];\n                        return [4 /*yield*/, _c.call(stream_1)];\n                    case 8:\n                        _f.sent();\n                        _f.label = 9;\n                    case 9: return [3 /*break*/, 11];\n                    case 10:\n                        if (e_1) throw e_1.error;\n                        return [7 /*endfinally*/];\n                    case 11: return [7 /*endfinally*/];\n                    case 12:\n                        if (decoded) {\n                            if (this.hasRemaining(1)) {\n                                throw this.createExtraByteError(this.totalPos);\n                            }\n                            return [2 /*return*/, object];\n                        }\n                        _e = this, headByte = _e.headByte, pos = _e.pos, totalPos = _e.totalPos;\n                        throw new RangeError(\"Insufficient data in parsing \".concat(prettyByte(headByte), \" at \").concat(totalPos, \" (\").concat(pos, \" in the current buffer)\"));\n                }\n            });\n        });\n    };\n    Decoder.prototype.decodeArrayStream = function (stream) {\n        return this.decodeMultiAsync(stream, true);\n    };\n    Decoder.prototype.decodeStream = function (stream) {\n        return this.decodeMultiAsync(stream, false);\n    };\n    Decoder.prototype.decodeMultiAsync = function (stream, isArray) {\n        return __asyncGenerator(this, arguments, function decodeMultiAsync_1() {\n            var isArrayHeaderRequired, arrayItemsLeft, _a, stream_2, stream_2_1, buffer, e_2, e_3_1;\n            var _b, e_3, _c, _d;\n            return __generator(this, function (_e) {\n                switch (_e.label) {\n                    case 0:\n                        isArrayHeaderRequired = isArray;\n                        arrayItemsLeft = -1;\n                        _e.label = 1;\n                    case 1:\n                        _e.trys.push([1, 15, 16, 21]);\n                        _a = true, stream_2 = __asyncValues(stream);\n                        _e.label = 2;\n                    case 2: return [4 /*yield*/, __await(stream_2.next())];\n                    case 3:\n                        if (!(stream_2_1 = _e.sent(), _b = stream_2_1.done, !_b)) return [3 /*break*/, 14];\n                        _d = stream_2_1.value;\n                        _a = false;\n                        _e.label = 4;\n                    case 4:\n                        _e.trys.push([4, , 12, 13]);\n                        buffer = _d;\n                        if (isArray && arrayItemsLeft === 0) {\n                            throw this.createExtraByteError(this.totalPos);\n                        }\n                        this.appendBuffer(buffer);\n                        if (isArrayHeaderRequired) {\n                            arrayItemsLeft = this.readArraySize();\n                            isArrayHeaderRequired = false;\n                            this.complete();\n                        }\n                        _e.label = 5;\n                    case 5:\n                        _e.trys.push([5, 10, , 11]);\n                        _e.label = 6;\n                    case 6:\n                        if (!true) return [3 /*break*/, 9];\n                        return [4 /*yield*/, __await(this.doDecodeSync())];\n                    case 7: return [4 /*yield*/, _e.sent()];\n                    case 8:\n                        _e.sent();\n                        if (--arrayItemsLeft === 0) {\n                            return [3 /*break*/, 9];\n                        }\n                        return [3 /*break*/, 6];\n                    case 9: return [3 /*break*/, 11];\n                    case 10:\n                        e_2 = _e.sent();\n                        if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {\n                            throw e_2; // rethrow\n                        }\n                        return [3 /*break*/, 11];\n                    case 11:\n                        this.totalPos += this.pos;\n                        return [3 /*break*/, 13];\n                    case 12:\n                        _a = true;\n                        return [7 /*endfinally*/];\n                    case 13: return [3 /*break*/, 2];\n                    case 14: return [3 /*break*/, 21];\n                    case 15:\n                        e_3_1 = _e.sent();\n                        e_3 = { error: e_3_1 };\n                        return [3 /*break*/, 21];\n                    case 16:\n                        _e.trys.push([16, , 19, 20]);\n                        if (!(!_a && !_b && (_c = stream_2.return))) return [3 /*break*/, 18];\n                        return [4 /*yield*/, __await(_c.call(stream_2))];\n                    case 17:\n                        _e.sent();\n                        _e.label = 18;\n                    case 18: return [3 /*break*/, 20];\n                    case 19:\n                        if (e_3) throw e_3.error;\n                        return [7 /*endfinally*/];\n                    case 20: return [7 /*endfinally*/];\n                    case 21: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    Decoder.prototype.doDecodeSync = function () {\n        DECODE: while (true) {\n            var headByte = this.readHeadByte();\n            var object = void 0;\n            if (headByte >= 0xe0) {\n                // negative fixint (111x xxxx) 0xe0 - 0xff\n                object = headByte - 0x100;\n            }\n            else if (headByte < 0xc0) {\n                if (headByte < 0x80) {\n                    // positive fixint (0xxx xxxx) 0x00 - 0x7f\n                    object = headByte;\n                }\n                else if (headByte < 0x90) {\n                    // fixmap (1000 xxxx) 0x80 - 0x8f\n                    var size = headByte - 0x80;\n                    if (size !== 0) {\n                        this.pushMapState(size);\n                        this.complete();\n                        continue DECODE;\n                    }\n                    else {\n                        object = {};\n                    }\n                }\n                else if (headByte < 0xa0) {\n                    // fixarray (1001 xxxx) 0x90 - 0x9f\n                    var size = headByte - 0x90;\n                    if (size !== 0) {\n                        this.pushArrayState(size);\n                        this.complete();\n                        continue DECODE;\n                    }\n                    else {\n                        object = [];\n                    }\n                }\n                else {\n                    // fixstr (101x xxxx) 0xa0 - 0xbf\n                    var byteLength = headByte - 0xa0;\n                    object = this.decodeUtf8String(byteLength, 0);\n                }\n            }\n            else if (headByte === 0xc0) {\n                // nil\n                object = null;\n            }\n            else if (headByte === 0xc2) {\n                // false\n                object = false;\n            }\n            else if (headByte === 0xc3) {\n                // true\n                object = true;\n            }\n            else if (headByte === 0xca) {\n                // float 32\n                object = this.readF32();\n            }\n            else if (headByte === 0xcb) {\n                // float 64\n                object = this.readF64();\n            }\n            else if (headByte === 0xcc) {\n                // uint 8\n                object = this.readU8();\n            }\n            else if (headByte === 0xcd) {\n                // uint 16\n                object = this.readU16();\n            }\n            else if (headByte === 0xce) {\n                // uint 32\n                object = this.readU32();\n            }\n            else if (headByte === 0xcf) {\n                // uint 64\n                if (this.useBigInt64) {\n                    object = this.readU64AsBigInt();\n                }\n                else {\n                    object = this.readU64();\n                }\n            }\n            else if (headByte === 0xd0) {\n                // int 8\n                object = this.readI8();\n            }\n            else if (headByte === 0xd1) {\n                // int 16\n                object = this.readI16();\n            }\n            else if (headByte === 0xd2) {\n                // int 32\n                object = this.readI32();\n            }\n            else if (headByte === 0xd3) {\n                // int 64\n                if (this.useBigInt64) {\n                    object = this.readI64AsBigInt();\n                }\n                else {\n                    object = this.readI64();\n                }\n            }\n            else if (headByte === 0xd9) {\n                // str 8\n                var byteLength = this.lookU8();\n                object = this.decodeUtf8String(byteLength, 1);\n            }\n            else if (headByte === 0xda) {\n                // str 16\n                var byteLength = this.lookU16();\n                object = this.decodeUtf8String(byteLength, 2);\n            }\n            else if (headByte === 0xdb) {\n                // str 32\n                var byteLength = this.lookU32();\n                object = this.decodeUtf8String(byteLength, 4);\n            }\n            else if (headByte === 0xdc) {\n                // array 16\n                var size = this.readU16();\n                if (size !== 0) {\n                    this.pushArrayState(size);\n                    this.complete();\n                    continue DECODE;\n                }\n                else {\n                    object = [];\n                }\n            }\n            else if (headByte === 0xdd) {\n                // array 32\n                var size = this.readU32();\n                if (size !== 0) {\n                    this.pushArrayState(size);\n                    this.complete();\n                    continue DECODE;\n                }\n                else {\n                    object = [];\n                }\n            }\n            else if (headByte === 0xde) {\n                // map 16\n                var size = this.readU16();\n                if (size !== 0) {\n                    this.pushMapState(size);\n                    this.complete();\n                    continue DECODE;\n                }\n                else {\n                    object = {};\n                }\n            }\n            else if (headByte === 0xdf) {\n                // map 32\n                var size = this.readU32();\n                if (size !== 0) {\n                    this.pushMapState(size);\n                    this.complete();\n                    continue DECODE;\n                }\n                else {\n                    object = {};\n                }\n            }\n            else if (headByte === 0xc4) {\n                // bin 8\n                var size = this.lookU8();\n                object = this.decodeBinary(size, 1);\n            }\n            else if (headByte === 0xc5) {\n                // bin 16\n                var size = this.lookU16();\n                object = this.decodeBinary(size, 2);\n            }\n            else if (headByte === 0xc6) {\n                // bin 32\n                var size = this.lookU32();\n                object = this.decodeBinary(size, 4);\n            }\n            else if (headByte === 0xd4) {\n                // fixext 1\n                object = this.decodeExtension(1, 0);\n            }\n            else if (headByte === 0xd5) {\n                // fixext 2\n                object = this.decodeExtension(2, 0);\n            }\n            else if (headByte === 0xd6) {\n                // fixext 4\n                object = this.decodeExtension(4, 0);\n            }\n            else if (headByte === 0xd7) {\n                // fixext 8\n                object = this.decodeExtension(8, 0);\n            }\n            else if (headByte === 0xd8) {\n                // fixext 16\n                object = this.decodeExtension(16, 0);\n            }\n            else if (headByte === 0xc7) {\n                // ext 8\n                var size = this.lookU8();\n                object = this.decodeExtension(size, 1);\n            }\n            else if (headByte === 0xc8) {\n                // ext 16\n                var size = this.lookU16();\n                object = this.decodeExtension(size, 2);\n            }\n            else if (headByte === 0xc9) {\n                // ext 32\n                var size = this.lookU32();\n                object = this.decodeExtension(size, 4);\n            }\n            else {\n                throw new DecodeError(\"Unrecognized type byte: \".concat(prettyByte(headByte)));\n            }\n            this.complete();\n            var stack = this.stack;\n            while (stack.length > 0) {\n                // arrays and maps\n                var state = stack[stack.length - 1];\n                if (state.type === STATE_ARRAY) {\n                    state.array[state.position] = object;\n                    state.position++;\n                    if (state.position === state.size) {\n                        stack.pop();\n                        object = state.array;\n                    }\n                    else {\n                        continue DECODE;\n                    }\n                }\n                else if (state.type === STATE_MAP_KEY) {\n                    if (!isValidMapKeyType(object)) {\n                        throw new DecodeError(\"The type of key must be string or number but \" + typeof object);\n                    }\n                    if (object === \"__proto__\") {\n                        throw new DecodeError(\"The key __proto__ is not allowed\");\n                    }\n                    state.key = object;\n                    state.type = STATE_MAP_VALUE;\n                    continue DECODE;\n                }\n                else {\n                    // it must be `state.type === State.MAP_VALUE` here\n                    state.map[state.key] = object;\n                    state.readCount++;\n                    if (state.readCount === state.size) {\n                        stack.pop();\n                        object = state.map;\n                    }\n                    else {\n                        state.key = null;\n                        state.type = STATE_MAP_KEY;\n                        continue DECODE;\n                    }\n                }\n            }\n            return object;\n        }\n    };\n    Decoder.prototype.readHeadByte = function () {\n        if (this.headByte === HEAD_BYTE_REQUIRED) {\n            this.headByte = this.readU8();\n            // console.log(\"headByte\", prettyByte(this.headByte));\n        }\n        return this.headByte;\n    };\n    Decoder.prototype.complete = function () {\n        this.headByte = HEAD_BYTE_REQUIRED;\n    };\n    Decoder.prototype.readArraySize = function () {\n        var headByte = this.readHeadByte();\n        switch (headByte) {\n            case 0xdc:\n                return this.readU16();\n            case 0xdd:\n                return this.readU32();\n            default: {\n                if (headByte < 0xa0) {\n                    return headByte - 0x90;\n                }\n                else {\n                    throw new DecodeError(\"Unrecognized array type byte: \".concat(prettyByte(headByte)));\n                }\n            }\n        }\n    };\n    Decoder.prototype.pushMapState = function (size) {\n        if (size > this.maxMapLength) {\n            throw new DecodeError(\"Max length exceeded: map length (\".concat(size, \") > maxMapLengthLength (\").concat(this.maxMapLength, \")\"));\n        }\n        this.stack.push({\n            type: STATE_MAP_KEY,\n            size: size,\n            key: null,\n            readCount: 0,\n            map: {},\n        });\n    };\n    Decoder.prototype.pushArrayState = function (size) {\n        if (size > this.maxArrayLength) {\n            throw new DecodeError(\"Max length exceeded: array length (\".concat(size, \") > maxArrayLength (\").concat(this.maxArrayLength, \")\"));\n        }\n        this.stack.push({\n            type: STATE_ARRAY,\n            size: size,\n            array: new Array(size),\n            position: 0,\n        });\n    };\n    Decoder.prototype.decodeUtf8String = function (byteLength, headerOffset) {\n        var _a;\n        if (byteLength > this.maxStrLength) {\n            throw new DecodeError(\"Max length exceeded: UTF-8 byte length (\".concat(byteLength, \") > maxStrLength (\").concat(this.maxStrLength, \")\"));\n        }\n        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {\n            throw MORE_DATA;\n        }\n        var offset = this.pos + headerOffset;\n        var object;\n        if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) {\n            object = this.keyDecoder.decode(this.bytes, offset, byteLength);\n        }\n        else {\n            object = utf8Decode(this.bytes, offset, byteLength);\n        }\n        this.pos += headerOffset + byteLength;\n        return object;\n    };\n    Decoder.prototype.stateIsMapKey = function () {\n        if (this.stack.length > 0) {\n            var state = this.stack[this.stack.length - 1];\n            return state.type === STATE_MAP_KEY;\n        }\n        return false;\n    };\n    Decoder.prototype.decodeBinary = function (byteLength, headOffset) {\n        if (byteLength > this.maxBinLength) {\n            throw new DecodeError(\"Max length exceeded: bin length (\".concat(byteLength, \") > maxBinLength (\").concat(this.maxBinLength, \")\"));\n        }\n        if (!this.hasRemaining(byteLength + headOffset)) {\n            throw MORE_DATA;\n        }\n        var offset = this.pos + headOffset;\n        var object = this.bytes.subarray(offset, offset + byteLength);\n        this.pos += headOffset + byteLength;\n        return object;\n    };\n    Decoder.prototype.decodeExtension = function (size, headOffset) {\n        if (size > this.maxExtLength) {\n            throw new DecodeError(\"Max length exceeded: ext length (\".concat(size, \") > maxExtLength (\").concat(this.maxExtLength, \")\"));\n        }\n        var extType = this.view.getInt8(this.pos + headOffset);\n        var data = this.decodeBinary(size, headOffset + 1 /* extType */);\n        return this.extensionCodec.decode(data, extType, this.context);\n    };\n    Decoder.prototype.lookU8 = function () {\n        return this.view.getUint8(this.pos);\n    };\n    Decoder.prototype.lookU16 = function () {\n        return this.view.getUint16(this.pos);\n    };\n    Decoder.prototype.lookU32 = function () {\n        return this.view.getUint32(this.pos);\n    };\n    Decoder.prototype.readU8 = function () {\n        var value = this.view.getUint8(this.pos);\n        this.pos++;\n        return value;\n    };\n    Decoder.prototype.readI8 = function () {\n        var value = this.view.getInt8(this.pos);\n        this.pos++;\n        return value;\n    };\n    Decoder.prototype.readU16 = function () {\n        var value = this.view.getUint16(this.pos);\n        this.pos += 2;\n        return value;\n    };\n    Decoder.prototype.readI16 = function () {\n        var value = this.view.getInt16(this.pos);\n        this.pos += 2;\n        return value;\n    };\n    Decoder.prototype.readU32 = function () {\n        var value = this.view.getUint32(this.pos);\n        this.pos += 4;\n        return value;\n    };\n    Decoder.prototype.readI32 = function () {\n        var value = this.view.getInt32(this.pos);\n        this.pos += 4;\n        return value;\n    };\n    Decoder.prototype.readU64 = function () {\n        var value = getUint64(this.view, this.pos);\n        this.pos += 8;\n        return value;\n    };\n    Decoder.prototype.readI64 = function () {\n        var value = getInt64(this.view, this.pos);\n        this.pos += 8;\n        return value;\n    };\n    Decoder.prototype.readU64AsBigInt = function () {\n        var value = this.view.getBigUint64(this.pos);\n        this.pos += 8;\n        return value;\n    };\n    Decoder.prototype.readI64AsBigInt = function () {\n        var value = this.view.getBigInt64(this.pos);\n        this.pos += 8;\n        return value;\n    };\n    Decoder.prototype.readF32 = function () {\n        var value = this.view.getFloat32(this.pos);\n        this.pos += 4;\n        return value;\n    };\n    Decoder.prototype.readF64 = function () {\n        var value = this.view.getFloat64(this.pos);\n        this.pos += 8;\n        return value;\n    };\n    return Decoder;\n}());\nexport { Decoder };\n//# sourceMappingURL=Decoder.mjs.map"],"names":["extendStatics","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","this","constructor","create","DecodeError","_super","message","_this","proto","defineProperty","configurable","enumerable","value","name","Error","ExtData","type","data","ExtensionCodec","builtInEncoders","builtInDecoders","encoders","decoders","register","timestamp","_a","encode","decode","index","tryToEncode","object","context","i","length","encodeExt","decodeExt","defaultCodec","CachedKeyDecoder","maxKeyLength","maxLengthPerKey","hit","miss","caches","push","canBeCached","byteLength","find","bytes","inputOffset","FIND_CHUNK","_i","records_1","record","recordBytes","j","str","store","records","Math","random","cachedValue","utf8","slicedCopyOfBytes","Uint8Array","slice","__generator","thisArg","body","f","y","t","g","_","label","sent","trys","ops","next","verb","Symbol","iterator","n","v","op","done","pop","e","step","__asyncValues","o","asyncIterator","m","__values","Promise","resolve","reject","then","settle","__await","STATE_ARRAY","STATE_MAP_KEY","EMPTY_VIEW","DataView","ArrayBuffer","EMPTY_BYTES","buffer","getInt8","RangeError","DataViewIndexOutOfBoundsError","MORE_DATA","sharedCachedKeyDecoder","Decoder","options","_b","_c","_d","_e","_f","_g","totalPos","pos","view","headByte","stack","extensionCodec","useBigInt64","maxStrLength","maxBinLength","maxArrayLength","maxMapLength","maxExtLength","keyDecoder","undefined","reinitializeState","setBuffer","appendBuffer","hasRemaining","remainingData","subarray","newData","newBuffer","set","size","createExtraByteError","posToShow","concat","doDecodeSync","decodeMulti","decodeAsync","stream","stream_1","stream_1_1","e_1","_arguments","P","generator","decoded","e_1_1","error","return","prettyByte","fulfilled","rejected","result","apply","decodeArrayStream","decodeMultiAsync","decodeStream","isArray","q","a","resume","r","fulfill","shift","__asyncGenerator","arguments","isArrayHeaderRequired","arrayItemsLeft","stream_2","stream_2_1","e_2","e_3_1","e_3","readArraySize","complete","DECODE","readHeadByte","pushMapState","pushArrayState","decodeUtf8String","readF32","readF64","readU8","readU16","readU32","readU64AsBigInt","readU64","readI8","readI16","readI32","readI64AsBigInt","readI64","lookU8","lookU16","lookU32","decodeBinary","decodeExtension","state","array","position","key","map","readCount","headerOffset","offset","stateIsMapKey","headOffset","extType","getUint8","getUint16","getUint32","getInt16","getInt32","getBigUint64","getBigInt64","getFloat32","getFloat64"],"sourceRoot":""}