react-input-emoji 5.0.0 → 5.0.1

package/dist/index.es.js

@@ -34,7 +34,539 @@ function styleInject(css, ref) {
 var css_248z = ".react-input-emoji--container {\n  color: #4b4b4b;\n  text-rendering: optimizeLegibility;\n  background-color: #fff;\n  border: 1px solid #fff;\n  border-radius: 21px;\n  margin: 5px 10px;\n  box-sizing: border-box;\n  flex: 1 1 auto;\n  font-size: 15px;\n  font-family: sans-serif;\n  font-weight: 400;\n  line-height: 20px;\n  min-height: 20px;\n  min-width: 0;\n  outline: none;\n  width: inherit;\n  will-change: width;\n  vertical-align: baseline;\n  border: 1px solid #eaeaea;\n  margin-right: 0;\n}\n\n.react-input-emoji--wrapper {\n  display: flex;\n  overflow: hidden;\n  flex: 1;\n  position: relative;\n  padding-right: 0;\n  vertical-align: baseline;\n  outline: none;\n  margin: 0;\n  padding: 0;\n  border: 0;\n}\n\n.react-input-emoji--input {\n  font-weight: 400;\n  max-height: 100px;\n  min-height: 20px;\n  outline: none;\n  overflow-x: hidden;\n  overflow-y: auto;\n  position: relative;\n  white-space: pre-wrap;\n  word-wrap: break-word;\n  z-index: 1;\n  width: 100%;\n  user-select: text;\n  padding: 9px 12px 11px;\n  text-align: left;\n}\n\n.react-input-emoji--input img {\n  vertical-align: middle;\n  width: 18px !important;\n  height: 18px !important;\n  display: inline !important;\n  margin-left: 1px;\n  margin-right: 1px;\n}\n\n.react-input-emoji--overlay {\n  position: fixed;\n  width: 100%;\n  height: 100%;\n  top: 0;\n  left: 0;\n  z-index: 9;\n}\n\n.react-input-emoji--placeholder {\n  color: #a0a0a0;\n  pointer-events: none;\n  position: absolute;\n  user-select: none;\n  z-index: 2;\n  left: 16px;\n  top: 0;\n  bottom: 0;\n  display: flex;\n  align-items: center;\n  width: calc(100% - 22px);\n}\n\n.react-input-emoji--button {\n  position: relative;\n  display: block;\n  text-align: center;\n  padding: 0 10px;\n  overflow: hidden;\n  transition: color 0.1s ease-out;\n  margin: 0;\n  box-shadow: none;\n  background: none;\n  border: none;\n  outline: none;\n  cursor: pointer;\n  flex-shrink: 0;\n}\n\n.react-input-emoji--button svg {\n  fill: #858585;\n}\n\n.react-input-emoji--button__show svg {\n  fill: #128b7e;\n}\n\n.react-emoji {\n  display: flex;\n  align-items: center;\n  position: relative;\n  width: 100%;\n}\n\n.react-emoji-picker--container {\n  position: absolute;\n  top: 0;\n  width: 100%;\n}\n\n.react-emoji-picker--wrapper {\n  position: absolute;\n  bottom: 0;\n  right: 0;\n  height: 435px;\n  width: 352px;\n  overflow: hidden;\n  z-index: 10;\n}\n\n.react-emoji-picker {\n  position: absolute;\n  top: 0;\n  left: 0;\n  animation: slidein 0.1s ease-in-out;\n}\n\n.react-emoji-picker__show {\n  top: 0;\n}\n\n.react-input-emoji--mention--container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  z-index: 10;\n}\n\n.react-input-emoji--mention--list {\n  background-color: #fafafa;\n  border: 1px solid #eaeaea;\n  border-radius: 4px;\n  margin: 0;\n  padding: 0;\n  list-style: none;\n  display: flex;\n  gap: 5px;\n  flex-direction: column;\n  position: absolute;\n  bottom: 0;\n  width: 100%;\n  left: 0;\n}\n\n.react-input-emoji--mention--item {\n  display: flex;\n  align-items: center;\n  gap: 10px;\n  padding: 5px 10px;\n  background-color: transparent;\n  width: 100%;\n  margin: 0;\n  border: 0;\n}\n\n.react-input-emoji--mention--item__selected {\n  background-color: #eeeeee;\n}\n\n.react-input-emoji--mention--item--img {\n  width: 34px;\n  height: 34px;\n  border-radius: 50%;\n}\n\n.react-input-emoji--mention--item--name {\n  font-size: 16px;\n  color: #333;\n}\n\n.react-input-emoji--mention--item--name__selected {\n  color: green;\n}\n\n.react-input-emoji--mention--text {\n  color: #039be5;\n}\n\n.react-input-emoji--mention--loading {\n  background-color: #fafafa;\n  border: 1px solid #eaeaea;\n  border-radius: 4px;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  padding: 10px 0;\n  position: absolute;\n  bottom: 0;\n  left: 0;\n  width: 100%;\n}\n\n.react-input-emoji--mention--loading--spinner,\n.react-input-emoji--mention--loading--spinner::after {\n  border-radius: 50%;\n  width: 10em;\n  height: 10em;\n}\n\n.react-input-emoji--mention--loading--spinner {\n  margin: 1px auto;\n  font-size: 2px;\n  position: relative;\n  text-indent: -9999em;\n  border-top: 1.1em solid rgba(0, 0, 0, 0.1);\n  border-right: 1.1em solid rgba(0, 0, 0, 0.1);\n  border-bottom: 1.1em solid rgba(0, 0, 0, 0.1);\n  border-left: 1.1em solid rgba(0, 0, 0, 0.4);\n  transform: translateZ(0);\n  animation: load8 1.1s infinite linear;\n}\n\n@keyframes load8 {\n  0% {\n    transform: rotate(0deg);\n  }\n  100% {\n    transform: rotate(360deg);\n  }\n}\n\n@keyframes slidein {\n  from {\n    opacity: 0;\n  }\n\n  to {\n    opacity: 1;\n  }\n}\n";
 styleInject(css_248z);
 
-// @ts-check
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
 /**
  * Replace all text with emoji with an image html tag
  * @param {string} text
@@ -42,12 +574,12 @@ styleInject(css_248z);
  */
 
 function replaceAllTextEmojis(text) {
-  let allEmojis = getAllEmojisFromText(text);
+  var allEmojis = getAllEmojisFromText(text);
 
   if (allEmojis) {
-    allEmojis = [...new Set(allEmojis)]; // remove duplicates
+    allEmojis = _toConsumableArray(new Set(allEmojis)); // remove duplicates
 
-    allEmojis.forEach(emoji => {
+    allEmojis.forEach(function (emoji) {
       text = replaceAll(text, emoji, getInputEmojiHTML(emoji));
     });
   }
@@ -84,7 +616,7 @@ function getAllEmojisFromText(text) {
 
 
 function getImageEmoji(emoji) {
-  return getInputEmojiHTML(emoji.native);
+  return getInputEmojiHTML(emoji["native"]);
 } // eslint-disable-next-line valid-jsdoc
 
 /**
@@ -94,7 +626,7 @@ function getImageEmoji(emoji) {
  */
 
 function getInputEmojiHTML(emoji) {
-  return `<span class="width: 18px; height: 18px; display: inline-block; margin: 0 1px;">${emoji}</span>`;
+  return "<span class=\"width: 18px; height: 18px; display: inline-block; margin: 0 1px;\">".concat(emoji, "</span>");
 }
 /**
  *
@@ -104,10 +636,10 @@ function getInputEmojiHTML(emoji) {
 
 
 function replaceAllTextEmojiToString(html) {
-  const container = document.createElement("div");
+  var container = document.createElement("div");
   container.innerHTML = html;
-  const images = Array.prototype.slice.call(container.querySelectorAll("img"));
-  images.forEach(image => {
+  var images = Array.prototype.slice.call(container.querySelectorAll("img"));
+  images.forEach(function (image) {
     container.innerHTML = container.innerHTML.replace(image.outerHTML, image.dataset.emoji);
   });
   return container.innerHTML;
@@ -120,8 +652,8 @@ function replaceAllTextEmojiToString(html) {
  */
 
 function handlePasteHtmlAtCaret(html) {
-  let sel;
-  let range;
+  var sel;
+  var range;
 
   if (window.getSelection) {
     // IE9 and non-IE
@@ -133,11 +665,11 @@ function handlePasteHtmlAtCaret(html) {
       range.deleteContents(); // Range.createContextualFragment() would be useful here but is
       // non-standard and not supported in all browsers (IE9, for one)
 
-      const el = document.createElement("div");
+      var el = document.createElement("div");
       el.innerHTML = html;
-      const frag = document.createDocumentFragment();
-      let node;
-      let lastNode;
+      var frag = document.createDocumentFragment();
+      var node;
+      var lastNode;
 
       while (node = el.firstChild) {
         lastNode = frag.appendChild(node);
@@ -161,12 +693,11 @@ function handlePasteHtmlAtCaret(html) {
  * @return {number}
  */
 
-function totalCharacters({
-  text,
-  html
-}) {
-  const textCount = text.length;
-  const emojisCount = (html.match(/<img/g) || []).length;
+function totalCharacters(_ref2) {
+  var text = _ref2.text,
+      html = _ref2.html;
+  var textCount = text.length;
+  var emojisCount = (html.match(/<img/g) || []).length;
   return textCount + emojisCount;
 } // eslint-disable-next-line valid-jsdoc
 
@@ -180,17 +711,17 @@ function totalCharacters({
 
 function useSanitize() {
   /** @type {React.MutableRefObject<SanitizeFn[]>} */
-  const sanitizeFnsRef = useRef([]);
-  const sanitizedTextRef = useRef("");
+  var sanitizeFnsRef = useRef([]);
+  var sanitizedTextRef = useRef("");
   /** @type {(fn: SanitizeFn) => void} */
 
-  const addSanitizeFn = useCallback(fn => {
+  var addSanitizeFn = useCallback(function (fn) {
     sanitizeFnsRef.current.push(fn);
   }, []);
   /** @type {(html: string) => string} */
 
-  const sanitize = useCallback(html => {
-    let result = sanitizeFnsRef.current.reduce((acc, fn) => {
+  var sanitize = useCallback(function (html) {
+    var result = sanitizeFnsRef.current.reduce(function (acc, fn) {
       return fn(acc);
     }, html);
     result = replaceAllHtmlToString(result);
@@ -198,9 +729,9 @@ function useSanitize() {
     return result;
   }, []);
   return {
-    addSanitizeFn,
-    sanitize,
-    sanitizedTextRef
+    addSanitizeFn: addSanitizeFn,
+    sanitize: sanitize,
+    sanitizedTextRef: sanitizedTextRef
   };
 }
 /**
@@ -210,9 +741,9 @@ function useSanitize() {
  */
 
 function replaceAllHtmlToString(html) {
-  const container = document.createElement("div");
+  var container = document.createElement("div");
   container.innerHTML = html;
-  let text = container.innerText || ""; // remove all ↵ for safari
+  var text = container.innerText || ""; // remove all ↵ for safari
 
   text = text.replace(/\n/gi, "");
   return text;
@@ -232,37 +763,39 @@ function replaceAllHtmlToString(html) {
  * @param {Props} props
  */
 
-function useExpose({
-  ref,
-  textInputRef,
-  setValue,
-  emitChange
-}) {
-  const {
-    sanitize,
-    sanitizedTextRef
-  } = useSanitize();
-  useImperativeHandle(ref, () => ({
-    get value() {
-      return sanitizedTextRef.current;
-    },
+function useExpose(_ref) {
+  var ref = _ref.ref,
+      textInputRef = _ref.textInputRef,
+      setValue = _ref.setValue,
+      emitChange = _ref.emitChange;
 
-    set value(value) {
-      setValue(value);
-    },
+  var _useSanitize = useSanitize(),
+      sanitize = _useSanitize.sanitize,
+      sanitizedTextRef = _useSanitize.sanitizedTextRef;
 
-    focus: () => {
-      if (textInputRef.current === null) return;
-      textInputRef.current.focus();
-    },
-    blur: () => {
-      if (textInputRef.current !== null) {
-        sanitize(textInputRef.current.html);
-      }
+  useImperativeHandle(ref, function () {
+    return {
+      get value() {
+        return sanitizedTextRef.current;
+      },
 
-      emitChange();
-    }
-  }));
+      set value(value) {
+        setValue(value);
+      },
+
+      focus: function focus() {
+        if (textInputRef.current === null) return;
+        textInputRef.current.focus();
+      },
+      blur: function blur() {
+        if (textInputRef.current !== null) {
+          sanitize(textInputRef.current.html);
+        }
+
+        emitChange();
+      }
+    };
+  });
 }
 
 // @ts-check
@@ -276,12 +809,12 @@ function useExpose({
 
 function useEmit(textInputRef, onResize, onChange) {
   /** @type {React.MutableRefObject<{width: number; height: number} | null>} */
-  const currentSizeRef = useRef(null);
-  const onChangeFn = useRef(onChange);
-  const checkAndEmitResize = useCallback(() => {
+  var currentSizeRef = useRef(null);
+  var onChangeFn = useRef(onChange);
+  var checkAndEmitResize = useCallback(function () {
     if (textInputRef.current !== null) {
-      const currentSize = currentSizeRef.current;
-      const nextSize = textInputRef.current.size;
+      var currentSize = currentSizeRef.current;
+      var nextSize = textInputRef.current.size;
 
       if ((!currentSize || currentSize.width !== nextSize.width || currentSize.height !== nextSize.height) && typeof onResize === "function") {
         onResize(nextSize);
@@ -290,7 +823,7 @@ function useEmit(textInputRef, onResize, onChange) {
       currentSizeRef.current = nextSize;
     }
   }, [onResize, textInputRef]);
-  const emitChange = useCallback(sanitizedText => {
+  var emitChange = useCallback(function (sanitizedText) {
     if (typeof onChangeFn.current === "function") {
       onChangeFn.current(sanitizedText);
     }
@@ -299,7 +832,7 @@ function useEmit(textInputRef, onResize, onChange) {
       checkAndEmitResize();
     }
   }, [checkAndEmitResize, onResize]);
-  useEffect(() => {
+  useEffect(function () {
     if (textInputRef.current) {
       checkAndEmitResize();
     }
@@ -307,7 +840,7 @@ function useEmit(textInputRef, onResize, onChange) {
   return emitChange;
 }
 
-// @ts-check
+var _excluded = ["placeholder", "style", "tabIndex", "className", "onChange"];
 /**
  * @typedef {Object} Props
  * @property {(event: React.KeyboardEvent) => void} onKeyDown
@@ -340,91 +873,92 @@ function useEmit(textInputRef, onResize, onChange) {
 
 /** @type {React.ForwardRefRenderFunction<Ref, Props>} */
 
-const TextInput = ({
-  placeholder,
-  style,
-  tabIndex,
-  className,
-  onChange,
-  ...props
-}, ref) => {
-  useImperativeHandle(ref, () => ({
-    appendContent: html => {
-      if (textInputRef.current) {
-        textInputRef.current.focus();
-      }
-
-      handlePasteHtmlAtCaret(html);
+var TextInput = function TextInput(_ref, ref) {
+  var placeholder = _ref.placeholder,
+      style = _ref.style,
+      tabIndex = _ref.tabIndex,
+      className = _ref.className,
+      onChange = _ref.onChange,
+      props = _objectWithoutProperties(_ref, _excluded);
 
-      if (textInputRef.current) {
-        textInputRef.current.focus();
-      }
-
-      if (textInputRef.current && placeholderRef.current && textInputRef.current.innerHTML.trim() === "") {
-        placeholderRef.current.style.visibility = "visible";
-      } else if (placeholderRef.current) {
-        placeholderRef.current.style.visibility = "hidden";
-      }
+  useImperativeHandle(ref, function () {
+    return {
+      appendContent: function appendContent(html) {
+        if (textInputRef.current) {
+          textInputRef.current.focus();
+        }
 
-      if (textInputRef.current && typeof onChange === 'function') {
-        onChange(textInputRef.current.innerHTML);
-      }
-    },
+        handlePasteHtmlAtCaret(html);
 
-    set html(value) {
-      if (textInputRef.current) {
-        textInputRef.current.innerHTML = value;
-      }
+        if (textInputRef.current) {
+          textInputRef.current.focus();
+        }
 
-      if (placeholderRef.current) {
-        if (value.trim() === "") {
+        if (textInputRef.current && placeholderRef.current && textInputRef.current.innerHTML.trim() === "") {
           placeholderRef.current.style.visibility = "visible";
-        } else {
+        } else if (placeholderRef.current) {
           placeholderRef.current.style.visibility = "hidden";
         }
-      }
 
-      if (typeof onChange === 'function' && textInputRef.current) {
-        onChange(textInputRef.current.innerHTML);
-      }
-    },
+        if (textInputRef.current && typeof onChange === 'function') {
+          onChange(textInputRef.current.innerHTML);
+        }
+      },
 
-    get html() {
-      if (!textInputRef.current) return '';
-      return textInputRef.current.innerHTML;
-    },
+      set html(value) {
+        if (textInputRef.current) {
+          textInputRef.current.innerHTML = value;
+        }
 
-    get text() {
-      if (!textInputRef.current) return '';
-      return textInputRef.current.innerText;
-    },
+        if (placeholderRef.current) {
+          if (value.trim() === "") {
+            placeholderRef.current.style.visibility = "visible";
+          } else {
+            placeholderRef.current.style.visibility = "hidden";
+          }
+        }
 
-    get size() {
-      if (!textInputRef.current) {
-        return {
-          width: 0,
-          height: 0
-        };
-      }
+        if (typeof onChange === 'function' && textInputRef.current) {
+          onChange(textInputRef.current.innerHTML);
+        }
+      },
 
-      return {
-        width: textInputRef.current.offsetWidth,
-        height: textInputRef.current.offsetHeight
-      };
-    },
+      get html() {
+        if (!textInputRef.current) return '';
+        return textInputRef.current.innerHTML;
+      },
 
-    focus() {
-      if (!textInputRef.current) return;
-      textInputRef.current.focus();
-    }
+      get text() {
+        if (!textInputRef.current) return '';
+        return textInputRef.current.innerText;
+      },
 
-  }));
+      get size() {
+        if (!textInputRef.current) {
+          return {
+            width: 0,
+            height: 0
+          };
+        }
+
+        return {
+          width: textInputRef.current.offsetWidth,
+          height: textInputRef.current.offsetHeight
+        };
+      },
+
+      focus: function focus() {
+        if (!textInputRef.current) return;
+        textInputRef.current.focus();
+      }
+    };
+  });
   /** @type {React.MutableRefObject<HTMLDivElement | null>} */
 
-  const placeholderRef = useRef(null);
+  var placeholderRef = useRef(null);
   /** @type {React.MutableRefObject<HTMLDivElement | null>} */
 
-  const textInputRef = useRef(null);
+  var textInputRef = useRef(null);
   /**
    *
    * @param {React.KeyboardEvent} event
@@ -459,10 +993,12 @@ const TextInput = ({
 
   function handleKeyUp(event) {
     props.onKeyUp(event);
-    const input = textInputRef.current;
+    var input = textInputRef.current;
 
     if (placeholderRef.current) {
-      if (input?.innerText?.trim() === "") {
+      var _input$innerText;
+
+      if ((input === null || input === void 0 ? void 0 : (_input$innerText = input.innerText) === null || _input$innerText === void 0 ? void 0 : _input$innerText.trim()) === "") {
         placeholderRef.current.style.visibility = "visible";
       } else {
         placeholderRef.current.style.visibility = "hidden";
@@ -489,7 +1025,7 @@ const TextInput = ({
     onKeyUp: handleKeyUp,
     tabIndex: tabIndex,
     contentEditable: true,
-    className: `react-input-emoji--input${className ? ` ${className}` : ""}`,
+    className: "react-input-emoji--input".concat(className ? " ".concat(className) : ""),
     onBlur: props.onBlur,
     onCopy: props.onCopy,
     onPaste: props.onPaste,
@@ -497,9 +1033,8 @@ const TextInput = ({
   })));
 };
 
-const TextInputWithRef = /*#__PURE__*/forwardRef(TextInput);
+var TextInputWithRef = /*#__PURE__*/forwardRef(TextInput);
 
-/* eslint-disable react/prop-types */
 /**
  * @typedef {object} Props
  * @property {boolean} showPicker
@@ -513,23 +1048,29 @@ const TextInputWithRef = /*#__PURE__*/forwardRef(TextInput);
  * @return {JSX.Element}
  */
 
-function EmojiPickerButton({
-  showPicker,
-  toggleShowPicker,
-  buttonElement
-}) {
-  const buttonRef = useRef(null);
-  const [showCustomButtonContent, setShowCustomButtonContent] = useState(false);
-  useEffect(() => {
-    if ((buttonElement?.childNodes?.length ?? 0) > 2) {
-      buttonRef.current.appendChild(buttonElement?.childNodes[0]);
+function EmojiPickerButton(_ref) {
+  var showPicker = _ref.showPicker,
+      toggleShowPicker = _ref.toggleShowPicker,
+      buttonElement = _ref.buttonElement;
+  var buttonRef = useRef(null);
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      showCustomButtonContent = _useState2[0],
+      setShowCustomButtonContent = _useState2[1];
+
+  useEffect(function () {
+    var _buttonElement$childN, _buttonElement$childN2;
+
+    if (((_buttonElement$childN = buttonElement === null || buttonElement === void 0 ? void 0 : (_buttonElement$childN2 = buttonElement.childNodes) === null || _buttonElement$childN2 === void 0 ? void 0 : _buttonElement$childN2.length) !== null && _buttonElement$childN !== void 0 ? _buttonElement$childN : 0) > 2) {
+      buttonRef.current.appendChild(buttonElement === null || buttonElement === void 0 ? void 0 : buttonElement.childNodes[0]);
       setShowCustomButtonContent(true);
     }
-  }, [buttonElement?.childNodes]);
+  }, [buttonElement === null || buttonElement === void 0 ? void 0 : buttonElement.childNodes]);
   return /*#__PURE__*/React.createElement("button", {
     ref: buttonRef,
     type: "button",
-    className: `react-input-emoji--button${showPicker ? " react-input-emoji--button__show" : ""}`,
+    className: "react-input-emoji--button".concat(showPicker ? " react-input-emoji--button__show" : ""),
     onClick: toggleShowPicker
   }, !showCustomButtonContent && /*#__PURE__*/React.createElement("svg", {
     xmlns: "http://www.w3.org/2000/svg",
@@ -42871,7 +43412,6 @@ function $e5534fc185f7111e$export$2e2bcd8739ae039(props) {
   });
 }
 
-// vendors
 /**
  * @typedef {object} Props
  * @property {'light' | 'dark' | 'auto'} theme
@@ -42887,23 +43427,21 @@ function $e5534fc185f7111e$export$2e2bcd8739ae039(props) {
  */
 
 function EmojiPicker(props) {
-  const {
-    theme,
-    onSelectEmoji,
-    disableRecent,
-    customEmojis
-  } = props;
+  var theme = props.theme,
+      onSelectEmoji = props.onSelectEmoji,
+      disableRecent = props.disableRecent,
+      customEmojis = props.customEmojis;
   /** @type {string[]} */
 
-  const categories = useMemo(() => {
+  var categories = useMemo(function () {
     /** @type {string[]} */
-    let categoryies = [];
+    var categoryies = [];
 
     if (!disableRecent) {
       categoryies.push("frequent");
     }
 
-    categoryies = [...categoryies, "people", "nature", "foods", "activity", "places", "objects", "symbols", "flags"];
+    categoryies = [].concat(_toConsumableArray(categoryies), ["people", "nature", "foods", "activity", "places", "objects", "symbols", "flags"]);
     return categoryies;
   }, [disableRecent]);
   return /*#__PURE__*/React.createElement($e5534fc185f7111e$export$2e2bcd8739ae039, {
@@ -42939,18 +43477,19 @@ var EmojiPicker$1 = /*#__PURE__*/memo(EmojiPicker);
  * @return {JSX.Element}
  */
 
-function EmojiPickerContainer({
-  showPicker,
-  theme,
-  handleSelectEmoji,
-  disableRecent,
-  customEmojis
-}) {
+function EmojiPickerContainer(_ref) {
+  var showPicker = _ref.showPicker,
+      theme = _ref.theme,
+      handleSelectEmoji = _ref.handleSelectEmoji,
+      disableRecent = _ref.disableRecent,
+      customEmojis = _ref.customEmojis;
   return /*#__PURE__*/React.createElement("div", {
     className: "react-emoji-picker--container"
   }, showPicker && /*#__PURE__*/React.createElement("div", {
     className: "react-emoji-picker--wrapper",
-    onClick: evt => evt.stopPropagation()
+    onClick: function onClick(evt) {
+      return evt.stopPropagation();
+    }
   }, /*#__PURE__*/React.createElement("div", {
     className: "react-emoji-picker"
   }, /*#__PURE__*/React.createElement(EmojiPicker$1, {
@@ -42961,7 +43500,6 @@ function EmojiPickerContainer({
   }))));
 }
 
-// @ts-check
 /**
  * @typedef {import('../types/types').SanitizeFn} SanitizeFn
  */
@@ -42985,28 +43523,35 @@ function EmojiPickerContainer({
 
 /** @type {React.FC<Props>} */
 
-const EmojiPickerWrapper = props => {
-  const {
-    theme,
-    keepOpened,
-    disableRecent,
-    customEmojis,
-    addSanitizeFn,
-    addPolluteFn,
-    appendContent,
-    buttonElement
-  } = props;
-  const [showPicker, setShowPicker] = useState(false);
+var EmojiPickerWrapper = function EmojiPickerWrapper(props) {
+  var theme = props.theme,
+      keepOpened = props.keepOpened,
+      disableRecent = props.disableRecent,
+      customEmojis = props.customEmojis,
+      addSanitizeFn = props.addSanitizeFn,
+      addPolluteFn = props.addPolluteFn,
+      appendContent = props.appendContent,
+      buttonElement = props.buttonElement;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      showPicker = _useState2[0],
+      setShowPicker = _useState2[1];
   /** @type {[HTMLDivElement | undefined, React.Dispatch<React.SetStateAction<HTMLDivElement | undefined>>]} */
 
-  const [customButton, setCustomButton] = useState();
-  useEffect(() => {
+
+  var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      customButton = _useState4[0],
+      setCustomButton = _useState4[1];
+
+  useEffect(function () {
     addSanitizeFn(replaceAllTextEmojiToString);
   }, [addSanitizeFn]);
-  useEffect(() => {
+  useEffect(function () {
     addPolluteFn(replaceAllTextEmojis);
   }, [addPolluteFn]);
-  useEffect(() => {
+  useEffect(function () {
     /**
      *
      * @param {MouseEvent} event
@@ -43014,7 +43559,7 @@ const EmojiPickerWrapper = props => {
     function checkClickOutside(event) {
       /** @type {HTMLElement} */
       // @ts-ignore
-      const element = event.target;
+      var element = event.target;
 
       if (element.classList.contains("react-input-emoji--button") || element.classList.contains("react-input-emoji--button--icon")) {
         return;
@@ -43024,7 +43569,7 @@ const EmojiPickerWrapper = props => {
     }
 
     document.addEventListener("click", checkClickOutside);
-    return () => {
+    return function () {
       document.removeEventListener("click", checkClickOutside);
     };
   }, []);
@@ -43036,7 +43581,9 @@ const EmojiPickerWrapper = props => {
   function toggleShowPicker(event) {
     event.stopPropagation();
     event.preventDefault();
-    setShowPicker(currentShowPicker => !currentShowPicker);
+    setShowPicker(function (currentShowPicker) {
+      return !currentShowPicker;
+    });
   } // eslint-disable-next-line valid-jsdoc
 
   /**
@@ -43049,12 +43596,14 @@ const EmojiPickerWrapper = props => {
     appendContent(getImageEmoji(emoji));
 
     if (!keepOpened) {
-      setShowPicker(currentShowPicker => !currentShowPicker);
+      setShowPicker(function (currentShowPicker) {
+        return !currentShowPicker;
+      });
     }
   }
 
-  useEffect(() => {
-    if (buttonElement?.style) {
+  useEffect(function () {
+    if (buttonElement !== null && buttonElement !== void 0 && buttonElement.style) {
       buttonElement.style.position = "relative";
       setCustomButton(buttonElement);
     }
@@ -43088,16 +43637,16 @@ const EmojiPickerWrapper = props => {
  * @return {string | null}
  */
 function getTextFromAtToCaret() {
-  const range = getRangeFromAtToCaret();
+  var range = getRangeFromAtToCaret();
   if (!range) return null;
-  const text = range.text.substring(range.begin, range.end);
+  var text = range.text.substring(range.begin, range.end);
   return text || null;
 } // eslint-disable-next-line valid-jsdoc
 
 /** */
 
 function deleteTextFromAtToCaret() {
-  const range = getRangeFromAtToCaret();
+  var range = getRangeFromAtToCaret();
   if (!range) return; // @ts-ignore
 
   range.element.deleteData(range.begin, range.end - range.begin);
@@ -43108,18 +43657,16 @@ function deleteTextFromAtToCaret() {
  */
 
 function getRangeFromAtToCaret() {
-  const elementWithFocus = getElementWithFocus();
+  var elementWithFocus = getElementWithFocus();
 
   if (!elementWithFocus) {
     return null;
   }
 
-  const {
-    element,
-    caretOffset
-  } = elementWithFocus;
-  const text = element.textContent;
-  const lastAt = text.lastIndexOf("@");
+  var element = elementWithFocus.element,
+      caretOffset = elementWithFocus.caretOffset;
+  var text = element.textContent;
+  var lastAt = text.lastIndexOf("@");
 
   if (lastAt === -1 || lastAt >= caretOffset || lastAt !== 0 && text[lastAt - 1] !== " ") {
     return null;
@@ -43128,8 +43675,8 @@ function getRangeFromAtToCaret() {
   return {
     begin: lastAt,
     end: caretOffset,
-    text,
-    element
+    text: text,
+    element: element
   };
 }
 /**
@@ -43139,17 +43686,17 @@ function getRangeFromAtToCaret() {
 
 
 function getElementWithFocus() {
-  const element = getSelectionStart();
+  var element = getSelectionStart();
 
   if (element === null) {
     return null;
   }
 
-  let caretOffset = 0;
+  var caretOffset = 0;
 
   if (typeof window.getSelection != "undefined") {
-    const range = window.getSelection().getRangeAt(0);
-    const preCaretRange = range.cloneRange();
+    var range = window.getSelection().getRangeAt(0);
+    var preCaretRange = range.cloneRange();
     preCaretRange.selectNodeContents(element);
     preCaretRange.setEnd(range.endContainer, range.endOffset);
     caretOffset = preCaretRange.toString().length;
@@ -43157,17 +43704,17 @@ function getElementWithFocus() {
   typeof document.selection != "undefined" && // @ts-ignore
   document.selection.type != "Control") {
     // @ts-ignore
-    const textRange = document.selection.createRange(); // @ts-ignore
+    var textRange = document.selection.createRange(); // @ts-ignore
 
-    const preCaretTextRange = document.body.createTextRange();
+    var preCaretTextRange = document.body.createTextRange();
     preCaretTextRange.moveToElementText(element);
     preCaretTextRange.setEndPoint("EndToEnd", textRange);
     caretOffset = preCaretTextRange.text.length;
   }
 
   return {
-    element,
-    caretOffset
+    element: element,
+    caretOffset: caretOffset
   };
 }
 /**
@@ -43176,11 +43723,10 @@ function getElementWithFocus() {
  */
 
 function getSelectionStart() {
-  const node = document.getSelection().anchorNode;
-  return node?.nodeType == 3 ? node : null;
+  var node = document.getSelection().anchorNode;
+  return (node === null || node === void 0 ? void 0 : node.nodeType) == 3 ? node : null;
 }
 
-// @ts-check
 /**
  * @typedef {import('../types/types').MentionUser} MentionUser
  */
@@ -43193,58 +43739,117 @@ function getSelectionStart() {
  */
 
 function useMention(searchMention) {
-  const [loading, setLoading] = useState(false);
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      loading = _useState2[0],
+      setLoading = _useState2[1];
   /** @type {[MentionUser[], React.Dispatch<React.SetStateAction<MentionUser[]>>]} */
 
-  const [mentionUsers, setMentionUsers] = useState([]);
+
+  var _useState3 = useState([]),
+      _useState4 = _slicedToArray(_useState3, 2),
+      mentionUsers = _useState4[0],
+      setMentionUsers = _useState4[1];
   /** @type {[string | null, React.Dispatch<React.SetStateAction<string | null>>]} */
 
-  const [mentionSearchText, setMentionSearchText] = useState(null);
-  const onSelectUser = useCallback(() => {
+
+  var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      mentionSearchText = _useState6[0],
+      setMentionSearchText = _useState6[1];
+
+  var onSelectUser = useCallback(function () {
     deleteTextFromAtToCaret();
     setMentionUsers([]);
   }, []);
   /** */
 
-  const checkMentionText = useCallback(async () => {
-    const metionText = getTextFromAtToCaret();
-    setMentionSearchText(metionText);
+  var checkMentionText = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var metionText, users;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            metionText = getTextFromAtToCaret();
+            setMentionSearchText(metionText);
+
+            if (!(metionText === null)) {
+              _context.next = 6;
+              break;
+            }
 
-    if (metionText === null) {
-      setMentionUsers([]);
-    } else {
-      setLoading(true);
-      const users = await searchMention(metionText);
-      setLoading(false);
-      setMentionUsers(users);
-    }
-  }, [searchMention]);
+            setMentionUsers([]);
+            _context.next = 12;
+            break;
+
+          case 6:
+            setLoading(true);
+            _context.next = 9;
+            return searchMention(metionText);
+
+          case 9:
+            users = _context.sent;
+            setLoading(false);
+            setMentionUsers(users);
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })), [searchMention]);
   /** @type {(event: React.KeyboardEvent) => void} */
 
-  const onKeyUp = useCallback(async event => {
-    if (typeof searchMention !== "function") return;
+  var onKeyUp = useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(event) {
+      var _getElementWithFocus;
+
+      var elementWithFocus;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!(typeof searchMention !== "function")) {
+                _context2.next = 2;
+                break;
+              }
 
-    if (event.key === "Backspace" && getElementWithFocus()?.element.parentElement.hasAttribute("data-mention-id")) {
-      const elementWithFocus = getElementWithFocus();
-      elementWithFocus.element.parentElement.remove();
-    } else if (!["ArrowUp", "ArrowDown", "Esc", "Escape"].includes(event.key)) {
-      checkMentionText();
-    }
-  }, [checkMentionText, searchMention]);
-  const onFocus = useCallback(() => {
+              return _context2.abrupt("return");
+
+            case 2:
+              if (event.key === "Backspace" && (_getElementWithFocus = getElementWithFocus()) !== null && _getElementWithFocus !== void 0 && _getElementWithFocus.element.parentElement.hasAttribute("data-mention-id")) {
+                elementWithFocus = getElementWithFocus();
+                elementWithFocus.element.parentElement.remove();
+              } else if (!["ArrowUp", "ArrowDown", "Esc", "Escape"].includes(event.key)) {
+                checkMentionText();
+              }
+
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [checkMentionText, searchMention]);
+  var onFocus = useCallback(function () {
     checkMentionText();
   }, [checkMentionText]);
   return {
-    mentionSearchText,
-    mentionUsers,
-    onKeyUp,
-    onFocus,
-    onSelectUser,
-    loading
+    mentionSearchText: mentionSearchText,
+    mentionUsers: mentionUsers,
+    onKeyUp: onKeyUp,
+    onFocus: onFocus,
+    onSelectUser: onSelectUser,
+    loading: loading
   };
 }
 
-// @ts-check
 /**
  * @typedef {import('../types/types').MentionUser} MentionUser
  */
@@ -43268,34 +43873,40 @@ function useMention(searchMention) {
 
 /** @type {React.ForwardRefRenderFunction<Ref, Props>} */
 
-const MentionUserList = ({
-  users,
-  mentionSearchText,
-  onSelect,
-  addEventListener
-}, ref) => {
-  const [selectedUser, setSelectedUser] = useState(0);
-  useImperativeHandle(ref, () => ({
-    prevUser: () => {
-      setSelectedUser(currentSelectedUser => {
-        if (currentSelectedUser === 0) {
-          return 0;
-        }
+var MentionUserList = function MentionUserList(_ref, ref) {
+  var users = _ref.users,
+      mentionSearchText = _ref.mentionSearchText,
+      onSelect = _ref.onSelect,
+      addEventListener = _ref.addEventListener;
 
-        return currentSelectedUser - 1;
-      });
-    },
-    nextUser: () => {
-      setSelectedUser(currentSelectedUser => {
-        if (currentSelectedUser === users.length - 1) {
-          return users.length - 1;
-        }
+  var _useState = useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
+      selectedUser = _useState2[0],
+      setSelectedUser = _useState2[1];
 
-        return currentSelectedUser + 1;
-      });
-    }
-  }));
-  useEffect(() => {
+  useImperativeHandle(ref, function () {
+    return {
+      prevUser: function prevUser() {
+        setSelectedUser(function (currentSelectedUser) {
+          if (currentSelectedUser === 0) {
+            return 0;
+          }
+
+          return currentSelectedUser - 1;
+        });
+      },
+      nextUser: function nextUser() {
+        setSelectedUser(function (currentSelectedUser) {
+          if (currentSelectedUser === users.length - 1) {
+            return users.length - 1;
+          }
+
+          return currentSelectedUser + 1;
+        });
+      }
+    };
+  });
+  useEffect(function () {
     setSelectedUser(0);
   }, [users]);
   /**
@@ -43306,22 +43917,22 @@ const MentionUserList = ({
    */
 
   function getMentionSelectedNameEl(selectedText, rest) {
-    return `<span class="react-input-emoji--mention--item--name__selected" data-testid="metion-selected-word">${selectedText}</span>${rest}`;
+    return "<span class=\"react-input-emoji--mention--item--name__selected\" data-testid=\"metion-selected-word\">".concat(selectedText, "</span>").concat(rest);
   }
   /** @type {(MentionUser & {nameHtml: string})[]} */
 
 
-  const usersFiltered = useMemo(() => {
-    const searchText = mentionSearchText ? mentionSearchText.substring(1).toLocaleLowerCase() : "";
-    return users.map(user => {
-      let nameHtml = user.name;
+  var usersFiltered = useMemo(function () {
+    var searchText = mentionSearchText ? mentionSearchText.substring(1).toLocaleLowerCase() : "";
+    return users.map(function (user) {
+      var nameHtml = user.name;
 
       if (mentionSearchText && mentionSearchText.length > 1) {
         if (user.name.toLowerCase().startsWith(searchText)) {
           nameHtml = getMentionSelectedNameEl(user.name.substring(0, searchText.length), user.name.substring(searchText.length));
         } else {
-          const names = user.name.split(" ");
-          nameHtml = names.map(name => {
+          var names = user.name.split(" ");
+          nameHtml = names.map(function (name) {
             if (name.toLocaleLowerCase().startsWith(searchText)) {
               return getMentionSelectedNameEl(name.substring(0, searchText.length), name.substring(searchText.length));
             }
@@ -43331,9 +43942,9 @@ const MentionUserList = ({
         }
       }
 
-      return { ...user,
-        nameHtml
-      };
+      return _objectSpread2(_objectSpread2({}, user), {}, {
+        nameHtml: nameHtml
+      });
     });
   }, [mentionSearchText, users]); // eslint-disable-next-line valid-jsdoc
 
@@ -43344,50 +43955,53 @@ const MentionUserList = ({
    */
 
   function handleClick(user) {
-    return event => {
+    return function (event) {
       event.stopPropagation();
       event.preventDefault();
       onSelect(user);
     };
   }
 
-  useEffect(() => {
-    const unsubscribe = addEventListener("enter", event => {
+  useEffect(function () {
+    var unsubscribe = addEventListener("enter", function (event) {
       event.stopPropagation();
       event.preventDefault();
       onSelect(usersFiltered[selectedUser]);
     });
-    return () => {
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, onSelect, selectedUser, usersFiltered]);
   return /*#__PURE__*/React.createElement("ul", {
     className: "react-input-emoji--mention--list",
     "data-testid": "mention-user-list"
-  }, usersFiltered.map((user, index) => /*#__PURE__*/React.createElement("li", {
-    key: user.id
-  }, /*#__PURE__*/React.createElement("button", {
-    type: "button",
-    onClick: handleClick(user),
-    className: `react-input-emoji--mention--item${selectedUser === index ? " react-input-emoji--mention--item__selected" : ""}`,
-    onMouseOver: () => setSelectedUser(index)
-  }, /*#__PURE__*/React.createElement("img", {
-    className: "react-input-emoji--mention--item--img",
-    src: user.image
-  }), /*#__PURE__*/React.createElement("div", {
-    className: "react-input-emoji--mention--item--name",
-    dangerouslySetInnerHTML: {
-      __html: user.nameHtml
-    }
-  })))));
+  }, usersFiltered.map(function (user, index) {
+    return /*#__PURE__*/React.createElement("li", {
+      key: user.id
+    }, /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: handleClick(user),
+      className: "react-input-emoji--mention--item".concat(selectedUser === index ? " react-input-emoji--mention--item__selected" : ""),
+      onMouseOver: function onMouseOver() {
+        return setSelectedUser(index);
+      }
+    }, /*#__PURE__*/React.createElement("img", {
+      className: "react-input-emoji--mention--item--img",
+      src: user.image
+    }), /*#__PURE__*/React.createElement("div", {
+      className: "react-input-emoji--mention--item--name",
+      dangerouslySetInnerHTML: {
+        __html: user.nameHtml
+      }
+    })));
+  }));
 };
 
-const MentionUserListWithRef = /*#__PURE__*/forwardRef(MentionUserList);
+var MentionUserListWithRef = /*#__PURE__*/forwardRef(MentionUserList);
 MentionUserListWithRef.propTypes = {
   users: t.array.isRequired
 };
 
-// @ts-check
 /**
  * @typedef {import('../types/types').MentionUser} MetionUser
  */
@@ -43411,55 +44025,60 @@ MentionUserListWithRef.propTypes = {
 
 /** @type {React.FC<Props>} */
 
-const MentionWrapper = ({
-  searchMention,
-  addEventListener,
-  appendContent,
-  addSanitizeFn
-}) => {
+var MentionWrapper = function MentionWrapper(_ref) {
+  var searchMention = _ref.searchMention,
+      addEventListener = _ref.addEventListener,
+      appendContent = _ref.appendContent,
+      addSanitizeFn = _ref.addSanitizeFn;
+
   /** @type {React.MutableRefObject<import('./mention-user-list').Ref | null>} */
-  const metionUserListRef = useRef(null);
-  const [showUserList, setShowUserList] = useState(false);
-  const {
-    mentionSearchText,
-    mentionUsers,
-    loading,
-    onKeyUp,
-    onFocus,
-    onSelectUser
-  } = useMention(searchMention);
-  useEffect(() => {
-    addSanitizeFn(html => {
-      const container = document.createElement("div");
+  var metionUserListRef = useRef(null);
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      showUserList = _useState2[0],
+      setShowUserList = _useState2[1];
+
+  var _useMention = useMention(searchMention),
+      mentionSearchText = _useMention.mentionSearchText,
+      mentionUsers = _useMention.mentionUsers,
+      loading = _useMention.loading,
+      onKeyUp = _useMention.onKeyUp,
+      onFocus = _useMention.onFocus,
+      onSelectUser = _useMention.onSelectUser;
+
+  useEffect(function () {
+    addSanitizeFn(function (html) {
+      var container = document.createElement("div");
       container.innerHTML = html;
-      const mentionsEl = Array.prototype.slice.call(container.querySelectorAll(".react-input-emoji--mention--text"));
-      mentionsEl.forEach(mentionEl => {
-        container.innerHTML = container.innerHTML.replace(mentionEl.outerHTML, `@[${mentionEl.dataset.mentionName}](userId:${mentionEl.dataset.mentionId})`);
+      var mentionsEl = Array.prototype.slice.call(container.querySelectorAll(".react-input-emoji--mention--text"));
+      mentionsEl.forEach(function (mentionEl) {
+        container.innerHTML = container.innerHTML.replace(mentionEl.outerHTML, "@[".concat(mentionEl.dataset.mentionName, "](userId:").concat(mentionEl.dataset.mentionId, ")"));
       });
       return container.innerHTML;
     });
   }, [addSanitizeFn]);
-  useEffect(() => {
+  useEffect(function () {
     setShowUserList(mentionUsers.length > 0);
   }, [mentionUsers]);
-  useEffect(() => {
+  useEffect(function () {
     /** */
     function checkClickOutside() {
       setShowUserList(false);
     }
 
     document.addEventListener("click", checkClickOutside);
-    return () => {
+    return function () {
       document.removeEventListener("click", checkClickOutside);
     };
   }, []);
-  useEffect(() => {
-    const unsubscribe = addEventListener("keyUp", onKeyUp);
-    return () => {
+  useEffect(function () {
+    var unsubscribe = addEventListener("keyUp", onKeyUp);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, onKeyUp]);
-  useEffect(() => {
+  useEffect(function () {
     /**
      *
      * @param {React.KeyboardEvent} event
@@ -43474,30 +44093,30 @@ const MentionWrapper = ({
       }
     }
 
-    const unsubscribe = addEventListener("keyDown", handleKeyDown);
-    return () => {
+    var unsubscribe = addEventListener("keyDown", handleKeyDown);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener]);
-  useEffect(() => {
-    const unsubscribe = addEventListener("focus", onFocus);
-    return () => {
+  useEffect(function () {
+    var unsubscribe = addEventListener("focus", onFocus);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, onFocus]);
-  useEffect(() => {
+  useEffect(function () {
     if (showUserList) {
-      const unsubscribeArrowUp = addEventListener("arrowUp", event => {
+      var unsubscribeArrowUp = addEventListener("arrowUp", function (event) {
         event.stopPropagation();
         event.preventDefault();
         metionUserListRef.current.prevUser();
       });
-      const unsubscribeArrowDown = addEventListener("arrowDown", event => {
+      var unsubscribeArrowDown = addEventListener("arrowDown", function (event) {
         event.stopPropagation();
         event.preventDefault();
         metionUserListRef.current.nextUser();
       });
-      return () => {
+      return function () {
         unsubscribeArrowUp();
         unsubscribeArrowDown();
       };
@@ -43510,7 +44129,7 @@ const MentionWrapper = ({
 
   function handleSelect(user) {
     onSelectUser();
-    appendContent(`<span class="react-input-emoji--mention--text" data-mention-id="${user.id}" data-mention-name="${user.name}">@${user.name}</span> `);
+    appendContent("<span class=\"react-input-emoji--mention--text\" data-mention-id=\"".concat(user.id, "\" data-mention-name=\"").concat(user.name, "\">@").concat(user.name, "</span> "));
   }
 
   return /*#__PURE__*/React.createElement(React.Fragment, null, loading ? /*#__PURE__*/React.createElement("div", {
@@ -43521,7 +44140,9 @@ const MentionWrapper = ({
     className: "react-input-emoji--mention--loading--spinner"
   }, "Loading..."))) : showUserList && /*#__PURE__*/React.createElement("div", {
     className: "react-input-emoji--mention--container",
-    onClick: evt => evt.stopPropagation()
+    onClick: function onClick(evt) {
+      return evt.stopPropagation();
+    }
   }, /*#__PURE__*/React.createElement(MentionUserListWithRef, {
     ref: metionUserListRef,
     mentionSearchText: mentionSearchText,
@@ -43540,16 +44161,20 @@ const MentionWrapper = ({
  */
 function createObserver() {
   /** @type {import('../types/types').Listerner<T>[]} */
-  let listeners = [];
+  var listeners = [];
   return {
-    subscribe: listener => {
+    subscribe: function subscribe(listener) {
       listeners.push(listener);
-      return () => {
-        listeners = listeners.filter(l => l !== listener);
+      return function () {
+        listeners = listeners.filter(function (l) {
+          return l !== listener;
+        });
       };
     },
-    publish: event => {
-      listeners.forEach(listener => listener(event));
+    publish: function publish(event) {
+      listeners.forEach(function (listener) {
+        return listener(event);
+      });
     },
 
     get currentListerners() {
@@ -43569,26 +44194,28 @@ function createObserver() {
 
 function useEventListeners() {
   /** @type {TextInputListeners} */
-  const listeners = useMemo(() => ({
-    keyDown: createObserver(),
-    keyUp: createObserver(),
-    arrowUp: createObserver(),
-    arrowDown: createObserver(),
-    enter: createObserver(),
-    focus: createObserver(),
-    blur: createObserver()
-  }), []);
+  var listeners = useMemo(function () {
+    return {
+      keyDown: createObserver(),
+      keyUp: createObserver(),
+      arrowUp: createObserver(),
+      arrowDown: createObserver(),
+      enter: createObserver(),
+      focus: createObserver(),
+      blur: createObserver()
+    };
+  }, []);
   /**
    * @template {keyof TextInputListeners} T, K
    * @type {(event: keyof TextInputListeners, fn: import('../types/types').Listerner<any>) => () => void}
    */
 
-  const addEventListener = useCallback((event, fn) => {
+  var addEventListener = useCallback(function (event, fn) {
     return listeners[event].subscribe(fn);
   }, [listeners]);
   return {
-    addEventListener,
-    listeners
+    addEventListener: addEventListener,
+    listeners: listeners
   };
 }
 
@@ -43602,23 +44229,23 @@ function useEventListeners() {
 
 function usePollute() {
   /** @type {React.MutableRefObject<PolluteFn[]>} */
-  const polluteFnsRef = useRef([]);
+  var polluteFnsRef = useRef([]);
   /** @type {(fn: PolluteFn) => void} */
 
-  const addPolluteFn = useCallback(fn => {
+  var addPolluteFn = useCallback(function (fn) {
     polluteFnsRef.current.push(fn);
   }, []);
   /** @type {(html: string) => string} */
 
-  const pollute = useCallback(text => {
-    const result = polluteFnsRef.current.reduce((acc, fn) => {
+  var pollute = useCallback(function (text) {
+    var result = polluteFnsRef.current.reduce(function (acc, fn) {
       return fn(acc);
     }, text);
     return result;
   }, []);
   return {
-    addPolluteFn,
-    pollute
+    addPolluteFn: addPolluteFn,
+    pollute: pollute
   };
 }
 
@@ -43667,72 +44294,71 @@ function usePollute() {
  */
 
 function InputEmoji(props, ref) {
-  const {
-    onChange,
-    onEnter,
-    onResize,
-    onClick,
-    onFocus,
-    onBlur,
-    onKeyDown,
-    theme,
-    cleanOnEnter,
-    placeholder,
-    maxLength,
-    keepOpened,
-    inputClass,
-    disableRecent,
-    tabIndex,
-    value,
-    customEmojis,
-    searchMention,
-    buttonElement,
-    // style
-    borderRadius,
-    borderColor,
-    fontSize,
-    fontFamily
-  } = props;
+  var onChange = props.onChange,
+      onEnter = props.onEnter,
+      onResize = props.onResize,
+      onClick = props.onClick,
+      onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      onKeyDown = props.onKeyDown,
+      theme = props.theme,
+      cleanOnEnter = props.cleanOnEnter,
+      placeholder = props.placeholder,
+      maxLength = props.maxLength,
+      keepOpened = props.keepOpened,
+      inputClass = props.inputClass,
+      disableRecent = props.disableRecent,
+      tabIndex = props.tabIndex,
+      value = props.value,
+      customEmojis = props.customEmojis,
+      searchMention = props.searchMention,
+      buttonElement = props.buttonElement,
+      borderRadius = props.borderRadius,
+      borderColor = props.borderColor,
+      fontSize = props.fontSize,
+      fontFamily = props.fontFamily;
   /** @type {React.MutableRefObject<import('./text-input').Ref | null>} */
 
-  const textInputRef = useRef(null);
-  const {
-    addEventListener,
-    listeners
-  } = useEventListeners();
-  const {
-    addSanitizeFn,
-    sanitize,
-    sanitizedTextRef
-  } = useSanitize();
-  const {
-    addPolluteFn,
-    pollute
-  } = usePollute();
-  const updateHTML = useCallback((nextValue = "") => {
+  var textInputRef = useRef(null);
+
+  var _useEventListeners = useEventListeners(),
+      addEventListener = _useEventListeners.addEventListener,
+      listeners = _useEventListeners.listeners;
+
+  var _useSanitize = useSanitize(),
+      addSanitizeFn = _useSanitize.addSanitizeFn,
+      sanitize = _useSanitize.sanitize,
+      sanitizedTextRef = _useSanitize.sanitizedTextRef;
+
+  var _usePollute = usePollute(),
+      addPolluteFn = _usePollute.addPolluteFn,
+      pollute = _usePollute.pollute;
+
+  var updateHTML = useCallback(function () {
+    var nextValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
     if (textInputRef.current === null) return;
     textInputRef.current.html = replaceAllTextEmojis(nextValue);
     sanitizedTextRef.current = nextValue;
   }, [sanitizedTextRef]);
-  const setValue = useCallback(value => {
+  var setValue = useCallback(function (value) {
     updateHTML(value);
   }, [updateHTML]);
-  const emitChange = useEmit(textInputRef, onResize, onChange);
+  var emitChange = useEmit(textInputRef, onResize, onChange);
   useExpose({
-    ref,
-    setValue,
-    textInputRef,
-    emitChange
+    ref: ref,
+    setValue: setValue,
+    textInputRef: textInputRef,
+    emitChange: emitChange
   });
-  useEffect(() => {
+  useEffect(function () {
     if (sanitizedTextRef.current !== value) {
       setValue(value);
     }
   }, [sanitizedTextRef, setValue, value]);
-  useEffect(() => {
+  useEffect(function () {
     updateHTML();
   }, [updateHTML]);
-  useEffect(() => {
+  useEffect(function () {
     /**
      * Handle keydown event
      * @param {React.KeyboardEvent} event
@@ -43745,7 +44371,7 @@ function InputEmoji(props, ref) {
 
       if (event.key === "Enter" && textInputRef.current) {
         event.preventDefault();
-        const text = sanitize(textInputRef.current.html);
+        var text = sanitize(textInputRef.current.html);
         emitChange(sanitizedTextRef.current);
 
         if (typeof onEnter === "function" && listeners.enter.currentListerners.length === 0) {
@@ -43770,12 +44396,12 @@ function InputEmoji(props, ref) {
       return true;
     }
 
-    const unsubscribe = addEventListener("keyDown", handleKeydown);
-    return () => {
+    var unsubscribe = addEventListener("keyDown", handleKeydown);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, cleanOnEnter, emitChange, listeners.enter.currentListerners.length, maxLength, onEnter, onKeyDown, sanitize, sanitizedTextRef, updateHTML]);
-  useEffect(() => {
+  useEffect(function () {
     /** */
     function handleFocus() {
       if (typeof onClick === "function") {
@@ -43787,12 +44413,12 @@ function InputEmoji(props, ref) {
       }
     }
 
-    const unsubscribe = addEventListener("focus", handleFocus);
-    return () => {
+    var unsubscribe = addEventListener("focus", handleFocus);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, onClick, onFocus]);
-  useEffect(() => {
+  useEffect(function () {
     /** */
     function handleBlur() {
       if (typeof onBlur === "function") {
@@ -43800,8 +44426,8 @@ function InputEmoji(props, ref) {
       }
     }
 
-    const unsubscribe = addEventListener("blur", handleBlur);
-    return () => {
+    var unsubscribe = addEventListener("blur", handleBlur);
+    return function () {
       unsubscribe();
     };
   }, [addEventListener, onBlur]);
@@ -43847,7 +44473,7 @@ function InputEmoji(props, ref) {
 
   function handlePaste(event) {
     event.preventDefault();
-    let content;
+    var content;
 
     if (event.clipboardData) {
       content = event.clipboardData.getData("text/plain");
@@ -43876,10 +44502,10 @@ function InputEmoji(props, ref) {
     onEnter: listeners.enter.publish,
     placeholder: placeholder,
     style: {
-      borderRadius,
-      borderColor,
-      fontSize,
-      fontFamily
+      borderRadius: borderRadius,
+      borderColor: borderColor,
+      fontSize: fontSize,
+      fontFamily: fontFamily
     },
     tabIndex: tabIndex,
     className: inputClass,
@@ -43896,7 +44522,7 @@ function InputEmoji(props, ref) {
   }));
 }
 
-const InputEmojiWithRef = /*#__PURE__*/forwardRef(InputEmoji);
+var InputEmojiWithRef = /*#__PURE__*/forwardRef(InputEmoji);
 InputEmojiWithRef.defaultProps = {
   theme:
   /** @type {const} */