@onekeyfe/hd-web-sdk 0.2.10 → 0.2.12

package/build/onekey-js-sdk.js

@@ -7482,6 +7482,11 @@ const inject = ({
       connectId,
       deviceId,
       method: 'cardanoSignTransaction'
+    })),
+    cardanoSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'cardanoSignMessage'
     }))
   };
   return api;
@@ -9979,6 +9984,12 @@ var nested = {
       POLICY_ID: 2
     }
   },
+  CardanoTxOutputSerializationFormat: {
+    values: {
+      ARRAY_LEGACY: 0,
+      MAP_BABBAGE: 1
+    }
+  },
   CardanoCertificateType: {
     values: {
       STAKE_REGISTRATION: 0,
@@ -9997,14 +10008,21 @@ var nested = {
   CardanoTxAuxiliaryDataSupplementType: {
     values: {
       NONE: 0,
-      CATALYST_REGISTRATION_SIGNATURE: 1
+      GOVERNANCE_REGISTRATION_SIGNATURE: 1
+    }
+  },
+  CardanoGovernanceRegistrationFormat: {
+    values: {
+      CIP15: 0,
+      CIP36: 1
     }
   },
   CardanoTxSigningMode: {
     values: {
       ORDINARY_TRANSACTION: 0,
       POOL_REGISTRATION_AS_OWNER: 1,
-      MULTISIG_TRANSACTION: 2
+      MULTISIG_TRANSACTION: 2,
+      PLUTUS_TRANSACTION: 3
     }
   },
   CardanoTxWitnessType: {
@@ -10358,6 +10376,31 @@ var nested = {
         rule: "required",
         type: "uint32",
         id: 4
+      },
+      datum_hash: {
+        type: "bytes",
+        id: 5
+      },
+      format: {
+        type: "CardanoTxOutputSerializationFormat",
+        id: 6,
+        options: {
+          "default": "ARRAY_LEGACY"
+        }
+      },
+      inline_datum_size: {
+        type: "uint32",
+        id: 7,
+        options: {
+          "default": 0
+        }
+      },
+      reference_script_size: {
+        type: "uint32",
+        id: 8,
+        options: {
+          "default": 0
+        }
       }
     }
   },
@@ -10392,6 +10435,24 @@ var nested = {
       }
     }
   },
