sceyt-chat-react-uikit 1.8.8-beta.7 → 1.8.8-beta.8

package/index.js

@@ -1,5 +1,24 @@
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) { return e; } else {
+    var n = {};
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      });
+    }
+    n['default'] = e;
+    return n;
+  }
+}
+
 var React = require('react');
 var React__default = _interopDefault(React);
 var reactRedux = require('react-redux');
@@ -14849,198 +14868,677 @@ function calculateSize(width, height, maxWidth, maxHeight) {
 }
 var pica = new Pica();
 
-var getVideoFirstFrame = function getVideoFirstFrame(videoSrc, maxWidth, maxHeight, quality) {
-  if (quality === void 0) {
-    quality = 0.8;
+var dbg = function dbg() {
+  var _console;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return (_console = console).log.apply(_console, ['[VIDEO_FIRST_FRAME]'].concat(args));
+};
+var toHex = function toHex(bytes) {
+  return Array.from(bytes).map(function (b) {
+    return b.toString(16).padStart(2, '0');
+  }).join(' ');
+};
+var NATIVE_VIDEO_TYPES = new Set(['video/mp4', 'video/webm', 'video/ogg']);
+var findFourccs = function findFourccs(bytes, fourccs) {
+  var found = [];
+  for (var _iterator = _createForOfIteratorHelperLoose(fourccs), _step; !(_step = _iterator()).done;) {
+    var cc = _step.value;
+    var c0 = cc.charCodeAt(0);
+    var c1 = cc.charCodeAt(1);
+    var c2 = cc.charCodeAt(2);
+    var c3 = cc.charCodeAt(3);
+    for (var i = 0; i <= bytes.length - 4; i++) {
+      if (bytes[i] === c0 && bytes[i + 1] === c1 && bytes[i + 2] === c2 && bytes[i + 3] === c3) {
+        found.push(cc);
+        break;
+      }
+    }
   }
+  return found;
+};
+var VIDEO_CODEC_FOURCCS = ['avc1', 'avc3', 'hvc1', 'hev1', 'av01', 'vp09', 'mp4v', 'apcn', 'apch', 'ap4h'];
+var isQuickTimeContainer = function isQuickTimeContainer(info) {
+  return info.isoBrand === 'qt  ';
+};
+var inspectVideoBlob = function inspectVideoBlob(blob) {
   try {
-    return Promise.resolve(new Promise(function (resolve) {
-      try {
-        var video = document.createElement('video');
-        video.preload = 'metadata';
-        video.muted = true;
-        video.setAttribute('playsinline', 'true');
-        if (videoSrc instanceof Blob) {
-          video.src = URL.createObjectURL(videoSrc);
-        } else {
-          video.src = videoSrc;
-        }
-        var videoUrlCreated = false;
-        var cleanup = function cleanup() {
-          if (videoUrlCreated && videoSrc instanceof Blob) {
-            URL.revokeObjectURL(video.src);
+    var info = {
+      mimeType: null,
+      isoBrand: null,
+      codecs: []
+    };
+    return Promise.resolve(_catch(function () {
+      return Promise.resolve(blob.slice(0, 16).arrayBuffer()).then(function (_blob$slice$arrayBuff) {
+        var _exit = false;
+        function _temp4(_result) {
+          if (_exit) return _result;
+          if (head.length >= 4 && head[0] === 0x1a && head[1] === 0x45 && head[2] === 0xdf && head[3] === 0xa3) {
+            dbg('sniff: EBML (webm/mkv) detected');
+            info.mimeType = 'video/webm';
+            return info;
           }
-        };
-        var extractFrame = function extractFrame() {
-          try {
-            if (video.videoWidth === 0 || video.videoHeight === 0) {
-              cleanup();
-              resolve(null);
-              return;
-            }
-            var canvasWidth = maxWidth || video.videoWidth / 2;
-            var canvasHeight = maxHeight || video.videoHeight / 2;
-            var canvas = document.createElement('canvas');
-            canvas.width = canvasWidth;
-            canvas.height = canvasHeight;
-            var ctx = canvas.getContext('2d');
-            if (!ctx) {
-              cleanup();
-              resolve(null);
-              return;
-            }
-            ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-            canvas.toBlob(function (blob) {
-              if (!blob) {
-                cleanup();
-                resolve(null);
-                return;
+          if (head.length >= 4 && head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53) {
+            dbg('sniff: Ogg detected');
+            info.mimeType = 'video/ogg';
+            return info;
+          }
+          dbg('sniff: unknown container');
+          return info;
+        }
+        var head = new Uint8Array(_blob$slice$arrayBuff);
+        dbg('sniff: first bytes =', toHex(head));
+        var _temp3 = function () {
+          if (head.length >= 8 && head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70) {
+            info.mimeType = 'video/mp4';
+            info.isoBrand = String.fromCharCode(head[8] || 0, head[9] || 0, head[10] || 0, head[11] || 0);
+            var scanSize = 512 * 1024;
+            return Promise.resolve(blob.slice(0, Math.min(scanSize, blob.size)).arrayBuffer()).then(function (_blob$slice$arrayBuff2) {
+              function _temp2() {
+                dbg('sniff: ISO-BMFF, major brand =', JSON.stringify(info.isoBrand), 'codecs =', info.codecs.join(',') || 'none-found');
+                _exit = true;
+                return info;
               }
-              var frameBlobUrl = URL.createObjectURL(blob);
-              cleanup();
-              resolve({
-                frameBlobUrl: frameBlobUrl,
-                blob: blob
-              });
-            }, 'image/jpeg', quality);
-          } catch (error) {
-            log.error('Error extracting video frame:', error);
-            cleanup();
-            resolve(null);
+              var headChunk = new Uint8Array(_blob$slice$arrayBuff2);
+              info.codecs = findFourccs(headChunk, VIDEO_CODEC_FOURCCS);
+              var _temp = function () {
+                if (!info.codecs.length && blob.size > scanSize) {
+                  return Promise.resolve(blob.slice(Math.max(0, blob.size - scanSize)).arrayBuffer()).then(function (_blob$slice$arrayBuff3) {
+                    var tailChunk = new Uint8Array(_blob$slice$arrayBuff3);
+                    info.codecs = findFourccs(tailChunk, VIDEO_CODEC_FOURCCS);
+                  });
+                }
+              }();
+              return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+            });
           }
-        };
-        video.onloadedmetadata = function () {
-          videoUrlCreated = true;
-          video.currentTime = 0.01;
-          video.onseeked = function () {
-            video.onseeked = null;
-            var capture = function capture() {
-              return requestAnimationFrame(extractFrame);
-            };
-            video.play().then(function () {
-              var done = false;
-              var _finish = function finish() {
-                if (done) return;
-                done = true;
-                video.removeEventListener('timeupdate', _finish);
-                video.removeEventListener('ended', _finish);
-                video.pause();
-                capture();
-              };
-              video.addEventListener('timeupdate', _finish);
-              video.addEventListener('ended', _finish);
-              setTimeout(_finish, 500);
-            })["catch"](capture);
-          };
-          video.onerror = function (error) {
-            log.error('Error seeking video for frame extraction', error);
-            cleanup();
-            resolve(null);
+        }();
+        return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+      });
+    }, function (error) {
+      log.error('Failed to sniff video container:', error);
+      return info;
+    }));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var isFirefox = function isFirefox() {
+  return typeof navigator !== 'undefined' && /firefox/i.test(navigator.userAgent);
+};
+
+var dbg$1 = function dbg() {
+  var _console;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return (_console = console).log.apply(_console, ['[VIDEO_FIRST_FRAME]'].concat(args));
+};
+var REMUX_MAX_BYTES = 200 * 1024 * 1024;
+var remuxCounter = 0;
+var remuxToMp4 = function remuxToMp4(blob) {
+  try {
+    if (blob.size > REMUX_MAX_BYTES) {
+      dbg$1('remux: skipped, file too large:', blob.size);
+      log.warn('remuxToMp4: file too large to remux in browser:', blob.size);
+      return Promise.resolve(null);
+    }
+    var id = Date.now() + "_" + remuxCounter++;
+    var inputName = "remux_" + id + "_in.mov";
+    var outputName = "remux_" + id + "_out.mp4";
+    var ffmpeg = null;
+    return Promise.resolve(_finallyRethrows(function () {
+      return _catch(function () {
+        dbg$1('remux: starting ffmpeg -c copy remux, size =', blob.size);
+        return Promise.resolve(Promise.all([Promise.resolve().then(function () { return audioConversion; }), new Promise(function (resolve) { resolve(_interopNamespace(require('@ffmpeg/util'))); })])).then(function (_ref) {
+          var initFFmpeg = _ref[0].initFFmpeg,
+            fetchFile = _ref[1].fetchFile;
+          return Promise.resolve(initFFmpeg()).then(function (_initFFmpeg) {
+            ffmpeg = _initFFmpeg;
+            var _ffmpeg = ffmpeg,
+              _writeFile = _ffmpeg.writeFile;
+            return Promise.resolve(fetchFile(blob)).then(function (_fetchFile) {
+              return Promise.resolve(_writeFile.call(_ffmpeg, inputName, _fetchFile)).then(function () {
+                return Promise.resolve(ffmpeg.exec(['-i', inputName, '-c', 'copy', '-movflags', '+faststart', outputName])).then(function () {
+                  return Promise.resolve(ffmpeg.readFile(outputName)).then(function (data) {
+                    var bytes;
+                    if (data instanceof Uint8Array) {
+                      bytes = data;
+                    } else if (typeof data === 'string') {
+                      var binaryString = atob(data);
+                      bytes = new Uint8Array(binaryString.length);
+                      for (var i = 0; i < binaryString.length; i++) {
+                        bytes[i] = binaryString.charCodeAt(i);
+                      }
+                    } else {
+                      bytes = new Uint8Array(data);
+                    }
+                    if (!bytes.length) {
+                      dbg$1('remux: ffmpeg produced empty output');
+                      return null;
+                    }
+                    var arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+                    dbg$1('remux: done, output size =', bytes.length);
+                    return new Blob([arrayBuffer], {
+                      type: 'video/mp4'
+                    });
+                  });
+                });
+              });
+            });
+          });
+        });
+      }, function (error) {
+        dbg$1('remux: FAILED', error);
+        log.error('remuxToMp4: remux failed:', error);
+        return null;
+      });
+    }, function (_wasThrown, _result) {
+      function _temp5() {
+        if (_wasThrown) throw _result;
+        return _result;
+      }
+      var _temp4 = function () {
+        if (ffmpeg) {
+          var _temp3 = function _temp3() {
+            var _temp = _catch(function () {
+              return Promise.resolve(ffmpeg.deleteFile(outputName)).then(function () {});
+            }, function () {});
+            if (_temp && _temp.then) return _temp.then(function () {});
           };
+          var _temp2 = _catch(function () {
+            return Promise.resolve(ffmpeg.deleteFile(inputName)).then(function () {});
+          }, function () {});
+          return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
+        }
+      }();
+      return _temp4 && _temp4.then ? _temp4.then(_temp5) : _temp5(_temp4);
+    }));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var remuxVideoFileForUpload = function remuxVideoFileForUpload(file) {
+  try {
+    return Promise.resolve(_catch(function () {
+      return Promise.resolve(inspectVideoBlob(file)).then(function (info) {
+        if (!isQuickTimeContainer(info)) {
+          return file;
+        }
+        dbg$1('upload: QuickTime file picked, remuxing before upload:', file.name);
+        return Promise.resolve(remuxToMp4(file)).then(function (remuxed) {
+          if (!remuxed) {
+            log.warn('remuxVideoFileForUpload: remux failed, uploading original file');
+            return file;
+          }
+          var newName = /\.(mov|qt)$/i.test(file.name) ? file.name.replace(/\.(mov|qt)$/i, '.mp4') : file.name + ".mp4";
+          return new File([remuxed], newName, {
+            type: 'video/mp4',
+            lastModified: file.lastModified
+          });
+        });
+      });
+    }, function (error) {
+      log.error('remuxVideoFileForUpload failed, uploading original file:', error);
+      return file;
+    }));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var ensurePlayableVideoBlob = function ensurePlayableVideoBlob(blob) {
+  try {
+    return Promise.resolve(_catch(function () {
+      return isFirefox() ? Promise.resolve(inspectVideoBlob(blob)).then(function (info) {
+        if (!isQuickTimeContainer(info)) {
+          return blob;
+        }
+        dbg$1('download: QuickTime blob in Firefox, remuxing for playback');
+        return Promise.resolve(remuxToMp4(blob)).then(function (remuxed) {
+          return remuxed || blob;
+        });
+      }) : blob;
+    }, function (error) {
+      log.error('ensurePlayableVideoBlob failed, using original blob:', error);
+      return blob;
+    }));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+var getFrame = function getFrame(videoSrc, _time) {
+  try {
+    if (!videoSrc) {
+      throw new Error('src not found');
+    }
+    return Promise.resolve(getVideoFirstFrame(videoSrc)).then(function (frameResult) {
+      if (!frameResult) {
+        throw new Error('Failed to extract video frame');
+      }
+      var frameBlobUrl = frameResult.frameBlobUrl,
+        origWidth = frameResult.width,
+        origHeight = frameResult.height;
+      var duration = Number(frameResult.duration.toFixed(0));
+      var _calculateSize = calculateSize(origWidth, origHeight, 100, 100),
+        newWidth = _calculateSize[0],
+        newHeight = _calculateSize[1];
+      return new Promise(function (resolve, reject) {
+        var img = document.createElement('img');
+        img.onload = function () {
+          var canvas = document.createElement('canvas');
+          canvas.width = newWidth;
+          canvas.height = newHeight;
+          var ctx = canvas.getContext('2d');
+          if (!ctx) {
+            URL.revokeObjectURL(frameBlobUrl);
+            reject(new Error('Failed to get canvas context'));
+            return;
+          }
+          ctx.drawImage(img, 0, 0, newWidth, newHeight);
+          var pixels = ctx.getImageData(0, 0, canvas.width, canvas.height);
+          var binaryThumbHash = rgbaToThumbHash(pixels.width, pixels.height, pixels.data);
+          var thumb = binaryToBase64(binaryThumbHash);
+          URL.revokeObjectURL(frameBlobUrl);
+          resolve({
+            thumb: thumb,
+            width: origWidth,
+            height: origHeight,
+            duration: duration
+          });
         };
-        video.onerror = function () {
-          log.error('Error loading video metadata for frame extraction');
-          cleanup();
-          resolve(null);
+        img.onerror = function () {
+          URL.revokeObjectURL(frameBlobUrl);
+          reject(new Error('Failed to load frame image'));
         };
-      } catch (error) {
-        log.error('Error in getVideoFirstFrame:', error);
-        resolve(null);
+        img.src = frameBlobUrl;
+      });
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var getVideoFirstFrame = function getVideoFirstFrame(videoSrc, maxWidth, maxHeight, quality) {
+  if (quality === void 0) {
+    quality = 0.8;
+  }
+  try {
+    var _exit3 = false;
+    return Promise.resolve(_catch(function () {
+      function _temp0(_result3) {
+        var _exit4 = false;
+        if (_exit3) return _result3;
+        function _temp8(_result4) {
+          if (_exit4) return _result4;
+          dbg$2('source: remote URL —', videoSrc.slice(0, 150));
+          return Promise.resolve(extractFrameFromUrl(videoSrc, maxWidth, maxHeight, quality)).then(function (direct) {
+            if (direct) {
+              return direct;
+            }
+            dbg$2('source: direct remote load failed, retrying via fetch + relabel');
+            return _catch(function () {
+              return Promise.resolve(fetch(videoSrc)).then(function (response) {
+                return Promise.resolve(response.blob()).then(function (blob) {
+                  dbg$2('source: remote fetched, Content-Type =', JSON.stringify(response.headers.get('content-type')), 'blob type =', JSON.stringify(blob.type), 'size =', blob.size);
+                  return Promise.resolve(_extractFrameFromBlob2(blob, maxWidth, maxHeight, quality));
+                });
+              });
+            }, function (error) {
+              dbg$2('source: remote fetch retry FAILED', error);
+              log.error('getVideoFirstFrame: fetch retry failed:', error);
+              return null;
+            });
+          });
+        }
+        var _temp7 = function () {
+          if (videoSrc.startsWith('blob:')) {
+            dbg$2('source: blob URL string —', videoSrc.slice(0, 100));
+            return _catch(function () {
+              return Promise.resolve(fetch(videoSrc)).then(function (_fetch) {
+                return Promise.resolve(_fetch.blob()).then(function (blob) {
+                  dbg$2('source: blob URL re-fetched, type =', JSON.stringify(blob.type), 'size =', blob.size);
+                  return Promise.resolve(_extractFrameFromBlob2(blob, maxWidth, maxHeight, quality)).then(function (_await$_extractFrameF2) {
+                    _exit4 = true;
+                    return _await$_extractFrameF2;
+                  });
+                });
+              });
+            }, function (error) {
+              dbg$2('source: blob URL re-fetch FAILED, falling back to direct', error);
+              log.warn('getVideoFirstFrame: failed to re-fetch blob url, trying directly', error);
+              return Promise.resolve(extractFrameFromUrl(videoSrc, maxWidth, maxHeight, quality)).then(function (_await$extractFrameFr) {
+                _exit4 = true;
+                return _await$extractFrameFr;
+              });
+            });
+          }
+        }();
+        return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7);
       }
+      var _temp9 = function () {
+        if (videoSrc instanceof Blob) {
+          dbg$2('source: Blob, type =', JSON.stringify(videoSrc.type), 'size =', videoSrc.size);
+          return Promise.resolve(_extractFrameFromBlob2(videoSrc, maxWidth, maxHeight, quality)).then(function (_await$_extractFrameF) {
+            _exit3 = true;
+            return _await$_extractFrameF;
+          });
+        }
+      }();
+      return _temp9 && _temp9.then ? _temp9.then(_temp0) : _temp0(_temp9);
+    }, function (error) {
+      log.error('Error in getVideoFirstFrame:', error);
+      return null;
     }));
   } catch (e) {
     return Promise.reject(e);
   }
 };
-var getFrame = function getFrame(videoSrc, _time) {
+var dbg$2 = function dbg() {
+  var _console;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return (_console = console).log.apply(_console, ['[VIDEO_FIRST_FRAME]'].concat(args));
+};
+var normalizeVideoBlob = function normalizeVideoBlob(blob) {
   try {
-    return Promise.resolve(new Promise(function (resolve, reject) {
-      if (!videoSrc) {
-        reject(new Error('src not found'));
-        return;
+    return Promise.resolve(inspectVideoBlob(blob)).then(function (info) {
+      var baseType = (blob.type || '').split(';')[0].trim().toLowerCase();
+      if (NATIVE_VIDEO_TYPES.has(baseType)) {
+        dbg$2('normalize: declared type is native:', JSON.stringify(blob.type), '→', JSON.stringify(baseType));
+        return {
+          safeBlob: baseType === blob.type ? blob : new Blob([blob], {
+            type: baseType
+          }),
+          info: info
+        };
       }
+      var relabeledType = info.mimeType || 'video/mp4';
+      dbg$2('normalize: declared', JSON.stringify(blob.type), '→ relabeled to', JSON.stringify(relabeledType));
+      return {
+        safeBlob: new Blob([blob], {
+          type: relabeledType
+        }),
+        info: info
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+var FRAME_LOAD_TIMEOUT_MS = 8000;
+var READY_STATES = ['HAVE_NOTHING', 'HAVE_METADATA', 'HAVE_CURRENT_DATA', 'HAVE_FUTURE_DATA', 'HAVE_ENOUGH_DATA'];
+var NETWORK_STATES = ['NETWORK_EMPTY', 'NETWORK_IDLE', 'NETWORK_LOADING', 'NETWORK_NO_SOURCE'];
+var describeVideoState = function describeVideoState(video) {
+  var buffered = 'none';
+  try {
+    var ranges = [];
+    for (var i = 0; i < video.buffered.length; i++) {
+      ranges.push(video.buffered.start(i).toFixed(2) + "-" + video.buffered.end(i).toFixed(2));
+    }
+    buffered = ranges.join(',') || 'empty';
+  } catch (e) {
+    buffered = 'unavailable';
+  }
+  return "readyState=" + (READY_STATES[video.readyState] || video.readyState) + " " + ("networkState=" + (NETWORK_STATES[video.networkState] || video.networkState) + " ") + ("currentTime=" + video.currentTime + " duration=" + video.duration + " ") + ("videoWidth=" + video.videoWidth + " videoHeight=" + video.videoHeight + " ") + ("buffered=[" + buffered + "] error=" + (video.error ? video.error.code + ":" + video.error.message : 'null'));
+};
+var extractFrameFromUrl = function extractFrameFromUrl(srcUrl, maxWidth, maxHeight, quality) {
+  if (quality === void 0) {
+    quality = 0.8;
+  }
+  return new Promise(function (resolve) {
+    try {
+      dbg$2('extract: start, src =', srcUrl.slice(0, 100));
       var video = document.createElement('video');
-      video.preload = 'metadata';
+      video.preload = 'auto';
       video.muted = true;
       video.setAttribute('playsinline', 'true');
-      video.src = videoSrc;
-      video.onloadedmetadata = function () {
+      if (!srcUrl.startsWith('blob:') && !srcUrl.startsWith('data:')) {
+        video.crossOrigin = 'anonymous';
+      }
+      video.style.position = 'fixed';
+      video.style.bottom = '0';
+      video.style.left = '0';
+      video.style.width = '2px';
+      video.style.height = '2px';
+      video.style.opacity = '0';
+      video.style.pointerEvents = 'none';
+      video.style.zIndex = '-1';
+      document.body.appendChild(video);
+      var settled = false;
+      var finishOnce = function finishOnce(result) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(stallTimer);
+        if (video.parentNode) {
+          video.parentNode.removeChild(video);
+        }
+        dbg$2('extract: finished,', result ? 'SUCCESS' : 'NULL');
+        resolve(result);
+      };
+      var stallTimer = setTimeout(function () {
+        dbg$2('extract: TIMEOUT —', describeVideoState(video));
+        log.warn('getVideoFirstFrame: timed out waiting for video to load');
+        finishOnce(null);
+      }, FRAME_LOAD_TIMEOUT_MS);
+      var extractFrame = function extractFrame() {
         try {
-          var _video$duration;
-          var origWidth = video.videoWidth;
-          var origHeight = video.videoHeight;
-          var duration = Number((_video$duration = video.duration) === null || _video$duration === void 0 ? void 0 : _video$duration.toFixed(0));
-          var _calculateSize = calculateSize(origWidth, origHeight, 100, 100),
-            newWidth = _calculateSize[0],
-            newHeight = _calculateSize[1];
-          return Promise.resolve(_catch(function () {
-            return Promise.resolve(getVideoFirstFrame(videoSrc, newWidth, newHeight)).then(function (frameResult) {
-              if (!frameResult) {
-                reject(new Error('Failed to extract video frame'));
-                return;
-              }
-              var img = document.createElement('img');
-              img.onload = function () {
-                var canvas = document.createElement('canvas');
-                canvas.width = newWidth;
-                canvas.height = newHeight;
-                var ctx = canvas.getContext('2d');
-                if (!ctx) {
-                  URL.revokeObjectURL(frameResult.frameBlobUrl);
-                  reject(new Error('Failed to get canvas context'));
-                  return;
-                }
-                ctx.drawImage(img, 0, 0, newWidth, newHeight);
-                var pixels = ctx.getImageData(0, 0, canvas.width, canvas.height);
-                var binaryThumbHash = rgbaToThumbHash(pixels.width, pixels.height, pixels.data);
-                var thumb = binaryToBase64(binaryThumbHash);
-                URL.revokeObjectURL(frameResult.frameBlobUrl);
-                resolve({
-                  thumb: thumb,
-                  width: origWidth,
-                  height: origHeight,
-                  duration: duration
-                });
-              };
-              img.onerror = function () {
-                URL.revokeObjectURL(frameResult.frameBlobUrl);
-                reject(new Error('Failed to load frame image'));
-              };
-              img.src = frameResult.frameBlobUrl;
+          dbg$2('extract: extractFrame,', describeVideoState(video));
+          if (video.videoWidth === 0 || video.videoHeight === 0) {
+            finishOnce(null);
+            return;
+          }
+          var width = video.videoWidth;
+          var height = video.videoHeight;
+          var duration = Number.isFinite(video.duration) ? video.duration : 0;
+          var canvasWidth = maxWidth || width / 2;
+          var canvasHeight = maxHeight || height / 2;
+          var canvas = document.createElement('canvas');
+          canvas.width = canvasWidth;
+          canvas.height = canvasHeight;
+          var ctx = canvas.getContext('2d');
+          if (!ctx) {
+            finishOnce(null);
+            return;
+          }
+          ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+          canvas.toBlob(function (blob) {
+            if (!blob) {
+              dbg$2('extract: canvas.toBlob returned null');
+              finishOnce(null);
+              return;
+            }
+            var frameBlobUrl = URL.createObjectURL(blob);
+            finishOnce({
+              frameBlobUrl: frameBlobUrl,
+              blob: blob,
+              width: width,
+              height: height,
+              duration: duration
             });
-          }, function (err) {
-            reject(err);
-          }));
-        } catch (e) {
-          return Promise.reject(e);
+          }, 'image/jpeg', quality);
+        } catch (error) {
+          dbg$2('extract: extractFrame threw', error);
+          log.error('Error extracting video frame:', error);
+          finishOnce(null);
         }
       };
+      video.addEventListener('loadstart', function () {
+        return dbg$2('event: loadstart,', describeVideoState(video));
+      });
+      video.addEventListener('loadeddata', function () {
+        return dbg$2('event: loadeddata,', describeVideoState(video));
+      });
+      video.addEventListener('canplay', function () {
+        return dbg$2('event: canplay,', describeVideoState(video));
+      });
+      video.addEventListener('canplaythrough', function () {
+        return dbg$2('event: canplaythrough');
+      });
+      video.addEventListener('seeking', function () {
+        return dbg$2('event: seeking, currentTime =', video.currentTime);
+      });
+      video.addEventListener('stalled', function () {
+        return dbg$2('event: stalled,', describeVideoState(video));
+      });
+      video.addEventListener('suspend', function () {
+        return dbg$2('event: suspend,', describeVideoState(video));
+      });
+      video.addEventListener('waiting', function () {
+        return dbg$2('event: waiting,', describeVideoState(video));
+      });
+      video.addEventListener('emptied', function () {
+        return dbg$2('event: emptied,', describeVideoState(video));
+      });
+      video.onloadedmetadata = function () {
+        dbg$2('event: loadedmetadata,', describeVideoState(video));
+        video.currentTime = 0.01;
+        video.onseeked = function () {
+          dbg$2('event: seeked,', describeVideoState(video));
+          video.onseeked = null;
+          var capture = function capture() {
+            return requestAnimationFrame(extractFrame);
+          };
+          video.play().then(function () {
+            dbg$2('play(): resolved');
+            var done = false;
+            var _finish = function finish() {
+              if (done) return;
+              done = true;
+              video.removeEventListener('timeupdate', _finish);
+              video.removeEventListener('ended', _finish);
+              video.pause();
+              capture();
+            };
+            video.addEventListener('timeupdate', _finish);
+            video.addEventListener('ended', _finish);
+            setTimeout(_finish, 500);
+          })["catch"](function (err) {
+            dbg$2('play(): rejected —', err === null || err === void 0 ? void 0 : err.name, err === null || err === void 0 ? void 0 : err.message);
+            capture();
+          });
+        };
+      };
       video.onerror = function () {
-        reject(new Error('Failed to load video'));
+        dbg$2('event: error,', describeVideoState(video));
+        log.warn('getVideoFirstFrame: video failed to load', video.error);
+        finishOnce(null);
       };
-    }));
-  } catch (e) {
-    return Promise.reject(e);
+      video.onabort = function () {
+        dbg$2('event: abort,', describeVideoState(video));
+        finishOnce(null);
+      };
+      video.src = srcUrl;
+      dbg$2('extract: src assigned,', describeVideoState(video));
+    } catch (error) {
+      log.error('Error in extractFrameFromUrl:', error);
+      resolve(null);
+    }
+  });
+};
+var DATA_URL_MAX_BYTES = 64 * 1024 * 1024;
+var blobToDataUrl = function blobToDataUrl(blob) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function () {
+      return resolve(reader.result);
+    };
+    reader.onerror = function () {
+      return reject(reader.error);
+    };
+    reader.readAsDataURL(blob);
+  });
+};
+var _extractFrameFromBlob2 = function extractFrameFromBlob(blob, maxWidth, maxHeight, quality, allowRemux) {
+  if (quality === void 0) {
+    quality = 0.8;
   }
+  if (allowRemux === void 0) {
+    allowRemux = true;
+  }
+  return Promise.resolve(normalizeVideoBlob(blob)).then(function (_ref) {
+    var _exit = false;
+    var safeBlob = _ref.safeBlob,
+      info = _ref.info;
+    function _temp6(_result) {
+      var _exit2 = false;
+      if (_exit) return _result;
+      function _temp4(_result2) {
+        if (_exit2) return _result2;
+        if (safeBlob.size > DATA_URL_MAX_BYTES) {
+          dbg$2('fallback: blob too large for data URL fallback, size =', safeBlob.size);
+          return null;
+        }
+        return _catch(function () {
+          dbg$2('fallback: retrying via data URL, size =', safeBlob.size);
+          return Promise.resolve(blobToDataUrl(safeBlob)).then(function (dataUrl) {
+            return Promise.resolve(extractFrameFromUrl(dataUrl, maxWidth, maxHeight, quality));
+          });
+        }, function (error) {
+          dbg$2('fallback: data URL conversion failed', error);
+          log.error('getVideoFirstFrame: data URL fallback failed:', error);
+          return null;
+        });
+      }
+      var url = URL.createObjectURL(safeBlob);
+      var _temp3 = _finallyRethrows(function () {
+        return Promise.resolve(extractFrameFromUrl(url, maxWidth, maxHeight, quality)).then(function (result) {
+          if (result) {
+            _exit2 = true;
+            return result;
+          }
+        });
+      }, function (_wasThrown, _result2) {
+        URL.revokeObjectURL(url);
+        if (_wasThrown) throw _result2;
+        return _result2;
+      });
+      return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+    }
+    var _temp5 = function () {
+      if (isQuickTimeContainer(info) && isFirefox()) {
+        if (!allowRemux) {
+          dbg$2('skip: remuxed output is still a QuickTime container — giving up');
+          var _temp = null;
+          _exit = true;
+          return _temp;
+        }
+        dbg$2('skip: QuickTime (qt brand) container — Firefox cannot demux this, remuxing. codecs =', info.codecs.join(',') || '?');
+        return Promise.resolve(remuxToMp4(safeBlob)).then(function (remuxed) {
+          if (!remuxed) {
+            log.warn('getVideoFirstFrame: QuickTime container is not supported by Firefox and remux failed');
+            var _temp2 = null;
+            _exit = true;
+            return _temp2;
+          }
+          var _extractFrameFromBlob = _extractFrameFromBlob2(remuxed, maxWidth, maxHeight, quality, false);
+          _exit = true;
+          return _extractFrameFromBlob;
+        });
+      }
+    }();
+    return _temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5);
+  });
 };
 var compressAndCacheImage = function compressAndCacheImage(url, cacheKey, maxWidth, maxHeight, quality) {
   try {
     return Promise.resolve(_catch(function () {
       return Promise.resolve(fetch(url)).then(function (response) {
         return response.ok ? Promise.resolve(response.blob()).then(function (blob) {
-          var _exit = false;
-          function _temp2(_result2) {
-            if (_exit) return _result2;
+          var _exit5 = false;
+          function _temp10(_result5) {
+            if (_exit5) return _result5;
             setAttachmentToCache(cacheKey, response);
             return '';
           }
-          var _temp = function () {
+          var _temp1 = function () {
             if (blob.type.startsWith('image/')) {
               var file = new File([blob], 'image.jpeg', {
                 type: blob.type
               });
-              return Promise.resolve(resizeImageWithPica(file, maxWidth || 1280, maxHeight || 1080, quality || 1)).then(function (_ref) {
-                var compressedBlob = _ref.blob;
+              return Promise.resolve(resizeImageWithPica(file, maxWidth || 1280, maxHeight || 1080, quality || 1)).then(function (_ref2) {
+                var compressedBlob = _ref2.blob;
                 var returningUrl = compressedBlob ? URL.createObjectURL(compressedBlob) : '';
                 if (compressedBlob) {
                   var compressedResponse = new Response(compressedBlob, {
@@ -15049,13 +15547,13 @@ var compressAndCacheImage = function compressAndCacheImage(url, cacheKey, maxWid
                     }
                   });
                   setAttachmentToCache(cacheKey, compressedResponse);
-                  _exit = true;
+                  _exit5 = true;
                   return returningUrl;
                 }
               });
             }
           }();
-          return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+          return _temp1 && _temp1.then ? _temp1.then(_temp10) : _temp10(_temp1);
         }) : '';
       });
     }, function (error) {
@@ -37191,6 +37689,7 @@ var convertToAac = function convertToAac(file, messageId) {
     return Promise.reject(e);
   }
 };
+var convertMp3ToAac = convertToAac;
 var SAFARI_SUPPORTED_TYPES = new Set(['audio/mp4', 'audio/aac', 'audio/x-m4a', 'audio/wav', 'audio/x-wav', 'audio/aiff']);
 var convertAudioForSafari = function convertAudioForSafari(file, messageId) {
   try {
@@ -37212,6 +37711,15 @@ var convertAudioForSafari = function convertAudioForSafari(file, messageId) {
   }
 };
 
+var audioConversion = {
+  __proto__: null,
+  isSafari: isSafari,
+  initFFmpeg: initFFmpeg,
+  convertToAac: convertToAac,
+  convertMp3ToAac: convertMp3ToAac,
+  convertAudioForSafari: convertAudioForSafari
+};
+
 var _templateObject$v, _templateObject2$r, _templateObject3$l, _templateObject4$h, _templateObject5$e, _templateObject6$b, _templateObject7$a;
 var AudioPlayer = function AudioPlayer(_ref) {
   var _file$metadata6, _file$metadata7;
@@ -38199,80 +38707,82 @@ var Attachment = function Attachment(_ref) {
           }, messageType);
           setDownloadFilePromise(attachment.id, urlPromise);
           return Promise.resolve(urlPromise).then(function (result) {
-            function _temp5() {
-              setIsCached(true);
-              setDownloadingFile(false);
-              setAttachmentUrl(downloadingUrl);
-            }
-            var url = URL.createObjectURL(result.Body);
-            setSizeProgress(undefined);
-            var downloadingUrl = url;
-            var _temp4 = function () {
-              if (attachment.type === attachmentTypes.image) {
-                return Promise.resolve(compressAndCacheImage(url, attachment.url, renderWidth, renderHeight)).then(function (compressedUrl) {
-                  if (compressedUrl) {
-                    downloadingUrl = compressedUrl;
-                  }
-                  setAttachmentToCache(attachment.url + '_original_image_url', new Response(result.Body, {
-                    headers: {
-                      'Content-Type': 'image/jpeg'
+            function _temp7(body) {
+              function _temp6() {
+                setIsCached(true);
+                setDownloadingFile(false);
+                setAttachmentUrl(downloadingUrl);
+              }
+              var url = URL.createObjectURL(body);
+              setSizeProgress(undefined);
+              var downloadingUrl = url;
+              var _temp5 = function () {
+                if (attachment.type === attachmentTypes.image) {
+                  return Promise.resolve(compressAndCacheImage(url, attachment.url, renderWidth, renderHeight)).then(function (compressedUrl) {
+                    if (compressedUrl) {
+                      downloadingUrl = compressedUrl;
                     }
-                  }));
-                  dispatch(setUpdateMessageAttachmentAC(attachment.url + '_original_image_url', url));
-                });
-              } else {
-                var _temp3 = function _temp3() {
-                  if (attachment.type === attachmentTypes.video) {
-                    setAttachmentToCache(attachment.url + "_original_video_url", new Response(result.Body, {
+                    setAttachmentToCache(attachment.url + '_original_image_url', new Response(result.Body, {
                       headers: {
-                        'Content-Type': attachment.type || 'application/octet-stream'
+                        'Content-Type': 'image/jpeg'
                       }
                     }));
-                    dispatch(setUpdateMessageAttachmentAC(attachment.url + "_original_video_url", url));
-                  } else {
-                    setAttachmentToCache(attachment.url, new Response(result.Body, {
-                      headers: {
-                        'Content-Type': attachment.type || 'application/octet-stream'
-                      }
-                    }));
-                    dispatch(setUpdateMessageAttachmentAC(attachment.url, url));
-                  }
-                };
-                var _temp2 = function () {
-                  if (attachment.type === attachmentTypes.video) {
-                    return Promise.resolve(getVideoFirstFrame(url, renderWidth, renderHeight, 0.8)).then(function (result) {
-                      var _temp = function () {
-                        if (result) {
-                          var frameBlobUrl = result.frameBlobUrl,
-                            blob = result.blob;
-                          var response = new Response(blob, {
+                    dispatch(setUpdateMessageAttachmentAC(attachment.url + '_original_image_url', url));
+                  });
+                } else {
+                  var _temp4 = function () {
+                    if (attachment.type === attachmentTypes.video) {
+                      return Promise.resolve(getVideoFirstFrame(body, renderWidth, renderHeight, 0.8)).then(function (frameResult) {
+                        function _temp3() {
+                          setAttachmentToCache(attachment.url + "_original_video_url", new Response(body, {
                             headers: {
-                              'Content-Type': 'image/jpeg'
+                              'Content-Type': body.type || 'application/octet-stream'
                             }
-                          });
-                          var key = attachment.url;
-                          return Promise.resolve(setAttachmentToCache(key, response)).then(function () {
-                            dispatch(setUpdateMessageAttachmentAC(key, frameBlobUrl));
-                          });
+                          }));
+                          dispatch(setUpdateMessageAttachmentAC(attachment.url + "_original_video_url", url));
                         }
-                      }();
-                      if (_temp && _temp.then) return _temp.then(function () {});
-                    });
-                  }
-                }();
-                return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
-              }
-            }();
-            return _temp4 && _temp4.then ? _temp4.then(_temp5) : _temp5(_temp4);
+                        var _temp2 = function () {
+                          if (frameResult) {
+                            var frameBlobUrl = frameResult.frameBlobUrl,
+                              blob = frameResult.blob;
+                            var response = new Response(blob, {
+                              headers: {
+                                'Content-Type': 'image/jpeg'
+                              }
+                            });
+                            var key = attachment.url;
+                            return Promise.resolve(setAttachmentToCache(key, response)).then(function () {
+                              dispatch(setUpdateMessageAttachmentAC(key, frameBlobUrl));
+                            });
+                          }
+                        }();
+                        return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
+                      });
+                    } else {
+                      setAttachmentToCache(attachment.url, new Response(result.Body, {
+                        headers: {
+                          'Content-Type': attachment.type || 'application/octet-stream'
+                        }
+                      }));
+                      dispatch(setUpdateMessageAttachmentAC(attachment.url, url));
+                    }
+                  }();
+                  if (_temp4 && _temp4.then) return _temp4.then(function () {});
+                }
+              }();
+              return _temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5);
+            }
+            var _temp = attachment.type === attachmentTypes.video;
+            return _temp ? Promise.resolve(ensurePlayableVideoBlob(result.Body)).then(_temp7) : _temp7(result.Body);
           });
         } else {
-          var _temp7 = function _temp7(_result2) {
+          var _temp9 = function _temp9(_result2) {
             if (_exit) return _result2;
             setAttachmentUrl(downloadingUrl);
           };
           var _exit = false;
           var downloadingUrl = attachment.url;
-          var _temp6 = function () {
+          var _temp8 = function () {
             if (attachment.type === attachmentTypes.image) {
               return Promise.resolve(compressAndCacheImage(attachment.url, attachment.url, renderWidth, renderHeight)).then(function (compressedUrl) {
                 if (compressedUrl) {
@@ -38283,47 +38793,51 @@ var Attachment = function Attachment(_ref) {
             } else {
               fetch(attachment.url).then(function (response) {
                 try {
-                  return Promise.resolve(response.blob()).then(function (blob) {
-                    function _temp1() {
-                      setAttachmentUrl(blobUrl);
-                      setIsCached(true);
-                    }
-                    var blobUrl = URL.createObjectURL(blob);
-                    var _temp0 = function () {
-                      if (attachment.type === attachmentTypes.video) {
-                        return Promise.resolve(getVideoFirstFrame(blobUrl, renderWidth, renderHeight, 0.8)).then(function (frameResult) {
-                          function _temp9() {
-                            setAttachmentToCache(attachment.url + '_original_video_url', new Response(blob, {
-                              headers: {
-                                'Content-Type': blob.type || 'video/mp4'
-                              }
-                            }));
-                            dispatch(setUpdateMessageAttachmentAC(attachment.url + '_original_video_url', blobUrl));
-                          }
-                          var _temp8 = function () {
-                            if (frameResult) {
-                              var frameBlobUrl = frameResult.frameBlobUrl,
-                                frameBlob = frameResult.blob;
-                              return Promise.resolve(setAttachmentToCache(attachment.url, new Response(frameBlob, {
+                  return Promise.resolve(response.blob()).then(function (rawBlob) {
+                    function _temp13(blob) {
+                      function _temp12() {
+                        setAttachmentUrl(blobUrl);
+                        setIsCached(true);
+                      }
+                      var blobUrl = URL.createObjectURL(blob);
+                      var _temp11 = function () {
+                        if (attachment.type === attachmentTypes.video) {
+                          return Promise.resolve(getVideoFirstFrame(blob, renderWidth, renderHeight, 0.8)).then(function (frameResult) {
+                            function _temp10() {
+                              setAttachmentToCache(attachment.url + '_original_video_url', new Response(blob, {
                                 headers: {
-                                  'Content-Type': 'image/jpeg'
+                                  'Content-Type': blob.type || 'video/mp4'
                                 }
-                              }))).then(function () {
-                                dispatch(setUpdateMessageAttachmentAC(getAttachmentURLWithVersion(attachment.url), frameBlobUrl));
-                              });
+                              }));
+                              dispatch(setUpdateMessageAttachmentAC(attachment.url + '_original_video_url', blobUrl));
                             }
-                          }();
-                          return _temp8 && _temp8.then ? _temp8.then(_temp9) : _temp9(_temp8);
-                        });
-                      } else {
-                        setAttachmentToCache(attachment.url, new Response(blob, {
-                          headers: {
-                            'Content-Type': blob.type || 'application/octet-stream'
-                          }
-                        }));
-                      }
-                    }();
-                    return _temp0 && _temp0.then ? _temp0.then(_temp1) : _temp1(_temp0);
+                            var _temp1 = function () {
+                              if (frameResult) {
+                                var frameBlobUrl = frameResult.frameBlobUrl,
+                                  frameBlob = frameResult.blob;
+                                return Promise.resolve(setAttachmentToCache(attachment.url, new Response(frameBlob, {
+                                  headers: {
+                                    'Content-Type': 'image/jpeg'
+                                  }
+                                }))).then(function () {
+                                  dispatch(setUpdateMessageAttachmentAC(getAttachmentURLWithVersion(attachment.url), frameBlobUrl));
+                                });
+                              }
+                            }();
+                            return _temp1 && _temp1.then ? _temp1.then(_temp10) : _temp10(_temp1);
+                          });
+                        } else {
+                          setAttachmentToCache(attachment.url, new Response(blob, {
+                            headers: {
+                              'Content-Type': blob.type || 'application/octet-stream'
+                            }
+                          }));
+                        }
+                      }();
+                      return _temp11 && _temp11.then ? _temp11.then(_temp12) : _temp12(_temp11);
+                    }
+                    var _temp0 = attachment.type === attachmentTypes.video;
+                    return _temp0 ? Promise.resolve(ensurePlayableVideoBlob(rawBlob)).then(_temp13) : _temp13(rawBlob);
                   });
                 } catch (e) {
                   return Promise.reject(e);
@@ -38334,7 +38848,7 @@ var Attachment = function Attachment(_ref) {
               _exit = true;
             }
           }();
-          return _temp6 && _temp6.then ? _temp6.then(_temp7) : _temp7(_temp6);
+          return _temp8 && _temp8.then ? _temp8.then(_temp9) : _temp9(_temp8);
         }
       }());
     } catch (e) {
@@ -38350,9 +38864,9 @@ var Attachment = function Attachment(_ref) {
     if (!attachment.attachmentUrl && connectionStatus === CONNECTION_STATUS.CONNECTED && attachment.id && !attachmentUrlFromMap && !(attachment.type === attachmentTypes.file || attachment.type === attachmentTypes.link)) {
       getAttachmentUrlFromCache(attachment.url).then(function (cachedUrl) {
         try {
-          var _temp12 = function () {
+          var _temp16 = function () {
             if (attachment.type === attachmentTypes.image && !isPreview) {
-              var _temp11 = function () {
+              var _temp15 = function () {
                 if (cachedUrl) {
                   setAttachmentUrl(cachedUrl);
                   dispatch(setUpdateMessageAttachmentAC(attachment.url, cachedUrl));
@@ -38360,7 +38874,7 @@ var Attachment = function Attachment(_ref) {
                 } else {
                   setIsCached(false);
                   setDownloadingFile(true);
-                  var _temp10 = function () {
+                  var _temp14 = function () {
                     if (customDownloader) {
                       customDownloader(attachment.url, false, function (progress) {
                         var loadedRes = progress.loaded && progress.loaded / progress.total;
@@ -38412,10 +38926,10 @@ var Attachment = function Attachment(_ref) {
                       });
                     }
                   }();
-                  if (_temp10 && _temp10.then) return _temp10.then(function () {});
+                  if (_temp14 && _temp14.then) return _temp14.then(function () {});
                 }
               }();
-              if (_temp11 && _temp11.then) return _temp11.then(function () {});
+              if (_temp15 && _temp15.then) return _temp15.then(function () {});
             } else {
               if (cachedUrl) {
                 setAttachmentUrl(cachedUrl);
@@ -38429,7 +38943,7 @@ var Attachment = function Attachment(_ref) {
               }
             }
           }();
-          return Promise.resolve(_temp12 && _temp12.then ? _temp12.then(function () {}) : void 0);
+          return Promise.resolve(_temp16 && _temp16.then ? _temp16.then(function () {}) : void 0);
         } catch (e) {
           return Promise.reject(e);
         }
@@ -38447,13 +38961,13 @@ var Attachment = function Attachment(_ref) {
             setProgress(uploadPercent);
           }, messageType).then(function (url) {
             try {
-              var _temp14 = function _temp14() {
+              var _temp18 = function _temp18() {
                 setAttachmentUrl(downloadingUrl);
                 dispatch(setUpdateMessageAttachmentAC(attachment.url, attachment.url));
                 setDownloadingFile(false);
               };
               var downloadingUrl = url;
-              var _temp13 = function () {
+              var _temp17 = function () {
                 if (attachment.type === attachmentTypes.image) {
                   return Promise.resolve(compressAndCacheImage(url, attachment.url, renderWidth, renderHeight)).then(function (compressedUrl) {
                     if (compressedUrl) {
@@ -38466,7 +38980,7 @@ var Attachment = function Attachment(_ref) {
                   });
                 }
               }();
-              return Promise.resolve(_temp13 && _temp13.then ? _temp13.then(_temp14) : _temp14(_temp13));
+              return Promise.resolve(_temp17 && _temp17.then ? _temp17.then(_temp18) : _temp18(_temp17));
             } catch (e) {
               return Promise.reject(e);
             }
@@ -51384,252 +51898,260 @@ var SendMessageInput = function SendMessageInput(_ref3) {
   };
   var handleAddAttachment = function handleAddAttachment(file, isMediaAttachment) {
     try {
-      var customUploader = getCustomUploader();
-      var fileType = file.type.split('/')[0];
-      var tid = uuid.v4();
-      var reader = new FileReader();
-      var handleAttachmentImageForCache = function handleAttachmentImageForCache(attachment) {
-        try {
-          var _attachment$metadata;
-          var url = URL.createObjectURL(attachment.data);
-          dispatch(setUpdateMessageAttachmentAC((attachment === null || attachment === void 0 ? void 0 : (_attachment$metadata = attachment.metadata) === null || _attachment$metadata === void 0 ? void 0 : _attachment$metadata.tmb) || '', url));
-          return Promise.resolve();
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
-      var handleAttachmentVideoForCache = function handleAttachmentVideoForCache(attachment) {
-        try {
-          var _calculateRenderedIma = calculateRenderedImageWidth(attachment.metadata.szh || 400, attachment.metadata.szh || 400),
-            newWidth = _calculateRenderedIma[0],
-            newHeight = _calculateRenderedIma[1];
-          var url = URL.createObjectURL(attachment.data);
-          return Promise.resolve(getVideoFirstFrame(url, newWidth, newHeight, 0.8)).then(function (result) {
-            if (result) {
-              var _attachment$metadata2;
-              var frameBlobUrl = result.frameBlobUrl;
-              dispatch(setUpdateMessageAttachmentAC((attachment === null || attachment === void 0 ? void 0 : (_attachment$metadata2 = attachment.metadata) === null || _attachment$metadata2 === void 0 ? void 0 : _attachment$metadata2.tmb) || '', frameBlobUrl));
-            }
-          });
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
-      reader.onload = function () {
-        try {
-          setPendingAttachment(tid, {
-            file: file
-          });
-          var _temp8 = function () {
-            if (customUploader) {
-              var _temp4 = function () {
-                if (fileType === 'image') {
-                  resizeImage(file).then(function (resizedFile) {
-                    try {
-                      return Promise.resolve(createImageThumbnail(file)).then(function (_ref4) {
-                        var _resizedFile$blob;
-                        var thumbnail = _ref4.thumbnail,
-                          imageWidth = _ref4.imageWidth,
-                          imageHeight = _ref4.imageHeight;
-                        var attachment = {
-                          data: file,
-                          upload: false,
-                          type: isMediaAttachment ? fileType : 'file',
-                          attachmentUrl: URL.createObjectURL(resizedFile.blob),
-                          tid: tid,
-                          size: isMediaAttachment ? resizedFile !== null && resizedFile !== void 0 && resizedFile.blob ? resizedFile === null || resizedFile === void 0 ? void 0 : (_resizedFile$blob = resizedFile.blob) === null || _resizedFile$blob === void 0 ? void 0 : _resizedFile$blob.size : file.size : file.size,
-                          metadata: {
-                            szw: imageWidth,
-                            szh: imageHeight,
-                            tmb: thumbnail
-                          }
-                        };
-                        handleAttachmentImageForCache(attachment);
+      var _temp4 = function _temp4() {
+        var fileType = file.type.split('/')[0];
+        var tid = uuid.v4();
+        var reader = new FileReader();
+        var handleAttachmentImageForCache = function handleAttachmentImageForCache(attachment) {
+          try {
+            var _attachment$metadata;
+            var url = URL.createObjectURL(attachment.data);
+            dispatch(setUpdateMessageAttachmentAC((attachment === null || attachment === void 0 ? void 0 : (_attachment$metadata = attachment.metadata) === null || _attachment$metadata === void 0 ? void 0 : _attachment$metadata.tmb) || '', url));
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+        var handleAttachmentVideoForCache = function handleAttachmentVideoForCache(attachment) {
+          try {
+            var _calculateRenderedIma = calculateRenderedImageWidth(attachment.metadata.szh || 400, attachment.metadata.szh || 400),
+              newWidth = _calculateRenderedIma[0],
+              newHeight = _calculateRenderedIma[1];
+            return Promise.resolve(getVideoFirstFrame(attachment.data, newWidth, newHeight, 0.8)).then(function (result) {
+              if (result) {
+                var _attachment$metadata2;
+                var frameBlobUrl = result.frameBlobUrl;
+                dispatch(setUpdateMessageAttachmentAC((attachment === null || attachment === void 0 ? void 0 : (_attachment$metadata2 = attachment.metadata) === null || _attachment$metadata2 === void 0 ? void 0 : _attachment$metadata2.tmb) || '', frameBlobUrl));
+              }
+            });
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+        reader.onload = function () {
+          try {
+            setPendingAttachment(tid, {
+              file: file
+            });
+            var _temp0 = function () {
+              if (customUploader) {
+                var _temp6 = function () {
+                  if (fileType === 'image') {
+                    resizeImage(file).then(function (resizedFile) {
+                      try {
+                        return Promise.resolve(createImageThumbnail(file)).then(function (_ref4) {
+                          var _resizedFile$blob;
+                          var thumbnail = _ref4.thumbnail,
+                            imageWidth = _ref4.imageWidth,
+                            imageHeight = _ref4.imageHeight;
+                          var attachment = {
+                            data: file,
+                            upload: false,
+                            type: isMediaAttachment ? fileType : 'file',
+                            attachmentUrl: URL.createObjectURL(resizedFile.blob),
+                            tid: tid,
+                            size: isMediaAttachment ? resizedFile !== null && resizedFile !== void 0 && resizedFile.blob ? resizedFile === null || resizedFile === void 0 ? void 0 : (_resizedFile$blob = resizedFile.blob) === null || _resizedFile$blob === void 0 ? void 0 : _resizedFile$blob.size : file.size : file.size,
+                            metadata: {
+                              szw: imageWidth,
+                              szh: imageHeight,
+                              tmb: thumbnail
+                            }
+                          };
+                          handleAttachmentImageForCache(attachment);
+                          setAttachments(function (prevState) {
+                            return [].concat(prevState, [attachment]);
+                          });
+                        });
+                      } catch (e) {
+                        return Promise.reject(e);
+                      }
+                    });
+                  } else {
+                    var _temp1 = function () {
+                      if (fileType === 'video') {
+                        return Promise.resolve(getFrame(file, 0)).then(function (_ref5) {
+                          var thumb = _ref5.thumb,
+                            width = _ref5.width,
+                            height = _ref5.height,
+                            duration = _ref5.duration;
+                          var attachment = {
+                            data: file,
+                            upload: false,
+                            type: isMediaAttachment ? fileType : 'file',
+                            attachmentUrl: URL.createObjectURL(file),
+                            tid: tid,
+                            size: file.size,
+                            metadata: {
+                              szw: width,
+                              szh: height,
+                              tmb: thumb,
+                              dur: duration
+                            }
+                          };
+                          handleAttachmentVideoForCache(attachment);
+                          setAttachments(function (prevState) {
+                            return [].concat(prevState, [attachment]);
+                          });
+                        });
+                      } else {
                         setAttachments(function (prevState) {
-                          return [].concat(prevState, [attachment]);
+                          return [].concat(prevState, [{
+                            data: file,
+                            upload: false,
+                            type: 'file',
+                            tid: tid,
+                            size: file.size
+                          }]);
                         });
-                      });
-                    } catch (e) {
-                      return Promise.reject(e);
-                    }
-                  });
-                } else {
-                  var _temp9 = function () {
-                    if (fileType === 'video') {
-                      return Promise.resolve(getFrame(URL.createObjectURL(file), 0)).then(function (_ref5) {
-                        var thumb = _ref5.thumb,
-                          width = _ref5.width,
-                          height = _ref5.height,
-                          duration = _ref5.duration;
-                        var attachment = {
-                          data: file,
-                          upload: false,
-                          type: isMediaAttachment ? fileType : 'file',
-                          attachmentUrl: URL.createObjectURL(file),
-                          tid: tid,
-                          size: file.size,
-                          metadata: {
-                            szw: width,
-                            szh: height,
-                            tmb: thumb,
-                            dur: duration
+                      }
+                    }();
+                    if (_temp1 && _temp1.then) return _temp1.then(function () {});
+                  }
+                }();
+                if (_temp6 && _temp6.then) return _temp6.then(function () {});
+              } else {
+                var _temp9 = function () {
+                  if (fileType === 'image') {
+                    var _temp7 = function () {
+                      if (isMediaAttachment) {
+                        return Promise.resolve(createImageThumbnail(file)).then(function (_ref6) {
+                          var thumbnail = _ref6.thumbnail,
+                            imageWidth = _ref6.imageWidth,
+                            imageHeight = _ref6.imageHeight;
+                          var metas = {
+                            thumbnail: thumbnail,
+                            imageWidth: imageWidth,
+                            imageHeight: imageHeight
+                          };
+                          if (file.type === 'image/gif') {
+                            setAttachments(function (prevState) {
+                              return [].concat(prevState, [{
+                                data: file,
+                                upload: true,
+                                attachmentUrl: URL.createObjectURL(file),
+                                tid: tid,
+                                type: fileType,
+                                size: file.size,
+                                metadata: JSON.stringify({
+                                  tmb: metas.thumbnail,
+                                  szw: metas.imageWidth,
+                                  szh: metas.imageHeight
+                                })
+                              }]);
+                            });
+                          } else {
+                            resizeImage(file).then(function (resizedFileData) {
+                              try {
+                                var resizedFile = new File([resizedFileData.blob], resizedFileData.file.name);
+                                var attachment = {
+                                  data: resizedFile,
+                                  upload: true,
+                                  attachmentUrl: URL.createObjectURL(resizedFile),
+                                  tid: tid,
+                                  type: fileType,
+                                  size: resizedFile.size,
+                                  metadata: JSON.stringify({
+                                    tmb: metas.thumbnail,
+                                    szw: resizedFileData.newWidth,
+                                    szh: resizedFileData.newHeight
+                                  })
+                                };
+                                handleAttachmentImageForCache(attachment);
+                                setAttachments(function (prevState) {
+                                  return [].concat(prevState, [attachment]);
+                                });
+                                return Promise.resolve();
+                              } catch (e) {
+                                return Promise.reject(e);
+                              }
+                            });
                           }
-                        };
-                        handleAttachmentVideoForCache(attachment);
-                        setAttachments(function (prevState) {
-                          return [].concat(prevState, [attachment]);
                         });
-                      });
-                    } else {
-                      setAttachments(function (prevState) {
-                        return [].concat(prevState, [{
-                          data: file,
-                          upload: false,
-                          type: 'file',
-                          tid: tid,
-                          size: file.size
-                        }]);
-                      });
-                    }
-                  }();
-                  if (_temp9 && _temp9.then) return _temp9.then(function () {});
-                }
-              }();
-              if (_temp4 && _temp4.then) return _temp4.then(function () {});
-            } else {
-              var _temp7 = function () {
-                if (fileType === 'image') {
-                  var _temp5 = function () {
-                    if (isMediaAttachment) {
-                      return Promise.resolve(createImageThumbnail(file)).then(function (_ref6) {
-                        var thumbnail = _ref6.thumbnail,
-                          imageWidth = _ref6.imageWidth,
-                          imageHeight = _ref6.imageHeight;
-                        var metas = {
-                          thumbnail: thumbnail,
-                          imageWidth: imageWidth,
-                          imageHeight: imageHeight
-                        };
-                        if (file.type === 'image/gif') {
+                      } else {
+                        return Promise.resolve(createImageThumbnail(file, undefined, 50, 50)).then(function (_ref7) {
+                          var thumbnail = _ref7.thumbnail;
                           setAttachments(function (prevState) {
                             return [].concat(prevState, [{
                               data: file,
+                              type: 'file',
                               upload: true,
                               attachmentUrl: URL.createObjectURL(file),
                               tid: tid,
-                              type: fileType,
                               size: file.size,
                               metadata: JSON.stringify({
-                                tmb: metas.thumbnail,
-                                szw: metas.imageWidth,
-                                szh: metas.imageHeight
+                                tmb: thumbnail
                               })
                             }]);
                           });
-                        } else {
-                          resizeImage(file).then(function (resizedFileData) {
-                            try {
-                              var resizedFile = new File([resizedFileData.blob], resizedFileData.file.name);
-                              var attachment = {
-                                data: resizedFile,
-                                upload: true,
-                                attachmentUrl: URL.createObjectURL(resizedFile),
-                                tid: tid,
-                                type: fileType,
-                                size: resizedFile.size,
-                                metadata: JSON.stringify({
-                                  tmb: metas.thumbnail,
-                                  szw: resizedFileData.newWidth,
-                                  szh: resizedFileData.newHeight
-                                })
-                              };
-                              handleAttachmentImageForCache(attachment);
-                              setAttachments(function (prevState) {
-                                return [].concat(prevState, [attachment]);
-                              });
-                              return Promise.resolve();
-                            } catch (e) {
-                              return Promise.reject(e);
-                            }
+                        });
+                      }
+                    }();
+                    if (_temp7 && _temp7.then) return _temp7.then(function () {});
+                  } else {
+                    var _temp10 = function () {
+                      if (fileType === 'video') {
+                        return Promise.resolve(getFrame(file, 0)).then(function (_ref8) {
+                          var thumb = _ref8.thumb,
+                            width = _ref8.width,
+                            height = _ref8.height,
+                            duration = _ref8.duration;
+                          var metas = JSON.stringify({
+                            tmb: thumb,
+                            width: width,
+                            height: height,
+                            dur: duration
                           });
-                        }
-                      });
-                    } else {
-                      return Promise.resolve(createImageThumbnail(file, undefined, 50, 50)).then(function (_ref7) {
-                        var thumbnail = _ref7.thumbnail;
-                        setAttachments(function (prevState) {
-                          return [].concat(prevState, [{
+                          var attachment = {
                             data: file,
-                            type: 'file',
+                            type: 'video',
                             upload: true,
+                            size: file.size,
                             attachmentUrl: URL.createObjectURL(file),
                             tid: tid,
-                            size: file.size,
-                            metadata: JSON.stringify({
-                              tmb: thumbnail
-                            })
-                          }]);
-                        });
-                      });
-                    }
-                  }();
-                  if (_temp5 && _temp5.then) return _temp5.then(function () {});
-                } else {
-                  var _temp0 = function () {
-                    if (fileType === 'video') {
-                      return Promise.resolve(getFrame(URL.createObjectURL(file), 0)).then(function (_ref8) {
-                        var thumb = _ref8.thumb,
-                          width = _ref8.width,
-                          height = _ref8.height,
-                          duration = _ref8.duration;
-                        var metas = JSON.stringify({
-                          tmb: thumb,
-                          width: width,
-                          height: height,
-                          dur: duration
+                            metadata: metas
+                          };
+                          handleAttachmentVideoForCache(attachment);
+                          setAttachments(function (prevState) {
+                            return [].concat(prevState, [attachment]);
+                          });
                         });
-                        var attachment = {
-                          data: file,
-                          type: 'video',
-                          upload: true,
-                          size: file.size,
-                          attachmentUrl: URL.createObjectURL(file),
-                          tid: tid,
-                          metadata: metas
-                        };
-                        handleAttachmentVideoForCache(attachment);
+                      } else {
                         setAttachments(function (prevState) {
-                          return [].concat(prevState, [attachment]);
+                          return [].concat(prevState, [{
+                            data: file,
+                            upload: true,
+                            type: 'file',
+                            size: file.size,
+                            tid: tid
+                          }]);
                         });
-                      });
-                    } else {
-                      setAttachments(function (prevState) {
-                        return [].concat(prevState, [{
-                          data: file,
-                          upload: true,
-                          type: 'file',
-                          size: file.size,
-                          tid: tid
-                        }]);
-                      });
-                    }
-                  }();
-                  if (_temp0 && _temp0.then) return _temp0.then(function () {});
-                }
-              }();
-              if (_temp7 && _temp7.then) return _temp7.then(function () {});
-            }
-          }();
-          return Promise.resolve(_temp8 && _temp8.then ? _temp8.then(function () {}) : void 0);
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
-      reader.onerror = function (e) {
-        log.info(' error on read file onError', e);
+                      }
+                    }();
+                    if (_temp10 && _temp10.then) return _temp10.then(function () {});
+                  }
+                }();
+                if (_temp9 && _temp9.then) return _temp9.then(function () {});
+              }
+            }();
+            return Promise.resolve(_temp0 && _temp0.then ? _temp0.then(function () {}) : void 0);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+        reader.onerror = function (e) {
+          log.info(' error on read file onError', e);
+        };
+        reader.readAsBinaryString(file);
       };
-      reader.readAsBinaryString(file);
-      return Promise.resolve();
+      var customUploader = getCustomUploader();
+      var _temp3 = function () {
+        if (file.type.split('/')[0] === 'video') {
+          return Promise.resolve(remuxVideoFileForUpload(file)).then(function (_remuxVideoFileForUpl) {
+            file = _remuxVideoFileForUpl;
+          });
+        }
+      }();
+      return Promise.resolve(_temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3));
     } catch (e) {
       return Promise.reject(e);
     }
@@ -51688,14 +52210,14 @@ var SendMessageInput = function SendMessageInput(_ref3) {
               }
             }
           }
-          var _temp1 = function () {
+          var _temp11 = function () {
             if (allowUpload) {
               return Promise.resolve(handleAddAttachmentWithViewOnceCheck(file, isMediaAttachment)).then(function () {});
             } else {
               showFileUploadError(errorMessage);
             }
           }();
-          return Promise.resolve(_temp1 && _temp1.then ? _temp1.then(function () {}) : void 0);
+          return Promise.resolve(_temp11 && _temp11.then ? _temp11.then(function () {}) : void 0);
         } catch (e) {
           return Promise.reject(e);
         }