{"version":3,"sources":["webpack://signalR.protocols.msgpack/webpack/universalModuleDefinition","webpack://signalR.protocols.msgpack/external \"signalR\"","webpack://signalR.protocols.msgpack/webpack/bootstrap","webpack://signalR.protocols.msgpack/webpack/runtime/define property getters","webpack://signalR.protocols.msgpack/webpack/runtime/hasOwnProperty shorthand","webpack://signalR.protocols.msgpack/webpack/runtime/make namespace object","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs","webpack://signalR.protocols.msgpack/node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs","webpack://signalR.protocols.msgpack/src/BinaryMessageFormat.ts","webpack://signalR.protocols.msgpack/src/MessagePackHubProtocol.ts","webpack://signalR.protocols.msgpack/src/Utils.ts","webpack://signalR.protocols.msgpack/src/index.ts"],"names":["root","factory","self","__WEBPACK_EXTERNAL_MODULE__1__","module","exports","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","r","Symbol","toStringTag","value","UINT32_MAX","setInt64","view","offset","high","Math","floor","low","setUint32","getInt64","getInt32","getUint32","TEXT_ENCODING_AVAILABLE","process","env","TEXT_ENCODING","TextEncoder","TextDecoder","utf8Count","str","strLength","length","byteLength","pos","charCodeAt","extra","sharedTextEncoder","TEXT_ENCODER_THRESHOLD","utf8EncodeTE","encodeInto","output","outputOffset","subarray","set","encode","utf8DecodeJs","bytes","inputOffset","end","units","result","byte1","push","byte2","byte3","unit","String","fromCharCode","apply","extendStatics","sharedTextDecoder","TEXT_DECODER_THRESHOLD","TEXT_DECODER","ExtData","type","data","this","__extends","b","setPrototypeOf","__proto__","Array","p","TypeError","__","constructor","create","DecodeError","_super","message","_this","proto","configurable","name","Error","timestampExtension","object","msec","sec","nsec","nsecInSec","Date","_a","rv","Uint8Array","DataView","buffer","secHigh","secLow","getTime","decode","timeSpec","byteOffset","nsec30AndSecHigh2","ExtensionCodec","builtInEncoders","builtInDecoders","encoders","decoders","register","index","tryToEncode","context","i","encodeExt","decodeExt","defaultCodec","ensureUint8Array","ArrayBuffer","isView","from","Encoder","extensionCodec","maxDepth","initialBufferSize","sortKeys","forceFloat32","ignoreUndefined","forceIntegerToFloat","undefined","getUint8Array","reinitializeState","doEncode","depth","encodeNil","encodeBoolean","encodeNumber","encodeString","encodeObject","ensureBufferSizeToWrite","sizeToWrite","requiredSize","resizeBuffer","newSize","newBuffer","newBytes","newView","writeU8","Number","isSafeInteger","writeU16","writeU32","writeU64","writeI8","writeI16","writeI32","writeI64","writeF32","writeF64","writeStringHeader","ext","encodeExtension","isArray","encodeArray","encodeBinary","toString","encodeMap","size","writeU8a","_i","object_1","item","countWithoutUndefined","keys","count","keys_1","sort","keys_2","setUint8","values","setInt8","setUint16","setInt16","setInt32","setFloat32","setFloat64","prettyByte","byte","abs","padStart","CachedKeyDecoder","maxKeyLength","maxLengthPerKey","hit","miss","caches","canBeCached","find","FIND_CHUNK","records_1","record","recordBytes","j","store","records","random","cachedValue","slicedCopyOfBytes","slice","__generator","thisArg","body","f","y","t","g","_","label","sent","trys","ops","next","verb","throw","return","iterator","n","v","op","done","pop","e","__asyncValues","asyncIterator","m","__values","Promise","resolve","reject","then","__await","__asyncGenerator","_arguments","generator","q","a","resume","fulfill","settle","shift","EMPTY_VIEW","EMPTY_BYTES","DataViewIndexOutOfBoundsError","getInt8","MORE_DATA","sharedCachedKeyDecoder","Decoder","maxStrLength","maxBinLength","maxArrayLength","maxMapLength","maxExtLength","keyDecoder","totalPos","headByte","stack","setBuffer","bufferView","appendBuffer","hasRemaining","remainingData","newData","createExtraByteError","posToShow","RangeError","doDecodeSync","decodeMulti","decodeAsync","stream","stream_1","stream_1_1","e_1","P","fulfilled","step","rejected","__awaiter","decoded","e_1_1","_b","_c","error","decodeArrayStream","decodeMultiAsync","decodeStream","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","readU64","readI8","readI16","readI32","readI64","lookU8","lookU16","lookU32","decodeBinary","decodeExtension","state","array","position","keyType","map","readCount","headerOffset","stateIsMapKey","stringBytes","headOffset","extType","getUint8","getUint16","getInt16","getFloat32","getFloat64","BinaryMessageFormat","[object Object]","lenBuffer","sizePart","input","uint8Array","numBitsToShift","byteRead","numBytes","min","SERIALIZED_PING_MESSAGE","O","MessageType","Ping","MessagePackHubProtocol","messagePackOptions","version","transferFormat","TransferFormat","Binary","_errorResult","_voidResult","_nonVoidResult","_encoder","_decoder","logger","val","NullLogger","instance","messages","parse","hubMessages","parsedMessage","_parseMessage","Invocation","_writeInvocation","StreamInvocation","_writeStreamInvocation","StreamItem","_writeStreamItem","Completion","_writeCompletion","write","CancelInvocation","_writeCancelInvocation","properties","messageType","_createInvocationMessage","_readHeaders","_createStreamItemMessage","_createCompletionMessage","_createPingMessage","Close","_createCloseMessage","log","LogLevel","Information","allowReconnect","headers","invocationId","streamIds","target","resultKind","invocationMessage","payload","streamInvocationMessage","streamItemMessage","completionMessage","cancelInvocationMessage","VERSION","require","define","amd","msgpack","signalR","protocols"],"mappings":"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","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"signalR\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"signalR\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"msgpack\"] = factory(require(\"signalR\"));\n\telse\n\t\troot[\"signalR\"] = root[\"signalR\"] || {}, root[\"signalR\"][\"protocols\"] = root[\"signalR\"][\"protocols\"] || {}, root[\"signalR\"][\"protocols\"][\"msgpack\"] = factory(root[\"signalR\"]);\n})(self, function(__WEBPACK_EXTERNAL_MODULE__1__) {\nreturn ","module.exports = __WEBPACK_EXTERNAL_MODULE__1__;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","// 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","import { UINT32_MAX } from \"./int.mjs\";\nvar TEXT_ENCODING_AVAILABLE = (typeof process === \"undefined\" || process.env[\"TEXT_ENCODING\"] !== \"never\") &&\n    typeof TextEncoder !== \"undefined\" &&\n    typeof TextDecoder !== \"undefined\";\nexport 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}\nvar sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;\nexport var TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE\n    ? UINT32_MAX\n    : typeof process !== \"undefined\" && process.env[\"TEXT_ENCODING\"] !== \"force\"\n        ? 200\n        : 0;\nfunction utf8EncodeTEencode(str, output, outputOffset) {\n    output.set(sharedTextEncoder.encode(str), outputOffset);\n}\nfunction utf8EncodeTEencodeInto(str, output, outputOffset) {\n    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));\n}\nexport var utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;\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 = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;\nexport var TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE\n    ? UINT32_MAX\n    : typeof process !== \"undefined\" && process.env[\"TEXT_DECODER\"] !== \"force\"\n        ? 200\n        : 0;\nexport function utf8DecodeTD(bytes, inputOffset, byteLength) {\n    var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);\n    return sharedTextDecoder.decode(stringBytes);\n}\n//# sourceMappingURL=utf8.mjs.map","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","// 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): \" + 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","// ExtensionCodec to handle MessagePack extensions\nimport { ExtData } from \"./ExtData.mjs\";\nimport { timestampExtension } from \"./timestamp.mjs\";\nvar 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}());\nexport { ExtensionCodec };\n//# sourceMappingURL=ExtensionCodec.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","import { utf8EncodeJs, utf8Count, TEXT_ENCODER_THRESHOLD, utf8EncodeTE } from \"./utils/utf8.mjs\";\nimport { ExtensionCodec } from \"./ExtensionCodec.mjs\";\nimport { setInt64, setUint64 } from \"./utils/int.mjs\";\nimport { ensureUint8Array } from \"./utils/typedArrays.mjs\";\nexport var DEFAULT_MAX_DEPTH = 100;\nexport var DEFAULT_INITIAL_BUFFER_SIZE = 2048;\nvar Encoder = /** @class */ (function () {\n    function Encoder(extensionCodec, context, maxDepth, initialBufferSize, sortKeys, forceFloat32, ignoreUndefined, forceIntegerToFloat) {\n        if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }\n        if (context === void 0) { context = undefined; }\n        if (maxDepth === void 0) { maxDepth = DEFAULT_MAX_DEPTH; }\n        if (initialBufferSize === void 0) { initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE; }\n        if (sortKeys === void 0) { sortKeys = false; }\n        if (forceFloat32 === void 0) { forceFloat32 = false; }\n        if (ignoreUndefined === void 0) { ignoreUndefined = false; }\n        if (forceIntegerToFloat === void 0) { forceIntegerToFloat = false; }\n        this.extensionCodec = extensionCodec;\n        this.context = context;\n        this.maxDepth = maxDepth;\n        this.initialBufferSize = initialBufferSize;\n        this.sortKeys = sortKeys;\n        this.forceFloat32 = forceFloat32;\n        this.ignoreUndefined = ignoreUndefined;\n        this.forceIntegerToFloat = forceIntegerToFloat;\n        this.pos = 0;\n        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));\n        this.bytes = new Uint8Array(this.view.buffer);\n    }\n    Encoder.prototype.getUint8Array = function () {\n        return this.bytes.subarray(0, this.pos);\n    };\n    Encoder.prototype.reinitializeState = function () {\n        this.pos = 0;\n    };\n    Encoder.prototype.encode = function (object) {\n        this.reinitializeState();\n        this.doEncode(object, 1);\n        return this.getUint8Array();\n    };\n    Encoder.prototype.doEncode = function (object, depth) {\n        if (depth > this.maxDepth) {\n            throw new Error(\"Too deep objects in depth \" + depth);\n        }\n        if (object == null) {\n            this.encodeNil();\n        }\n        else if (typeof object === \"boolean\") {\n            this.encodeBoolean(object);\n        }\n        else if (typeof object === \"number\") {\n            this.encodeNumber(object);\n        }\n        else if (typeof object === \"string\") {\n            this.encodeString(object);\n        }\n        else {\n            this.encodeObject(object, depth);\n        }\n    };\n    Encoder.prototype.ensureBufferSizeToWrite = function (sizeToWrite) {\n        var requiredSize = this.pos + sizeToWrite;\n        if (this.view.byteLength < requiredSize) {\n            this.resizeBuffer(requiredSize * 2);\n        }\n    };\n    Encoder.prototype.resizeBuffer = function (newSize) {\n        var newBuffer = new ArrayBuffer(newSize);\n        var newBytes = new Uint8Array(newBuffer);\n        var newView = new DataView(newBuffer);\n        newBytes.set(this.bytes);\n        this.view = newView;\n        this.bytes = newBytes;\n    };\n    Encoder.prototype.encodeNil = function () {\n        this.writeU8(0xc0);\n    };\n    Encoder.prototype.encodeBoolean = function (object) {\n        if (object === false) {\n            this.writeU8(0xc2);\n        }\n        else {\n            this.writeU8(0xc3);\n        }\n    };\n    Encoder.prototype.encodeNumber = function (object) {\n        if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {\n            if (object >= 0) {\n                if (object < 0x80) {\n                    // positive fixint\n                    this.writeU8(object);\n                }\n                else if (object < 0x100) {\n                    // uint 8\n                    this.writeU8(0xcc);\n                    this.writeU8(object);\n                }\n                else if (object < 0x10000) {\n                    // uint 16\n                    this.writeU8(0xcd);\n                    this.writeU16(object);\n                }\n                else if (object < 0x100000000) {\n                    // uint 32\n                    this.writeU8(0xce);\n                    this.writeU32(object);\n                }\n                else {\n                    // uint 64\n                    this.writeU8(0xcf);\n                    this.writeU64(object);\n                }\n            }\n            else {\n                if (object >= -0x20) {\n                    // negative fixint\n                    this.writeU8(0xe0 | (object + 0x20));\n                }\n                else if (object >= -0x80) {\n                    // int 8\n                    this.writeU8(0xd0);\n                    this.writeI8(object);\n                }\n                else if (object >= -0x8000) {\n                    // int 16\n                    this.writeU8(0xd1);\n                    this.writeI16(object);\n                }\n                else if (object >= -0x80000000) {\n                    // int 32\n                    this.writeU8(0xd2);\n                    this.writeI32(object);\n                }\n                else {\n                    // int 64\n                    this.writeU8(0xd3);\n                    this.writeI64(object);\n                }\n            }\n        }\n        else {\n            // non-integer numbers\n            if (this.forceFloat32) {\n                // float 32\n                this.writeU8(0xca);\n                this.writeF32(object);\n            }\n            else {\n                // float 64\n                this.writeU8(0xcb);\n                this.writeF64(object);\n            }\n        }\n    };\n    Encoder.prototype.writeStringHeader = function (byteLength) {\n        if (byteLength < 32) {\n            // fixstr\n            this.writeU8(0xa0 + byteLength);\n        }\n        else if (byteLength < 0x100) {\n            // str 8\n            this.writeU8(0xd9);\n            this.writeU8(byteLength);\n        }\n        else if (byteLength < 0x10000) {\n            // str 16\n            this.writeU8(0xda);\n            this.writeU16(byteLength);\n        }\n        else if (byteLength < 0x100000000) {\n            // str 32\n            this.writeU8(0xdb);\n            this.writeU32(byteLength);\n        }\n        else {\n            throw new Error(\"Too long string: \" + byteLength + \" bytes in UTF-8\");\n        }\n    };\n    Encoder.prototype.encodeString = function (object) {\n        var maxHeaderSize = 1 + 4;\n        var strLength = object.length;\n        if (strLength > TEXT_ENCODER_THRESHOLD) {\n            var byteLength = utf8Count(object);\n            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);\n            this.writeStringHeader(byteLength);\n            utf8EncodeTE(object, this.bytes, this.pos);\n            this.pos += byteLength;\n        }\n        else {\n            var byteLength = utf8Count(object);\n            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);\n            this.writeStringHeader(byteLength);\n            utf8EncodeJs(object, this.bytes, this.pos);\n            this.pos += byteLength;\n        }\n    };\n    Encoder.prototype.encodeObject = function (object, depth) {\n        // try to encode objects with custom codec first of non-primitives\n        var ext = this.extensionCodec.tryToEncode(object, this.context);\n        if (ext != null) {\n            this.encodeExtension(ext);\n        }\n        else if (Array.isArray(object)) {\n            this.encodeArray(object, depth);\n        }\n        else if (ArrayBuffer.isView(object)) {\n            this.encodeBinary(object);\n        }\n        else if (typeof object === \"object\") {\n            this.encodeMap(object, depth);\n        }\n        else {\n            // symbol, function and other special object come here unless extensionCodec handles them.\n            throw new Error(\"Unrecognized object: \" + Object.prototype.toString.apply(object));\n        }\n    };\n    Encoder.prototype.encodeBinary = function (object) {\n        var size = object.byteLength;\n        if (size < 0x100) {\n            // bin 8\n            this.writeU8(0xc4);\n            this.writeU8(size);\n        }\n        else if (size < 0x10000) {\n            // bin 16\n            this.writeU8(0xc5);\n            this.writeU16(size);\n        }\n        else if (size < 0x100000000) {\n            // bin 32\n            this.writeU8(0xc6);\n            this.writeU32(size);\n        }\n        else {\n            throw new Error(\"Too large binary: \" + size);\n        }\n        var bytes = ensureUint8Array(object);\n        this.writeU8a(bytes);\n    };\n    Encoder.prototype.encodeArray = function (object, depth) {\n        var size = object.length;\n        if (size < 16) {\n            // fixarray\n            this.writeU8(0x90 + size);\n        }\n        else if (size < 0x10000) {\n            // array 16\n            this.writeU8(0xdc);\n            this.writeU16(size);\n        }\n        else if (size < 0x100000000) {\n            // array 32\n            this.writeU8(0xdd);\n            this.writeU32(size);\n        }\n        else {\n            throw new Error(\"Too large array: \" + size);\n        }\n        for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {\n            var item = object_1[_i];\n            this.doEncode(item, depth + 1);\n        }\n    };\n    Encoder.prototype.countWithoutUndefined = function (object, keys) {\n        var count = 0;\n        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n            var key = keys_1[_i];\n            if (object[key] !== undefined) {\n                count++;\n            }\n        }\n        return count;\n    };\n    Encoder.prototype.encodeMap = function (object, depth) {\n        var keys = Object.keys(object);\n        if (this.sortKeys) {\n            keys.sort();\n        }\n        var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;\n        if (size < 16) {\n            // fixmap\n            this.writeU8(0x80 + size);\n        }\n        else if (size < 0x10000) {\n            // map 16\n            this.writeU8(0xde);\n            this.writeU16(size);\n        }\n        else if (size < 0x100000000) {\n            // map 32\n            this.writeU8(0xdf);\n            this.writeU32(size);\n        }\n        else {\n            throw new Error(\"Too large map object: \" + size);\n        }\n        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {\n            var key = keys_2[_i];\n            var value = object[key];\n            if (!(this.ignoreUndefined && value === undefined)) {\n                this.encodeString(key);\n                this.doEncode(value, depth + 1);\n            }\n        }\n    };\n    Encoder.prototype.encodeExtension = function (ext) {\n        var size = ext.data.length;\n        if (size === 1) {\n            // fixext 1\n            this.writeU8(0xd4);\n        }\n        else if (size === 2) {\n            // fixext 2\n            this.writeU8(0xd5);\n        }\n        else if (size === 4) {\n            // fixext 4\n            this.writeU8(0xd6);\n        }\n        else if (size === 8) {\n            // fixext 8\n            this.writeU8(0xd7);\n        }\n        else if (size === 16) {\n            // fixext 16\n            this.writeU8(0xd8);\n        }\n        else if (size < 0x100) {\n            // ext 8\n            this.writeU8(0xc7);\n            this.writeU8(size);\n        }\n        else if (size < 0x10000) {\n            // ext 16\n            this.writeU8(0xc8);\n            this.writeU16(size);\n        }\n        else if (size < 0x100000000) {\n            // ext 32\n            this.writeU8(0xc9);\n            this.writeU32(size);\n        }\n        else {\n            throw new Error(\"Too large extension object: \" + size);\n        }\n        this.writeI8(ext.type);\n        this.writeU8a(ext.data);\n    };\n    Encoder.prototype.writeU8 = function (value) {\n        this.ensureBufferSizeToWrite(1);\n        this.view.setUint8(this.pos, value);\n        this.pos++;\n    };\n    Encoder.prototype.writeU8a = function (values) {\n        var size = values.length;\n        this.ensureBufferSizeToWrite(size);\n        this.bytes.set(values, this.pos);\n        this.pos += size;\n    };\n    Encoder.prototype.writeI8 = function (value) {\n        this.ensureBufferSizeToWrite(1);\n        this.view.setInt8(this.pos, value);\n        this.pos++;\n    };\n    Encoder.prototype.writeU16 = function (value) {\n        this.ensureBufferSizeToWrite(2);\n        this.view.setUint16(this.pos, value);\n        this.pos += 2;\n    };\n    Encoder.prototype.writeI16 = function (value) {\n        this.ensureBufferSizeToWrite(2);\n        this.view.setInt16(this.pos, value);\n        this.pos += 2;\n    };\n    Encoder.prototype.writeU32 = function (value) {\n        this.ensureBufferSizeToWrite(4);\n        this.view.setUint32(this.pos, value);\n        this.pos += 4;\n    };\n    Encoder.prototype.writeI32 = function (value) {\n        this.ensureBufferSizeToWrite(4);\n        this.view.setInt32(this.pos, value);\n        this.pos += 4;\n    };\n    Encoder.prototype.writeF32 = function (value) {\n        this.ensureBufferSizeToWrite(4);\n        this.view.setFloat32(this.pos, value);\n        this.pos += 4;\n    };\n    Encoder.prototype.writeF64 = function (value) {\n        this.ensureBufferSizeToWrite(8);\n        this.view.setFloat64(this.pos, value);\n        this.pos += 8;\n    };\n    Encoder.prototype.writeU64 = function (value) {\n        this.ensureBufferSizeToWrite(8);\n        setUint64(this.view, this.pos, value);\n        this.pos += 8;\n    };\n    Encoder.prototype.writeI64 = function (value) {\n        this.ensureBufferSizeToWrite(8);\n        setInt64(this.view, this.pos, value);\n        this.pos += 8;\n    };\n    return Encoder;\n}());\nexport { Encoder };\n//# sourceMappingURL=Encoder.mjs.map","export function prettyByte(byte) {\n    return (byte < 0 ? \"-\" : \"\") + \"0x\" + Math.abs(byte).toString(16).padStart(2, \"0\");\n}\n//# sourceMappingURL=prettyByte.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 (_) 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 { utf8DecodeJs, TEXT_DECODER_THRESHOLD, utf8DecodeTD } from \"./utils/utf8.mjs\";\nimport { createDataView, ensureUint8Array } from \"./utils/typedArrays.mjs\";\nimport { CachedKeyDecoder } from \"./CachedKeyDecoder.mjs\";\nimport { DecodeError } from \"./DecodeError.mjs\";\nvar isValidMapKeyType = function (key) {\n    var keyType = typeof key;\n    return keyType === \"string\" || keyType === \"number\";\n};\nvar HEAD_BYTE_REQUIRED = -1;\nvar EMPTY_VIEW = new DataView(new ArrayBuffer(0));\nvar EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);\n// IE11: Hack to support IE11.\n// IE11: Drop this hack and just use RangeError when IE11 is obsolete.\nexport var DataViewIndexOutOfBoundsError = (function () {\n    try {\n        // IE11: The spec says it should throw RangeError,\n        // IE11: but in IE11 it throws TypeError.\n        EMPTY_VIEW.getInt8(0);\n    }\n    catch (e) {\n        return e.constructor;\n    }\n    throw new Error(\"never reached\");\n})();\nvar MORE_DATA = new DataViewIndexOutOfBoundsError(\"Insufficient data\");\nvar sharedCachedKeyDecoder = new CachedKeyDecoder();\nvar Decoder = /** @class */ (function () {\n    function Decoder(extensionCodec, context, maxStrLength, maxBinLength, maxArrayLength, maxMapLength, maxExtLength, keyDecoder) {\n        if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }\n        if (context === void 0) { context = undefined; }\n        if (maxStrLength === void 0) { maxStrLength = UINT32_MAX; }\n        if (maxBinLength === void 0) { maxBinLength = UINT32_MAX; }\n        if (maxArrayLength === void 0) { maxArrayLength = UINT32_MAX; }\n        if (maxMapLength === void 0) { maxMapLength = UINT32_MAX; }\n        if (maxExtLength === void 0) { maxExtLength = UINT32_MAX; }\n        if (keyDecoder === void 0) { keyDecoder = sharedCachedKeyDecoder; }\n        this.extensionCodec = extensionCodec;\n        this.context = context;\n        this.maxStrLength = maxStrLength;\n        this.maxBinLength = maxBinLength;\n        this.maxArrayLength = maxArrayLength;\n        this.maxMapLength = maxMapLength;\n        this.maxExtLength = maxExtLength;\n        this.keyDecoder = keyDecoder;\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    }\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 \" + (view.byteLength - pos) + \" of \" + view.byteLength + \" byte(s) found at buffer[\" + posToShow + \"]\");\n    };\n    /**\n     * @throws {DecodeError}\n     * @throws {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 stream_1, stream_1_1;\n        var e_1, _a;\n        return __awaiter(this, void 0, void 0, function () {\n            var decoded, object, buffer, e_1_1, _b, headByte, pos, totalPos;\n            return __generator(this, function (_c) {\n                switch (_c.label) {\n                    case 0:\n                        decoded = false;\n                        _c.label = 1;\n                    case 1:\n                        _c.trys.push([1, 6, 7, 12]);\n                        stream_1 = __asyncValues(stream);\n                        _c.label = 2;\n                    case 2: return [4 /*yield*/, stream_1.next()];\n                    case 3:\n                        if (!(stream_1_1 = _c.sent(), !stream_1_1.done)) return [3 /*break*/, 5];\n                        buffer = stream_1_1.value;\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                        _c.label = 4;\n                    case 4: return [3 /*break*/, 2];\n                    case 5: return [3 /*break*/, 12];\n                    case 6:\n                        e_1_1 = _c.sent();\n                        e_1 = { error: e_1_1 };\n                        return [3 /*break*/, 12];\n                    case 7:\n                        _c.trys.push([7, , 10, 11]);\n                        if (!(stream_1_1 && !stream_1_1.done && (_a = stream_1.return))) return [3 /*break*/, 9];\n                        return [4 /*yield*/, _a.call(stream_1)];\n                    case 8:\n                        _c.sent();\n                        _c.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                        _b = this, headByte = _b.headByte, pos = _b.pos, totalPos = _b.totalPos;\n                        throw new RangeError(\"Insufficient data in parsing \" + prettyByte(headByte) + \" at \" + totalPos + \" (\" + 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, stream_2, stream_2_1, buffer, e_2, e_3_1;\n            var e_3, _a;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        isArrayHeaderRequired = isArray;\n                        arrayItemsLeft = -1;\n                        _b.label = 1;\n                    case 1:\n                        _b.trys.push([1, 13, 14, 19]);\n                        stream_2 = __asyncValues(stream);\n                        _b.label = 2;\n                    case 2: return [4 /*yield*/, __await(stream_2.next())];\n                    case 3:\n                        if (!(stream_2_1 = _b.sent(), !stream_2_1.done)) return [3 /*break*/, 12];\n                        buffer = stream_2_1.value;\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                        _b.label = 4;\n                    case 4:\n                        _b.trys.push([4, 9, , 10]);\n                        _b.label = 5;\n                    case 5:\n                        if (!true) return [3 /*break*/, 8];\n                        return [4 /*yield*/, __await(this.doDecodeSync())];\n                    case 6: return [4 /*yield*/, _b.sent()];\n                    case 7:\n                        _b.sent();\n                        if (--arrayItemsLeft === 0) {\n                            return [3 /*break*/, 8];\n                        }\n                        return [3 /*break*/, 5];\n                    case 8: return [3 /*break*/, 10];\n                    case 9:\n                        e_2 = _b.sent();\n                        if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {\n                            throw e_2; // rethrow\n                        }\n                        return [3 /*break*/, 10];\n                    case 10:\n                        this.totalPos += this.pos;\n                        _b.label = 11;\n                    case 11: return [3 /*break*/, 2];\n                    case 12: return [3 /*break*/, 19];\n                    case 13:\n                        e_3_1 = _b.sent();\n                        e_3 = { error: e_3_1 };\n                        return [3 /*break*/, 19];\n                    case 14:\n                        _b.trys.push([14, , 17, 18]);\n                        if (!(stream_2_1 && !stream_2_1.done && (_a = stream_2.return))) return [3 /*break*/, 16];\n                        return [4 /*yield*/, __await(_a.call(stream_2))];\n                    case 15:\n                        _b.sent();\n                        _b.label = 16;\n                    case 16: return [3 /*break*/, 18];\n                    case 17:\n                        if (e_3) throw e_3.error;\n                        return [7 /*endfinally*/];\n                    case 18: return [7 /*endfinally*/];\n                    case 19: 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                object = this.readU64();\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                object = this.readI64();\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: \" + 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 === 0 /* 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 === 1 /* 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 = 2 /* 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 = 1 /* 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: \" + 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 (\" + size + \") > maxMapLengthLength (\" + this.maxMapLength + \")\");\n        }\n        this.stack.push({\n            type: 1 /* 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 (\" + size + \") > maxArrayLength (\" + this.maxArrayLength + \")\");\n        }\n        this.stack.push({\n            type: 0 /* 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 (\" + byteLength + \") > maxStrLength (\" + 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 if (byteLength > TEXT_DECODER_THRESHOLD) {\n            object = utf8DecodeTD(this.bytes, offset, byteLength);\n        }\n        else {\n            object = utf8DecodeJs(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 === 1 /* 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 (\" + byteLength + \") > maxBinLength (\" + 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 (\" + size + \") > maxExtLength (\" + 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.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","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n\r\n// Not exported from index.\r\n/** @private */\r\nexport class BinaryMessageFormat {\r\n\r\n    // The length prefix of binary messages is encoded as VarInt. Read the comment in\r\n    // the BinaryMessageParser.TryParseMessage for details.\r\n\r\n    public static write(output: Uint8Array): ArrayBuffer {\r\n        let size = output.byteLength || output.length;\r\n        const lenBuffer = [];\r\n        do {\r\n            let sizePart = size & 0x7f;\r\n            size = size >> 7;\r\n            if (size > 0) {\r\n                sizePart |= 0x80;\r\n            }\r\n            lenBuffer.push(sizePart);\r\n        }\r\n        while (size > 0);\r\n\r\n        size = output.byteLength || output.length;\r\n\r\n        const buffer = new Uint8Array(lenBuffer.length + size);\r\n        buffer.set(lenBuffer, 0);\r\n        buffer.set(output, lenBuffer.length);\r\n        return buffer.buffer;\r\n    }\r\n\r\n    public static parse(input: ArrayBuffer): Uint8Array[] {\r\n        const result: Uint8Array[] = [];\r\n        const uint8Array = new Uint8Array(input);\r\n        const maxLengthPrefixSize = 5;\r\n        const numBitsToShift = [0, 7, 14, 21, 28 ];\r\n\r\n        for (let offset = 0; offset < input.byteLength;) {\r\n            let numBytes = 0;\r\n            let size = 0;\r\n            let byteRead;\r\n            do {\r\n                byteRead = uint8Array[offset + numBytes];\r\n                size = size | ((byteRead & 0x7f) << (numBitsToShift[numBytes]));\r\n                numBytes++;\r\n            }\r\n            while (numBytes < Math.min(maxLengthPrefixSize, input.byteLength - offset) && (byteRead & 0x80) !== 0);\r\n\r\n            if ((byteRead & 0x80) !== 0 && numBytes < maxLengthPrefixSize) {\r\n                throw new Error(\"Cannot read message size.\");\r\n            }\r\n\r\n            if (numBytes === maxLengthPrefixSize && byteRead > 7) {\r\n                throw new Error(\"Messages bigger than 2GB are not supported.\");\r\n            }\r\n\r\n            if (uint8Array.byteLength >= (offset + numBytes + size)) {\r\n                // IE does not support .slice() so use subarray\r\n                result.push(uint8Array.slice\r\n                    ? uint8Array.slice(offset + numBytes, offset + numBytes + size)\r\n                    : uint8Array.subarray(offset + numBytes, offset + numBytes + size));\r\n            } else {\r\n                throw new Error(\"Incomplete message.\");\r\n            }\r\n\r\n            offset = offset + numBytes + size;\r\n        }\r\n\r\n        return result;\r\n    }\r\n}\r\n","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n\r\nimport { Encoder, Decoder } from \"@msgpack/msgpack\";\r\n\r\nimport { MessagePackOptions } from \"./MessagePackOptions\";\r\n\r\nimport {\r\n    CancelInvocationMessage, CompletionMessage, HubMessage, IHubProtocol, ILogger, InvocationMessage,\r\n    LogLevel, MessageHeaders, MessageType, NullLogger, StreamInvocationMessage, StreamItemMessage, TransferFormat,\r\n} from \"@microsoft/signalr\";\r\n\r\nimport { BinaryMessageFormat } from \"./BinaryMessageFormat\";\r\nimport { isArrayBuffer } from \"./Utils\";\r\n\r\n// TypeDoc's @inheritDoc and @link don't work across modules :(\r\n\r\n// constant encoding of the ping message\r\n// see: https://github.com/aspnet/SignalR/blob/dev/specs/HubProtocol.md#ping-message-encoding-1\r\n// Don't use Uint8Array.from as IE does not support it\r\nconst SERIALIZED_PING_MESSAGE: Uint8Array = new Uint8Array([0x91, MessageType.Ping]);\r\n\r\n/** Implements the MessagePack Hub Protocol */\r\nexport class MessagePackHubProtocol implements IHubProtocol {\r\n    /** The name of the protocol. This is used by SignalR to resolve the protocol between the client and server. */\r\n    public readonly name: string = \"messagepack\";\r\n    /** The version of the protocol. */\r\n    public readonly version: number = 1;\r\n    /** The TransferFormat of the protocol. */\r\n    public readonly transferFormat: TransferFormat = TransferFormat.Binary;\r\n\r\n    private readonly _errorResult = 1;\r\n    private readonly _voidResult = 2;\r\n    private readonly _nonVoidResult = 3;\r\n\r\n    private readonly _encoder: Encoder<undefined>;\r\n    private readonly _decoder: Decoder<undefined>;\r\n\r\n    /**\r\n     *\r\n     * @param messagePackOptions MessagePack options passed to @msgpack/msgpack\r\n     */\r\n    constructor(messagePackOptions?: MessagePackOptions) {\r\n        messagePackOptions = messagePackOptions || {};\r\n        this._encoder = new Encoder(\r\n            messagePackOptions.extensionCodec,\r\n            messagePackOptions.context,\r\n            messagePackOptions.maxDepth,\r\n            messagePackOptions.initialBufferSize,\r\n            messagePackOptions.sortKeys,\r\n            messagePackOptions.forceFloat32,\r\n            messagePackOptions.ignoreUndefined,\r\n            messagePackOptions.forceIntegerToFloat,\r\n        );\r\n\r\n        this._decoder = new Decoder(\r\n            messagePackOptions.extensionCodec,\r\n            messagePackOptions.context,\r\n            messagePackOptions.maxStrLength,\r\n            messagePackOptions.maxBinLength,\r\n            messagePackOptions.maxArrayLength,\r\n            messagePackOptions.maxMapLength,\r\n            messagePackOptions.maxExtLength,\r\n        );\r\n    }\r\n\r\n    /** Creates an array of HubMessage objects from the specified serialized representation.\r\n     *\r\n     * @param {ArrayBuffer} input An ArrayBuffer containing the serialized representation.\r\n     * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.\r\n     */\r\n    public parseMessages(input: ArrayBuffer, logger: ILogger): HubMessage[] {\r\n        // The interface does allow \"string\" to be passed in, but this implementation does not. So let's throw a useful error.\r\n        if (!(isArrayBuffer(input))) {\r\n            throw new Error(\"Invalid input for MessagePack hub protocol. Expected an ArrayBuffer.\");\r\n        }\r\n\r\n        if (logger === null) {\r\n            logger = NullLogger.instance;\r\n        }\r\n\r\n        const messages = BinaryMessageFormat.parse(input);\r\n\r\n        const hubMessages = [];\r\n        for (const message of messages) {\r\n            const parsedMessage = this._parseMessage(message, logger);\r\n            // Can be null for an unknown message. Unknown message is logged in parseMessage\r\n            if (parsedMessage) {\r\n                hubMessages.push(parsedMessage);\r\n            }\r\n        }\r\n\r\n        return hubMessages;\r\n    }\r\n\r\n    /** Writes the specified HubMessage to an ArrayBuffer and returns it.\r\n     *\r\n     * @param {HubMessage} message The message to write.\r\n     * @returns {ArrayBuffer} An ArrayBuffer containing the serialized representation of the message.\r\n     */\r\n    public writeMessage(message: HubMessage): ArrayBuffer {\r\n        switch (message.type) {\r\n            case MessageType.Invocation:\r\n                return this._writeInvocation(message as InvocationMessage);\r\n            case MessageType.StreamInvocation:\r\n                return this._writeStreamInvocation(message as StreamInvocationMessage);\r\n            case MessageType.StreamItem:\r\n                return this._writeStreamItem(message as StreamItemMessage);\r\n            case MessageType.Completion:\r\n                return this._writeCompletion(message as CompletionMessage);\r\n            case MessageType.Ping:\r\n                return BinaryMessageFormat.write(SERIALIZED_PING_MESSAGE);\r\n            case MessageType.CancelInvocation:\r\n                return this._writeCancelInvocation(message as CancelInvocationMessage);\r\n            default:\r\n                throw new Error(\"Invalid message type.\");\r\n        }\r\n    }\r\n\r\n    private _parseMessage(input: Uint8Array, logger: ILogger): HubMessage | null {\r\n        if (input.length === 0) {\r\n            throw new Error(\"Invalid payload.\");\r\n        }\r\n\r\n        const properties = this._decoder.decode(input) as any;\r\n        if (properties.length === 0 || !(properties instanceof Array)) {\r\n            throw new Error(\"Invalid payload.\");\r\n        }\r\n\r\n        const messageType = properties[0] as MessageType;\r\n\r\n        switch (messageType) {\r\n            case MessageType.Invocation:\r\n                return this._createInvocationMessage(this._readHeaders(properties), properties);\r\n            case MessageType.StreamItem:\r\n                return this._createStreamItemMessage(this._readHeaders(properties), properties);\r\n            case MessageType.Completion:\r\n                return this._createCompletionMessage(this._readHeaders(properties), properties);\r\n            case MessageType.Ping:\r\n                return this._createPingMessage(properties);\r\n            case MessageType.Close:\r\n                return this._createCloseMessage(properties);\r\n            default:\r\n                // Future protocol changes can add message types, old clients can ignore them\r\n                logger.log(LogLevel.Information, \"Unknown message type '\" + messageType + \"' ignored.\");\r\n                return null;\r\n        }\r\n    }\r\n\r\n    private _createCloseMessage(properties: any[]): HubMessage {\r\n        // check minimum length to allow protocol to add items to the end of objects in future releases\r\n        if (properties.length < 2) {\r\n            throw new Error(\"Invalid payload for Close message.\");\r\n        }\r\n\r\n        return {\r\n            // Close messages have no headers.\r\n            allowReconnect: properties.length >= 3 ? properties[2] : undefined,\r\n            error: properties[1],\r\n            type: MessageType.Close,\r\n        } as HubMessage;\r\n    }\r\n\r\n    private _createPingMessage(properties: any[]): HubMessage {\r\n        // check minimum length to allow protocol to add items to the end of objects in future releases\r\n        if (properties.length < 1) {\r\n            throw new Error(\"Invalid payload for Ping message.\");\r\n        }\r\n\r\n        return {\r\n            // Ping messages have no headers.\r\n            type: MessageType.Ping,\r\n        } as HubMessage;\r\n    }\r\n\r\n    private _createInvocationMessage(headers: MessageHeaders, properties: any[]): InvocationMessage {\r\n        // check minimum length to allow protocol to add items to the end of objects in future releases\r\n        if (properties.length < 5) {\r\n            throw new Error(\"Invalid payload for Invocation message.\");\r\n        }\r\n\r\n        const invocationId = properties[2] as string;\r\n        if (invocationId) {\r\n            return {\r\n                arguments: properties[4],\r\n                headers,\r\n                invocationId,\r\n                streamIds: [],\r\n                target: properties[3] as string,\r\n                type: MessageType.Invocation,\r\n            };\r\n        } else {\r\n            return {\r\n                arguments: properties[4],\r\n                headers,\r\n                streamIds: [],\r\n                target: properties[3],\r\n                type: MessageType.Invocation,\r\n            };\r\n        }\r\n\r\n    }\r\n\r\n    private _createStreamItemMessage(headers: MessageHeaders, properties: any[]): StreamItemMessage {\r\n        // check minimum length to allow protocol to add items to the end of objects in future releases\r\n        if (properties.length < 4) {\r\n            throw new Error(\"Invalid payload for StreamItem message.\");\r\n        }\r\n\r\n        return {\r\n            headers,\r\n            invocationId: properties[2],\r\n            item: properties[3],\r\n            type: MessageType.StreamItem,\r\n        } as StreamItemMessage;\r\n    }\r\n\r\n    private _createCompletionMessage(headers: MessageHeaders, properties: any[]): CompletionMessage {\r\n        // check minimum length to allow protocol to add items to the end of objects in future releases\r\n        if (properties.length < 4) {\r\n            throw new Error(\"Invalid payload for Completion message.\");\r\n        }\r\n\r\n        const resultKind = properties[3];\r\n\r\n        if (resultKind !== this._voidResult && properties.length < 5) {\r\n            throw new Error(\"Invalid payload for Completion message.\");\r\n        }\r\n\r\n        let error: string | undefined;\r\n        let result: any;\r\n\r\n        switch (resultKind) {\r\n            case this._errorResult:\r\n                error = properties[4];\r\n                break;\r\n            case this._nonVoidResult:\r\n                result = properties[4];\r\n                break;\r\n        }\r\n\r\n        const completionMessage: CompletionMessage = {\r\n            error,\r\n            headers,\r\n            invocationId: properties[2],\r\n            result,\r\n            type: MessageType.Completion,\r\n        };\r\n\r\n        return completionMessage;\r\n    }\r\n\r\n    private _writeInvocation(invocationMessage: InvocationMessage): ArrayBuffer {\r\n        let payload: any;\r\n        if (invocationMessage.streamIds) {\r\n            payload = this._encoder.encode([MessageType.Invocation, invocationMessage.headers || {}, invocationMessage.invocationId || null,\r\n            invocationMessage.target, invocationMessage.arguments, invocationMessage.streamIds]);\r\n        } else {\r\n            payload = this._encoder.encode([MessageType.Invocation, invocationMessage.headers || {}, invocationMessage.invocationId || null,\r\n            invocationMessage.target, invocationMessage.arguments]);\r\n        }\r\n\r\n        return BinaryMessageFormat.write(payload.slice());\r\n    }\r\n\r\n    private _writeStreamInvocation(streamInvocationMessage: StreamInvocationMessage): ArrayBuffer {\r\n        let payload: any;\r\n        if (streamInvocationMessage.streamIds) {\r\n            payload = this._encoder.encode([MessageType.StreamInvocation, streamInvocationMessage.headers || {}, streamInvocationMessage.invocationId,\r\n            streamInvocationMessage.target, streamInvocationMessage.arguments, streamInvocationMessage.streamIds]);\r\n        } else {\r\n            payload = this._encoder.encode([MessageType.StreamInvocation, streamInvocationMessage.headers || {}, streamInvocationMessage.invocationId,\r\n            streamInvocationMessage.target, streamInvocationMessage.arguments]);\r\n        }\r\n\r\n        return BinaryMessageFormat.write(payload.slice());\r\n    }\r\n\r\n    private _writeStreamItem(streamItemMessage: StreamItemMessage): ArrayBuffer {\r\n        const payload = this._encoder.encode([MessageType.StreamItem, streamItemMessage.headers || {}, streamItemMessage.invocationId,\r\n        streamItemMessage.item]);\r\n\r\n        return BinaryMessageFormat.write(payload.slice());\r\n    }\r\n\r\n    private _writeCompletion(completionMessage: CompletionMessage): ArrayBuffer {\r\n        const resultKind = completionMessage.error ? this._errorResult : completionMessage.result ? this._nonVoidResult : this._voidResult;\r\n\r\n        let payload: any;\r\n        switch (resultKind) {\r\n            case this._errorResult:\r\n                payload = this._encoder.encode([MessageType.Completion, completionMessage.headers || {}, completionMessage.invocationId, resultKind, completionMessage.error]);\r\n                break;\r\n            case this._voidResult:\r\n                payload = this._encoder.encode([MessageType.Completion, completionMessage.headers || {}, completionMessage.invocationId, resultKind]);\r\n                break;\r\n            case this._nonVoidResult:\r\n                payload = this._encoder.encode([MessageType.Completion, completionMessage.headers || {}, completionMessage.invocationId, resultKind, completionMessage.result]);\r\n                break;\r\n        }\r\n\r\n        return BinaryMessageFormat.write(payload.slice());\r\n    }\r\n\r\n    private _writeCancelInvocation(cancelInvocationMessage: CancelInvocationMessage): ArrayBuffer {\r\n        const payload = this._encoder.encode([MessageType.CancelInvocation, cancelInvocationMessage.headers || {}, cancelInvocationMessage.invocationId]);\r\n\r\n        return BinaryMessageFormat.write(payload.slice());\r\n    }\r\n\r\n    private _readHeaders(properties: any): MessageHeaders {\r\n        const headers: MessageHeaders = properties[1] as MessageHeaders;\r\n        if (typeof headers !== \"object\") {\r\n            throw new Error(\"Invalid headers.\");\r\n        }\r\n        return headers;\r\n    }\r\n}\r\n","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n\r\n// Copied from signalr/Utils.ts\r\n/** @private */\r\nexport function isArrayBuffer(val: any): val is ArrayBuffer {\r\n    return val && typeof ArrayBuffer !== \"undefined\" &&\r\n        (val instanceof ArrayBuffer ||\r\n        // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof\r\n        (val.constructor && val.constructor.name === \"ArrayBuffer\"));\r\n}\r\n","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n\r\n// Version token that will be replaced by the prepack command\r\n/** The version of the SignalR Message Pack protocol library. */\r\nexport const VERSION = \"0.0.0-DEV_BUILD\";\r\n\r\nexport { MessagePackHubProtocol } from \"./MessagePackHubProtocol\";\r\n\r\nexport { MessagePackOptions } from \"./MessagePackOptions\";\r\n"]}