+  CardanoTxInlineDatumChunk: {
+    fields: {
+      data: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      }
+    }
+  },
+  CardanoTxReferenceScriptChunk: {
+    fields: {
+      data: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      }
+    }
+  },
   CardanoPoolOwner: {
     fields: {
       staking_key_path: {
@@ -10484,22 +10545,6 @@ var nested = {
         type: "string",
         id: 7
       },
-      owners: {
-        rule: "repeated",
-        type: "CardanoPoolOwner",
-        id: 8,
-        options: {
-          deprecated: true
-        }
-      },
-      relays: {
-        rule: "repeated",
-        type: "CardanoPoolRelayParameters",
-        id: 9,
-        options: {
-          deprecated: true
-        }
-      },
       metadata: {
         type: "CardanoPoolMetadataType",
         id: 10
@@ -10542,6 +10587,10 @@ var nested = {
       script_hash: {
         type: "bytes",
         id: 5
+      },
+      key_hash: {
+        type: "bytes",
+        id: 6
       }
     }
   },
@@ -10563,16 +10612,33 @@ var nested = {
       script_hash: {
         type: "bytes",
         id: 3
+      },
+      key_hash: {
+        type: "bytes",
+        id: 4
       }
     }
   },
-  CardanoCatalystRegistrationParametersType: {
+  CardanoGovernanceRegistrationDelegation: {
     fields: {
       voting_public_key: {
         rule: "required",
         type: "bytes",
         id: 1
       },
+      weight: {
+        rule: "required",
+        type: "uint32",
+        id: 2
+      }
+    }
+  },
+  CardanoGovernanceRegistrationParametersType: {
+    fields: {
+      voting_public_key: {
+        type: "bytes",
+        id: 1
+      },
       staking_path: {
         rule: "repeated",
         type: "uint32",
@@ -10590,13 +10656,29 @@ var nested = {
         rule: "required",
         type: "uint64",
         id: 4
+      },
+      format: {
+        type: "CardanoGovernanceRegistrationFormat",
+        id: 5,
+        options: {
+          "default": "CIP15"
+        }
+      },
+      delegations: {
+        rule: "repeated",
+        type: "CardanoGovernanceRegistrationDelegation",
+        id: 6
+      },
+      voting_purpose: {
+        type: "uint64",
+        id: 7
       }
     }
   },
   CardanoTxAuxiliaryData: {
     fields: {
-      catalyst_registration_parameters: {
-        type: "CardanoCatalystRegistrationParametersType",
+      governance_registration_parameters: {
+        type: "CardanoGovernanceRegistrationParametersType",
         id: 1
       },
       hash: {
@@ -10614,6 +10696,50 @@ var nested = {
       }
     }
   },
+  CardanoTxCollateralInput: {
+    fields: {
+      prev_hash: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      },
+      prev_index: {
+        rule: "required",
+        type: "uint32",
+        id: 2
+      }
+    }
+  },
+  CardanoTxRequiredSigner: {
+    fields: {
+      key_hash: {
+        type: "bytes",
+        id: 1
+      },
+      key_path: {
+        rule: "repeated",
+        type: "uint32",
+        id: 2,
+        options: {
+          packed: false
+        }
+      }
+    }
+  },
+  CardanoTxReferenceInput: {
+    fields: {
+      prev_hash: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      },
+      prev_index: {
+        rule: "required",
+        type: "uint32",
+        id: 2
+      }
+    }
+  },
   CardanoTxItemAck: {
     fields: {}
   },
@@ -10628,7 +10754,7 @@ var nested = {
         type: "bytes",
         id: 2
       },
-      catalyst_signature: {
+      governance_signature: {
         type: "bytes",
         id: 3
       }
@@ -10684,258 +10810,42 @@ var nested = {
   CardanoSignTxFinished: {
     fields: {}
   },
-  CardanoSignTx: {
-    options: {
-      deprecated: true
-    },
+  CardanoSignMessage: {
     fields: {
-      inputs: {
-        rule: "repeated",
-        type: "CardanoTxInputType",
-        id: 1
-      },
-      outputs: {
+      address_n: {
         rule: "repeated",
-        type: "CardanoTxOutputType",
-        id: 2
-      },
-      protocol_magic: {
-        rule: "required",
         type: "uint32",
-        id: 5
+        id: 1,
+        options: {
+          packed: false
+        }
       },
-      fee: {
+      message: {
         rule: "required",
-        type: "uint64",
-        id: 6
+        type: "bytes",
+        id: 2
       },
-      ttl: {
-        type: "uint64",
-        id: 7
+      derivation_type: {
+        rule: "required",
+        type: "CardanoDerivationType",
+        id: 3
       },
       network_id: {
         rule: "required",
         type: "uint32",
-        id: 8
-      },
-      certificates: {
-        rule: "repeated",
-        type: "CardanoTxCertificateType",
-        id: 9
-      },
-      withdrawals: {
-        rule: "repeated",
-        type: "CardanoTxWithdrawalType",
-        id: 10
-      },
-      validity_interval_start: {
-        type: "uint64",
-        id: 12
-      },
-      auxiliary_data: {
-        type: "CardanoTxAuxiliaryDataType",
-        id: 13
-      }
-    },
-    nested: {
-      CardanoTxInputType: {
-        fields: {
-          address_n: {
-            rule: "repeated",
-            type: "uint32",
-            id: 1,
-            options: {
-              packed: false
-            }
-          },
-          prev_hash: {
-            rule: "required",
-            type: "bytes",
-            id: 2
-          },
-          prev_index: {
-            rule: "required",
-            type: "uint32",
-            id: 3
-          }
-        }
-      },
-      CardanoTxOutputType: {
-        fields: {
-          address: {
-            type: "string",
-            id: 1
-          },
-          amount: {
-            rule: "required",
-            type: "uint64",
-            id: 3
-          },
-          address_parameters: {
-            type: "CardanoAddressParametersType",
-            id: 4
-          },
-          token_bundle: {
-            rule: "repeated",
-            type: "CardanoAssetGroupType",
-            id: 5
-          }
-        }
-      },
-      CardanoAssetGroupType: {
-        fields: {
-          policy_id: {
-            rule: "required",
-            type: "bytes",
-            id: 1
-          },
-          tokens: {
-            rule: "repeated",
-            type: "CardanoTokenType",
-            id: 2
-          }
-        }
-      },
-      CardanoTokenType: {
-        fields: {
-          asset_name_bytes: {
-            rule: "required",
-            type: "bytes",
-            id: 1
-          },
-          amount: {
-            rule: "required",
-            type: "uint64",
-            id: 2
-          }
-        }
-      },
-      CardanoPoolOwnerType: {
-        fields: {
-          staking_key_path: {
-            rule: "repeated",
-            type: "uint32",
-            id: 1,
-            options: {
-              packed: false
-            }
-          },
-          staking_key_hash: {
-            type: "bytes",
-            id: 2
-          }
-        }
-      },
-      CardanoPoolRelayParametersType: {
-        fields: {
-          type: {
-            rule: "required",
-            type: "CardanoPoolRelayType",
-            id: 1
-          },
-          ipv4_address: {
-            type: "bytes",
-            id: 2
-          },
-          ipv6_address: {
-            type: "bytes",
-            id: 3
-          },
-          host_name: {
-            type: "string",
-            id: 4
-          },
-          port: {
-            type: "uint32",
-            id: 5
-          }
-        }
-      },
-      CardanoTxCertificateType: {
-        fields: {
-          type: {
-            rule: "required",
-            type: "CardanoCertificateType",
-            id: 1
-          },
-          path: {
-            rule: "repeated",
-            type: "uint32",
-            id: 2,
-            options: {
-              packed: false
-            }
-          },
-          pool: {
-            type: "bytes",
-            id: 3
-          },
-          pool_parameters: {
-            type: "CardanoPoolParametersType",
-            id: 4
-          }
-        }
-      },
-      CardanoTxWithdrawalType: {
-        fields: {
-          path: {
-            rule: "repeated",
-            type: "uint32",
-            id: 1,
-            options: {
-              packed: false
-            }
-          },
-          amount: {
-            rule: "required",
-            type: "uint64",
-            id: 2
-          }
-        }
-      },
-      CardanoTxAuxiliaryDataType: {
-        fields: {
-          blob: {
-            type: "bytes",
-            id: 1
-          },
-          catalyst_registration_parameters: {
-            type: "CardanoCatalystRegistrationParametersType",
-            id: 2
-          }
-        }
-      }
-    }
-  },
-  CardanoSignedTxChunk: {
-    options: {
-      deprecated: true
-    },
-    fields: {
-      signed_tx_chunk: {
-        rule: "required",
-        type: "bytes",
-        id: 1
+        id: 4
       }
     }
   },
-  CardanoSignedTxChunkAck: {
-    options: {
-      deprecated: true
-    },
-    fields: {}
-  },
-  CardanoSignedTx: {
-    options: {
-      deprecated: true
-    },
+  CardanoMessageSignature: {
     fields: {
-      tx_hash: {
+      signature: {
         rule: "required",
         type: "bytes",
         id: 1
       },
-      serialized_tx: {
+      key: {
+        rule: "required",
         type: "bytes",
         id: 2
       }
@@ -13827,11 +13737,16 @@ var nested = {
       zoom_data_length: {
         rule: "required",
         type: "uint32",
+        id: 4
+      },
+      file_name_no_ext: {
+        rule: "required",
+        type: "string",
         id: 5
       },
-      nft_meta_data: {
+      nft_metadata: {
         type: "bytes",
-        id: 4
+        id: 6
       }
     },
     nested: {
@@ -17032,14 +16947,10 @@ var nested = {
       MessageType_StellarManageBuyOfferOp: 222,
       MessageType_StellarPathPaymentStrictSendOp: 223,
       MessageType_StellarSignedTx: 230,
-      MessageType_CardanoSignTx: 303,
       MessageType_CardanoGetPublicKey: 305,
       MessageType_CardanoPublicKey: 306,
       MessageType_CardanoGetAddress: 307,
       MessageType_CardanoAddress: 308,
-      MessageType_CardanoSignedTx: 310,
-      MessageType_CardanoSignedTxChunk: 311,
-      MessageType_CardanoSignedTxChunkAck: 312,
       MessageType_CardanoTxItemAck: 313,
       MessageType_CardanoTxAuxiliaryDataSupplement: 314,
       MessageType_CardanoTxWitnessRequest: 315,
@@ -17060,6 +16971,13 @@ var nested = {
       MessageType_CardanoGetNativeScriptHash: 330,
       MessageType_CardanoNativeScriptHash: 331,
       MessageType_CardanoTxMint: 332,
+      MessageType_CardanoTxCollateralInput: 333,
+      MessageType_CardanoTxRequiredSigner: 334,
+      MessageType_CardanoTxInlineDatumChunk: 335,
+      MessageType_CardanoTxReferenceScriptChunk: 336,
+      MessageType_CardanoTxReferenceInput: 337,
+      MessageType_CardanoSignMessage: 350,
+      MessageType_CardanoMessageSignature: 351,
       MessageType_RippleGetAddress: 400,
       MessageType_RippleAddress: 401,
       MessageType_RippleSignTx: 402,
@@ -20594,6 +20512,9 @@ class DeviceUploadResource extends BaseMethod {
     }, {
       name: 'nftMetaData',
       type: 'string'
+    }, {
+      name: 'file_name_no_ext',
+      type: 'boolean'
     }]);
     const {
       suffix,
@@ -20611,7 +20532,8 @@ class DeviceUploadResource extends BaseMethod {
       data_length: this.paramsData.data.byteLength,
       zoom_data_length: this.paramsData.thumbnailData.byteLength,
       res_type: resType,
-      nft_meta_data: nftMetaData
+      nft_metadata: nftMetaData,
+      file_name_no_ext: this.payload.file_name_no_ext
     };
   }
 
@@ -25971,12 +25893,20 @@ class CardanoGetAddress extends BaseMethod {
         address: batch.address,
         protocol_magic: batch.protocolMagic,
         network_id: batch.networkId,
-        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS,
         show_display: typeof batch.showOnOneKey === 'boolean' ? !!batch.showOnOneKey : true
       };
     });
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0'
+      }
+    };
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const responses = [];
@@ -26066,12 +25996,20 @@ class CardanoGetPublicKey extends BaseMethod {
       const path = validatePath(batch.path, 3);
       return {
         address_n: path,
-        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS,
         show_display: typeof batch.showOnOneKey === 'boolean' ? batch.showOnOneKey : false
       };
     });
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0'
+      }
+    };
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const responses = [];
@@ -26649,6 +26587,14 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
 };
 
 class CardanoSignTransaction extends BaseMethod {
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0'
+      }
+    };
+  }
+
   init() {
     var _a;
 
@@ -26829,7 +26775,7 @@ class CardanoSignTransaction extends BaseMethod {
       networkId: payload.networkId,
       witnessPaths: gatherWitnessPaths(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
       additionalWitnessRequests,
-      derivationType: typeof payload.derivationType !== 'undefined' ? payload.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+      derivationType: typeof payload.derivationType !== 'undefined' ? payload.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS,
       includeNetworkId: payload.includeNetworkId
     };
   }
@@ -26989,6 +26935,55 @@ class CardanoSignTransaction extends BaseMethod {
 
 }
 
+class CardanoSignMessage extends BaseMethod {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    const {
+      payload
+    } = this;
+    validateParams(payload, [{
+      name: 'path',
+      type: 'string',
+      required: true
+    }, {
+      name: 'message',
+      type: 'string',
+      required: true
+    }, {
+      name: 'derivationType',
+      type: 'number'
+    }, {
+      name: 'networkId',
+      type: 'number',
+      required: true
+    }]);
+    const addressN = validatePath(payload.path, 3);
+    this.params = {
+      address_n: addressN,
+      message: payload.message,
+      derivation_type: typeof payload.derivationType !== 'undefined' ? payload.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS,
+      network_id: payload.networkId
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0'
+      }
+    };
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('CardanoSignMessage', 'CardanoMessageSignature', this.params);
+      return res.message;
+    });
+  }
+
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
   __proto__: null,
   searchDevices: SearchDevices,
@@ -27064,7 +27059,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   suiSignTransaction: SuiSignTransaction,
   cardanoGetAddress: CardanoGetAddress,
   cardanoGetPublicKey: CardanoGetPublicKey,
-  cardanoSignTransaction: CardanoSignTransaction
+  cardanoSignTransaction: CardanoSignTransaction,
+  cardanoSignMessage: CardanoSignMessage
 });
 
 function findMethod(message) {
@@ -27933,6 +27929,7 @@ __webpack_unused_export__ = getEnv;
 __webpack_unused_export__ = getHDPath;
 __webpack_unused_export__ = getLog;
 exports.jl = getLogger;
+__webpack_unused_export__ = getOutputScriptType;
 __webpack_unused_export__ = getSDKVersion;
 __webpack_unused_export__ = getScriptType;
 __webpack_unused_export__ = getTimeStamp;
@@ -28596,6 +28593,13 @@ exports.CardanoNativeScriptHashDisplayFormat = void 0;
   CardanoNativeScriptHashDisplayFormat[CardanoNativeScriptHashDisplayFormat["POLICY_ID"] = 2] = "POLICY_ID";
 })(exports.CardanoNativeScriptHashDisplayFormat || (exports.CardanoNativeScriptHashDisplayFormat = {}));
 
+exports.CardanoTxOutputSerializationFormat = void 0;
+
+(function (CardanoTxOutputSerializationFormat) {
+  CardanoTxOutputSerializationFormat[CardanoTxOutputSerializationFormat["ARRAY_LEGACY"] = 0] = "ARRAY_LEGACY";
+  CardanoTxOutputSerializationFormat[CardanoTxOutputSerializationFormat["MAP_BABBAGE"] = 1] = "MAP_BABBAGE";
+})(exports.CardanoTxOutputSerializationFormat || (exports.CardanoTxOutputSerializationFormat = {}));
+
 exports.CardanoCertificateType = void 0;
 
 (function (CardanoCertificateType) {
@@ -28617,15 +28621,23 @@ exports.CardanoTxAuxiliaryDataSupplementType = void 0;
 
 (function (CardanoTxAuxiliaryDataSupplementType) {
   CardanoTxAuxiliaryDataSupplementType[CardanoTxAuxiliaryDataSupplementType["NONE"] = 0] = "NONE";
-  CardanoTxAuxiliaryDataSupplementType[CardanoTxAuxiliaryDataSupplementType["CATALYST_REGISTRATION_SIGNATURE"] = 1] = "CATALYST_REGISTRATION_SIGNATURE";
+  CardanoTxAuxiliaryDataSupplementType[CardanoTxAuxiliaryDataSupplementType["GOVERNANCE_REGISTRATION_SIGNATURE"] = 1] = "GOVERNANCE_REGISTRATION_SIGNATURE";
 })(exports.CardanoTxAuxiliaryDataSupplementType || (exports.CardanoTxAuxiliaryDataSupplementType = {}));
 
+exports.CardanoGovernanceRegistrationFormat = void 0;
+
+(function (CardanoGovernanceRegistrationFormat) {
+  CardanoGovernanceRegistrationFormat[CardanoGovernanceRegistrationFormat["CIP15"] = 0] = "CIP15";
+  CardanoGovernanceRegistrationFormat[CardanoGovernanceRegistrationFormat["CIP36"] = 1] = "CIP36";
+})(exports.CardanoGovernanceRegistrationFormat || (exports.CardanoGovernanceRegistrationFormat = {}));
+
 exports.CardanoTxSigningMode = void 0;
 
 (function (CardanoTxSigningMode) {
   CardanoTxSigningMode[CardanoTxSigningMode["ORDINARY_TRANSACTION"] = 0] = "ORDINARY_TRANSACTION";
   CardanoTxSigningMode[CardanoTxSigningMode["POOL_REGISTRATION_AS_OWNER"] = 1] = "POOL_REGISTRATION_AS_OWNER";
   CardanoTxSigningMode[CardanoTxSigningMode["MULTISIG_TRANSACTION"] = 2] = "MULTISIG_TRANSACTION";
+  CardanoTxSigningMode[CardanoTxSigningMode["PLUTUS_TRANSACTION"] = 3] = "PLUTUS_TRANSACTION";
 })(exports.CardanoTxSigningMode || (exports.CardanoTxSigningMode = {}));
 
 exports.CardanoTxWitnessType = void 0;
@@ -28924,6 +28936,10 @@ var messages = /*#__PURE__*/Object.freeze({
     return exports.CardanoNativeScriptHashDisplayFormat;
   },
 
+  get CardanoTxOutputSerializationFormat() {
+    return exports.CardanoTxOutputSerializationFormat;
+  },
+
   get CardanoCertificateType() {
     return exports.CardanoCertificateType;
   },
@@ -28936,6 +28952,10 @@ var messages = /*#__PURE__*/Object.freeze({
     return exports.CardanoTxAuxiliaryDataSupplementType;
   },
 
+  get CardanoGovernanceRegistrationFormat() {
+    return exports.CardanoGovernanceRegistrationFormat;
+  },
+
   get CardanoTxSigningMode() {
     return exports.CardanoTxSigningMode;
   },
@@ -43592,7 +43612,7 @@ module.exports = function GetIntrinsic(name, allowMissing) {
 
 var Buffer = (__webpack_require__(7834).Buffer)
 var Transform = (__webpack_require__(4851).Transform)
-var StringDecoder = (__webpack_require__(214)/* .StringDecoder */ .s)
+var StringDecoder = (__webpack_require__(3974)/* .StringDecoder */ .s)
 var inherits = __webpack_require__(1285)
 
 function CipherBase (hashMode) {
@@ -60884,7 +60904,7 @@ function ReadableState(options, stream, isDuplex) {
   this.encoding = null;
 
   if (options.encoding) {
-    if (!StringDecoder) StringDecoder = (__webpack_require__(214)/* .StringDecoder */ .s);
+    if (!StringDecoder) StringDecoder = (__webpack_require__(1922)/* .StringDecoder */ .s);
     this.decoder = new StringDecoder(options.encoding);
     this.encoding = options.encoding;
   }
@@ -61046,7 +61066,7 @@ Readable.prototype.isPaused = function () {
 
 
 Readable.prototype.setEncoding = function (enc) {
-  if (!StringDecoder) StringDecoder = (__webpack_require__(214)/* .StringDecoder */ .s);
+  if (!StringDecoder) StringDecoder = (__webpack_require__(1922)/* .StringDecoder */ .s);
   var decoder = new StringDecoder(enc);
   this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
 
@@ -63569,6 +63589,309 @@ module.exports = {
 module.exports = __webpack_require__(2699).EventEmitter;
 
 
+/***/ }),
+
+/***/ 1922:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+/*<replacement>*/
+
+var Buffer = (__webpack_require__(7834).Buffer);
+/*</replacement>*/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+  encoding = '' + encoding;
+  switch (encoding && encoding.toLowerCase()) {
+    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+      return true;
+    default:
+      return false;
+  }
+};
+
+function _normalizeEncoding(enc) {
+  if (!enc) return 'utf8';
+  var retried;
+  while (true) {
+    switch (enc) {
+      case 'utf8':
+      case 'utf-8':
+        return 'utf8';
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return 'utf16le';
+      case 'latin1':
+      case 'binary':
+        return 'latin1';
+      case 'base64':
+      case 'ascii':
+      case 'hex':
+        return enc;
+      default:
+        if (retried) return; // undefined
+        enc = ('' + enc).toLowerCase();
+        retried = true;
+    }
+  }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+  var nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+  return nenc || enc;
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.s = StringDecoder;
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  var nb;
+  switch (this.encoding) {
+    case 'utf16le':
+      this.text = utf16Text;
+      this.end = utf16End;
+      nb = 4;
+      break;
+    case 'utf8':
+      this.fillLast = utf8FillLast;
+      nb = 4;
+      break;
+    case 'base64':
+      this.text = base64Text;
+      this.end = base64End;
+      nb = 3;
+      break;
+    default:
+      this.write = simpleWrite;
+      this.end = simpleEnd;
+      return;
+  }
+  this.lastNeed = 0;
+  this.lastTotal = 0;
+  this.lastChar = Buffer.allocUnsafe(nb);
+}
+
+StringDecoder.prototype.write = function (buf) {
+  if (buf.length === 0) return '';
+  var r;
+  var i;
+  if (this.lastNeed) {
+    r = this.fillLast(buf);
+    if (r === undefined) return '';
+    i = this.lastNeed;
+    this.lastNeed = 0;
+  } else {
+    i = 0;
+  }
+  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+  return r || '';
+};
+
+StringDecoder.prototype.end = utf8End;
+
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
+
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+  this.lastNeed -= buf.length;
+};
+
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+  return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+  var j = buf.length - 1;
+  if (j < i) return 0;
+  var nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 1;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 2;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+    }
+    return nb;
+  }
+  return 0;
+}
+
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+  if ((buf[0] & 0xC0) !== 0x80) {
+    self.lastNeed = 0;
+    return '\ufffd';
+  }
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 0xC0) !== 0x80) {
+      self.lastNeed = 1;
+      return '\ufffd';
+    }
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 0xC0) !== 0x80) {
+        self.lastNeed = 2;
+        return '\ufffd';
+      }
+    }
+  }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+  var p = this.lastTotal - this.lastNeed;
+  var r = utf8CheckExtraBytes(this, buf, p);
+  if (r !== undefined) return r;
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+  var total = utf8CheckIncomplete(this, buf, i);
+  if (!this.lastNeed) return buf.toString('utf8', i);
+  this.lastTotal = total;
+  var end = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end);
+  return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + '\ufffd';
+  return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+  if ((buf.length - i) % 2 === 0) {
+    var r = buf.toString('utf16le', i);
+    if (r) {
+      var c = r.charCodeAt(r.length - 1);
+      if (c >= 0xD800 && c <= 0xDBFF) {
+        this.lastNeed = 2;
+        this.lastTotal = 4;
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+        return r.slice(0, -1);
+      }
+    }
+    return r;
+  }
+  this.lastNeed = 1;
+  this.lastTotal = 2;
+  this.lastChar[0] = buf[buf.length - 1];
+  return buf.toString('utf16le', i, buf.length - 1);
+}
+
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) {
+    var end = this.lastTotal - this.lastNeed;
+    return r + this.lastChar.toString('utf16le', 0, end);
+  }
+  return r;
+}
+
+function base64Text(buf, i) {
+  var n = (buf.length - i) % 3;
+  if (n === 0) return buf.toString('base64', i);
+  this.lastNeed = 3 - n;
+  this.lastTotal = 3;
+  if (n === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
+  }
+  return buf.toString('base64', i, buf.length - n);
+}
+
+function base64End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+  return r;
+}
+
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+  return buf.toString(this.encoding);
+}
+
+function simpleEnd(buf) {
+  return buf && buf.length ? this.write(buf) : '';
+}
+
 /***/ }),
 
 /***/ 696:
