@heybox/hb-sdk 0.7.4 → 0.7.5-alpha.0

package/dist/index.cjs.js

@@ -672,7 +672,7 @@ function createMessageId() {
 /** 构建时替换为当前发布包的实际版本。 */
 const HB_SDK_VERSION = typeof undefined === 'string'
     ? undefined
-    : '0.7.4';
+    : '0.7.5-alpha.0';
 
 const DEFAULT_TIMEOUT = 10000;
 const HANDSHAKE_RETRY_INTERVAL = 250;
@@ -1061,42 +1061,71 @@ function copyLink(requester, options) {
     return requester.request(SHARE_COPY_LINK_METHOD, options);
 }
 
-// TextEncoder and TextDecoder are standardized in whatwg encoding:
-// https://encoding.spec.whatwg.org/
-// and available in all the modern browsers:
-// https://caniuse.com/textencoder
-// They are available in Node.js since v12 LTS as well:
-// https://nodejs.org/api/globals.html#textencoder
-new TextEncoder();
-const CHUNK_SIZE = 4096;
+// Integer Utility
+var UINT32_MAX = 4294967295;
+function setInt64(view, offset, value) {
+    var high = Math.floor(value / 4294967296);
+    var low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+    var high = view.getInt32(offset);
+    var low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+function getUint64(view, offset) {
+    var high = view.getUint32(offset);
+    var low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+
+var _a, _b, _c;
+var TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["TEXT_ENCODING"]) !== "never") &&
+    typeof TextEncoder !== "undefined" &&
+    typeof TextDecoder !== "undefined";
+var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
+!TEXT_ENCODING_AVAILABLE
+    ? UINT32_MAX
+    : typeof process !== "undefined" && ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b["TEXT_ENCODING"]) !== "force"
+        ? 200
+        : 0;
+function utf8EncodeTEencode(str, output, outputOffset) {
+    output.set(sharedTextEncoder.encode(str), outputOffset);
+}
+function utf8EncodeTEencodeInto(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+(sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+var CHUNK_SIZE = 4096;
 function utf8DecodeJs(bytes, inputOffset, byteLength) {
-    let offset = inputOffset;
-    const end = offset + byteLength;
-    const units = [];
-    let result = "";
+    var offset = inputOffset;
+    var end = offset + byteLength;
+    var units = [];
+    var result = "";
     while (offset < end) {
-        const byte1 = bytes[offset++];
+        var byte1 = bytes[offset++];
         if ((byte1 & 0x80) === 0) {
             // 1 byte
             units.push(byte1);
         }
         else if ((byte1 & 0xe0) === 0xc0) {
             // 2 bytes
-            const byte2 = bytes[offset++] & 0x3f;
+            var byte2 = bytes[offset++] & 0x3f;
             units.push(((byte1 & 0x1f) << 6) | byte2);
         }
         else if ((byte1 & 0xf0) === 0xe0) {
             // 3 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
+            var byte2 = bytes[offset++] & 0x3f;
+            var byte3 = bytes[offset++] & 0x3f;
             units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
         }
         else if ((byte1 & 0xf8) === 0xf0) {
             // 4 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
-            const byte4 = bytes[offset++] & 0x3f;
-            let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+            var byte2 = bytes[offset++] & 0x3f;
+            var byte3 = bytes[offset++] & 0x3f;
+            var byte4 = bytes[offset++] & 0x3f;
+            var unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
             if (unit > 0xffff) {
                 unit -= 0x10000;
                 units.push(((unit >>> 10) & 0x3ff) | 0xd800);
@@ -1108,97 +1137,90 @@ function utf8DecodeJs(bytes, inputOffset, byteLength) {
             units.push(byte1);
         }
         if (units.length >= CHUNK_SIZE) {
-            result += String.fromCharCode(...units);
+            result += String.fromCharCode.apply(String, units);
             units.length = 0;
         }
     }
     if (units.length > 0) {
-        result += String.fromCharCode(...units);
+        result += String.fromCharCode.apply(String, units);
     }
     return result;
 }
-const sharedTextDecoder = new TextDecoder();
-// This threshold should be determined by benchmarking, which might vary in engines and input data.
-// Run `npx ts-node benchmark/decode-string.ts` for details.
-const TEXT_DECODER_THRESHOLD = 200;
+var sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
+var TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+    ? UINT32_MAX
+    : typeof process !== "undefined" && ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c["TEXT_DECODER"]) !== "force"
+        ? 200
+        : 0;
 function utf8DecodeTD(bytes, inputOffset, byteLength) {
-    const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+    var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
     return sharedTextDecoder.decode(stringBytes);
 }
-function utf8Decode(bytes, inputOffset, byteLength) {
-    if (byteLength > TEXT_DECODER_THRESHOLD) {
-        return utf8DecodeTD(bytes, inputOffset, byteLength);
-    }
-    else {
-        return utf8DecodeJs(bytes, inputOffset, byteLength);
-    }
-}
 
 /**
  * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
  */
-class ExtData {
-    type;
-    data;
-    constructor(type, data) {
+var ExtData = /** @class */ (function () {
+    function ExtData(type, data) {
         this.type = type;
         this.data = data;
     }
-}
+    return ExtData;
+}());
 
-class DecodeError extends Error {
-    constructor(message) {
-        super(message);
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var DecodeError = /** @class */ (function (_super) {
+    __extends(DecodeError, _super);
+    function DecodeError(message) {
+        var _this = _super.call(this, message) || this;
         // fix the prototype chain in a cross-platform way
-        const proto = Object.create(DecodeError.prototype);
-        Object.setPrototypeOf(this, proto);
-        Object.defineProperty(this, "name", {
+        var proto = Object.create(DecodeError.prototype);
+        Object.setPrototypeOf(_this, proto);
+        Object.defineProperty(_this, "name", {
             configurable: true,
             enumerable: false,
             value: DecodeError.name,
         });
+        return _this;
     }
-}
-
-// Integer Utility
-const UINT32_MAX = 4294967295;
-function setInt64(view, offset, value) {
-    const high = Math.floor(value / 4294967296);
-    const low = value; // high bits are truncated by DataView
-    view.setUint32(offset, high);
-    view.setUint32(offset + 4, low);
-}
-function getInt64(view, offset) {
-    const high = view.getInt32(offset);
-    const low = view.getUint32(offset + 4);
-    return high * 4294967296 + low;
-}
-function getUint64(view, offset) {
-    const high = view.getUint32(offset);
-    const low = view.getUint32(offset + 4);
-    return high * 4294967296 + low;
-}
+    return DecodeError;
+}(Error));
 
 // https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
-const EXT_TIMESTAMP = -1;
-const TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
-const TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
-function encodeTimeSpecToTimestamp({ sec, nsec }) {
+var EXT_TIMESTAMP = -1;
+var TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+var TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+function encodeTimeSpecToTimestamp(_a) {
+    var sec = _a.sec, nsec = _a.nsec;
     if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
         // Here sec >= 0 && nsec >= 0
         if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
             // timestamp 32 = { sec32 (unsigned) }
-            const rv = new Uint8Array(4);
-            const view = new DataView(rv.buffer);
+            var rv = new Uint8Array(4);
+            var view = new DataView(rv.buffer);
             view.setUint32(0, sec);
             return rv;
         }
         else {
             // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
-            const secHigh = sec / 0x100000000;
-            const secLow = sec & 0xffffffff;
-            const rv = new Uint8Array(8);
-            const view = new DataView(rv.buffer);
+            var secHigh = sec / 0x100000000;
+            var secLow = sec & 0xffffffff;
+            var rv = new Uint8Array(8);
+            var view = new DataView(rv.buffer);
             // nsec30 | secHigh2
             view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
             // secLow32
@@ -1208,19 +1230,19 @@ function encodeTimeSpecToTimestamp({ sec, nsec }) {
     }
     else {
         // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
-        const rv = new Uint8Array(12);
-        const view = new DataView(rv.buffer);
+        var rv = new Uint8Array(12);
+        var view = new DataView(rv.buffer);
         view.setUint32(0, nsec);
         setInt64(view, 4, sec);
         return rv;
     }
 }
 function encodeDateToTimeSpec(date) {
-    const msec = date.getTime();
-    const sec = Math.floor(msec / 1e3);
-    const nsec = (msec - sec * 1e3) * 1e6;
+    var msec = date.getTime();
+    var sec = Math.floor(msec / 1e3);
+    var nsec = (msec - sec * 1e3) * 1e6;
     // Normalizes { sec, nsec } to ensure nsec is unsigned.
-    const nsecInSec = Math.floor(nsec / 1e9);
+    var nsecInSec = Math.floor(nsec / 1e9);
     return {
         sec: sec + nsecInSec,
         nsec: nsec - nsecInSec * 1e9,
@@ -1228,7 +1250,7 @@ function encodeDateToTimeSpec(date) {
 }
 function encodeTimestampExtension(object) {
     if (object instanceof Date) {
-        const timeSpec = encodeDateToTimeSpec(object);
+        var timeSpec = encodeDateToTimeSpec(object);
         return encodeTimeSpecToTimestamp(timeSpec);
     }
     else {
@@ -1236,60 +1258,56 @@ function encodeTimestampExtension(object) {
     }
 }
 function decodeTimestampToTimeSpec(data) {
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     // data may be 32, 64, or 96 bits
     switch (data.byteLength) {
         case 4: {
             // timestamp 32 = { sec32 }
-            const sec = view.getUint32(0);
-            const nsec = 0;
-            return { sec, nsec };
+            var sec = view.getUint32(0);
+            var nsec = 0;
+            return { sec: sec, nsec: nsec };
         }
         case 8: {
             // timestamp 64 = { nsec30, sec34 }
-            const nsec30AndSecHigh2 = view.getUint32(0);
-            const secLow32 = view.getUint32(4);
-            const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
-            const nsec = nsec30AndSecHigh2 >>> 2;
-            return { sec, nsec };
+            var nsec30AndSecHigh2 = view.getUint32(0);
+            var secLow32 = view.getUint32(4);
+            var sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+            var nsec = nsec30AndSecHigh2 >>> 2;
+            return { sec: sec, nsec: nsec };
         }
         case 12: {
             // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
-            const sec = getInt64(view, 4);
-            const nsec = view.getUint32(0);
-            return { sec, nsec };
+            var sec = getInt64(view, 4);
+            var nsec = view.getUint32(0);
+            return { sec: sec, nsec: nsec };
         }
         default:
-            throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+            throw new DecodeError("Unrecognized data size for timestamp (expected 4, 8, or 12): ".concat(data.length));
     }
 }
 function decodeTimestampExtension(data) {
-    const timeSpec = decodeTimestampToTimeSpec(data);
+    var timeSpec = decodeTimestampToTimeSpec(data);
     return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
 }
-const timestampExtension = {
+var timestampExtension = {
     type: EXT_TIMESTAMP,
     encode: encodeTimestampExtension,
     decode: decodeTimestampExtension,
 };
 
 // ExtensionCodec to handle MessagePack extensions
-class ExtensionCodec {
-    static defaultCodec = new ExtensionCodec();
-    // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
-    // this will make type errors a lot more clear
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    __brand;
-    // built-in extensions
-    builtInEncoders = [];
-    builtInDecoders = [];
-    // custom extensions
-    encoders = [];
-    decoders = [];
-    constructor() {
+var ExtensionCodec = /** @class */ (function () {
+    function ExtensionCodec() {
+        // built-in extensions
+        this.builtInEncoders = [];
+        this.builtInDecoders = [];
+        // custom extensions
+        this.encoders = [];
+        this.decoders = [];
         this.register(timestampExtension);
     }
-    register({ type, encode, decode, }) {
+    ExtensionCodec.prototype.register = function (_a) {
+        var type = _a.type, encode = _a.encode, decode = _a.decode;
         if (type >= 0) {
             // custom extensions
             this.encoders[type] = encode;
@@ -1297,30 +1315,30 @@ class ExtensionCodec {
         }
         else {
             // built-in extensions
-            const index = -1 - type;
+            var index = 1 + type;
             this.builtInEncoders[index] = encode;
             this.builtInDecoders[index] = decode;
         }
-    }
-    tryToEncode(object, context) {
+    };
+    ExtensionCodec.prototype.tryToEncode = function (object, context) {
         // built-in extensions
-        for (let i = 0; i < this.builtInEncoders.length; i++) {
-            const encodeExt = this.builtInEncoders[i];
+        for (var i = 0; i < this.builtInEncoders.length; i++) {
+            var encodeExt = this.builtInEncoders[i];
             if (encodeExt != null) {
-                const data = encodeExt(object, context);
+                var data = encodeExt(object, context);
                 if (data != null) {
-                    const type = -1 - i;
+                    var type = -1 - i;
                     return new ExtData(type, data);
                 }
             }
         }
         // custom extensions
-        for (let i = 0; i < this.encoders.length; i++) {
-            const encodeExt = this.encoders[i];
+        for (var i = 0; i < this.encoders.length; i++) {
+            var encodeExt = this.encoders[i];
             if (encodeExt != null) {
-                const data = encodeExt(object, context);
+                var data = encodeExt(object, context);
                 if (data != null) {
-                    const type = i;
+                    var type = i;
                     return new ExtData(type, data);
                 }
             }
@@ -1330,9 +1348,9 @@ class ExtensionCodec {
             return object;
         }
         return null;
-    }
-    decode(data, type, context) {
-        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+    };
+    ExtensionCodec.prototype.decode = function (data, type, context) {
+        var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
         if (decodeExt) {
             return decodeExt(data, type, context);
         }
@@ -1340,12 +1358,11 @@ class ExtensionCodec {
             // decode() does not fail, returns ExtData instead.
             return new ExtData(type, data);
         }
-    }
-}
+    };
+    ExtensionCodec.defaultCodec = new ExtensionCodec();
+    return ExtensionCodec;
+}());
 
-function isArrayBufferLike(buffer) {
-    return (buffer instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer));
-}
 function ensureUint8Array(buffer) {
     if (buffer instanceof Uint8Array) {
         return buffer;
@@ -1353,7 +1370,7 @@ function ensureUint8Array(buffer) {
     else if (ArrayBuffer.isView(buffer)) {
         return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     }
-    else if (isArrayBufferLike(buffer)) {
+    else if (buffer instanceof ArrayBuffer) {
         return new Uint8Array(buffer);
     }
     else {
@@ -1361,37 +1378,44 @@ function ensureUint8Array(buffer) {
         return Uint8Array.from(buffer);
     }
 }
+function createDataView(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return new DataView(buffer);
+    }
+    var bufferView = ensureUint8Array(buffer);
+    return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
+}
 
 function prettyByte(byte) {
-    return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+    return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
 }
 
-const DEFAULT_MAX_KEY_LENGTH = 16;
-const DEFAULT_MAX_LENGTH_PER_KEY = 16;
-class CachedKeyDecoder {
-    hit = 0;
-    miss = 0;
-    caches;
-    maxKeyLength;
-    maxLengthPerKey;
-    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+var DEFAULT_MAX_KEY_LENGTH = 16;
+var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+var CachedKeyDecoder = /** @class */ (function () {
+    function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {
+        if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }
+        if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }
         this.maxKeyLength = maxKeyLength;
         this.maxLengthPerKey = maxLengthPerKey;
+        this.hit = 0;
+        this.miss = 0;
         // avoid `new Array(N)`, which makes a sparse array,
         // because a sparse array is typically slower than a non-sparse array.
         this.caches = [];
-        for (let i = 0; i < this.maxKeyLength; i++) {
+        for (var i = 0; i < this.maxKeyLength; i++) {
             this.caches.push([]);
         }
     }
-    canBeCached(byteLength) {
+    CachedKeyDecoder.prototype.canBeCached = function (byteLength) {
         return byteLength > 0 && byteLength <= this.maxKeyLength;
-    }
-    find(bytes, inputOffset, byteLength) {
-        const records = this.caches[byteLength - 1];
-        FIND_CHUNK: for (const record of records) {
-            const recordBytes = record.bytes;
-            for (let j = 0; j < byteLength; j++) {
+    };
+    CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {
+        var records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
+            var record = records_1[_i];
+            var recordBytes = record.bytes;
+            for (var j = 0; j < byteLength; j++) {
                 if (recordBytes[j] !== bytes[inputOffset + j]) {
                     continue FIND_CHUNK;
                 }
@@ -1399,10 +1423,10 @@ class CachedKeyDecoder {
             return record.str;
         }
         return null;
-    }
-    store(bytes, value) {
-        const records = this.caches[bytes.length - 1];
-        const record = { bytes, str: value };
+    };
+    CachedKeyDecoder.prototype.store = function (bytes, value) {
+        var records = this.caches[bytes.length - 1];
+        var record = { bytes: bytes, str: value };
         if (records.length >= this.maxLengthPerKey) {
             // `records` are full!
             // Set `record` to an arbitrary position.
@@ -1411,323 +1435,335 @@ class CachedKeyDecoder {
         else {
             records.push(record);
         }
-    }
-    decode(bytes, inputOffset, byteLength) {
-        const cachedValue = this.find(bytes, inputOffset, byteLength);
+    };
+    CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {
+        var cachedValue = this.find(bytes, inputOffset, byteLength);
         if (cachedValue != null) {
             this.hit++;
             return cachedValue;
         }
         this.miss++;
-        const str = utf8DecodeJs(bytes, inputOffset, byteLength);
-        // Ensure to copy a slice of bytes because the bytes may be a NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
-        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        var str = utf8DecodeJs(bytes, inputOffset, byteLength);
+        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+        var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
         this.store(slicedCopyOfBytes, str);
         return str;
-    }
-}
+    };
+    return CachedKeyDecoder;
+}());
 
-const STATE_ARRAY = "array";
-const STATE_MAP_KEY = "map_key";
-const STATE_MAP_VALUE = "map_value";
-const mapKeyConverter = (key) => {
-    if (typeof key === "string" || typeof key === "number") {
-        return key;
-    }
-    throw new DecodeError("The type of key must be string or number but " + typeof key);
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-class StackPool {
-    stack = [];
-    stackHeadPosition = -1;
-    get length() {
-        return this.stackHeadPosition + 1;
-    }
-    top() {
-        return this.stack[this.stackHeadPosition];
-    }
-    pushArrayState(size) {
-        const state = this.getUninitializedStateFromPool();
-        state.type = STATE_ARRAY;
-        state.position = 0;
-        state.size = size;
-        state.array = new Array(size);
-    }
-    pushMapState(size) {
-        const state = this.getUninitializedStateFromPool();
-        state.type = STATE_MAP_KEY;
-        state.readCount = 0;
-        state.size = size;
-        state.map = {};
-    }
-    getUninitializedStateFromPool() {
-        this.stackHeadPosition++;
-        if (this.stackHeadPosition === this.stack.length) {
-            const partialState = {
-                type: undefined,
-                size: 0,
-                array: undefined,
-                position: 0,
-                readCount: 0,
-                map: undefined,
-                key: null,
-            };
-            this.stack.push(partialState);
-        }
-        return this.stack[this.stackHeadPosition];
-    }
-    release(state) {
-        const topStackState = this.stack[this.stackHeadPosition];
-        if (topStackState !== state) {
-            throw new Error("Invalid stack state. Released state is not on top of the stack.");
-        }
-        if (state.type === STATE_ARRAY) {
-            const partialState = state;
-            partialState.size = 0;
-            partialState.array = undefined;
-            partialState.position = 0;
-            partialState.type = undefined;
-        }
-        if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
-            const partialState = state;
-            partialState.size = 0;
-            partialState.map = undefined;
-            partialState.readCount = 0;
-            partialState.type = undefined;
-        }
-        this.stackHeadPosition--;
-    }
-    reset() {
-        this.stack.length = 0;
-        this.stackHeadPosition = -1;
-    }
-}
-const HEAD_BYTE_REQUIRED = -1;
-const EMPTY_VIEW = new DataView(new ArrayBuffer(0));
-const EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
-try {
-    // IE11: The spec says it should throw RangeError,
-    // IE11: but in IE11 it throws TypeError.
-    EMPTY_VIEW.getInt8(0);
-}
-catch (e) {
-    if (!(e instanceof RangeError)) {
-        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
-    }
-}
-const MORE_DATA = new RangeError("Insufficient data");
-const sharedCachedKeyDecoder = new CachedKeyDecoder();
-class Decoder {
-    extensionCodec;
-    context;
-    useBigInt64;
-    rawStrings;
-    maxStrLength;
-    maxBinLength;
-    maxArrayLength;
-    maxMapLength;
-    maxExtLength;
-    keyDecoder;
-    mapKeyConverter;
-    totalPos = 0;
-    pos = 0;
-    view = EMPTY_VIEW;
-    bytes = EMPTY_BYTES;
-    headByte = HEAD_BYTE_REQUIRED;
-    stack = new StackPool();
-    entered = false;
-    constructor(options) {
-        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
-        this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
-        this.useBigInt64 = options?.useBigInt64 ?? false;
-        this.rawStrings = options?.rawStrings ?? false;
-        this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
-        this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
-        this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
-        this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
-        this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
-        this.keyDecoder = options?.keyDecoder !== undefined ? options.keyDecoder : sharedCachedKeyDecoder;
-        this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
-    }
-    clone() {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return new Decoder({
-            extensionCodec: this.extensionCodec,
-            context: this.context,
-            useBigInt64: this.useBigInt64,
-            rawStrings: this.rawStrings,
-            maxStrLength: this.maxStrLength,
-            maxBinLength: this.maxBinLength,
-            maxArrayLength: this.maxArrayLength,
-            maxMapLength: this.maxMapLength,
-            maxExtLength: this.maxExtLength,
-            keyDecoder: this.keyDecoder,
-        });
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            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;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-    reinitializeState() {
+};
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    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);
+    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); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); };
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    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); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var isValidMapKeyType = function (key) {
+    var keyType = typeof key;
+    return keyType === "string" || keyType === "number";
+};
+var HEAD_BYTE_REQUIRED = -1;
+var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+// IE11: Hack to support IE11.
+// IE11: Drop this hack and just use RangeError when IE11 is obsolete.
+var DataViewIndexOutOfBoundsError = (function () {
+    try {
+        // IE11: The spec says it should throw RangeError,
+        // IE11: but in IE11 it throws TypeError.
+        EMPTY_VIEW.getInt8(0);
+    }
+    catch (e) {
+        return e.constructor;
+    }
+    throw new Error("never reached");
+})();
+var MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
+var sharedCachedKeyDecoder = new CachedKeyDecoder();
+var Decoder = /** @class */ (function () {
+    function Decoder(extensionCodec, context, maxStrLength, maxBinLength, maxArrayLength, maxMapLength, maxExtLength, keyDecoder) {
+        if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }
+        if (context === void 0) { context = undefined; }
+        if (maxStrLength === void 0) { maxStrLength = UINT32_MAX; }
+        if (maxBinLength === void 0) { maxBinLength = UINT32_MAX; }
+        if (maxArrayLength === void 0) { maxArrayLength = UINT32_MAX; }
+        if (maxMapLength === void 0) { maxMapLength = UINT32_MAX; }
+        if (maxExtLength === void 0) { maxExtLength = UINT32_MAX; }
+        if (keyDecoder === void 0) { keyDecoder = sharedCachedKeyDecoder; }
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxStrLength = maxStrLength;
+        this.maxBinLength = maxBinLength;
+        this.maxArrayLength = maxArrayLength;
+        this.maxMapLength = maxMapLength;
+        this.maxExtLength = maxExtLength;
+        this.keyDecoder = keyDecoder;
         this.totalPos = 0;
+        this.pos = 0;
+        this.view = EMPTY_VIEW;
+        this.bytes = EMPTY_BYTES;
         this.headByte = HEAD_BYTE_REQUIRED;
-        this.stack.reset();
-        // view, bytes, and pos will be re-initialized in setBuffer()
+        this.stack = [];
     }
-    setBuffer(buffer) {
-        const bytes = ensureUint8Array(buffer);
-        this.bytes = bytes;
-        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    Decoder.prototype.reinitializeState = function () {
+        this.totalPos = 0;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack.length = 0;
+        // view, bytes, and pos will be re-initialized in setBuffer()
+    };
+    Decoder.prototype.setBuffer = function (buffer) {
+        this.bytes = ensureUint8Array(buffer);
+        this.view = createDataView(this.bytes);
         this.pos = 0;
-    }
-    appendBuffer(buffer) {
+    };
+    Decoder.prototype.appendBuffer = function (buffer) {
         if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
             this.setBuffer(buffer);
         }
         else {
-            const remainingData = this.bytes.subarray(this.pos);
-            const newData = ensureUint8Array(buffer);
+            var remainingData = this.bytes.subarray(this.pos);
+            var newData = ensureUint8Array(buffer);
             // concat remainingData + newData
-            const newBuffer = new Uint8Array(remainingData.length + newData.length);
+            var newBuffer = new Uint8Array(remainingData.length + newData.length);
             newBuffer.set(remainingData);
             newBuffer.set(newData, remainingData.length);
             this.setBuffer(newBuffer);
         }
-    }
-    hasRemaining(size) {
+    };
+    Decoder.prototype.hasRemaining = function (size) {
         return this.view.byteLength - this.pos >= size;
-    }
-    createExtraByteError(posToShow) {
-        const { view, pos } = this;
-        return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
-    }
+    };
+    Decoder.prototype.createExtraByteError = function (posToShow) {
+        var _a = this, view = _a.view, pos = _a.pos;
+        return new RangeError("Extra ".concat(view.byteLength - pos, " of ").concat(view.byteLength, " byte(s) found at buffer[").concat(posToShow, "]"));
+    };
     /**
      * @throws {@link DecodeError}
      * @throws {@link RangeError}
      */
-    decode(buffer) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.decode(buffer);
+    Decoder.prototype.decode = function (buffer) {
+        this.reinitializeState();
+        this.setBuffer(buffer);
+        var object = this.doDecodeSync();
+        if (this.hasRemaining(1)) {
+            throw this.createExtraByteError(this.pos);
         }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.setBuffer(buffer);
-            const object = this.doDecodeSync();
-            if (this.hasRemaining(1)) {
-                throw this.createExtraByteError(this.pos);
-            }
-            return object;
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    *decodeMulti(buffer) {
-        if (this.entered) {
-            const instance = this.clone();
-            yield* instance.decodeMulti(buffer);
-            return;
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.setBuffer(buffer);
-            while (this.hasRemaining(1)) {
-                yield this.doDecodeSync();
-            }
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    async decodeAsync(stream) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.decodeAsync(stream);
-        }
-        try {
-            this.entered = true;
-            let decoded = false;
-            let object;
-            for await (const buffer of stream) {
-                if (decoded) {
-                    this.entered = false;
-                    throw this.createExtraByteError(this.totalPos);
-                }
-                this.appendBuffer(buffer);
-                try {
-                    object = this.doDecodeSync();
-                    decoded = true;
-                }
-                catch (e) {
-                    if (!(e instanceof RangeError)) {
-                        throw e; // rethrow
-                    }
-                    // fallthrough
-                }
-                this.totalPos += this.pos;
+        return object;
+    };
+    Decoder.prototype.decodeMulti = function (buffer) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    this.reinitializeState();
+                    this.setBuffer(buffer);
+                    _a.label = 1;
+                case 1:
+                    if (!this.hasRemaining(1)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, this.doDecodeSync()];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
             }
-            if (decoded) {
-                if (this.hasRemaining(1)) {
-                    throw this.createExtraByteError(this.totalPos);
+        });
+    };
+    Decoder.prototype.decodeAsync = function (stream) {
+        var stream_1, stream_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var decoded, object, buffer, e_1_1, _b, headByte, pos, totalPos;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        decoded = false;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, 7, 12]);
+                        stream_1 = __asyncValues(stream);
+                        _c.label = 2;
+                    case 2: return [4 /*yield*/, stream_1.next()];
+                    case 3:
+                        if (!(stream_1_1 = _c.sent(), !stream_1_1.done)) return [3 /*break*/, 5];
+                        buffer = stream_1_1.value;
+                        if (decoded) {
+                            throw this.createExtraByteError(this.totalPos);
+                        }
+                        this.appendBuffer(buffer);
+                        try {
+                            object = this.doDecodeSync();
+                            decoded = true;
+                        }
+                        catch (e) {
+                            if (!(e instanceof DataViewIndexOutOfBoundsError)) {
+                                throw e; // rethrow
+                            }
+                            // fallthrough
+                        }
+                        this.totalPos += this.pos;
+                        _c.label = 4;
+                    case 4: return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _c.trys.push([7, , 10, 11]);
+                        if (!(stream_1_1 && !stream_1_1.done && (_a = stream_1.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _a.call(stream_1)];
+                    case 8:
+                        _c.sent();
+                        _c.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12:
+                        if (decoded) {
+                            if (this.hasRemaining(1)) {
+                                throw this.createExtraByteError(this.totalPos);
+                            }
+                            return [2 /*return*/, object];
+                        }
+                        _b = this, headByte = _b.headByte, pos = _b.pos, totalPos = _b.totalPos;
+                        throw new RangeError("Insufficient data in parsing ".concat(prettyByte(headByte), " at ").concat(totalPos, " (").concat(pos, " in the current buffer)"));
                 }
-                return object;
-            }
-            const { headByte, pos, totalPos } = this;
-            throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    decodeArrayStream(stream) {
+            });
+        });
+    };
+    Decoder.prototype.decodeArrayStream = function (stream) {
         return this.decodeMultiAsync(stream, true);
-    }
-    decodeStream(stream) {
+    };
+    Decoder.prototype.decodeStream = function (stream) {
         return this.decodeMultiAsync(stream, false);
-    }
-    async *decodeMultiAsync(stream, isArray) {
-        if (this.entered) {
-            const instance = this.clone();
-            yield* instance.decodeMultiAsync(stream, isArray);
-            return;
-        }
-        try {
-            this.entered = true;
-            let isArrayHeaderRequired = isArray;
-            let arrayItemsLeft = -1;
-            for await (const buffer of stream) {
-                if (isArray && arrayItemsLeft === 0) {
-                    throw this.createExtraByteError(this.totalPos);
-                }
-                this.appendBuffer(buffer);
-                if (isArrayHeaderRequired) {
-                    arrayItemsLeft = this.readArraySize();
-                    isArrayHeaderRequired = false;
-                    this.complete();
-                }
-                try {
-                    while (true) {
-                        yield this.doDecodeSync();
+    };
+    Decoder.prototype.decodeMultiAsync = function (stream, isArray) {
+        return __asyncGenerator(this, arguments, function decodeMultiAsync_1() {
+            var isArrayHeaderRequired, arrayItemsLeft, stream_2, stream_2_1, buffer, e_2, e_3_1;
+            var e_3, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        isArrayHeaderRequired = isArray;
+                        arrayItemsLeft = -1;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 13, 14, 19]);
+                        stream_2 = __asyncValues(stream);
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, __await(stream_2.next())];
+                    case 3:
+                        if (!(stream_2_1 = _b.sent(), !stream_2_1.done)) return [3 /*break*/, 12];
+                        buffer = stream_2_1.value;
+                        if (isArray && arrayItemsLeft === 0) {
+                            throw this.createExtraByteError(this.totalPos);
+                        }
+                        this.appendBuffer(buffer);
+                        if (isArrayHeaderRequired) {
+                            arrayItemsLeft = this.readArraySize();
+                            isArrayHeaderRequired = false;
+                            this.complete();
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, , 10]);
+                        _b.label = 5;
+                    case 5:
+                        return [4 /*yield*/, __await(this.doDecodeSync())];
+                    case 6: return [4 /*yield*/, _b.sent()];
+                    case 7:
+                        _b.sent();
                         if (--arrayItemsLeft === 0) {
-                            break;
+                            return [3 /*break*/, 8];
                         }
-                    }
-                }
-                catch (e) {
-                    if (!(e instanceof RangeError)) {
-                        throw e; // rethrow
-                    }
-                    // fallthrough
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        e_2 = _b.sent();
+                        if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
+                            throw e_2; // rethrow
+                        }
+                        return [3 /*break*/, 10];
+                    case 10:
+                        this.totalPos += this.pos;
+                        _b.label = 11;
+                    case 11: return [3 /*break*/, 2];
+                    case 12: return [3 /*break*/, 19];
+                    case 13:
+                        e_3_1 = _b.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 19];
+                    case 14:
+                        _b.trys.push([14, , 17, 18]);
+                        if (!(stream_2_1 && !stream_2_1.done && (_a = stream_2.return))) return [3 /*break*/, 16];
+                        return [4 /*yield*/, __await(_a.call(stream_2))];
+                    case 15:
+                        _b.sent();
+                        _b.label = 16;
+                    case 16: return [3 /*break*/, 18];
+                    case 17:
+                        if (e_3) throw e_3.error;
+                        return [7 /*endfinally*/];
+                    case 18: return [7 /*endfinally*/];
+                    case 19: return [2 /*return*/];
                 }
-                this.totalPos += this.pos;
-            }
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    doDecodeSync() {
+            });
+        });
+    };
+    Decoder.prototype.doDecodeSync = function () {
         DECODE: while (true) {
-            const headByte = this.readHeadByte();
-            let object;
+            var headByte = this.readHeadByte();
+            var object = void 0;
             if (headByte >= 0xe0) {
                 // negative fixint (111x xxxx) 0xe0 - 0xff
                 object = headByte - 0x100;
@@ -1739,7 +1775,7 @@ class Decoder {
                 }
                 else if (headByte < 0x90) {
                     // fixmap (1000 xxxx) 0x80 - 0x8f
-                    const size = headByte - 0x80;
+                    var size = headByte - 0x80;
                     if (size !== 0) {
                         this.pushMapState(size);
                         this.complete();
@@ -1751,7 +1787,7 @@ class Decoder {
                 }
                 else if (headByte < 0xa0) {
                     // fixarray (1001 xxxx) 0x90 - 0x9f
-                    const size = headByte - 0x90;
+                    var size = headByte - 0x90;
                     if (size !== 0) {
                         this.pushArrayState(size);
                         this.complete();
@@ -1763,8 +1799,8 @@ class Decoder {
                 }
                 else {
                     // fixstr (101x xxxx) 0xa0 - 0xbf
-                    const byteLength = headByte - 0xa0;
-                    object = this.decodeString(byteLength, 0);
+                    var byteLength = headByte - 0xa0;
+                    object = this.decodeUtf8String(byteLength, 0);
                 }
             }
             else if (headByte === 0xc0) {
@@ -1801,12 +1837,7 @@ class Decoder {
             }
             else if (headByte === 0xcf) {
                 // uint 64
-                if (this.useBigInt64) {
-                    object = this.readU64AsBigInt();
-                }
-                else {
-                    object = this.readU64();
-                }
+                object = this.readU64();
             }
             else if (headByte === 0xd0) {
                 // int 8
@@ -1822,31 +1853,26 @@ class Decoder {
             }
             else if (headByte === 0xd3) {
                 // int 64
-                if (this.useBigInt64) {
-                    object = this.readI64AsBigInt();
-                }
-                else {
-                    object = this.readI64();
-                }
+                object = this.readI64();
             }
             else if (headByte === 0xd9) {
                 // str 8
-                const byteLength = this.lookU8();
-                object = this.decodeString(byteLength, 1);
+                var byteLength = this.lookU8();
+                object = this.decodeUtf8String(byteLength, 1);
             }
             else if (headByte === 0xda) {
                 // str 16
-                const byteLength = this.lookU16();
-                object = this.decodeString(byteLength, 2);
+                var byteLength = this.lookU16();
+                object = this.decodeUtf8String(byteLength, 2);
             }
             else if (headByte === 0xdb) {
                 // str 32
-                const byteLength = this.lookU32();
-                object = this.decodeString(byteLength, 4);
+                var byteLength = this.lookU32();
+                object = this.decodeUtf8String(byteLength, 4);
             }
             else if (headByte === 0xdc) {
                 // array 16
-                const size = this.readU16();
+                var size = this.readU16();
                 if (size !== 0) {
                     this.pushArrayState(size);
                     this.complete();
@@ -1858,7 +1884,7 @@ class Decoder {
             }
             else if (headByte === 0xdd) {
                 // array 32
-                const size = this.readU32();
+                var size = this.readU32();
                 if (size !== 0) {
                     this.pushArrayState(size);
                     this.complete();
@@ -1870,7 +1896,7 @@ class Decoder {
             }
             else if (headByte === 0xde) {
                 // map 16
-                const size = this.readU16();
+                var size = this.readU16();
                 if (size !== 0) {
                     this.pushMapState(size);
                     this.complete();
@@ -1882,7 +1908,7 @@ class Decoder {
             }
             else if (headByte === 0xdf) {
                 // map 32
-                const size = this.readU32();
+                var size = this.readU32();
                 if (size !== 0) {
                     this.pushMapState(size);
                     this.complete();
@@ -1894,17 +1920,17 @@ class Decoder {
             }
             else if (headByte === 0xc4) {
                 // bin 8
-                const size = this.lookU8();
+                var size = this.lookU8();
                 object = this.decodeBinary(size, 1);
             }
             else if (headByte === 0xc5) {
                 // bin 16
-                const size = this.lookU16();
+                var size = this.lookU16();
                 object = this.decodeBinary(size, 2);
             }
             else if (headByte === 0xc6) {
                 // bin 32
-                const size = this.lookU32();
+                var size = this.lookU32();
                 object = this.decodeBinary(size, 4);
             }
             else if (headByte === 0xd4) {
@@ -1929,44 +1955,47 @@ class Decoder {
             }
             else if (headByte === 0xc7) {
                 // ext 8
-                const size = this.lookU8();
+                var size = this.lookU8();
                 object = this.decodeExtension(size, 1);
             }
             else if (headByte === 0xc8) {
                 // ext 16
-                const size = this.lookU16();
+                var size = this.lookU16();
                 object = this.decodeExtension(size, 2);
             }
             else if (headByte === 0xc9) {
                 // ext 32
-                const size = this.lookU32();
+                var size = this.lookU32();
                 object = this.decodeExtension(size, 4);
             }
             else {
-                throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+                throw new DecodeError("Unrecognized type byte: ".concat(prettyByte(headByte)));
             }
             this.complete();
-            const stack = this.stack;
+            var stack = this.stack;
             while (stack.length > 0) {
                 // arrays and maps
-                const state = stack.top();
-                if (state.type === STATE_ARRAY) {
+                var state = stack[stack.length - 1];
+                if (state.type === 0 /* State.ARRAY */) {
                     state.array[state.position] = object;
                     state.position++;
                     if (state.position === state.size) {
+                        stack.pop();
                         object = state.array;
-                        stack.release(state);
                     }
                     else {
                         continue DECODE;
                     }
                 }
-                else if (state.type === STATE_MAP_KEY) {
+                else if (state.type === 1 /* State.MAP_KEY */) {
+                    if (!isValidMapKeyType(object)) {
+                        throw new DecodeError("The type of key must be string or number but " + typeof object);
+                    }
                     if (object === "__proto__") {
                         throw new DecodeError("The key __proto__ is not allowed");
                     }
-                    state.key = this.mapKeyConverter(object);
-                    state.type = STATE_MAP_VALUE;
+                    state.key = object;
+                    state.type = 2 /* State.MAP_VALUE */;
                     continue DECODE;
                 }
                 else {
@@ -1974,31 +2003,31 @@ class Decoder {
                     state.map[state.key] = object;
                     state.readCount++;
                     if (state.readCount === state.size) {
+                        stack.pop();
                         object = state.map;
-                        stack.release(state);
                     }
                     else {
                         state.key = null;
-                        state.type = STATE_MAP_KEY;
+                        state.type = 1 /* State.MAP_KEY */;
                         continue DECODE;
                     }
                 }
             }
             return object;
         }
-    }
-    readHeadByte() {
+    };
+    Decoder.prototype.readHeadByte = function () {
         if (this.headByte === HEAD_BYTE_REQUIRED) {
             this.headByte = this.readU8();
             // console.log("headByte", prettyByte(this.headByte));
         }
         return this.headByte;
-    }
-    complete() {
+    };
+    Decoder.prototype.complete = function () {
         this.headByte = HEAD_BYTE_REQUIRED;
-    }
-    readArraySize() {
-        const headByte = this.readHeadByte();
+    };
+    Decoder.prototype.readArraySize = function () {
+        var headByte = this.readHeadByte();
         switch (headByte) {
             case 0xdc:
                 return this.readU16();
@@ -2009,162 +2038,158 @@ class Decoder {
                     return headByte - 0x90;
                 }
                 else {
-                    throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+                    throw new DecodeError("Unrecognized array type byte: ".concat(prettyByte(headByte)));
                 }
             }
         }
-    }
-    pushMapState(size) {
+    };
+    Decoder.prototype.pushMapState = function (size) {
         if (size > this.maxMapLength) {
-            throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
-        }
-        this.stack.pushMapState(size);
-    }
-    pushArrayState(size) {
+            throw new DecodeError("Max length exceeded: map length (".concat(size, ") > maxMapLengthLength (").concat(this.maxMapLength, ")"));
+        }
+        this.stack.push({
+            type: 1 /* State.MAP_KEY */,
+            size: size,
+            key: null,
+            readCount: 0,
+            map: {},
+        });
+    };
+    Decoder.prototype.pushArrayState = function (size) {
         if (size > this.maxArrayLength) {
-            throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+            throw new DecodeError("Max length exceeded: array length (".concat(size, ") > maxArrayLength (").concat(this.maxArrayLength, ")"));
         }
-        this.stack.pushArrayState(size);
-    }
-    decodeString(byteLength, headerOffset) {
-        if (!this.rawStrings || this.stateIsMapKey()) {
-            return this.decodeUtf8String(byteLength, headerOffset);
-        }
-        return this.decodeBinary(byteLength, headerOffset);
-    }
-    /**
-     * @throws {@link RangeError}
-     */
-    decodeUtf8String(byteLength, headerOffset) {
+        this.stack.push({
+            type: 0 /* State.ARRAY */,
+            size: size,
+            array: new Array(size),
+            position: 0,
+        });
+    };
+    Decoder.prototype.decodeUtf8String = function (byteLength, headerOffset) {
+        var _a;
         if (byteLength > this.maxStrLength) {
-            throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+            throw new DecodeError("Max length exceeded: UTF-8 byte length (".concat(byteLength, ") > maxStrLength (").concat(this.maxStrLength, ")"));
         }
         if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
             throw MORE_DATA;
         }
-        const offset = this.pos + headerOffset;
-        let object;
-        if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+        var offset = this.pos + headerOffset;
+        var object;
+        if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) {
             object = this.keyDecoder.decode(this.bytes, offset, byteLength);
         }
+        else if (byteLength > TEXT_DECODER_THRESHOLD) {
+            object = utf8DecodeTD(this.bytes, offset, byteLength);
+        }
         else {
-            object = utf8Decode(this.bytes, offset, byteLength);
+            object = utf8DecodeJs(this.bytes, offset, byteLength);
         }
         this.pos += headerOffset + byteLength;
         return object;
-    }
-    stateIsMapKey() {
+    };
+    Decoder.prototype.stateIsMapKey = function () {
         if (this.stack.length > 0) {
-            const state = this.stack.top();
-            return state.type === STATE_MAP_KEY;
+            var state = this.stack[this.stack.length - 1];
+            return state.type === 1 /* State.MAP_KEY */;
         }
         return false;
-    }
-    /**
-     * @throws {@link RangeError}
-     */
-    decodeBinary(byteLength, headOffset) {
+    };
+    Decoder.prototype.decodeBinary = function (byteLength, headOffset) {
         if (byteLength > this.maxBinLength) {
-            throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+            throw new DecodeError("Max length exceeded: bin length (".concat(byteLength, ") > maxBinLength (").concat(this.maxBinLength, ")"));
         }
         if (!this.hasRemaining(byteLength + headOffset)) {
             throw MORE_DATA;
         }
-        const offset = this.pos + headOffset;
-        const object = this.bytes.subarray(offset, offset + byteLength);
+        var offset = this.pos + headOffset;
+        var object = this.bytes.subarray(offset, offset + byteLength);
         this.pos += headOffset + byteLength;
         return object;
-    }
-    decodeExtension(size, headOffset) {
+    };
+    Decoder.prototype.decodeExtension = function (size, headOffset) {
         if (size > this.maxExtLength) {
-            throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+            throw new DecodeError("Max length exceeded: ext length (".concat(size, ") > maxExtLength (").concat(this.maxExtLength, ")"));
         }
-        const extType = this.view.getInt8(this.pos + headOffset);
-        const data = this.decodeBinary(size, headOffset + 1 /* extType */);
+        var extType = this.view.getInt8(this.pos + headOffset);
+        var data = this.decodeBinary(size, headOffset + 1 /* extType */);
         return this.extensionCodec.decode(data, extType, this.context);
-    }
-    lookU8() {
+    };
+    Decoder.prototype.lookU8 = function () {
         return this.view.getUint8(this.pos);
-    }
-    lookU16() {
+    };
+    Decoder.prototype.lookU16 = function () {
         return this.view.getUint16(this.pos);
-    }
-    lookU32() {
+    };
+    Decoder.prototype.lookU32 = function () {
         return this.view.getUint32(this.pos);
-    }
-    readU8() {
-        const value = this.view.getUint8(this.pos);
+    };
+    Decoder.prototype.readU8 = function () {
+        var value = this.view.getUint8(this.pos);
         this.pos++;
         return value;
-    }
-    readI8() {
-        const value = this.view.getInt8(this.pos);
+    };
+    Decoder.prototype.readI8 = function () {
+        var value = this.view.getInt8(this.pos);
         this.pos++;
         return value;
-    }
-    readU16() {
-        const value = this.view.getUint16(this.pos);
+    };
+    Decoder.prototype.readU16 = function () {
+        var value = this.view.getUint16(this.pos);
         this.pos += 2;
         return value;
-    }
-    readI16() {
-        const value = this.view.getInt16(this.pos);
+    };
+    Decoder.prototype.readI16 = function () {
+        var value = this.view.getInt16(this.pos);
         this.pos += 2;
         return value;
-    }
-    readU32() {
-        const value = this.view.getUint32(this.pos);
+    };
+    Decoder.prototype.readU32 = function () {
+        var value = this.view.getUint32(this.pos);
         this.pos += 4;
         return value;
-    }
-    readI32() {
-        const value = this.view.getInt32(this.pos);
+    };
+    Decoder.prototype.readI32 = function () {
+        var value = this.view.getInt32(this.pos);
         this.pos += 4;
         return value;
-    }
-    readU64() {
-        const value = getUint64(this.view, this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readI64() {
-        const value = getInt64(this.view, this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readU64AsBigInt() {
-        const value = this.view.getBigUint64(this.pos);
+    };
+    Decoder.prototype.readU64 = function () {
+        var value = getUint64(this.view, this.pos);
         this.pos += 8;
         return value;
-    }
-    readI64AsBigInt() {
-        const value = this.view.getBigInt64(this.pos);
+    };
+    Decoder.prototype.readI64 = function () {
+        var value = getInt64(this.view, this.pos);
         this.pos += 8;
         return value;
-    }
-    readF32() {
-        const value = this.view.getFloat32(this.pos);
+    };
+    Decoder.prototype.readF32 = function () {
+        var value = this.view.getFloat32(this.pos);
         this.pos += 4;
         return value;
-    }
-    readF64() {
-        const value = this.view.getFloat64(this.pos);
+    };
+    Decoder.prototype.readF64 = function () {
+        var value = this.view.getFloat64(this.pos);
         this.pos += 8;
         return value;
-    }
-}
+    };
+    return Decoder;
+}());
 
+var defaultDecodeOptions = {};
 /**
  * It decodes a single MessagePack object in a buffer.
  *
  * This is a synchronous decoding function.
- * See other variants for asynchronous decoding: {@link decodeAsync}, {@link decodeMultiStream}, or {@link decodeArrayStream}.
+ * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.
  *
  * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
  * @throws {@link DecodeError} if the buffer contains invalid data.
  */
 function decode(buffer, options) {
-    const decoder = new Decoder(options);
+    if (options === void 0) { options = defaultDecodeOptions; }
+    var decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
     return decoder.decode(buffer);
 }