@teselagen/ove 0.7.3 → 0.7.5

package/index.umd.js

@@ -102796,7 +102796,7 @@ ${latestSubscriptionCallbackError.current.stack}
         this.props.children && isFunction$2(this.props.children) ? this.props.children(windowDimensions) : this.props.children
       );
       if (asPortal)
-        return ReactDOM$1(inner2, window.document.body);
+        return reactExports.createPortal(inner2, window.document.body);
       return inner2;
     }
   }, __name(_F, "FillWindow"), _F);
@@ -145041,6 +145041,684 @@ ${seq.sequence}
   )(Droppable$1);
   ConnectedDroppable.defaultProps = defaultProps;
   var ConnectedDroppable$1 = ConnectedDroppable;
+  var clipboard = { exports: {} };
+  /*!
+   * clipboard.js v2.0.11
+   * https://clipboardjs.com/
+   *
+   * Licensed MIT © Zeno Rocha
+   */
+  (function(module2, exports3) {
+    (/* @__PURE__ */ __name(function webpackUniversalModuleDefinition(root2, factory) {
+      module2.exports = factory();
+    }, "webpackUniversalModuleDefinition"))(commonjsGlobal, function() {
+      return (
+        /******/
+        function() {
+          var __webpack_modules__ = {
+            /***/
+            686: (
+              /***/
+              function(__unused_webpack_module, __webpack_exports__, __webpack_require__2) {
+                __webpack_require__2.d(__webpack_exports__, {
+                  "default": function() {
+                    return (
+                      /* binding */
+                      clipboard2
+                    );
+                  }
+                });
+                var tiny_emitter = __webpack_require__2(279);
+                var tiny_emitter_default = /* @__PURE__ */ __webpack_require__2.n(tiny_emitter);
+                var listen = __webpack_require__2(370);
+                var listen_default = /* @__PURE__ */ __webpack_require__2.n(listen);
+                var src_select = __webpack_require__2(817);
+                var select_default = /* @__PURE__ */ __webpack_require__2.n(src_select);
+                function command(type2) {
+                  try {
+                    return document.execCommand(type2);
+                  } catch (err2) {
+                    return false;
+                  }
+                }
+                __name(command, "command");
+                var ClipboardActionCut = /* @__PURE__ */ __name(function ClipboardActionCut2(target) {
+                  var selectedText = select_default()(target);
+                  command("cut");
+                  return selectedText;
+                }, "ClipboardActionCut");
+                var actions_cut = ClipboardActionCut;
+                function createFakeElement(value) {
+                  var isRTL = document.documentElement.getAttribute("dir") === "rtl";
+                  var fakeElement = document.createElement("textarea");
+                  fakeElement.style.fontSize = "12pt";
+                  fakeElement.style.border = "0";
+                  fakeElement.style.padding = "0";
+                  fakeElement.style.margin = "0";
+                  fakeElement.style.position = "absolute";
+                  fakeElement.style[isRTL ? "right" : "left"] = "-9999px";
+                  var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+                  fakeElement.style.top = "".concat(yPosition, "px");
+                  fakeElement.setAttribute("readonly", "");
+                  fakeElement.value = value;
+                  return fakeElement;
+                }
+                __name(createFakeElement, "createFakeElement");
+                var fakeCopyAction = /* @__PURE__ */ __name(function fakeCopyAction2(value, options) {
+                  var fakeElement = createFakeElement(value);
+                  options.container.appendChild(fakeElement);
+                  var selectedText = select_default()(fakeElement);
+                  command("copy");
+                  fakeElement.remove();
+                  return selectedText;
+                }, "fakeCopyAction");
+                var ClipboardActionCopy = /* @__PURE__ */ __name(function ClipboardActionCopy2(target) {
+                  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                    container: document.body
+                  };
+                  var selectedText = "";
+                  if (typeof target === "string") {
+                    selectedText = fakeCopyAction(target, options);
+                  } else if (target instanceof HTMLInputElement && !["text", "search", "url", "tel", "password"].includes(target === null || target === void 0 ? void 0 : target.type)) {
+                    selectedText = fakeCopyAction(target.value, options);
+                  } else {
+                    selectedText = select_default()(target);
+                    command("copy");
+                  }
+                  return selectedText;
+                }, "ClipboardActionCopy");
+                var actions_copy = ClipboardActionCopy;
+                function _typeof2(obj) {
+                  "@babel/helpers - typeof";
+                  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+                    _typeof2 = /* @__PURE__ */ __name(function _typeof3(obj2) {
+                      return typeof obj2;
+                    }, "_typeof");
+                  } else {
+                    _typeof2 = /* @__PURE__ */ __name(function _typeof3(obj2) {
+                      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+                    }, "_typeof");
+                  }
+                  return _typeof2(obj);
+                }
+                __name(_typeof2, "_typeof");
+                var ClipboardActionDefault = /* @__PURE__ */ __name(function ClipboardActionDefault2() {
+                  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                  var _options$action = options.action, action2 = _options$action === void 0 ? "copy" : _options$action, container = options.container, target = options.target, text2 = options.text;
+                  if (action2 !== "copy" && action2 !== "cut") {
+                    throw new Error('Invalid "action" value, use either "copy" or "cut"');
+                  }
+                  if (target !== void 0) {
+                    if (target && _typeof2(target) === "object" && target.nodeType === 1) {
+                      if (action2 === "copy" && target.hasAttribute("disabled")) {
+                        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+                      }
+                      if (action2 === "cut" && (target.hasAttribute("readonly") || target.hasAttribute("disabled"))) {
+                        throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`);
+                      }
+                    } else {
+                      throw new Error('Invalid "target" value, use a valid Element');
+                    }
+                  }
+                  if (text2) {
+                    return actions_copy(text2, {
+                      container
+                    });
+                  }
+                  if (target) {
+                    return action2 === "cut" ? actions_cut(target) : actions_copy(target, {
+                      container
+                    });
+                  }
+                }, "ClipboardActionDefault");
+                var actions_default = ClipboardActionDefault;
+                function clipboard_typeof(obj) {
+                  "@babel/helpers - typeof";
+                  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+                    clipboard_typeof = /* @__PURE__ */ __name(function _typeof3(obj2) {
+                      return typeof obj2;
+                    }, "_typeof");
+                  } else {
+                    clipboard_typeof = /* @__PURE__ */ __name(function _typeof3(obj2) {
+                      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+                    }, "_typeof");
+                  }
+                  return clipboard_typeof(obj);
+                }
+                __name(clipboard_typeof, "clipboard_typeof");
+                function _classCallCheck2(instance, Constructor) {
+                  if (!(instance instanceof Constructor)) {
+                    throw new TypeError("Cannot call a class as a function");
+                  }
+                }
+                __name(_classCallCheck2, "_classCallCheck");
+                function _defineProperties2(target, props) {
+                  for (var i2 = 0; i2 < props.length; i2++) {
+                    var descriptor = props[i2];
+                    descriptor.enumerable = descriptor.enumerable || false;
+                    descriptor.configurable = true;
+                    if ("value" in descriptor)
+                      descriptor.writable = true;
+                    Object.defineProperty(target, descriptor.key, descriptor);
+                  }
+                }
+                __name(_defineProperties2, "_defineProperties");
+                function _createClass2(Constructor, protoProps, staticProps) {
+                  if (protoProps)
+                    _defineProperties2(Constructor.prototype, protoProps);
+                  if (staticProps)
+                    _defineProperties2(Constructor, staticProps);
+                  return Constructor;
+                }
+                __name(_createClass2, "_createClass");
+                function _inherits2(subClass, superClass) {
+                  if (typeof superClass !== "function" && superClass !== null) {
+                    throw new TypeError("Super expression must either be null or a function");
+                  }
+                  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+                  if (superClass)
+                    _setPrototypeOf2(subClass, superClass);
+                }
+                __name(_inherits2, "_inherits");
+                function _setPrototypeOf2(o2, p2) {
+                  _setPrototypeOf2 = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf3(o3, p3) {
+                    o3.__proto__ = p3;
+                    return o3;
+                  }, "_setPrototypeOf");
+                  return _setPrototypeOf2(o2, p2);
+                }
+                __name(_setPrototypeOf2, "_setPrototypeOf");
+                function _createSuper2(Derived) {
+                  var hasNativeReflectConstruct = _isNativeReflectConstruct2();
+                  return /* @__PURE__ */ __name(function _createSuperInternal() {
+                    var Super = _getPrototypeOf2(Derived), result;
+                    if (hasNativeReflectConstruct) {
+                      var NewTarget = _getPrototypeOf2(this).constructor;
+                      result = Reflect.construct(Super, arguments, NewTarget);
+                    } else {
+                      result = Super.apply(this, arguments);
+                    }
+                    return _possibleConstructorReturn2(this, result);
+                  }, "_createSuperInternal");
+                }
+                __name(_createSuper2, "_createSuper");
+                function _possibleConstructorReturn2(self2, call2) {
+                  if (call2 && (clipboard_typeof(call2) === "object" || typeof call2 === "function")) {
+                    return call2;
+                  }
+                  return _assertThisInitialized2(self2);
+                }
+                __name(_possibleConstructorReturn2, "_possibleConstructorReturn");
+                function _assertThisInitialized2(self2) {
+                  if (self2 === void 0) {
+                    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                  }
+                  return self2;
+                }
+                __name(_assertThisInitialized2, "_assertThisInitialized");
+                function _isNativeReflectConstruct2() {
+                  if (typeof Reflect === "undefined" || !Reflect.construct)
+                    return false;
+                  if (Reflect.construct.sham)
+                    return false;
+                  if (typeof Proxy === "function")
+                    return true;
+                  try {
+                    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+                    }));
+                    return true;
+                  } catch (e2) {
+                    return false;
+                  }
+                }
+                __name(_isNativeReflectConstruct2, "_isNativeReflectConstruct");
+                function _getPrototypeOf2(o2) {
+                  _getPrototypeOf2 = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf3(o3) {
+                    return o3.__proto__ || Object.getPrototypeOf(o3);
+                  }, "_getPrototypeOf");
+                  return _getPrototypeOf2(o2);
+                }
+                __name(_getPrototypeOf2, "_getPrototypeOf");
+                function getAttributeValue(suffix, element2) {
+                  var attribute = "data-clipboard-".concat(suffix);
+                  if (!element2.hasAttribute(attribute)) {
+                    return;
+                  }
+                  return element2.getAttribute(attribute);
+                }
+                __name(getAttributeValue, "getAttributeValue");
+                var Clipboard2 = /* @__PURE__ */ function(_Emitter) {
+                  _inherits2(Clipboard3, _Emitter);
+                  var _super = _createSuper2(Clipboard3);
+                  function Clipboard3(trigger2, options) {
+                    var _this;
+                    _classCallCheck2(this, Clipboard3);
+                    _this = _super.call(this);
+                    _this.resolveOptions(options);
+                    _this.listenClick(trigger2);
+                    return _this;
+                  }
+                  __name(Clipboard3, "Clipboard");
+                  _createClass2(Clipboard3, [{
+                    key: "resolveOptions",
+                    value: /* @__PURE__ */ __name(function resolveOptions() {
+                      var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                      this.action = typeof options.action === "function" ? options.action : this.defaultAction;
+                      this.target = typeof options.target === "function" ? options.target : this.defaultTarget;
+                      this.text = typeof options.text === "function" ? options.text : this.defaultText;
+                      this.container = clipboard_typeof(options.container) === "object" ? options.container : document.body;
+                    }, "resolveOptions")
+                    /**
+                     * Adds a click event listener to the passed trigger.
+                     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+                     */
+                  }, {
+                    key: "listenClick",
+                    value: /* @__PURE__ */ __name(function listenClick(trigger2) {
+                      var _this2 = this;
+                      this.listener = listen_default()(trigger2, "click", function(e2) {
+                        return _this2.onClick(e2);
+                      });
+                    }, "listenClick")
+                    /**
+                     * Defines a new `ClipboardAction` on each click event.
+                     * @param {Event} e
+                     */
+                  }, {
+                    key: "onClick",
+                    value: /* @__PURE__ */ __name(function onClick(e2) {
+                      var trigger2 = e2.delegateTarget || e2.currentTarget;
+                      var action2 = this.action(trigger2) || "copy";
+                      var text2 = actions_default({
+                        action: action2,
+                        container: this.container,
+                        target: this.target(trigger2),
+                        text: this.text(trigger2)
+                      });
+                      this.emit(text2 ? "success" : "error", {
+                        action: action2,
+                        text: text2,
+                        trigger: trigger2,
+                        clearSelection: /* @__PURE__ */ __name(function clearSelection() {
+                          if (trigger2) {
+                            trigger2.focus();
+                          }
+                          window.getSelection().removeAllRanges();
+                        }, "clearSelection")
+                      });
+                    }, "onClick")
+                    /**
+                     * Default `action` lookup function.
+                     * @param {Element} trigger
+                     */
+                  }, {
+                    key: "defaultAction",
+                    value: /* @__PURE__ */ __name(function defaultAction(trigger2) {
+                      return getAttributeValue("action", trigger2);
+                    }, "defaultAction")
+                    /**
+                     * Default `target` lookup function.
+                     * @param {Element} trigger
+                     */
+                  }, {
+                    key: "defaultTarget",
+                    value: /* @__PURE__ */ __name(function defaultTarget(trigger2) {
+                      var selector = getAttributeValue("target", trigger2);
+                      if (selector) {
+                        return document.querySelector(selector);
+                      }
+                    }, "defaultTarget")
+                    /**
+                     * Allow fire programmatically a copy action
+                     * @param {String|HTMLElement} target
+                     * @param {Object} options
+                     * @returns Text copied.
+                     */
+                  }, {
+                    key: "defaultText",
+                    /**
+                     * Default `text` lookup function.
+                     * @param {Element} trigger
+                     */
+                    value: /* @__PURE__ */ __name(function defaultText(trigger2) {
+                      return getAttributeValue("text", trigger2);
+                    }, "defaultText")
+                    /**
+                     * Destroy lifecycle.
+                     */
+                  }, {
+                    key: "destroy",
+                    value: /* @__PURE__ */ __name(function destroy2() {
+                      this.listener.destroy();
+                    }, "destroy")
+                  }], [{
+                    key: "copy",
+                    value: /* @__PURE__ */ __name(function copy2(target) {
+                      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                        container: document.body
+                      };
+                      return actions_copy(target, options);
+                    }, "copy")
+                    /**
+                     * Allow fire programmatically a cut action
+                     * @param {String|HTMLElement} target
+                     * @returns Text cutted.
+                     */
+                  }, {
+                    key: "cut",
+                    value: /* @__PURE__ */ __name(function cut(target) {
+                      return actions_cut(target);
+                    }, "cut")
+                    /**
+                     * Returns the support of the given action, or all actions if no action is
+                     * given.
+                     * @param {String} [action]
+                     */
+                  }, {
+                    key: "isSupported",
+                    value: /* @__PURE__ */ __name(function isSupported() {
+                      var action2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ["copy", "cut"];
+                      var actions2 = typeof action2 === "string" ? [action2] : action2;
+                      var support = !!document.queryCommandSupported;
+                      actions2.forEach(function(action3) {
+                        support = support && !!document.queryCommandSupported(action3);
+                      });
+                      return support;
+                    }, "isSupported")
+                  }]);
+                  return Clipboard3;
+                }(tiny_emitter_default());
+                var clipboard2 = Clipboard2;
+              }
+            ),
+            /***/
+            828: (
+              /***/
+              function(module3) {
+                var DOCUMENT_NODE_TYPE = 9;
+                if (typeof Element !== "undefined" && !Element.prototype.matches) {
+                  var proto = Element.prototype;
+                  proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
+                }
+                function closest2(element2, selector) {
+                  while (element2 && element2.nodeType !== DOCUMENT_NODE_TYPE) {
+                    if (typeof element2.matches === "function" && element2.matches(selector)) {
+                      return element2;
+                    }
+                    element2 = element2.parentNode;
+                  }
+                }
+                __name(closest2, "closest");
+                module3.exports = closest2;
+              }
+            ),
+            /***/
+            438: (
+              /***/
+              function(module3, __unused_webpack_exports, __webpack_require__2) {
+                var closest2 = __webpack_require__2(828);
+                function _delegate(element2, selector, type2, callback2, useCapture) {
+                  var listenerFn = listener.apply(this, arguments);
+                  element2.addEventListener(type2, listenerFn, useCapture);
+                  return {
+                    destroy: function() {
+                      element2.removeEventListener(type2, listenerFn, useCapture);
+                    }
+                  };
+                }
+                __name(_delegate, "_delegate");
+                function delegate(elements, selector, type2, callback2, useCapture) {
+                  if (typeof elements.addEventListener === "function") {
+                    return _delegate.apply(null, arguments);
+                  }
+                  if (typeof type2 === "function") {
+                    return _delegate.bind(null, document).apply(null, arguments);
+                  }
+                  if (typeof elements === "string") {
+                    elements = document.querySelectorAll(elements);
+                  }
+                  return Array.prototype.map.call(elements, function(element2) {
+                    return _delegate(element2, selector, type2, callback2, useCapture);
+                  });
+                }
+                __name(delegate, "delegate");
+                function listener(element2, selector, type2, callback2) {
+                  return function(e2) {
+                    e2.delegateTarget = closest2(e2.target, selector);
+                    if (e2.delegateTarget) {
+                      callback2.call(element2, e2);
+                    }
+                  };
+                }
+                __name(listener, "listener");
+                module3.exports = delegate;
+              }
+            ),
+            /***/
+            879: (
+              /***/
+              function(__unused_webpack_module, exports4) {
+                exports4.node = function(value) {
+                  return value !== void 0 && value instanceof HTMLElement && value.nodeType === 1;
+                };
+                exports4.nodeList = function(value) {
+                  var type2 = Object.prototype.toString.call(value);
+                  return value !== void 0 && (type2 === "[object NodeList]" || type2 === "[object HTMLCollection]") && "length" in value && (value.length === 0 || exports4.node(value[0]));
+                };
+                exports4.string = function(value) {
+                  return typeof value === "string" || value instanceof String;
+                };
+                exports4.fn = function(value) {
+                  var type2 = Object.prototype.toString.call(value);
+                  return type2 === "[object Function]";
+                };
+              }
+            ),
+            /***/
+            370: (
+              /***/
+              function(module3, __unused_webpack_exports, __webpack_require__2) {
+                var is2 = __webpack_require__2(879);
+                var delegate = __webpack_require__2(438);
+                function listen(target, type2, callback2) {
+                  if (!target && !type2 && !callback2) {
+                    throw new Error("Missing required arguments");
+                  }
+                  if (!is2.string(type2)) {
+                    throw new TypeError("Second argument must be a String");
+                  }
+                  if (!is2.fn(callback2)) {
+                    throw new TypeError("Third argument must be a Function");
+                  }
+                  if (is2.node(target)) {
+                    return listenNode(target, type2, callback2);
+                  } else if (is2.nodeList(target)) {
+                    return listenNodeList(target, type2, callback2);
+                  } else if (is2.string(target)) {
+                    return listenSelector(target, type2, callback2);
+                  } else {
+                    throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList");
+                  }
+                }
+                __name(listen, "listen");
+                function listenNode(node2, type2, callback2) {
+                  node2.addEventListener(type2, callback2);
+                  return {
+                    destroy: function() {
+                      node2.removeEventListener(type2, callback2);
+                    }
+                  };
+                }
+                __name(listenNode, "listenNode");
+                function listenNodeList(nodeList, type2, callback2) {
+                  Array.prototype.forEach.call(nodeList, function(node2) {
+                    node2.addEventListener(type2, callback2);
+                  });
+                  return {
+                    destroy: function() {
+                      Array.prototype.forEach.call(nodeList, function(node2) {
+                        node2.removeEventListener(type2, callback2);
+                      });
+                    }
+                  };
+                }
+                __name(listenNodeList, "listenNodeList");
+                function listenSelector(selector, type2, callback2) {
+                  return delegate(document.body, selector, type2, callback2);
+                }
+                __name(listenSelector, "listenSelector");
+                module3.exports = listen;
+              }
+            ),
+            /***/
+            817: (
+              /***/
+              function(module3) {
+                function select(element2) {
+                  var selectedText;
+                  if (element2.nodeName === "SELECT") {
+                    element2.focus();
+                    selectedText = element2.value;
+                  } else if (element2.nodeName === "INPUT" || element2.nodeName === "TEXTAREA") {
+                    var isReadOnly = element2.hasAttribute("readonly");
+                    if (!isReadOnly) {
+                      element2.setAttribute("readonly", "");
+                    }
+                    element2.select();
+                    element2.setSelectionRange(0, element2.value.length);
+                    if (!isReadOnly) {
+                      element2.removeAttribute("readonly");
+                    }
+                    selectedText = element2.value;
+                  } else {
+                    if (element2.hasAttribute("contenteditable")) {
+                      element2.focus();
+                    }
+                    var selection = window.getSelection();
+                    var range2 = document.createRange();
+                    range2.selectNodeContents(element2);
+                    selection.removeAllRanges();
+                    selection.addRange(range2);
+                    selectedText = selection.toString();
+                  }
+                  return selectedText;
+                }
+                __name(select, "select");
+                module3.exports = select;
+              }
+            ),
+            /***/
+            279: (
+              /***/
+              function(module3) {
+                function E2() {
+                }
+                __name(E2, "E");
+                E2.prototype = {
+                  on: function(name2, callback2, ctx) {
+                    var e2 = this.e || (this.e = {});
+                    (e2[name2] || (e2[name2] = [])).push({
+                      fn: callback2,
+                      ctx
+                    });
+                    return this;
+                  },
+                  once: function(name2, callback2, ctx) {
+                    var self2 = this;
+                    function listener() {
+                      self2.off(name2, listener);
+                      callback2.apply(ctx, arguments);
+                    }
+                    __name(listener, "listener");
+                    listener._ = callback2;
+                    return this.on(name2, listener, ctx);
+                  },
+                  emit: function(name2) {
+                    var data = [].slice.call(arguments, 1);
+                    var evtArr = ((this.e || (this.e = {}))[name2] || []).slice();
+                    var i2 = 0;
+                    var len2 = evtArr.length;
+                    for (i2; i2 < len2; i2++) {
+                      evtArr[i2].fn.apply(evtArr[i2].ctx, data);
+                    }
+                    return this;
+                  },
+                  off: function(name2, callback2) {
+                    var e2 = this.e || (this.e = {});
+                    var evts = e2[name2];
+                    var liveEvents = [];
+                    if (evts && callback2) {
+                      for (var i2 = 0, len2 = evts.length; i2 < len2; i2++) {
+                        if (evts[i2].fn !== callback2 && evts[i2].fn._ !== callback2)
+                          liveEvents.push(evts[i2]);
+                      }
+                    }
+                    liveEvents.length ? e2[name2] = liveEvents : delete e2[name2];
+                    return this;
+                  }
+                };
+                module3.exports = E2;
+                module3.exports.TinyEmitter = E2;
+              }
+            )
+            /******/
+          };
+          var __webpack_module_cache__ = {};
+          function __webpack_require__(moduleId) {
+            if (__webpack_module_cache__[moduleId]) {
+              return __webpack_module_cache__[moduleId].exports;
+            }
+            var module3 = __webpack_module_cache__[moduleId] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            __webpack_modules__[moduleId](module3, module3.exports, __webpack_require__);
+            return module3.exports;
+          }
+          __name(__webpack_require__, "__webpack_require__");
+          !function() {
+            __webpack_require__.n = function(module3) {
+              var getter = module3 && module3.__esModule ? (
+                /******/
+                function() {
+                  return module3["default"];
+                }
+              ) : (
+                /******/
+                function() {
+                  return module3;
+                }
+              );
+              __webpack_require__.d(getter, { a: getter });
+              return getter;
+            };
+          }();
+          !function() {
+            __webpack_require__.d = function(exports4, definition2) {
+              for (var key2 in definition2) {
+                if (__webpack_require__.o(definition2, key2) && !__webpack_require__.o(exports4, key2)) {
+                  Object.defineProperty(exports4, key2, { enumerable: true, get: definition2[key2] });
+                }
+              }
+            };
+          }();
+          !function() {
+            __webpack_require__.o = function(obj, prop2) {
+              return Object.prototype.hasOwnProperty.call(obj, prop2);
+            };
+          }();
+          return __webpack_require__(686);
+        }().default
+      );
+    });
+  })(clipboard);
+  var clipboardExports = clipboard.exports;
+  const Clipboard$1 = /* @__PURE__ */ getDefaultExportFromCjs(clipboardExports);
   var connectionStore = /* @__PURE__ */ new WeakMap();
   var ITERATION_KEY = Symbol("iteration key");
   function storeObservable(obj) {
@@ -150981,7 +151659,7 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
   }
   __name(showFileDialog, "showFileDialog");
   const name = "@teselagen/ove";
-  const version = "0.7.2";
+  const version = "0.7.4";
   const main = "./src/index.js";
   const type = "module";
   const exports$1 = {
@@ -153284,7 +153962,7 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
     return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
   }
   __name(isElementInViewport, "isElementInViewport");
-  const _Keyboard = class _Keyboard extends React$2.Component {
+  const _Clipboard = class _Clipboard extends React$2.Component {
     constructor() {
       super(...arguments);
       __publicField(this, "handleKeyDown", /* @__PURE__ */ __name((e2) => {
@@ -153353,14 +154031,14 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
       );
     }
   };
-  __name(_Keyboard, "Keyboard");
+  __name(_Clipboard, "Clipboard");
   // static propTypes = {
   //   value: PropTypes.string.isRequired
   // };
-  __publicField(_Keyboard, "defaultProps", {
+  __publicField(_Clipboard, "defaultProps", {
     className: "clipboard"
   });
-  let Keyboard = _Keyboard;
+  let Clipboard = _Clipboard;
   let dragInProgress = false;
   let selectionStartOrEndGrabbed;
   let caretPositionOnDragStart;
@@ -154376,8 +155054,14 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
           const { sequenceData: sequenceData2, readOnly: readOnly2, disableBpEditing, selectionLayer: selectionLayer2 } = this.props;
           const { isProtein: isProtein2 } = sequenceData2;
           const makeTextCopyable = /* @__PURE__ */ __name((transformFunc, className, action2 = "copy") => {
-            document.querySelectorAll(`.${className}`).forEach((element2) => {
-              element2.addEventListener("click", () => __async(this, null, function* () {
+            return new Clipboard$1(`.${className}`, {
+              action: () => action2,
+              text: () => {
+                if (action2 === "copy") {
+                  document.body.addEventListener("copy", this.handleCopy);
+                } else {
+                  document.body.addEventListener("cut", this.handleCut);
+                }
                 const { editorName, store: store2 } = this.props;
                 const { sequenceData: sequenceData22, copyOptions: copyOptions2, selectionLayer: selectionLayer22 } = store2.getState().VectorEditor[editorName];
                 const selectedSeqData = getSequenceDataBetweenRange(
@@ -154402,22 +155086,12 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
                   sequenceData22
                 );
                 this.sequenceDataToCopy = sequenceDataToCopy;
-                const textToCopy = sequenceDataToCopy.textToCopy || sequenceDataToCopy.sequence;
-                try {
-                  yield navigator.clipboard.writeText(textToCopy);
-                } catch (err2) {
-                  console.error("Failed to copy text:", err2);
-                }
-                if (action2 === "copy") {
-                  document.body.addEventListener("copy", this.handleCopy);
-                } else {
-                  document.body.addEventListener("cut", this.handleCut);
-                }
                 if (window.Cypress) {
                   window.Cypress.textToCopy = sequenceDataToCopy.textToCopy;
                   window.Cypress.seqDataToCopy = sequenceDataToCopy;
                 }
-              }));
+                return sequenceDataToCopy.textToCopy || sequenceDataToCopy.sequence;
+              }
             });
           }, "makeTextCopyable");
           const aaCopy = {
@@ -155055,7 +155729,7 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
           },
           closePanelButton,
           /* @__PURE__ */ React$2.createElement(
-            Keyboard,
+            Clipboard,
             {
               value: selectedBps,
               onCopy: this.handleCopy,
@@ -173228,27 +173902,15 @@ ${seqDataToCopy}\r
                                 this.copyAllAlignmentsFastaClipboardHelper && this.copyAllAlignmentsFastaClipboardHelper.destroy();
                               },
                               didMount: () => {
-                                const elements = document.querySelectorAll(
-                                  `.copyAllAlignmentsFastaClipboardHelper`
+                                this.copyAllAlignmentsFastaClipboardHelper = new Clipboard$1(
+                                  `.copyAllAlignmentsFastaClipboardHelper`,
+                                  {
+                                    action: "copyAllAlignmentsFasta",
+                                    text: () => {
+                                      return this.getAllAlignmentsFastaText();
+                                    }
+                                  }
                                 );
-                                elements.forEach((element2) => {
-                                  element2.addEventListener(
-                                    "click",
-                                    () => __async(this, null, function* () {
-                                      const textToCopy = this.getAllAlignmentsFastaText();
-                                      try {
-                                        yield navigator.clipboard.writeText(
-                                          textToCopy
-                                        );
-                                      } catch (err2) {
-                                        console.error(
-                                          "Failed to copy text:",
-                                          err2
-                                        );
-                                      }
-                                    })
-                                  );
-                                });
                               },
                               onClick: () => {
                                 window.toastr.success("Selection Copied");
@@ -173261,13 +173923,11 @@ ${seqDataToCopy}\r
                                 this.copySpecificAlignmentFastaClipboardHelper && this.copySpecificAlignmentFastaClipboardHelper.destroy();
                               },
                               didMount: () => {
-                                const elements = document.querySelectorAll(
-                                  `.copySpecificAlignmentFastaClipboardHelper`
-                                );
-                                elements.forEach((element2) => {
-                                  element2.addEventListener(
-                                    "click",
-                                    () => __async(this, null, function* () {
+                                this.copySpecificAlignmentFastaClipboardHelper = new Clipboard$1(
+                                  `.copySpecificAlignmentFastaClipboardHelper`,
+                                  {
+                                    action: "copySpecificAlignmentFasta",
+                                    text: () => {
                                       const { selectionLayer: selectionLayer2 } = this.props.store.getState().VectorEditor.__allEditorsOptions.alignments[this.props.id] || {};
                                       const seqDataToCopy = getSequenceDataBetweenRange(
                                         alignmentData,
@@ -173276,19 +173936,10 @@ ${seqDataToCopy}\r
                                       const seqDataToCopyAsFasta = `>${name2}\r
 ${seqDataToCopy}\r
 `;
-                                      try {
-                                        yield navigator.clipboard.writeText(
-                                          seqDataToCopyAsFasta
-                                        );
-                                      } catch (err2) {
-                                        console.error(
-                                          "Failed to copy text:",
-                                          err2
-                                        );
-                                      }
-                                    })
-                                  );
-                                });
+                                      return seqDataToCopyAsFasta;
+                                    }
+                                  }
+                                );
                               },
                               onClick: () => {
                                 window.toastr.success(
@@ -173303,31 +173954,20 @@ ${seqDataToCopy}\r
                                 this.copySpecificAlignmentAsPlainClipboardHelper && this.copySpecificAlignmentAsPlainClipboardHelper.destroy();
                               },
                               didMount: () => {
-                                const elements = document.querySelectorAll(
-                                  `.copySpecificAlignmentAsPlainClipboardHelper`
-                                );
-                                elements.forEach((element2) => {
-                                  element2.addEventListener(
-                                    "click",
-                                    () => __async(this, null, function* () {
+                                this.copySpecificAlignmentAsPlainClipboardHelper = new Clipboard$1(
+                                  `.copySpecificAlignmentAsPlainClipboardHelper`,
+                                  {
+                                    action: "copySpecificAlignmentFasta",
+                                    text: () => {
                                       const { selectionLayer: selectionLayer2 } = this.props.store.getState().VectorEditor.__allEditorsOptions.alignments[this.props.id] || {};
                                       const seqDataToCopy = getSequenceDataBetweenRange(
                                         alignmentData,
                                         selectionLayer2
                                       ).sequence;
-                                      try {
-                                        yield navigator.clipboard.writeText(
-                                          seqDataToCopy
-                                        );
-                                      } catch (err2) {
-                                        console.error(
-                                          "Failed to copy text:",
-                                          err2
-                                        );
-                                      }
-                                    })
-                                  );
-                                });
+                                      return seqDataToCopy;
+                                    }
+                                  }
+                                );
                               },
                               onClick: () => {
                                 window.toastr.success("Selection Copied");