@@ -71353,10 +71676,9 @@ Stream.prototype.pipe = function(dest, options) {
 
 /***/ }),
 
-/***/ 214:
+/***/ 3974:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-"use strict";
 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -71378,282 +71700,208 @@ Stream.prototype.pipe = function(dest, options) {
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+var Buffer = (__webpack_require__(8834).Buffer);
 
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
 
-/*<replacement>*/
 
-var Buffer = (__webpack_require__(7834).Buffer);
-/*</replacement>*/
-
-var isEncoding = Buffer.isEncoding || function (encoding) {
-  encoding = '' + encoding;
-  switch (encoding && encoding.toLowerCase()) {
-    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
-      return true;
-    default:
-      return false;
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
   }
-};
-
-function _normalizeEncoding(enc) {
-  if (!enc) return 'utf8';
-  var retried;
-  while (true) {
-    switch (enc) {
-      case 'utf8':
-      case 'utf-8':
-        return 'utf8';
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return 'utf16le';
-      case 'latin1':
-      case 'binary':
-        return 'latin1';
-      case 'base64':
-      case 'ascii':
-      case 'hex':
-        return enc;
-      default:
-        if (retried) return; // undefined
-        enc = ('' + enc).toLowerCase();
-        retried = true;
-    }
-  }
-};
-
-// Do not cache `Buffer.isEncoding` when checking encoding names as some
-// modules monkey-patch it to support additional encodings
-function normalizeEncoding(enc) {
-  var nenc = _normalizeEncoding(enc);
-  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
-  return nenc || enc;
 }
 
 // StringDecoder provides an interface for efficiently splitting a series of
 // buffers into a series of JS strings without breaking apart multi-byte
-// characters.
-exports.s = StringDecoder;
-function StringDecoder(encoding) {
-  this.encoding = normalizeEncoding(encoding);
-  var nb;
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.s = function(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
   switch (this.encoding) {
-    case 'utf16le':
-      this.text = utf16Text;
-      this.end = utf16End;
-      nb = 4;
-      break;
     case 'utf8':
-      this.fillLast = utf8FillLast;
-      nb = 4;
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
       break;
     case 'base64':
-      this.text = base64Text;
-      this.end = base64End;
-      nb = 3;
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
       break;
     default:
-      this.write = simpleWrite;
-      this.end = simpleEnd;
+      this.write = passThroughWrite;
       return;
   }
-  this.lastNeed = 0;
-  this.lastTotal = 0;
-  this.lastChar = Buffer.allocUnsafe(nb);
-}
 
-StringDecoder.prototype.write = function (buf) {
-  if (buf.length === 0) return '';
-  var r;
-  var i;
-  if (this.lastNeed) {
-    r = this.fillLast(buf);
-    if (r === undefined) return '';
-    i = this.lastNeed;
-    this.lastNeed = 0;
-  } else {
-    i = 0;
-  }
-  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
-  return r || '';
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
 };
 
-StringDecoder.prototype.end = utf8End;
 
-// Returns only complete characters in a Buffer
-StringDecoder.prototype.text = utf8Text;
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
 
-// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
-StringDecoder.prototype.fillLast = function (buf) {
-  if (this.lastNeed <= buf.length) {
-    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
-    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
   }
-  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
-  this.lastNeed -= buf.length;
-};
 
-// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
-// continuation byte. If an invalid byte is detected, -2 is returned.
-function utf8CheckByte(byte) {
-  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
-  return byte >> 6 === 0x02 ? -1 : -2;
-}
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
 
-// Checks at most 3 bytes at the end of a Buffer in order to detect an
-// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
-// needed to complete the UTF-8 character (if applicable) are returned.
-function utf8CheckIncomplete(self, buf, i) {
-  var j = buf.length - 1;
-  if (j < i) return 0;
-  var nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) self.lastNeed = nb - 1;
-    return nb;
-  }
-  if (--j < i || nb === -2) return 0;
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) self.lastNeed = nb - 2;
-    return nb;
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
   }
