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

package/dist/devtools/browser-dev-host/main.js

@@ -2884,12 +2884,38 @@ function bridgeError$2(code, message) {
     return { code, message };
 }
 
+// Integer Utility
+var UINT32_MAX = 4294967295;
+// DataView extension to handle int64 / uint64,
+// where the actual range is 53-bits integer (a.k.a. safe integer)
+function setUint64(view, offset, value) {
+    var high = value / 4294967296;
+    var low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+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;
+}
+
+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";
 function utf8Count(str) {
-    const strLength = str.length;
-    let byteLength = 0;
-    let pos = 0;
+    var strLength = str.length;
+    var byteLength = 0;
+    var pos = 0;
     while (pos < strLength) {
-        let value = str.charCodeAt(pos++);
+        var value = str.charCodeAt(pos++);
         if ((value & 0xffffff80) === 0) {
             // 1-byte
             byteLength++;
@@ -2904,7 +2930,7 @@ function utf8Count(str) {
             if (value >= 0xd800 && value <= 0xdbff) {
                 // high surrogate
                 if (pos < strLength) {
-                    const extra = str.charCodeAt(pos);
+                    var extra = str.charCodeAt(pos);
                     if ((extra & 0xfc00) === 0xdc00) {
                         ++pos;
                         value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
@@ -2924,11 +2950,11 @@ function utf8Count(str) {
     return byteLength;
 }
 function utf8EncodeJs(str, output, outputOffset) {
-    const strLength = str.length;
-    let offset = outputOffset;
-    let pos = 0;
+    var strLength = str.length;
+    var offset = outputOffset;
+    var pos = 0;
     while (pos < strLength) {
-        let value = str.charCodeAt(pos++);
+        var value = str.charCodeAt(pos++);
         if ((value & 0xffffff80) === 0) {
             // 1-byte
             output[offset++] = value;
@@ -2943,7 +2969,7 @@ function utf8EncodeJs(str, output, outputOffset) {
             if (value >= 0xd800 && value <= 0xdbff) {
                 // high surrogate
                 if (pos < strLength) {
-                    const extra = str.charCodeAt(pos);
+                    var extra = str.charCodeAt(pos);
                     if ((extra & 0xfc00) === 0xdc00) {
                         ++pos;
                         value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
@@ -2965,56 +2991,48 @@ function utf8EncodeJs(str, output, outputOffset) {
         output[offset++] = (value & 0x3f) | 0x80;
     }
 }
-// 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
-const sharedTextEncoder = new TextEncoder();
-// This threshold should be determined by benchmarking, which might vary in engines and input data.
-// Run `npx ts-node benchmark/encode-string.ts` for details.
-const TEXT_ENCODER_THRESHOLD = 50;
-function utf8EncodeTE(str, output, outputOffset) {
-    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
+var TEXT_ENCODER_THRESHOLD = !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 utf8Encode(str, output, outputOffset) {
-    if (str.length > TEXT_ENCODER_THRESHOLD) {
-        utf8EncodeTE(str, output, outputOffset);
-    }
-    else {
-        utf8EncodeJs(str, output, outputOffset);
-    }
+function utf8EncodeTEencodeInto(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
 }
-const CHUNK_SIZE = 4096;
+var utf8EncodeTE = (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);
@@ -3026,84 +3044,86 @@ 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;
 }
-new TextDecoder();
+TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
+!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;
 
 /**
  * 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
-// DataView extension to handle int64 / uint64,
-// where the actual range is 53-bits integer (a.k.a. safe integer)
-function setUint64(view, offset, value) {
-    const high = value / 4294967296;
-    const low = value; // high bits are truncated by DataView
-    view.setUint32(offset, high);
-    view.setUint32(offset + 4, low);
-}
-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;
-}
+    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
@@ -3113,19 +3133,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,
@@ -3133,7 +3153,7 @@ function encodeDateToTimeSpec(date) {
 }
 function encodeTimestampExtension(object) {
     if (object instanceof Date) {
-        const timeSpec = encodeDateToTimeSpec(object);
+        var timeSpec = encodeDateToTimeSpec(object);
         return encodeTimeSpecToTimestamp(timeSpec);
     }
     else {
@@ -3141,60 +3161,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;
@@ -3202,30 +3218,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);
                 }
             }
@@ -3235,9 +3251,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);
         }
@@ -3245,12 +3261,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;
@@ -3258,7 +3273,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 {
@@ -3267,96 +3282,54 @@ function ensureUint8Array(buffer) {
     }
 }
 
-const DEFAULT_MAX_DEPTH = 100;
-const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
-class Encoder {
-    extensionCodec;
-    context;
-    useBigInt64;
-    maxDepth;
-    initialBufferSize;
-    sortKeys;
-    forceFloat32;
-    ignoreUndefined;
-    forceIntegerToFloat;
-    pos;
-    view;
-    bytes;
-    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.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-        this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
-        this.sortKeys = options?.sortKeys ?? false;
-        this.forceFloat32 = options?.forceFloat32 ?? false;
-        this.ignoreUndefined = options?.ignoreUndefined ?? false;
-        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = /** @class */ (function () {
+    function Encoder(extensionCodec, context, maxDepth, initialBufferSize, sortKeys, forceFloat32, ignoreUndefined, forceIntegerToFloat) {
+        if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }
+        if (context === void 0) { context = undefined; }
+        if (maxDepth === void 0) { maxDepth = DEFAULT_MAX_DEPTH; }
+        if (initialBufferSize === void 0) { initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE; }
+        if (sortKeys === void 0) { sortKeys = false; }
+        if (forceFloat32 === void 0) { forceFloat32 = false; }
+        if (ignoreUndefined === void 0) { ignoreUndefined = false; }
+        if (forceIntegerToFloat === void 0) { forceIntegerToFloat = false; }
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxDepth = maxDepth;
+        this.initialBufferSize = initialBufferSize;
+        this.sortKeys = sortKeys;
+        this.forceFloat32 = forceFloat32;
+        this.ignoreUndefined = ignoreUndefined;
+        this.forceIntegerToFloat = forceIntegerToFloat;
         this.pos = 0;
         this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
         this.bytes = new Uint8Array(this.view.buffer);
     }
-    clone() {
-        // Because of slightly special argument `context`,
-        // type assertion is needed.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return new Encoder({
-            extensionCodec: this.extensionCodec,
-            context: this.context,
-            useBigInt64: this.useBigInt64,
-            maxDepth: this.maxDepth,
-            initialBufferSize: this.initialBufferSize,
-            sortKeys: this.sortKeys,
-            forceFloat32: this.forceFloat32,
-            ignoreUndefined: this.ignoreUndefined,
-            forceIntegerToFloat: this.forceIntegerToFloat,
-        });
-    }
-    reinitializeState() {
+    Encoder.prototype.reinitializeState = function () {
         this.pos = 0;
-    }
+    };
     /**
      * 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}.
      *
      * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
      */
-    encodeSharedRef(object) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.encodeSharedRef(object);
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.doEncode(object, 1);
-            return this.bytes.subarray(0, this.pos);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
+    Encoder.prototype.encodeSharedRef = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.subarray(0, this.pos);
+    };
     /**
      * @returns Encodes the object and returns a copy of the encoder's internal buffer.
      */
-    encode(object) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.encode(object);
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.doEncode(object, 1);
-            return this.bytes.slice(0, this.pos);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    doEncode(object, depth) {
+    Encoder.prototype.encode = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.slice(0, this.pos);
+    };
+    Encoder.prototype.doEncode = function (object, depth) {
         if (depth > this.maxDepth) {
-            throw new Error(`Too deep objects in depth ${depth}`);
+            throw new Error("Too deep objects in depth ".concat(depth));
         }
         if (object == null) {
             this.encodeNil();
@@ -3365,50 +3338,42 @@ class Encoder {
             this.encodeBoolean(object);
         }
         else if (typeof object === "number") {
-            if (!this.forceIntegerToFloat) {
-                this.encodeNumber(object);
-            }
-            else {
-                this.encodeNumberAsFloat(object);
-            }
+            this.encodeNumber(object);
         }
         else if (typeof object === "string") {
             this.encodeString(object);
         }
-        else if (this.useBigInt64 && typeof object === "bigint") {
-            this.encodeBigInt64(object);
-        }
         else {
             this.encodeObject(object, depth);
         }
-    }
-    ensureBufferSizeToWrite(sizeToWrite) {
-        const requiredSize = this.pos + sizeToWrite;
+    };
+    Encoder.prototype.ensureBufferSizeToWrite = function (sizeToWrite) {
+        var requiredSize = this.pos + sizeToWrite;
         if (this.view.byteLength < requiredSize) {
             this.resizeBuffer(requiredSize * 2);
         }
-    }
-    resizeBuffer(newSize) {
-        const newBuffer = new ArrayBuffer(newSize);
-        const newBytes = new Uint8Array(newBuffer);
-        const newView = new DataView(newBuffer);
+    };
+    Encoder.prototype.resizeBuffer = function (newSize) {
+        var newBuffer = new ArrayBuffer(newSize);
+        var newBytes = new Uint8Array(newBuffer);
+        var newView = new DataView(newBuffer);
         newBytes.set(this.bytes);
         this.view = newView;
         this.bytes = newBytes;
-    }
-    encodeNil() {
+    };
+    Encoder.prototype.encodeNil = function () {
         this.writeU8(0xc0);
-    }
-    encodeBoolean(object) {
+    };
+    Encoder.prototype.encodeBoolean = function (object) {
         if (object === false) {
             this.writeU8(0xc2);
         }
         else {
             this.writeU8(0xc3);
         }
-    }
-    encodeNumber(object) {
-        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+    };
+    Encoder.prototype.encodeNumber = function (object) {
+        if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {
             if (object >= 0) {
                 if (object < 0x80) {
                     // positive fixint
@@ -3429,14 +3394,11 @@ class Encoder {
                     this.writeU8(0xce);
                     this.writeU32(object);
                 }
-                else if (!this.useBigInt64) {
+                else {
                     // uint 64
                     this.writeU8(0xcf);
                     this.writeU64(object);
                 }
-                else {
-                    this.encodeNumberAsFloat(object);
-                }
             }
             else {
                 if (object >= -32) {
@@ -3458,45 +3420,28 @@ class Encoder {
                     this.writeU8(0xd2);
                     this.writeI32(object);
                 }
-                else if (!this.useBigInt64) {
+                else {
                     // int 64
                     this.writeU8(0xd3);
                     this.writeI64(object);
                 }
-                else {
-                    this.encodeNumberAsFloat(object);
-                }
             }
         }
         else {
-            this.encodeNumberAsFloat(object);
-        }
-    }
-    encodeNumberAsFloat(object) {
-        if (this.forceFloat32) {
-            // float 32
-            this.writeU8(0xca);
-            this.writeF32(object);
-        }
-        else {
-            // float 64
-            this.writeU8(0xcb);
-            this.writeF64(object);
-        }
-    }
-    encodeBigInt64(object) {
-        if (object >= BigInt(0)) {
-            // uint 64
-            this.writeU8(0xcf);
-            this.writeBigUint64(object);
-        }
-        else {
-            // int 64
-            this.writeU8(0xd3);
-            this.writeBigInt64(object);
+            // non-integer numbers
+            if (this.forceFloat32) {
+                // float 32
+                this.writeU8(0xca);
+                this.writeF32(object);
+            }
+            else {
+                // float 64
+                this.writeU8(0xcb);
+                this.writeF64(object);
+            }
         }
-    }
-    writeStringHeader(byteLength) {
+    };
+    Encoder.prototype.writeStringHeader = function (byteLength) {
         if (byteLength < 32) {
             // fixstr
             this.writeU8(0xa0 + byteLength);
@@ -3517,20 +3462,30 @@ class Encoder {
             this.writeU32(byteLength);
         }
         else {
-            throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+            throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
         }
-    }
-    encodeString(object) {
-        const maxHeaderSize = 1 + 4;
-        const byteLength = utf8Count(object);
-        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-        this.writeStringHeader(byteLength);
-        utf8Encode(object, this.bytes, this.pos);
-        this.pos += byteLength;
-    }
-    encodeObject(object, depth) {
+    };
+    Encoder.prototype.encodeString = function (object) {
+        var maxHeaderSize = 1 + 4;
+        var strLength = object.length;
+        if (strLength > TEXT_ENCODER_THRESHOLD) {
+            var byteLength = utf8Count(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            utf8EncodeTE(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+        else {
+            var byteLength = utf8Count(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            utf8EncodeJs(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+    };
+    Encoder.prototype.encodeObject = function (object, depth) {
         // try to encode objects with custom codec first of non-primitives
-        const ext = this.extensionCodec.tryToEncode(object, this.context);
+        var ext = this.extensionCodec.tryToEncode(object, this.context);
         if (ext != null) {
             this.encodeExtension(ext);
         }
@@ -3545,11 +3500,11 @@ class Encoder {
         }
         else {
             // symbol, function and other special object come here unless extensionCodec handles them.
-            throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+            throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
         }
-    }
-    encodeBinary(object) {
-        const size = object.byteLength;
+    };
+    Encoder.prototype.encodeBinary = function (object) {
+        var size = object.byteLength;
         if (size < 0x100) {
             // bin 8
             this.writeU8(0xc4);
@@ -3566,13 +3521,13 @@ class Encoder {
             this.writeU32(size);
         }
         else {
-            throw new Error(`Too large binary: ${size}`);
+            throw new Error("Too large binary: ".concat(size));
         }
-        const bytes = ensureUint8Array(object);
+        var bytes = ensureUint8Array(object);
         this.writeU8a(bytes);
-    }
-    encodeArray(object, depth) {
-        const size = object.length;
+    };
+    Encoder.prototype.encodeArray = function (object, depth) {
+        var size = object.length;
         if (size < 16) {
             // fixarray
             this.writeU8(0x90 + size);
@@ -3588,27 +3543,29 @@ class Encoder {
             this.writeU32(size);
         }
         else {
-            throw new Error(`Too large array: ${size}`);
+            throw new Error("Too large array: ".concat(size));
         }
-        for (const item of object) {
+        for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
+            var item = object_1[_i];
             this.doEncode(item, depth + 1);
         }
-    }
-    countWithoutUndefined(object, keys) {
-        let count = 0;
-        for (const key of keys) {
+    };
+    Encoder.prototype.countWithoutUndefined = function (object, keys) {
+        var count = 0;
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
             if (object[key] !== undefined) {
                 count++;
             }
         }
         return count;
-    }
-    encodeMap(object, depth) {
-        const keys = Object.keys(object);
+    };
+    Encoder.prototype.encodeMap = function (object, depth) {
+        var keys = Object.keys(object);
         if (this.sortKeys) {
             keys.sort();
         }
-        const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
         if (size < 16) {
             // fixmap
             this.writeU8(0x80 + size);
@@ -3624,30 +3581,19 @@ class Encoder {
             this.writeU32(size);
         }
         else {
-            throw new Error(`Too large map object: ${size}`);
+            throw new Error("Too large map object: ".concat(size));
         }
-        for (const key of keys) {
-            const value = object[key];
+        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
+            var key = keys_2[_i];
+            var value = object[key];
             if (!(this.ignoreUndefined && value === undefined)) {
                 this.encodeString(key);
                 this.doEncode(value, depth + 1);
             }
         }
-    }
-    encodeExtension(ext) {
-        if (typeof ext.data === "function") {
-            const data = ext.data(this.pos + 6);
-            const size = data.length;
-            if (size >= 0x100000000) {
-                throw new Error(`Too large extension object: ${size}`);
-            }
-            this.writeU8(0xc9);
-            this.writeU32(size);
-            this.writeI8(ext.type);
-            this.writeU8a(data);
-            return;
-        }
-        const size = ext.data.length;
+    };
+    Encoder.prototype.encodeExtension = function (ext) {
+        var size = ext.data.length;
         if (size === 1) {
             // fixext 1
             this.writeU8(0xd4);
@@ -3684,79 +3630,71 @@ class Encoder {
             this.writeU32(size);
         }
         else {
-            throw new Error(`Too large extension object: ${size}`);
+            throw new Error("Too large extension object: ".concat(size));
         }
         this.writeI8(ext.type);
         this.writeU8a(ext.data);
-    }
-    writeU8(value) {
+    };
+    Encoder.prototype.writeU8 = function (value) {
         this.ensureBufferSizeToWrite(1);
         this.view.setUint8(this.pos, value);
         this.pos++;
-    }
-    writeU8a(values) {
-        const size = values.length;
+    };
+    Encoder.prototype.writeU8a = function (values) {
+        var size = values.length;
         this.ensureBufferSizeToWrite(size);
         this.bytes.set(values, this.pos);
         this.pos += size;
-    }
-    writeI8(value) {
+    };
+    Encoder.prototype.writeI8 = function (value) {
         this.ensureBufferSizeToWrite(1);
         this.view.setInt8(this.pos, value);
         this.pos++;
-    }
-    writeU16(value) {
+    };
+    Encoder.prototype.writeU16 = function (value) {
         this.ensureBufferSizeToWrite(2);
         this.view.setUint16(this.pos, value);
         this.pos += 2;
-    }
-    writeI16(value) {
+    };
+    Encoder.prototype.writeI16 = function (value) {
         this.ensureBufferSizeToWrite(2);
         this.view.setInt16(this.pos, value);
         this.pos += 2;
-    }
-    writeU32(value) {
+    };
+    Encoder.prototype.writeU32 = function (value) {
         this.ensureBufferSizeToWrite(4);
         this.view.setUint32(this.pos, value);
         this.pos += 4;
-    }
-    writeI32(value) {
+    };
+    Encoder.prototype.writeI32 = function (value) {
         this.ensureBufferSizeToWrite(4);
         this.view.setInt32(this.pos, value);
         this.pos += 4;
-    }
-    writeF32(value) {
+    };
+    Encoder.prototype.writeF32 = function (value) {
         this.ensureBufferSizeToWrite(4);
         this.view.setFloat32(this.pos, value);
         this.pos += 4;
-    }
-    writeF64(value) {
+    };
+    Encoder.prototype.writeF64 = function (value) {
         this.ensureBufferSizeToWrite(8);
         this.view.setFloat64(this.pos, value);
         this.pos += 8;
-    }
-    writeU64(value) {
+    };
+    Encoder.prototype.writeU64 = function (value) {
         this.ensureBufferSizeToWrite(8);
         setUint64(this.view, this.pos, value);
         this.pos += 8;
-    }
-    writeI64(value) {
+    };
+    Encoder.prototype.writeI64 = function (value) {
         this.ensureBufferSizeToWrite(8);
         setInt64(this.view, this.pos, value);
         this.pos += 8;
-    }
-    writeBigUint64(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigUint64(this.pos, value);
-        this.pos += 8;
-    }
-    writeBigInt64(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigInt64(this.pos, value);
-        this.pos += 8;
-    }
-}
+    };
+    return Encoder;
+}());
 
+var defaultEncodeOptions = {};
 /**
  * It encodes `value` in the MessagePack format and
  * returns a byte buffer.
@@ -3764,36 +3702,37 @@ class Encoder {
  * 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`.
  */
 function encode(value, options) {
-    const encoder = new Encoder(options);
+    if (options === void 0) { options = defaultEncodeOptions; }
+    var encoder = new Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat);
     return encoder.encodeSharedRef(value);
 }
 
-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;
                 }
@@ -3801,10 +3740,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.
@@ -3813,36 +3752,174 @@ 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;
+}());
+
+(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());
+    });
+};
+(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 };
     }
-}
-
-const EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+};
+(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$1 = (undefined && undefined.__await) || function (v) { return this instanceof __await$1 ? (this.v = v, this) : new __await$1(v); };
+(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$1 ? 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 EMPTY_VIEW = new DataView(new ArrayBuffer(0));
 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");
+// 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");
+})();
+new DataViewIndexOutOfBoundsError("Insufficient data");
 new CachedKeyDecoder();
 
+// utility for whatwg streams
+(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 };
+    }
+};
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); };
+(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]); }
+};
+
+(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());
+    });
+};
+(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 };
+    }
+};
+
 function encodeMiniProgramShareExtra(value) {
     assertExtraValue(value);
     const bytes = encode(value);