{"version":3,"file":"msgpack.min.js","mappings":"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","sources":["webpack://MessagePack/webpack/universalModuleDefinition","webpack://MessagePack/webpack/bootstrap","webpack://MessagePack/webpack/runtime/define property getters","webpack://MessagePack/webpack/runtime/hasOwnProperty shorthand","webpack://MessagePack/webpack/runtime/make namespace object","webpack://MessagePack/./src/utils/utf8.ts","webpack://MessagePack/./src/ExtData.ts","webpack://MessagePack/./src/DecodeError.ts","webpack://MessagePack/./src/utils/int.ts","webpack://MessagePack/./src/timestamp.ts","webpack://MessagePack/./src/ExtensionCodec.ts","webpack://MessagePack/./src/utils/typedArrays.ts","webpack://MessagePack/./src/Encoder.ts","webpack://MessagePack/./src/encode.ts","webpack://MessagePack/./src/utils/prettyByte.ts","webpack://MessagePack/./src/CachedKeyDecoder.ts","webpack://MessagePack/./src/Decoder.ts","webpack://MessagePack/./src/decode.ts","webpack://MessagePack/./src/utils/stream.ts","webpack://MessagePack/./src/decodeAsync.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"MessagePack\"] = factory();\n\telse\n\t\troot[\"MessagePack\"] = factory();\n})(this, function() {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = function(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 = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(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};","\nexport function utf8Count(str: string): number {\n  const strLength = str.length;\n\n  let byteLength = 0;\n  let pos = 0;\n  while (pos < strLength) {\n    let value = str.charCodeAt(pos++);\n\n    if ((value & 0xffffff80) === 0) {\n      // 1-byte\n      byteLength++;\n      continue;\n    } else if ((value & 0xfffff800) === 0) {\n      // 2-bytes\n      byteLength += 2;\n    } else {\n      // handle surrogate pair\n      if (value >= 0xd800 && value <= 0xdbff) {\n        // high surrogate\n        if (pos < strLength) {\n          const extra = str.charCodeAt(pos);\n          if ((extra & 0xfc00) === 0xdc00) {\n            ++pos;\n            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;\n          }\n        }\n      }\n\n      if ((value & 0xffff0000) === 0) {\n        // 3-byte\n        byteLength += 3;\n      } else {\n        // 4-byte\n        byteLength += 4;\n      }\n    }\n  }\n  return byteLength;\n}\n\nexport function utf8EncodeJs(str: string, output: Uint8Array, outputOffset: number): void {\n  const strLength = str.length;\n  let offset = outputOffset;\n  let pos = 0;\n  while (pos < strLength) {\n    let value = str.charCodeAt(pos++);\n\n    if ((value & 0xffffff80) === 0) {\n      // 1-byte\n      output[offset++] = value;\n      continue;\n    } else if ((value & 0xfffff800) === 0) {\n      // 2-bytes\n      output[offset++] = ((value >> 6) & 0x1f) | 0xc0;\n    } else {\n      // handle surrogate pair\n      if (value >= 0xd800 && value <= 0xdbff) {\n        // high surrogate\n        if (pos < strLength) {\n          const extra = str.charCodeAt(pos);\n          if ((extra & 0xfc00) === 0xdc00) {\n            ++pos;\n            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;\n          }\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      } 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\n    output[offset++] = (value & 0x3f) | 0x80;\n  }\n}\n\n// TextEncoder and TextDecoder are standardized in whatwg encoding:\n// https://encoding.spec.whatwg.org/\n// and available in all the modern browsers:\n// https://caniuse.com/textencoder\n// They are available in Node.js since v12 LTS as well:\n// https://nodejs.org/api/globals.html#textencoder\n\nconst sharedTextEncoder = new TextEncoder();\n\n// This threshold should be determined by benchmarking, which might vary in engines and input data.\n// Run `npx ts-node benchmark/encode-string.ts` for details.\nconst TEXT_ENCODER_THRESHOLD = 50;\n\nexport function utf8EncodeTE(str: string, output: Uint8Array, outputOffset: number): void {\n  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));\n}\n\nexport function utf8Encode(str: string, output: Uint8Array, outputOffset: number): void {\n  if (str.length > TEXT_ENCODER_THRESHOLD) {\n    utf8EncodeTE(str, output, outputOffset);\n  } else {\n    utf8EncodeJs(str, output, outputOffset);\n  }\n}\n\nconst CHUNK_SIZE = 0x1_000;\n\nexport function utf8DecodeJs(bytes: Uint8Array, inputOffset: number, byteLength: number): string {\n  let offset = inputOffset;\n  const end = offset + byteLength;\n\n  const units: Array<number> = [];\n  let result = \"\";\n  while (offset < end) {\n    const byte1 = bytes[offset++]!;\n    if ((byte1 & 0x80) === 0) {\n      // 1 byte\n      units.push(byte1);\n    } else if ((byte1 & 0xe0) === 0xc0) {\n      // 2 bytes\n      const byte2 = bytes[offset++]! & 0x3f;\n      units.push(((byte1 & 0x1f) << 6) | byte2);\n    } else if ((byte1 & 0xf0) === 0xe0) {\n      // 3 bytes\n      const byte2 = bytes[offset++]! & 0x3f;\n      const byte3 = bytes[offset++]! & 0x3f;\n      units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);\n    } else if ((byte1 & 0xf8) === 0xf0) {\n      // 4 bytes\n      const byte2 = bytes[offset++]! & 0x3f;\n      const byte3 = bytes[offset++]! & 0x3f;\n      const byte4 = bytes[offset++]! & 0x3f;\n      let 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    } else {\n      units.push(byte1);\n    }\n\n    if (units.length >= CHUNK_SIZE) {\n      result += String.fromCharCode(...units);\n      units.length = 0;\n    }\n  }\n\n  if (units.length > 0) {\n    result += String.fromCharCode(...units);\n  }\n\n  return result;\n}\n\nconst sharedTextDecoder = new TextDecoder();\n\n// This threshold should be determined by benchmarking, which might vary in engines and input data.\n// Run `npx ts-node benchmark/decode-string.ts` for details.\nconst TEXT_DECODER_THRESHOLD = 200;\n\nexport function utf8DecodeTD(bytes: Uint8Array, inputOffset: number, byteLength: number): string {\n  const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);\n  return sharedTextDecoder.decode(stringBytes);\n}\n\nexport function utf8Decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string {\n  if (byteLength > TEXT_DECODER_THRESHOLD) {\n    return utf8DecodeTD(bytes, inputOffset, byteLength);\n  } else {\n    return utf8DecodeJs(bytes, inputOffset, byteLength);\n  }\n}\n","/**\n * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.\n */\nexport class ExtData {\n  constructor(readonly type: number, readonly data: Uint8Array) {}\n}\n","export class DecodeError extends Error {\n  constructor(message: string) {\n    super(message);\n\n    // fix the prototype chain in a cross-platform way\n    const proto: typeof DecodeError.prototype = Object.create(DecodeError.prototype);\n    Object.setPrototypeOf(this, proto);\n\n    Object.defineProperty(this, \"name\", {\n      configurable: true,\n      enumerable: false,\n      value: DecodeError.name,\n    });\n  }\n}\n","// Integer Utility\n\nexport const UINT32_MAX = 0xffff_ffff;\n\n// DataView extension to handle int64 / uint64,\n// where the actual range is 53-bits integer (a.k.a. safe integer)\n\nexport function setUint64(view: DataView, offset: number, value: number): void {\n  const high = value / 0x1_0000_0000;\n  const low = value; // high bits are truncated by DataView\n  view.setUint32(offset, high);\n  view.setUint32(offset + 4, low);\n}\n\nexport function setInt64(view: DataView, offset: number, value: number): void {\n  const high = Math.floor(value / 0x1_0000_0000);\n  const low = value; // high bits are truncated by DataView\n  view.setUint32(offset, high);\n  view.setUint32(offset + 4, low);\n}\n\nexport function getInt64(view: DataView, offset: number): number {\n  const high = view.getInt32(offset);\n  const low = view.getUint32(offset + 4);\n  return high * 0x1_0000_0000 + low;\n}\n\nexport function getUint64(view: DataView, offset: number): number {\n  const high = view.getUint32(offset);\n  const low = view.getUint32(offset + 4);\n  return high * 0x1_0000_0000 + low;\n}\n","// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type\nimport { DecodeError } from \"./DecodeError\";\nimport { getInt64, setInt64 } from \"./utils/int\";\n\nexport const EXT_TIMESTAMP = -1;\n\nexport type TimeSpec = {\n  sec: number;\n  nsec: number;\n};\n\nconst TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int\nconst TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int\n\nexport function encodeTimeSpecToTimestamp({ sec, nsec }: TimeSpec): Uint8Array {\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      const rv = new Uint8Array(4);\n      const view = new DataView(rv.buffer);\n      view.setUint32(0, sec);\n      return rv;\n    } else {\n      // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }\n      const secHigh = sec / 0x100000000;\n      const secLow = sec & 0xffffffff;\n      const rv = new Uint8Array(8);\n      const 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  } else {\n    // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }\n    const rv = new Uint8Array(12);\n    const view = new DataView(rv.buffer);\n    view.setUint32(0, nsec);\n    setInt64(view, 4, sec);\n    return rv;\n  }\n}\n\nexport function encodeDateToTimeSpec(date: Date): TimeSpec {\n  const msec = date.getTime();\n  const sec = Math.floor(msec / 1e3);\n  const nsec = (msec - sec * 1e3) * 1e6;\n\n  // Normalizes { sec, nsec } to ensure nsec is unsigned.\n  const nsecInSec = Math.floor(nsec / 1e9);\n  return {\n    sec: sec + nsecInSec,\n    nsec: nsec - nsecInSec * 1e9,\n  };\n}\n\nexport function encodeTimestampExtension(object: unknown): Uint8Array | null {\n  if (object instanceof Date) {\n    const timeSpec = encodeDateToTimeSpec(object);\n    return encodeTimeSpecToTimestamp(timeSpec);\n  } else {\n    return null;\n  }\n}\n\nexport function decodeTimestampToTimeSpec(data: Uint8Array): TimeSpec {\n  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n\n  // data may be 32, 64, or 96 bits\n  switch (data.byteLength) {\n    case 4: {\n      // timestamp 32 = { sec32 }\n      const sec = view.getUint32(0);\n      const nsec = 0;\n      return { sec, nsec };\n    }\n    case 8: {\n      // timestamp 64 = { nsec30, sec34 }\n      const nsec30AndSecHigh2 = view.getUint32(0);\n      const secLow32 = view.getUint32(4);\n      const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;\n      const nsec = nsec30AndSecHigh2 >>> 2;\n      return { sec, nsec };\n    }\n    case 12: {\n      // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }\n\n      const sec = getInt64(view, 4);\n      const nsec = view.getUint32(0);\n      return { sec, nsec };\n    }\n    default:\n      throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);\n  }\n}\n\nexport function decodeTimestampExtension(data: Uint8Array): Date {\n  const timeSpec = decodeTimestampToTimeSpec(data);\n  return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);\n}\n\nexport const timestampExtension = {\n  type: EXT_TIMESTAMP,\n  encode: encodeTimestampExtension,\n  decode: decodeTimestampExtension,\n};\n","// ExtensionCodec to handle MessagePack extensions\n\nimport { ExtData } from \"./ExtData\";\nimport { timestampExtension } from \"./timestamp\";\n\nexport type ExtensionDecoderType<ContextType> = (\n  data: Uint8Array,\n  extensionType: number,\n  context: ContextType,\n) => unknown;\n\nexport type ExtensionEncoderType<ContextType> = (input: unknown, context: ContextType) => Uint8Array | null;\n\n// immutable interface to ExtensionCodec\nexport type ExtensionCodecType<ContextType> = {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  __brand?: ContextType;\n  tryToEncode(object: unknown, context: ContextType): ExtData | null;\n  decode(data: Uint8Array, extType: number, context: ContextType): unknown;\n};\n\nexport class ExtensionCodec<ContextType = undefined> implements ExtensionCodecType<ContextType> {\n  public static readonly defaultCodec: ExtensionCodecType<undefined> = new ExtensionCodec();\n\n  // ensures ExtensionCodecType<X> matches ExtensionCodec<X>\n  // this will make type errors a lot more clear\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  __brand?: ContextType;\n\n  // built-in extensions\n  private readonly builtInEncoders: Array<ExtensionEncoderType<ContextType> | undefined | null> = [];\n  private readonly builtInDecoders: Array<ExtensionDecoderType<ContextType> | undefined | null> = [];\n\n  // custom extensions\n  private readonly encoders: Array<ExtensionEncoderType<ContextType> | undefined | null> = [];\n  private readonly decoders: Array<ExtensionDecoderType<ContextType> | undefined | null> = [];\n\n  public constructor() {\n    this.register(timestampExtension);\n  }\n\n  public register({\n    type,\n    encode,\n    decode,\n  }: {\n    type: number;\n    encode: ExtensionEncoderType<ContextType>;\n    decode: ExtensionDecoderType<ContextType>;\n  }): void {\n    if (type >= 0) {\n      // custom extensions\n      this.encoders[type] = encode;\n      this.decoders[type] = decode;\n    } else {\n      // built-in extensions\n      const index = 1 + type;\n      this.builtInEncoders[index] = encode;\n      this.builtInDecoders[index] = decode;\n    }\n  }\n\n  public tryToEncode(object: unknown, context: ContextType): ExtData | null {\n    // built-in extensions\n    for (let i = 0; i < this.builtInEncoders.length; i++) {\n      const encodeExt = this.builtInEncoders[i];\n      if (encodeExt != null) {\n        const data = encodeExt(object, context);\n        if (data != null) {\n          const type = -1 - i;\n          return new ExtData(type, data);\n        }\n      }\n    }\n\n    // custom extensions\n    for (let i = 0; i < this.encoders.length; i++) {\n      const encodeExt = this.encoders[i];\n      if (encodeExt != null) {\n        const data = encodeExt(object, context);\n        if (data != null) {\n          const type = i;\n          return new ExtData(type, data);\n        }\n      }\n    }\n\n    if (object instanceof ExtData) {\n      // to keep ExtData as is\n      return object;\n    }\n    return null;\n  }\n\n  public decode(data: Uint8Array, type: number, context: ContextType): unknown {\n    const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];\n    if (decodeExt) {\n      return decodeExt(data, type, context);\n    } else {\n      // decode() does not fail, returns ExtData instead.\n      return new ExtData(type, data);\n    }\n  }\n}\n","export function ensureUint8Array(buffer: ArrayLike<number> | Uint8Array | ArrayBufferView | ArrayBuffer): Uint8Array {\n  if (buffer instanceof Uint8Array) {\n    return buffer;\n  } else if (ArrayBuffer.isView(buffer)) {\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  } else if (buffer instanceof ArrayBuffer) {\n    return new Uint8Array(buffer);\n  } else {\n    // ArrayLike<number>\n    return Uint8Array.from(buffer);\n  }\n}\n\nexport function createDataView(buffer: ArrayLike<number> | ArrayBufferView | ArrayBuffer): DataView {\n  if (buffer instanceof ArrayBuffer) {\n    return new DataView(buffer);\n  }\n\n  const bufferView = ensureUint8Array(buffer);\n  return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);\n}\n","import { utf8Count, utf8Encode } from \"./utils/utf8\";\nimport { ExtensionCodec, ExtensionCodecType } from \"./ExtensionCodec\";\nimport { setInt64, setUint64 } from \"./utils/int\";\nimport { ensureUint8Array } from \"./utils/typedArrays\";\nimport type { ExtData } from \"./ExtData\";\nimport type { ContextOf } from \"./context\";\n\n\nexport const DEFAULT_MAX_DEPTH = 100;\nexport const DEFAULT_INITIAL_BUFFER_SIZE = 2048;\n\nexport type EncoderOptions<ContextType = undefined> = Partial<\n  Readonly<{\n    extensionCodec: ExtensionCodecType<ContextType>;\n\n    /**\n     * Encodes bigint as Int64 or Uint64 if it's set to true.\n     * {@link forceIntegerToFloat} does not affect bigint.\n     * Depends on ES2020's {@link DataView#setBigInt64} and\n     * {@link DataView#setBigUint64}.\n     *\n     * Defaults to false.\n     */\n    useBigInt64: boolean;\n\n    /**\n     * The maximum depth in nested objects and arrays.\n     *\n     * Defaults to 100.\n     */\n    maxDepth: number;\n\n    /**\n     * The initial size of the internal buffer.\n     *\n     * Defaults to 2048.\n     */\n    initialBufferSize: number;\n\n    /**\n     * If `true`, the keys of an object is sorted. In other words, the encoded\n     * binary is canonical and thus comparable to another encoded binary.\n     *\n     * Defaults to `false`. If enabled, it spends more time in encoding objects.\n     */\n    sortKeys: boolean;\n    /**\n     * If `true`, non-integer numbers are encoded in float32, not in float64 (the default).\n     *\n     * Only use it if precisions don't matter.\n     *\n     * Defaults to `false`.\n     */\n    forceFloat32: boolean;\n\n    /**\n     * If `true`, an object property with `undefined` value are ignored.\n     * e.g. `{ foo: undefined }` will be encoded as `{}`, as `JSON.stringify()` does.\n     *\n     * Defaults to `false`. If enabled, it spends more time in encoding objects.\n     */\n    ignoreUndefined: boolean;\n\n    /**\n     * If `true`, integer numbers are encoded as floating point numbers,\n     * with the `forceFloat32` option taken into account.\n     *\n     * Defaults to `false`.\n     */\n    forceIntegerToFloat: boolean;\n  }>\n> & ContextOf<ContextType>;\n\nexport class Encoder<ContextType = undefined> {\n  private readonly extensionCodec: ExtensionCodecType<ContextType>;\n  private readonly context: ContextType;\n  private readonly useBigInt64: boolean;\n  private readonly maxDepth: number;\n  private readonly initialBufferSize: number;\n  private readonly sortKeys: boolean;\n  private readonly forceFloat32: boolean;\n  private readonly ignoreUndefined: boolean;\n  private readonly forceIntegerToFloat: boolean;\n\n  private pos: number;\n  private view: DataView;\n  private bytes: Uint8Array;\n\n  public constructor(options?: EncoderOptions<ContextType>) {\n    this.extensionCodec = options?.extensionCodec ?? (ExtensionCodec.defaultCodec as ExtensionCodecType<ContextType>);\n    this.context = (options as { context: ContextType } | undefined)?.context as ContextType; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined\n\n    this.useBigInt64 = options?.useBigInt64 ?? false;\n    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;\n    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;\n    this.sortKeys = options?.sortKeys ?? false;\n    this.forceFloat32 = options?.forceFloat32 ?? false;\n    this.ignoreUndefined = options?.ignoreUndefined ?? false;\n    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;\n\n    this.pos = 0;\n    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));\n    this.bytes = new Uint8Array(this.view.buffer);\n  }\n\n  private reinitializeState() {\n    this.pos = 0;\n  }\n\n  /**\n   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.\n   *\n   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.\n   */\n  public encodeSharedRef(object: unknown): Uint8Array {\n    this.reinitializeState();\n    this.doEncode(object, 1);\n    return this.bytes.subarray(0, this.pos);\n  }\n\n  /**\n   * @returns Encodes the object and returns a copy of the encoder's internal buffer.\n   */\n  public encode(object: unknown): Uint8Array {\n    this.reinitializeState();\n    this.doEncode(object, 1);\n    return this.bytes.slice(0, this.pos);\n  }\n\n  private doEncode(object: unknown, depth: number): void {\n    if (depth > this.maxDepth) {\n      throw new Error(`Too deep objects in depth ${depth}`);\n    }\n\n    if (object == null) {\n      this.encodeNil();\n    } else if (typeof object === \"boolean\") {\n      this.encodeBoolean(object);\n    } else if (typeof object === \"number\") {\n      if (!this.forceIntegerToFloat) {\n        this.encodeNumber(object);\n      } else {\n        this.encodeNumberAsFloat(object);\n      }\n    } else if (typeof object === \"string\") {\n      this.encodeString(object);\n    } else if (this.useBigInt64 && typeof object === \"bigint\") {\n      this.encodeBigInt64(object);\n    } else {\n      this.encodeObject(object, depth);\n    }\n  }\n\n  private ensureBufferSizeToWrite(sizeToWrite: number) {\n    const requiredSize = this.pos + sizeToWrite;\n\n    if (this.view.byteLength < requiredSize) {\n      this.resizeBuffer(requiredSize * 2);\n    }\n  }\n\n  private resizeBuffer(newSize: number) {\n    const newBuffer = new ArrayBuffer(newSize);\n    const newBytes = new Uint8Array(newBuffer);\n    const newView = new DataView(newBuffer);\n\n    newBytes.set(this.bytes);\n\n    this.view = newView;\n    this.bytes = newBytes;\n  }\n\n  private encodeNil() {\n    this.writeU8(0xc0);\n  }\n\n  private encodeBoolean(object: boolean) {\n    if (object === false) {\n      this.writeU8(0xc2);\n    } else {\n      this.writeU8(0xc3);\n    }\n  }\n\n  private encodeNumber(object: number): void {\n    if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {\n      if (object >= 0) {\n        if (object < 0x80) {\n          // positive fixint\n          this.writeU8(object);\n        } else if (object < 0x100) {\n          // uint 8\n          this.writeU8(0xcc);\n          this.writeU8(object);\n        } else if (object < 0x10000) {\n          // uint 16\n          this.writeU8(0xcd);\n          this.writeU16(object);\n        } else if (object < 0x100000000) {\n          // uint 32\n          this.writeU8(0xce);\n          this.writeU32(object);\n        } else if (!this.useBigInt64) {\n          // uint 64\n          this.writeU8(0xcf);\n          this.writeU64(object);\n        } else {\n          this.encodeNumberAsFloat(object);\n        }\n      } else {\n        if (object >= -0x20) {\n          // negative fixint\n          this.writeU8(0xe0 | (object + 0x20));\n        } else if (object >= -0x80) {\n          // int 8\n          this.writeU8(0xd0);\n          this.writeI8(object);\n        } else if (object >= -0x8000) {\n          // int 16\n          this.writeU8(0xd1);\n          this.writeI16(object);\n        } else if (object >= -0x80000000) {\n          // int 32\n          this.writeU8(0xd2);\n          this.writeI32(object);\n        } else if (!this.useBigInt64) {\n          // int 64\n          this.writeU8(0xd3);\n          this.writeI64(object);\n        } else {\n          this.encodeNumberAsFloat(object);\n        }\n      }\n    } else {\n      this.encodeNumberAsFloat(object);\n    }\n  }\n\n  private encodeNumberAsFloat(object: number): void {\n    if (this.forceFloat32) {\n      // float 32\n      this.writeU8(0xca);\n      this.writeF32(object);\n    } else {\n      // float 64\n      this.writeU8(0xcb);\n      this.writeF64(object);\n    }\n  }\n\n  private encodeBigInt64(object: bigint): void {\n    if (object >= BigInt(0)) {\n      // uint 64\n      this.writeU8(0xcf);\n      this.writeBigUint64(object);\n    } else {\n      // int 64\n      this.writeU8(0xd3);\n      this.writeBigInt64(object);\n    }\n  }\n\n  private writeStringHeader(byteLength: number) {\n    if (byteLength < 32) {\n      // fixstr\n      this.writeU8(0xa0 + byteLength);\n    } else if (byteLength < 0x100) {\n      // str 8\n      this.writeU8(0xd9);\n      this.writeU8(byteLength);\n    } else if (byteLength < 0x10000) {\n      // str 16\n      this.writeU8(0xda);\n      this.writeU16(byteLength);\n    } else if (byteLength < 0x100000000) {\n      // str 32\n      this.writeU8(0xdb);\n      this.writeU32(byteLength);\n    } else {\n      throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);\n    }\n  }\n\n  private encodeString(object: string) {\n    const maxHeaderSize = 1 + 4;\n\n    const byteLength = utf8Count(object);\n    this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);\n    this.writeStringHeader(byteLength);\n    utf8Encode(object, this.bytes, this.pos);\n    this.pos += byteLength;\n  }\n\n  private encodeObject(object: unknown, depth: number) {\n    // try to encode objects with custom codec first of non-primitives\n    const ext = this.extensionCodec.tryToEncode(object, this.context);\n    if (ext != null) {\n      this.encodeExtension(ext);\n    } else if (Array.isArray(object)) {\n      this.encodeArray(object, depth);\n    } else if (ArrayBuffer.isView(object)) {\n      this.encodeBinary(object);\n    } else if (typeof object === \"object\") {\n      this.encodeMap(object as Record<string, unknown>, depth);\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\n  private encodeBinary(object: ArrayBufferView) {\n    const size = object.byteLength;\n    if (size < 0x100) {\n      // bin 8\n      this.writeU8(0xc4);\n      this.writeU8(size);\n    } else if (size < 0x10000) {\n      // bin 16\n      this.writeU8(0xc5);\n      this.writeU16(size);\n    } else if (size < 0x100000000) {\n      // bin 32\n      this.writeU8(0xc6);\n      this.writeU32(size);\n    } else {\n      throw new Error(`Too large binary: ${size}`);\n    }\n    const bytes = ensureUint8Array(object);\n    this.writeU8a(bytes);\n  }\n\n  private encodeArray(object: Array<unknown>, depth: number) {\n    const size = object.length;\n    if (size < 16) {\n      // fixarray\n      this.writeU8(0x90 + size);\n    } else if (size < 0x10000) {\n      // array 16\n      this.writeU8(0xdc);\n      this.writeU16(size);\n    } else if (size < 0x100000000) {\n      // array 32\n      this.writeU8(0xdd);\n      this.writeU32(size);\n    } else {\n      throw new Error(`Too large array: ${size}`);\n    }\n    for (const item of object) {\n      this.doEncode(item, depth + 1);\n    }\n  }\n\n  private countWithoutUndefined(object: Record<string, unknown>, keys: ReadonlyArray<string>): number {\n    let count = 0;\n\n    for (const key of keys) {\n      if (object[key] !== undefined) {\n        count++;\n      }\n    }\n\n    return count;\n  }\n\n  private encodeMap(object: Record<string, unknown>, depth: number) {\n    const keys = Object.keys(object);\n    if (this.sortKeys) {\n      keys.sort();\n    }\n\n    const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;\n\n    if (size < 16) {\n      // fixmap\n      this.writeU8(0x80 + size);\n    } else if (size < 0x10000) {\n      // map 16\n      this.writeU8(0xde);\n      this.writeU16(size);\n    } else if (size < 0x100000000) {\n      // map 32\n      this.writeU8(0xdf);\n      this.writeU32(size);\n    } else {\n      throw new Error(`Too large map object: ${size}`);\n    }\n\n    for (const key of keys) {\n      const value = object[key];\n\n      if (!(this.ignoreUndefined && value === undefined)) {\n        this.encodeString(key);\n        this.doEncode(value, depth + 1);\n      }\n    }\n  }\n\n  private encodeExtension(ext: ExtData) {\n    const size = ext.data.length;\n    if (size === 1) {\n      // fixext 1\n      this.writeU8(0xd4);\n    } else if (size === 2) {\n      // fixext 2\n      this.writeU8(0xd5);\n    } else if (size === 4) {\n      // fixext 4\n      this.writeU8(0xd6);\n    } else if (size === 8) {\n      // fixext 8\n      this.writeU8(0xd7);\n    } else if (size === 16) {\n      // fixext 16\n      this.writeU8(0xd8);\n    } else if (size < 0x100) {\n      // ext 8\n      this.writeU8(0xc7);\n      this.writeU8(size);\n    } else if (size < 0x10000) {\n      // ext 16\n      this.writeU8(0xc8);\n      this.writeU16(size);\n    } else if (size < 0x100000000) {\n      // ext 32\n      this.writeU8(0xc9);\n      this.writeU32(size);\n    } else {\n      throw new Error(`Too large extension object: ${size}`);\n    }\n    this.writeI8(ext.type);\n    this.writeU8a(ext.data);\n  }\n\n  private writeU8(value: number) {\n    this.ensureBufferSizeToWrite(1);\n\n    this.view.setUint8(this.pos, value);\n    this.pos++;\n  }\n\n  private writeU8a(values: ArrayLike<number>) {\n    const size = values.length;\n    this.ensureBufferSizeToWrite(size);\n\n    this.bytes.set(values, this.pos);\n    this.pos += size;\n  }\n\n  private writeI8(value: number) {\n    this.ensureBufferSizeToWrite(1);\n\n    this.view.setInt8(this.pos, value);\n    this.pos++;\n  }\n\n  private writeU16(value: number) {\n    this.ensureBufferSizeToWrite(2);\n\n    this.view.setUint16(this.pos, value);\n    this.pos += 2;\n  }\n\n  private writeI16(value: number) {\n    this.ensureBufferSizeToWrite(2);\n\n    this.view.setInt16(this.pos, value);\n    this.pos += 2;\n  }\n\n  private writeU32(value: number) {\n    this.ensureBufferSizeToWrite(4);\n\n    this.view.setUint32(this.pos, value);\n    this.pos += 4;\n  }\n\n  private writeI32(value: number) {\n    this.ensureBufferSizeToWrite(4);\n\n    this.view.setInt32(this.pos, value);\n    this.pos += 4;\n  }\n\n  private writeF32(value: number) {\n    this.ensureBufferSizeToWrite(4);\n\n    this.view.setFloat32(this.pos, value);\n    this.pos += 4;\n  }\n\n  private writeF64(value: number) {\n    this.ensureBufferSizeToWrite(8);\n\n    this.view.setFloat64(this.pos, value);\n    this.pos += 8;\n  }\n\n  private writeU64(value: number) {\n    this.ensureBufferSizeToWrite(8);\n\n    setUint64(this.view, this.pos, value);\n    this.pos += 8;\n  }\n\n  private writeI64(value: number) {\n    this.ensureBufferSizeToWrite(8);\n\n    setInt64(this.view, this.pos, value);\n    this.pos += 8;\n  }\n\n  private writeBigUint64(value: bigint) {\n    this.ensureBufferSizeToWrite(8);\n\n    this.view.setBigUint64(this.pos, value);\n    this.pos += 8;\n  }\n\n  private writeBigInt64(value: bigint) {\n    this.ensureBufferSizeToWrite(8);\n\n    this.view.setBigInt64(this.pos, value);\n    this.pos += 8;\n  }\n}\n","import { Encoder } from \"./Encoder\";\nimport type { EncoderOptions } from \"./Encoder\";\nimport type { SplitUndefined } from \"./context\";\n\n/**\n * @deprecated Use {@link EncoderOptions} instead.\n */\nexport type EncodeOptions = never;\n\n/**\n * @deprecated No longer supported.\n */\nexport const defaultEncodeOptions: never = undefined as never;\n\n/**\n * It encodes `value` in the MessagePack format and\n * returns a byte buffer.\n *\n * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.\n */\nexport function encode<ContextType = undefined>(\n  value: unknown,\n  options?: EncoderOptions<SplitUndefined<ContextType>>,\n): Uint8Array {\n  const encoder = new Encoder(options);\n  return encoder.encodeSharedRef(value);\n}\n","export function prettyByte(byte: number): string {\n  return `${byte < 0 ? \"-\" : \"\"}0x${Math.abs(byte).toString(16).padStart(2, \"0\")}`;\n}\n","import { utf8DecodeJs } from \"./utils/utf8\";\n\nconst DEFAULT_MAX_KEY_LENGTH = 16;\nconst DEFAULT_MAX_LENGTH_PER_KEY = 16;\n\nexport interface KeyDecoder {\n  canBeCached(byteLength: number): boolean;\n  decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string;\n}\ninterface KeyCacheRecord {\n  readonly bytes: Uint8Array;\n  readonly str: string;\n}\n\nexport class CachedKeyDecoder implements KeyDecoder {\n  hit = 0;\n  miss = 0;\n  private readonly caches: Array<Array<KeyCacheRecord>>;\n\n  constructor(readonly maxKeyLength = DEFAULT_MAX_KEY_LENGTH, readonly maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {\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 (let i = 0; i < this.maxKeyLength; i++) {\n      this.caches.push([]);\n    }\n  }\n\n  public canBeCached(byteLength: number): boolean {\n    return byteLength > 0 && byteLength <= this.maxKeyLength;\n  }\n\n  private find(bytes: Uint8Array, inputOffset: number, byteLength: number): string | null {\n    const records = this.caches[byteLength - 1]!;\n\n    FIND_CHUNK: for (const record of records) {\n      const recordBytes = record.bytes;\n\n      for (let 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\n  private store(bytes: Uint8Array, value: string) {\n    const records = this.caches[bytes.length - 1]!;\n    const record: KeyCacheRecord = { bytes, str: value };\n\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    } else {\n      records.push(record);\n    }\n  }\n\n  public decode(bytes: Uint8Array, inputOffset: number, byteLength: number): string {\n    const cachedValue = this.find(bytes, inputOffset, byteLength);\n    if (cachedValue != null) {\n      this.hit++;\n      return cachedValue;\n    }\n    this.miss++;\n\n    const 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    const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);\n    this.store(slicedCopyOfBytes, str);\n    return str;\n  }\n}\n","import { prettyByte } from \"./utils/prettyByte\";\nimport { ExtensionCodec, ExtensionCodecType } from \"./ExtensionCodec\";\nimport { getInt64, getUint64, UINT32_MAX } from \"./utils/int\";\nimport { utf8Decode } from \"./utils/utf8\";\nimport { createDataView, ensureUint8Array } from \"./utils/typedArrays\";\nimport { CachedKeyDecoder, KeyDecoder } from \"./CachedKeyDecoder\";\nimport { DecodeError } from \"./DecodeError\";\nimport type { ContextOf } from \"./context\";\n\nexport type DecoderOptions<ContextType = undefined> = Readonly<\n  Partial<{\n    extensionCodec: ExtensionCodecType<ContextType>;\n\n    /**\n     * Decodes Int64 and Uint64 as bigint if it's set to true.\n     * Depends on ES2020's {@link DataView#getBigInt64} and\n     * {@link DataView#getBigUint64}.\n     *\n     * Defaults to false.\n     */\n    useBigInt64: boolean;\n\n    /**\n     * Maximum string length.\n     *\n     * Defaults to 4_294_967_295 (UINT32_MAX).\n     */\n    maxStrLength: number;\n    /**\n     * Maximum binary length.\n     *\n     * Defaults to 4_294_967_295 (UINT32_MAX).\n     */\n    maxBinLength: number;\n    /**\n     * Maximum array length.\n     *\n     * Defaults to 4_294_967_295 (UINT32_MAX).\n     */\n    maxArrayLength: number;\n    /**\n     * Maximum map length.\n     *\n     * Defaults to 4_294_967_295 (UINT32_MAX).\n     */\n    maxMapLength: number;\n    /**\n     * Maximum extension length.\n     *\n     * Defaults to 4_294_967_295 (UINT32_MAX).\n     */\n    maxExtLength: number;\n\n    /**\n     * An object key decoder. Defaults to the shared instance of {@link CachedKeyDecoder}.\n     * `null` is a special value to disable the use of the key decoder at all.\n     */\n    keyDecoder: KeyDecoder | null;\n  }>\n> &\n  ContextOf<ContextType>;\n\n\nconst STATE_ARRAY = \"array\";\nconst STATE_MAP_KEY = \"map_key\";\nconst STATE_MAP_VALUE = \"map_value\";\n\ntype MapKeyType = string | number;\n\nconst isValidMapKeyType = (key: unknown): key is MapKeyType => {\n  return typeof key === \"string\" || typeof key === \"number\";\n};\n\ntype StackMapState = {\n  type: typeof STATE_MAP_KEY | typeof STATE_MAP_VALUE;\n  size: number;\n  key: MapKeyType | null;\n  readCount: number;\n  map: Record<string, unknown>;\n};\n\ntype StackArrayState = {\n  type: typeof STATE_ARRAY;\n  size: number;\n  array: Array<unknown>;\n  position: number;\n};\n\ntype StackState = StackArrayState | StackMapState;\n\nconst HEAD_BYTE_REQUIRED = -1;\n\nconst EMPTY_VIEW = new DataView(new ArrayBuffer(0));\nconst EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);\n\ntry {\n  // IE11: The spec says it should throw RangeError,\n  // IE11: but in IE11 it throws TypeError.\n  EMPTY_VIEW.getInt8(0);\n} catch (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 const DataViewIndexOutOfBoundsError = RangeError;\n\nconst MORE_DATA = new DataViewIndexOutOfBoundsError(\"Insufficient data\");\n\nconst sharedCachedKeyDecoder = new CachedKeyDecoder();\n\nexport class Decoder<ContextType = undefined> {\n  private readonly extensionCodec: ExtensionCodecType<ContextType>;\n  private readonly context: ContextType;\n  private readonly useBigInt64: boolean;\n  private readonly maxStrLength: number;\n  private readonly maxBinLength: number;\n  private readonly maxArrayLength: number;\n  private readonly maxMapLength: number;\n  private readonly maxExtLength: number;\n  private readonly keyDecoder: KeyDecoder | null;\n\n  private totalPos = 0;\n  private pos = 0;\n\n  private view = EMPTY_VIEW;\n  private bytes = EMPTY_BYTES;\n  private headByte = HEAD_BYTE_REQUIRED;\n  private readonly stack: Array<StackState> = [];\n\n  public constructor(options?: DecoderOptions<ContextType>) {\n    this.extensionCodec = options?.extensionCodec ?? (ExtensionCodec.defaultCodec as ExtensionCodecType<ContextType>);\n    this.context = (options as { context: ContextType } | undefined)?.context as ContextType; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined\n\n    this.useBigInt64 = options?.useBigInt64 ?? false;\n    this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;\n    this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;\n    this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;\n    this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;\n    this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;\n    this.keyDecoder = (options?.keyDecoder !== undefined) ? options.keyDecoder : sharedCachedKeyDecoder;\n  }\n\n  private reinitializeState() {\n    this.totalPos = 0;\n    this.headByte = HEAD_BYTE_REQUIRED;\n    this.stack.length = 0;\n\n    // view, bytes, and pos will be re-initialized in setBuffer()\n  }\n\n  private setBuffer(buffer: ArrayLike<number> | BufferSource): void {\n    this.bytes = ensureUint8Array(buffer);\n    this.view = createDataView(this.bytes);\n    this.pos = 0;\n  }\n\n  private appendBuffer(buffer: ArrayLike<number> | BufferSource) {\n    if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {\n      this.setBuffer(buffer);\n    } else {\n      const remainingData = this.bytes.subarray(this.pos);\n      const newData = ensureUint8Array(buffer);\n\n      // concat remainingData + newData\n      const newBuffer = new Uint8Array(remainingData.length + newData.length);\n      newBuffer.set(remainingData);\n      newBuffer.set(newData, remainingData.length);\n      this.setBuffer(newBuffer);\n    }\n  }\n\n  private hasRemaining(size: number) {\n    return this.view.byteLength - this.pos >= size;\n  }\n\n  private createExtraByteError(posToShow: number): Error {\n    const { view, pos } = this;\n    return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);\n  }\n\n  /**\n   * @throws {@link DecodeError}\n   * @throws {@link RangeError}\n   */\n  public decode(buffer: ArrayLike<number> | BufferSource): unknown {\n    this.reinitializeState();\n    this.setBuffer(buffer);\n\n    const object = this.doDecodeSync();\n    if (this.hasRemaining(1)) {\n      throw this.createExtraByteError(this.pos);\n    }\n    return object;\n  }\n\n  public *decodeMulti(buffer: ArrayLike<number> | BufferSource): Generator<unknown, void, unknown> {\n    this.reinitializeState();\n    this.setBuffer(buffer);\n\n    while (this.hasRemaining(1)) {\n      yield this.doDecodeSync();\n    }\n  }\n\n  public async decodeAsync(stream: AsyncIterable<ArrayLike<number> | BufferSource>): Promise<unknown> {\n    let decoded = false;\n    let object: unknown;\n    for await (const buffer of stream) {\n      if (decoded) {\n        throw this.createExtraByteError(this.totalPos);\n      }\n\n      this.appendBuffer(buffer);\n\n      try {\n        object = this.doDecodeSync();\n        decoded = true;\n      } catch (e) {\n        if (!(e instanceof DataViewIndexOutOfBoundsError)) {\n          throw e; // rethrow\n        }\n        // fallthrough\n      }\n      this.totalPos += this.pos;\n    }\n\n    if (decoded) {\n      if (this.hasRemaining(1)) {\n        throw this.createExtraByteError(this.totalPos);\n      }\n      return object;\n    }\n\n    const { headByte, pos, totalPos } = this;\n    throw new RangeError(\n      `Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`,\n    );\n  }\n\n  public decodeArrayStream(\n    stream: AsyncIterable<ArrayLike<number> | BufferSource>,\n  ): AsyncGenerator<unknown, void, unknown> {\n    return this.decodeMultiAsync(stream, true);\n  }\n\n  public decodeStream(stream: AsyncIterable<ArrayLike<number> | BufferSource>): AsyncGenerator<unknown, void, unknown> {\n    return this.decodeMultiAsync(stream, false);\n  }\n\n  private async *decodeMultiAsync(stream: AsyncIterable<ArrayLike<number> | BufferSource>, isArray: boolean) {\n    let isArrayHeaderRequired = isArray;\n    let arrayItemsLeft = -1;\n\n    for await (const buffer of stream) {\n      if (isArray && arrayItemsLeft === 0) {\n        throw this.createExtraByteError(this.totalPos);\n      }\n\n      this.appendBuffer(buffer);\n\n      if (isArrayHeaderRequired) {\n        arrayItemsLeft = this.readArraySize();\n        isArrayHeaderRequired = false;\n        this.complete();\n      }\n\n      try {\n        while (true) {\n          yield this.doDecodeSync();\n          if (--arrayItemsLeft === 0) {\n            break;\n          }\n        }\n      } catch (e) {\n        if (!(e instanceof DataViewIndexOutOfBoundsError)) {\n          throw e; // rethrow\n        }\n        // fallthrough\n      }\n      this.totalPos += this.pos;\n    }\n  }\n\n  private doDecodeSync(): unknown {\n    DECODE: while (true) {\n      const headByte = this.readHeadByte();\n      let object: unknown;\n\n      if (headByte >= 0xe0) {\n        // negative fixint (111x xxxx) 0xe0 - 0xff\n        object = headByte - 0x100;\n      } else if (headByte < 0xc0) {\n        if (headByte < 0x80) {\n          // positive fixint (0xxx xxxx) 0x00 - 0x7f\n          object = headByte;\n        } else if (headByte < 0x90) {\n          // fixmap (1000 xxxx) 0x80 - 0x8f\n          const size = headByte - 0x80;\n          if (size !== 0) {\n            this.pushMapState(size);\n            this.complete();\n            continue DECODE;\n          } else {\n            object = {};\n          }\n        } else if (headByte < 0xa0) {\n          // fixarray (1001 xxxx) 0x90 - 0x9f\n          const size = headByte - 0x90;\n          if (size !== 0) {\n            this.pushArrayState(size);\n            this.complete();\n            continue DECODE;\n          } else {\n            object = [];\n          }\n        } else {\n          // fixstr (101x xxxx) 0xa0 - 0xbf\n          const byteLength = headByte - 0xa0;\n          object = this.decodeUtf8String(byteLength, 0);\n        }\n      } else if (headByte === 0xc0) {\n        // nil\n        object = null;\n      } else if (headByte === 0xc2) {\n        // false\n        object = false;\n      } else if (headByte === 0xc3) {\n        // true\n        object = true;\n      } else if (headByte === 0xca) {\n        // float 32\n        object = this.readF32();\n      } else if (headByte === 0xcb) {\n        // float 64\n        object = this.readF64();\n      } else if (headByte === 0xcc) {\n        // uint 8\n        object = this.readU8();\n      } else if (headByte === 0xcd) {\n        // uint 16\n        object = this.readU16();\n      } else if (headByte === 0xce) {\n        // uint 32\n        object = this.readU32();\n      } else if (headByte === 0xcf) {\n        // uint 64\n        if (this.useBigInt64) {\n          object = this.readU64AsBigInt();\n        } else {\n          object = this.readU64();\n        }\n      } else if (headByte === 0xd0) {\n        // int 8\n        object = this.readI8();\n      } else if (headByte === 0xd1) {\n        // int 16\n        object = this.readI16();\n      } else if (headByte === 0xd2) {\n        // int 32\n        object = this.readI32();\n      } else if (headByte === 0xd3) {\n        // int 64\n        if (this.useBigInt64) {\n          object = this.readI64AsBigInt();\n        } else {\n          object = this.readI64();\n        }\n      } else if (headByte === 0xd9) {\n        // str 8\n        const byteLength = this.lookU8();\n        object = this.decodeUtf8String(byteLength, 1);\n      } else if (headByte === 0xda) {\n        // str 16\n        const byteLength = this.lookU16();\n        object = this.decodeUtf8String(byteLength, 2);\n      } else if (headByte === 0xdb) {\n        // str 32\n        const byteLength = this.lookU32();\n        object = this.decodeUtf8String(byteLength, 4);\n      } else if (headByte === 0xdc) {\n        // array 16\n        const size = this.readU16();\n        if (size !== 0) {\n          this.pushArrayState(size);\n          this.complete();\n          continue DECODE;\n        } else {\n          object = [];\n        }\n      } else if (headByte === 0xdd) {\n        // array 32\n        const size = this.readU32();\n        if (size !== 0) {\n          this.pushArrayState(size);\n          this.complete();\n          continue DECODE;\n        } else {\n          object = [];\n        }\n      } else if (headByte === 0xde) {\n        // map 16\n        const size = this.readU16();\n        if (size !== 0) {\n          this.pushMapState(size);\n          this.complete();\n          continue DECODE;\n        } else {\n          object = {};\n        }\n      } else if (headByte === 0xdf) {\n        // map 32\n        const size = this.readU32();\n        if (size !== 0) {\n          this.pushMapState(size);\n          this.complete();\n          continue DECODE;\n        } else {\n          object = {};\n        }\n      } else if (headByte === 0xc4) {\n        // bin 8\n        const size = this.lookU8();\n        object = this.decodeBinary(size, 1);\n      } else if (headByte === 0xc5) {\n        // bin 16\n        const size = this.lookU16();\n        object = this.decodeBinary(size, 2);\n      } else if (headByte === 0xc6) {\n        // bin 32\n        const size = this.lookU32();\n        object = this.decodeBinary(size, 4);\n      } else if (headByte === 0xd4) {\n        // fixext 1\n        object = this.decodeExtension(1, 0);\n      } else if (headByte === 0xd5) {\n        // fixext 2\n        object = this.decodeExtension(2, 0);\n      } else if (headByte === 0xd6) {\n        // fixext 4\n        object = this.decodeExtension(4, 0);\n      } else if (headByte === 0xd7) {\n        // fixext 8\n        object = this.decodeExtension(8, 0);\n      } else if (headByte === 0xd8) {\n        // fixext 16\n        object = this.decodeExtension(16, 0);\n      } else if (headByte === 0xc7) {\n        // ext 8\n        const size = this.lookU8();\n        object = this.decodeExtension(size, 1);\n      } else if (headByte === 0xc8) {\n        // ext 16\n        const size = this.lookU16();\n        object = this.decodeExtension(size, 2);\n      } else if (headByte === 0xc9) {\n        // ext 32\n        const size = this.lookU32();\n        object = this.decodeExtension(size, 4);\n      } else {\n        throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);\n      }\n\n      this.complete();\n\n      const stack = this.stack;\n      while (stack.length > 0) {\n        // arrays and maps\n        const 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          } else {\n            continue DECODE;\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\n          state.key = object;\n          state.type = STATE_MAP_VALUE;\n          continue DECODE;\n        } else {\n          // it must be `state.type === State.MAP_VALUE` here\n\n          state.map[state.key!] = object;\n          state.readCount++;\n\n          if (state.readCount === state.size) {\n            stack.pop();\n            object = state.map;\n          } else {\n            state.key = null;\n            state.type = STATE_MAP_KEY;\n            continue DECODE;\n          }\n        }\n      }\n\n      return object;\n    }\n  }\n\n  private readHeadByte(): number {\n    if (this.headByte === HEAD_BYTE_REQUIRED) {\n      this.headByte = this.readU8();\n      // console.log(\"headByte\", prettyByte(this.headByte));\n    }\n\n    return this.headByte;\n  }\n\n  private complete(): void {\n    this.headByte = HEAD_BYTE_REQUIRED;\n  }\n\n  private readArraySize(): number {\n    const headByte = this.readHeadByte();\n\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        } else {\n          throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);\n        }\n      }\n    }\n  }\n\n  private pushMapState(size: number) {\n    if (size > this.maxMapLength) {\n      throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);\n    }\n\n    this.stack.push({\n      type: STATE_MAP_KEY,\n      size,\n      key: null,\n      readCount: 0,\n      map: {},\n    });\n  }\n\n  private pushArrayState(size: number) {\n    if (size > this.maxArrayLength) {\n      throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);\n    }\n\n    this.stack.push({\n      type: STATE_ARRAY,\n      size,\n      array: new Array<unknown>(size),\n      position: 0,\n    });\n  }\n\n  private decodeUtf8String(byteLength: number, headerOffset: number): string {\n    if (byteLength > this.maxStrLength) {\n      throw new DecodeError(\n        `Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`,\n      );\n    }\n\n    if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {\n      throw MORE_DATA;\n    }\n\n    const offset = this.pos + headerOffset;\n    let object: string;\n    if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {\n      object = this.keyDecoder.decode(this.bytes, offset, byteLength);\n    } else {\n      object = utf8Decode(this.bytes, offset, byteLength);\n    }\n    this.pos += headerOffset + byteLength;\n    return object;\n  }\n\n  private stateIsMapKey(): boolean {\n    if (this.stack.length > 0) {\n      const state = this.stack[this.stack.length - 1]!;\n      return state.type === STATE_MAP_KEY;\n    }\n    return false;\n  }\n\n  private decodeBinary(byteLength: number, headOffset: number): Uint8Array {\n    if (byteLength > this.maxBinLength) {\n      throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);\n    }\n\n    if (!this.hasRemaining(byteLength + headOffset)) {\n      throw MORE_DATA;\n    }\n\n    const offset = this.pos + headOffset;\n    const object = this.bytes.subarray(offset, offset + byteLength);\n    this.pos += headOffset + byteLength;\n    return object;\n  }\n\n  private decodeExtension(size: number, headOffset: number): unknown {\n    if (size > this.maxExtLength) {\n      throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);\n    }\n\n    const extType = this.view.getInt8(this.pos + headOffset);\n    const data = this.decodeBinary(size, headOffset + 1 /* extType */);\n    return this.extensionCodec.decode(data, extType, this.context);\n  }\n\n  private lookU8() {\n    return this.view.getUint8(this.pos);\n  }\n\n  private lookU16() {\n    return this.view.getUint16(this.pos);\n  }\n\n  private lookU32() {\n    return this.view.getUint32(this.pos);\n  }\n\n  private readU8(): number {\n    const value = this.view.getUint8(this.pos);\n    this.pos++;\n    return value;\n  }\n\n  private readI8(): number {\n    const value = this.view.getInt8(this.pos);\n    this.pos++;\n    return value;\n  }\n\n  private readU16(): number {\n    const value = this.view.getUint16(this.pos);\n    this.pos += 2;\n    return value;\n  }\n\n  private readI16(): number {\n    const value = this.view.getInt16(this.pos);\n    this.pos += 2;\n    return value;\n  }\n\n  private readU32(): number {\n    const value = this.view.getUint32(this.pos);\n    this.pos += 4;\n    return value;\n  }\n\n  private readI32(): number {\n    const value = this.view.getInt32(this.pos);\n    this.pos += 4;\n    return value;\n  }\n\n  private readU64(): number {\n    const value = getUint64(this.view, this.pos);\n    this.pos += 8;\n    return value;\n  }\n\n  private readI64(): number {\n    const value = getInt64(this.view, this.pos);\n    this.pos += 8;\n    return value;\n  }\n\n  private readU64AsBigInt(): bigint {\n    const value = this.view.getBigUint64(this.pos);\n    this.pos += 8;\n    return value;\n  }\n\n  private readI64AsBigInt(): bigint {\n    const value = this.view.getBigInt64(this.pos);\n    this.pos += 8;\n    return value;\n  }\n\n  private readF32() {\n    const value = this.view.getFloat32(this.pos);\n    this.pos += 4;\n    return value;\n  }\n\n  private readF64() {\n    const value = this.view.getFloat64(this.pos);\n    this.pos += 8;\n    return value;\n  }\n}\n","import { Decoder } from \"./Decoder\";\nimport type { DecoderOptions } from \"./Decoder\";\nimport type { SplitUndefined } from \"./context\";\n\n/**\n * @deprecated Use {@link DecoderOptions} instead.\n */\nexport type DecodeOptions = never;\n\n/**\n * @deprecated No longer supported.\n */\nexport const defaultDecodeOptions: never = undefined as never;\n\n/**\n * It decodes a single MessagePack object in a buffer.\n *\n * This is a synchronous decoding function.\n * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.\n *\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\nexport function decode<ContextType = undefined>(\n  buffer: ArrayLike<number> | BufferSource,\n  options?: DecoderOptions<SplitUndefined<ContextType>>,\n): unknown {\n  const decoder = new Decoder(options);\n  return decoder.decode(buffer);\n}\n\n/**\n * It decodes multiple MessagePack objects in a buffer.\n * This is corresponding to {@link decodeMultiStream()}.\n *\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\nexport function decodeMulti<ContextType = undefined>(\n  buffer: ArrayLike<number> | BufferSource,\n  options?: DecoderOptions<SplitUndefined<ContextType>>,\n): Generator<unknown, void, unknown> {\n  const decoder = new Decoder(options);\n  return decoder.decodeMulti(buffer);\n}\n","// utility for whatwg streams\n\n// The living standard of whatwg streams says\n// ReadableStream is also AsyncIterable, but\n// as of June 2019, no browser implements it.\n// See https://streams.spec.whatwg.org/ for details\nexport type ReadableStreamLike<T> = AsyncIterable<T> | ReadableStream<T>;\n\nexport function isAsyncIterable<T>(object: ReadableStreamLike<T>): object is AsyncIterable<T> {\n  return (object as any)[Symbol.asyncIterator] != null;\n}\n\nfunction assertNonNull<T>(value: T | null | undefined): asserts value is T {\n  if (value == null) {\n    throw new Error(\"Assertion Failure: value must not be null nor undefined\");\n  }\n}\n\nexport async function* asyncIterableFromStream<T>(stream: ReadableStream<T>): AsyncIterable<T> {\n  const reader = stream.getReader();\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) {\n        return;\n      }\n      assertNonNull(value);\n      yield value;\n    }\n  } finally {\n    reader.releaseLock();\n  }\n}\n\nexport function ensureAsyncIterable<T>(streamLike: ReadableStreamLike<T>): AsyncIterable<T> {\n  if (isAsyncIterable(streamLike)) {\n    return streamLike;\n  } else {\n    return asyncIterableFromStream(streamLike);\n  }\n}\n","import { Decoder } from \"./Decoder\";\nimport { ensureAsyncIterable } from \"./utils/stream\";\nimport type { DecoderOptions } from \"./Decoder\";\nimport type { ReadableStreamLike } from \"./utils/stream\";\nimport type { SplitUndefined } from \"./context\";\n\n/**\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\n export async function decodeAsync<ContextType = undefined>(\n  streamLike: ReadableStreamLike<ArrayLike<number> | BufferSource>,\n  options?: DecoderOptions<SplitUndefined<ContextType>>,\n): Promise<unknown> {\n  const stream = ensureAsyncIterable(streamLike);\n  const decoder = new Decoder(options);\n  return decoder.decodeAsync(stream);\n}\n\n/**\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\n export function decodeArrayStream<ContextType>(\n  streamLike: ReadableStreamLike<ArrayLike<number> | BufferSource>,\n  options?: DecoderOptions<SplitUndefined<ContextType>>,\n): AsyncGenerator<unknown, void, unknown> {\n  const stream = ensureAsyncIterable(streamLike);\n  const decoder = new Decoder(options);\n  return decoder.decodeArrayStream(stream);\n}\n\n/**\n * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.\n * @throws {@link DecodeError} if the buffer contains invalid data.\n */\nexport function decodeMultiStream<ContextType>(\n  streamLike: ReadableStreamLike<ArrayLike<number> | BufferSource>,\n  options?: DecoderOptions<SplitUndefined<ContextType>>,\n): AsyncGenerator<unknown, void, unknown> {\n  const stream = ensureAsyncIterable(streamLike);\n  const decoder = new Decoder(options);\n  return decoder.decodeStream(stream);\n}\n\n/**\n * @deprecated Use {@link decodeMultiStream()} instead.\n */\nexport const decodeStream: never = undefined as never;\n"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","sharedTextEncoder","TextEncoder","TEXT_ENCODER_THRESHOLD","CHUNK_SIZE","utf8DecodeJs","bytes","inputOffset","byteLength","offset","end","units","result","byte1","push","byte2","byte3","unit","length","String","fromCharCode","sharedTextDecoder","TextDecoder","TEXT_DECODER_THRESHOLD","type","data","message","proto","create","DecodeError","setPrototypeOf","configurable","name","Error","UINT32_MAX","setInt64","view","high","Math","floor","low","setUint32","getInt64","getInt32","getUint32","EXT_TIMESTAMP","TIMESTAMP32_MAX_SEC","TIMESTAMP64_MAX_SEC","encodeTimeSpecToTimestamp","sec","nsec","rv","Uint8Array","DataView","buffer","secHigh","secLow","encodeDateToTimeSpec","date","msec","getTime","nsecInSec","encodeTimestampExtension","object","Date","decodeTimestampToTimeSpec","byteOffset","nsec30AndSecHigh2","decodeTimestampExtension","timeSpec","timestampExtension","encode","decode","builtInEncoders","builtInDecoders","encoders","decoders","register","index","tryToEncode","context","i","encodeExt","ExtData","decodeExt","defaultCodec","ExtensionCodec","ensureUint8Array","ArrayBuffer","isView","from","options","extensionCodec","useBigInt64","maxDepth","initialBufferSize","sortKeys","forceFloat32","ignoreUndefined","forceIntegerToFloat","pos","reinitializeState","encodeSharedRef","doEncode","subarray","slice","depth","encodeNil","encodeBoolean","encodeNumberAsFloat","encodeNumber","encodeString","encodeBigInt64","encodeObject","ensureBufferSizeToWrite","sizeToWrite","requiredSize","resizeBuffer","newSize","newBuffer","newBytes","newView","set","writeU8","Number","isSafeInteger","writeU16","writeU32","writeU64","writeI8","writeI16","writeI32","writeI64","writeF32","writeF64","BigInt","writeBigUint64","writeBigInt64","writeStringHeader","str","output","outputOffset","strLength","charCodeAt","extra","utf8Count","encodeInto","utf8EncodeTE","utf8EncodeJs","ext","encodeExtension","Array","isArray","encodeArray","encodeBinary","toString","apply","encodeMap","size","writeU8a","item","countWithoutUndefined","keys","count","undefined","sort","setUint8","values","setInt8","setUint16","setInt16","setInt32","setFloat32","setFloat64","setUint64","setBigUint64","setBigInt64","Encoder","prettyByte","byte","abs","padStart","maxKeyLength","maxLengthPerKey","hit","miss","caches","canBeCached","find","records","FIND_CHUNK","record","recordBytes","j","store","random","cachedValue","slicedCopyOfBytes","STATE_ARRAY","STATE_MAP_KEY","EMPTY_VIEW","EMPTY_BYTES","getInt8","e","RangeError","DataViewIndexOutOfBoundsError","MORE_DATA","sharedCachedKeyDecoder","CachedKeyDecoder","totalPos","headByte","stack","maxStrLength","maxBinLength","maxArrayLength","maxMapLength","maxExtLength","keyDecoder","setBuffer","bufferView","createDataView","appendBuffer","hasRemaining","remainingData","newData","createExtraByteError","posToShow","doDecodeSync","decodeMulti","decodeAsync","stream","decoded","decodeArrayStream","decodeMultiAsync","decodeStream","isArrayHeaderRequired","arrayItemsLeft","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","pop","map","readCount","headerOffset","stateIsMapKey","stringBytes","utf8DecodeTD","utf8Decode","headOffset","extType","getUint8","getUint16","getInt16","getBigUint64","getBigInt64","getFloat32","getFloat64","Decoder","ensureAsyncIterable","streamLike","asyncIterator","reader","getReader","read","done","assertNonNull","releaseLock","asyncIterableFromStream","decodeMultiStream"],"sourceRoot":""}