-  if (--j < i || nb === -2) return 0;
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
-    }
-    return nb;
-  }
-  return 0;
-}
 
-// Validates as many continuation bytes for a multi-byte UTF-8 character as
-// needed or are available. If we see a non-continuation byte where we expect
-// one, we "replace" the validated continuation bytes we've seen so far with
-// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
-// behavior. The continuation byte check is included three times in the case
-// where all of the continuation bytes for a character exist in the same buffer.
-// It is also done this way as a slight performance increase instead of using a
-// loop.
-function utf8CheckExtraBytes(self, buf, p) {
-  if ((buf[0] & 0xC0) !== 0x80) {
-    self.lastNeed = 0;
-    return '\ufffd';
-  }
-  if (self.lastNeed > 1 && buf.length > 1) {
-    if ((buf[1] & 0xC0) !== 0x80) {
-      self.lastNeed = 1;
-      return '\ufffd';
-    }
-    if (self.lastNeed > 2 && buf.length > 2) {
-      if ((buf[2] & 0xC0) !== 0x80) {
-        self.lastNeed = 2;
-        return '\ufffd';
-      }
-    }
-  }
-}
+  charStr += buffer.toString(this.encoding, 0, end);
 
-// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
-function utf8FillLast(buf) {
-  var p = this.lastTotal - this.lastNeed;
-  var r = utf8CheckExtraBytes(this, buf, p);
-  if (r !== undefined) return r;
-  if (this.lastNeed <= buf.length) {
-    buf.copy(this.lastChar, p, 0, this.lastNeed);
-    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
   }
-  buf.copy(this.lastChar, p, 0, buf.length);
-  this.lastNeed -= buf.length;
-}
 
-// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
-// partial character, the character's bytes are buffered until the required
-// number of bytes are available.
-function utf8Text(buf, i) {
-  var total = utf8CheckIncomplete(this, buf, i);
-  if (!this.lastNeed) return buf.toString('utf8', i);
-  this.lastTotal = total;
-  var end = buf.length - (total - this.lastNeed);
-  buf.copy(this.lastChar, 0, end);
-  return buf.toString('utf8', i, end);
-}
+  // or just emit the charStr
+  return charStr;
+};
 
-// For UTF-8, a replacement character is added when ending on a partial
-// character.
-function utf8End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) return r + '\ufffd';
-  return r;
-}
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
 
-// UTF-16LE typically needs two bytes per character, but even if we have an even
-// number of bytes available, we need to check if we end on a leading/high
-// surrogate. In that case, we need to wait for the next two bytes in order to
-// decode the last character properly.
-function utf16Text(buf, i) {
-  if ((buf.length - i) % 2 === 0) {
-    var r = buf.toString('utf16le', i);
-    if (r) {
-      var c = r.charCodeAt(r.length - 1);
-      if (c >= 0xD800 && c <= 0xDBFF) {
-        this.lastNeed = 2;
-        this.lastTotal = 4;
-        this.lastChar[0] = buf[buf.length - 2];
-        this.lastChar[1] = buf[buf.length - 1];
-        return r.slice(0, -1);
-      }
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
     }
-    return r;
-  }
-  this.lastNeed = 1;
-  this.lastTotal = 2;
-  this.lastChar[0] = buf[buf.length - 1];
-  return buf.toString('utf16le', i, buf.length - 1);
-}
 
-// For UTF-16LE we do not explicitly append special replacement characters if we
-// end on a partial character, we simply let v8 handle that.
-function utf16End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) {
-    var end = this.lastTotal - this.lastNeed;
-    return r + this.lastChar.toString('utf16le', 0, end);
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
   }
-  return r;
-}
+  this.charReceived = i;
+};
 
-function base64Text(buf, i) {
-  var n = (buf.length - i) % 3;
-  if (n === 0) return buf.toString('base64', i);
-  this.lastNeed = 3 - n;
-  this.lastTotal = 3;
-  if (n === 1) {
-    this.lastChar[0] = buf[buf.length - 1];
-  } else {
-    this.lastChar[0] = buf[buf.length - 2];
-    this.lastChar[1] = buf[buf.length - 1];
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
   }
-  return buf.toString('base64', i, buf.length - n);
-}
 
-function base64End(buf) {
-  var r = buf && buf.length ? this.write(buf) : '';
-  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
-  return r;
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
 }
 
-// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
-function simpleWrite(buf) {
-  return buf.toString(this.encoding);
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
 }
 
-function simpleEnd(buf) {
-  return buf && buf.length ? this.write(buf) : '';
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
 }
 
+
 /***/ }),
 
 /***/ 5803:
@@ -73424,7 +73672,7 @@ module.exports = {"i8":"6.5.4"};
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"@onekeyfe/hd-core","version":"0.2.10","description":"> TODO: description","author":"OneKey","homepage":"https://github.com/OneKeyHQ/hardware-js-sdk#readme","license":"ISC","main":"dist/index.js","types":"dist/index.d.ts","repository":{"type":"git","url":"git+https://github.com/OneKeyHQ/hardware-js-sdk.git"},"publishConfig":{"access":"public"},"scripts":{"dev":"rimraf dist && rollup -c ../../build/rollup.config.js -w","build":"rimraf dist && rollup -c ../../build/rollup.config.js","lint":"eslint .","lint:fix":"eslint . --fix"},"bugs":{"url":"https://github.com/OneKeyHQ/hardware-js-sdk/issues"},"dependencies":{"@onekeyfe/hd-shared":"^0.2.10","@onekeyfe/hd-transport":"^0.2.10","axios":"^0.27.2","bignumber.js":"^9.0.2","jszip":"^3.10.1","parse-uri":"^1.0.7","semver":"^7.3.7"},"peerDependencies":{"@noble/hashes":"^1.1.3","ripple-keypairs":"^1.1.4"},"devDependencies":{"@noble/hashes":"^1.1.3","@types/parse-uri":"^1.0.0","@types/semver":"^7.3.9","ripple-keypairs":"^1.1.4"}}');
+module.exports = JSON.parse('{"name":"@onekeyfe/hd-core","version":"0.2.12","description":"> TODO: description","author":"OneKey","homepage":"https://github.com/OneKeyHQ/hardware-js-sdk#readme","license":"ISC","main":"dist/index.js","types":"dist/index.d.ts","repository":{"type":"git","url":"git+https://github.com/OneKeyHQ/hardware-js-sdk.git"},"publishConfig":{"access":"public"},"scripts":{"dev":"rimraf dist && rollup -c ../../build/rollup.config.js -w","build":"rimraf dist && rollup -c ../../build/rollup.config.js","lint":"eslint .","lint:fix":"eslint . --fix"},"bugs":{"url":"https://github.com/OneKeyHQ/hardware-js-sdk/issues"},"dependencies":{"@onekeyfe/hd-shared":"^0.2.12","@onekeyfe/hd-transport":"^0.2.12","axios":"^0.27.2","bignumber.js":"^9.0.2","jszip":"^3.10.1","parse-uri":"^1.0.7","semver":"^7.3.7"},"peerDependencies":{"@noble/hashes":"^1.1.3","ripple-keypairs":"^1.1.4"},"devDependencies":{"@noble/hashes":"^1.1.3","@types/parse-uri":"^1.0.0","@types/semver":"^7.3.9","ripple-keypairs":"^1.1.4"}}');
 
 /***/ })
 
@@ -75963,7 +76211,7 @@ const src_init = async settings => {
 
   try {
     await init({ ..._settings,
-      version: "0.2.10"
+      version: "0.2.12"
     });
     return true;
   } catch (e) {