@teselagen/ove 0.7.3 → 0.7.5

package/index.es.js

@@ -59,7 +59,7 @@ var __async = (__this, __arguments, generator) => {
 var _E, _F, _G, _H, _I, _L, _O, _V;
 import { Icon, Classes, Button, Intent, MenuItem, Keys, Tag, Popover, Tooltip, Spinner, Position, FormGroup, Checkbox, Switch, InputGroup, TextArea, EditableText, NumericInput, RadioGroup, Menu, Toaster, MenuDivider, useHotkeys, ContextMenu, Callout, Dialog, Card, Tabs, Tab, Colors, KeyCombo, AnchorButton, Slider as Slider$1, ButtonGroup, HTMLSelect, Label, ResizeSensor, FocusStyleManager } from "@blueprintjs/core";
 import * as React$2 from "react";
-import React__default$1, { useState, useEffect, forwardRef, useImperativeHandle, Fragment, useMemo as useMemo$1, useRef, useReducer, useCallback as useCallback$1, createElement, Component, useLayoutEffect as useLayoutEffect$1, createContext, memo, useContext, isValidElement, PureComponent } from "react";
+import React__default$1, { useState, useEffect, forwardRef, useImperativeHandle, Fragment, useMemo as useMemo$1, useRef, useReducer, useCallback as useCallback$1, createElement, Component, useLayoutEffect as useLayoutEffect$1, createContext, memo, useContext, isValidElement, PureComponent, createPortal as createPortal$1 } from "react";
 import { formValueSelector, initialize, change, Field, reduxForm, SubmissionError, destroy as destroy$1, touch, FormName, reducer as reducer$4, getFormValues, FieldArray } from "redux-form";
 import ReactDOM$1, { unstable_batchedUpdates, createPortal, flushSync, findDOMNode as findDOMNode$1, unmountComponentAtNode, render as render$2 } from "react-dom";
 import { connect, useDispatch, useSelector, useStore, Provider } from "react-redux";
@@ -17945,25 +17945,16 @@ var getIntrinsic = /* @__PURE__ */ __name(function GetIntrinsic(name2, allowMiss
   return value;
 }, "GetIntrinsic");
 var callBind$3 = { exports: {} };
-var esDefineProperty;
-var hasRequiredEsDefineProperty;
-function requireEsDefineProperty() {
-  if (hasRequiredEsDefineProperty)
-    return esDefineProperty;
-  hasRequiredEsDefineProperty = 1;
-  var GetIntrinsic3 = getIntrinsic;
-  var $defineProperty2 = GetIntrinsic3("%Object.defineProperty%", true) || false;
-  if ($defineProperty2) {
-    try {
-      $defineProperty2({}, "a", { value: 1 });
-    } catch (e) {
-      $defineProperty2 = false;
-    }
+var GetIntrinsic$4 = getIntrinsic;
+var $defineProperty$2 = GetIntrinsic$4("%Object.defineProperty%", true) || false;
+if ($defineProperty$2) {
+  try {
+    $defineProperty$2({}, "a", { value: 1 });
+  } catch (e) {
+    $defineProperty$2 = false;
   }
-  esDefineProperty = $defineProperty2;
-  return esDefineProperty;
 }
-__name(requireEsDefineProperty, "requireEsDefineProperty");
+var esDefineProperty = $defineProperty$2;
 var GetIntrinsic$3 = getIntrinsic;
 var $gOPD$1 = GetIntrinsic$3("%Object.getOwnPropertyDescriptor%", true);
 if ($gOPD$1) {
@@ -17974,7 +17965,7 @@ if ($gOPD$1) {
   }
 }
 var gopd$1 = $gOPD$1;
-var $defineProperty$1 = requireEsDefineProperty();
+var $defineProperty$1 = esDefineProperty;
 var $SyntaxError = syntax;
 var $TypeError$4 = type$1;
 var gopd = gopd$1;
@@ -18015,7 +18006,7 @@ var defineDataProperty$1 = /* @__PURE__ */ __name(function defineDataProperty(ob
     throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
   }
 }, "defineDataProperty");
-var $defineProperty = requireEsDefineProperty();
+var $defineProperty = esDefineProperty;
 var hasPropertyDescriptors = /* @__PURE__ */ __name(function hasPropertyDescriptors2() {
   return !!$defineProperty;
 }, "hasPropertyDescriptors");
@@ -18084,7 +18075,7 @@ var setFunctionLength = /* @__PURE__ */ __name(function setFunctionLength2(fn4,
   var $apply = GetIntrinsic3("%Function.prototype.apply%");
   var $call = GetIntrinsic3("%Function.prototype.call%");
   var $reflectApply = GetIntrinsic3("%Reflect.apply%", true) || bind3.call($call, $apply);
-  var $defineProperty2 = requireEsDefineProperty();
+  var $defineProperty2 = esDefineProperty;
   var $max = GetIntrinsic3("%Math.max%");
   module2.exports = /* @__PURE__ */ __name(function callBind2(originalFunction) {
     if (typeof originalFunction !== "function") {
@@ -73504,7 +73495,7 @@ let FillWindow$1 = (_F = class extends React__default$1.Component {
       this.props.children && isFunction$7(this.props.children) ? this.props.children(windowDimensions) : this.props.children
     );
     if (asPortal)
-      return ReactDOM$1(inner2, window.document.body);
+      return createPortal$1(inner2, window.document.body);
     return inner2;
   }
 }, __name(_F, "FillWindow"), _F);
@@ -116418,6 +116409,684 @@ const ConnectedDroppable = connect(
 )(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, exports2) {
+  (/* @__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 i = 0; i < props.length; i++) {
+                  var descriptor = props[i];
+                  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 (e) {
+                  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(e) {
+                      return _this2.onClick(e);
+                    });
+                  }, "listenClick")
+                  /**
+                   * Defines a new `ClipboardAction` on each click event.
+                   * @param {Event} e
+                   */
+                }, {
+                  key: "onClick",
+                  value: /* @__PURE__ */ __name(function onClick(e) {
+                    var trigger2 = e.delegateTarget || e.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(e) {
+                  e.delegateTarget = closest2(e.target, selector);
+                  if (e.delegateTarget) {
+                    callback2.call(element2, e);
+                  }
+                };
+              }
+              __name(listener, "listener");
+              module3.exports = delegate;
+            }
+          ),
+          /***/
+          879: (
+            /***/
+            function(__unused_webpack_module, exports3) {
+              exports3.node = function(value) {
+                return value !== void 0 && value instanceof HTMLElement && value.nodeType === 1;
+              };
+              exports3.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 || exports3.node(value[0]));
+              };
+              exports3.string = function(value) {
+                return typeof value === "string" || value instanceof String;
+              };
+              exports3.fn = function(value) {
+                var type2 = Object.prototype.toString.call(value);
+                return type2 === "[object Function]";
+              };
+            }
+          ),
+          /***/
+          370: (
+            /***/
+            function(module3, __unused_webpack_exports, __webpack_require__2) {
+              var is3 = __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 (!is3.string(type2)) {
+                  throw new TypeError("Second argument must be a String");
+                }
+                if (!is3.fn(callback2)) {
+                  throw new TypeError("Third argument must be a Function");
+                }
+                if (is3.node(target)) {
+                  return listenNode(target, type2, callback2);
+                } else if (is3.nodeList(target)) {
+                  return listenNodeList(target, type2, callback2);
+                } else if (is3.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 e = this.e || (this.e = {});
+                  (e[name2] || (e[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 i = 0;
+                  var len = evtArr.length;
+                  for (i; i < len; i++) {
+                    evtArr[i].fn.apply(evtArr[i].ctx, data);
+                  }
+                  return this;
+                },
+                off: function(name2, callback2) {
+                  var e = this.e || (this.e = {});
+                  var evts = e[name2];
+                  var liveEvents = [];
+                  if (evts && callback2) {
+                    for (var i = 0, len = evts.length; i < len; i++) {
+                      if (evts[i].fn !== callback2 && evts[i].fn._ !== callback2)
+                        liveEvents.push(evts[i]);
+                    }
+                  }
+                  liveEvents.length ? e[name2] = liveEvents : delete e[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(exports3, definition2) {
+            for (var key in definition2) {
+              if (__webpack_require__.o(definition2, key) && !__webpack_require__.o(exports3, key)) {
+                Object.defineProperty(exports3, key, { enumerable: true, get: definition2[key] });
+              }
+            }
+          };
+        }();
+        !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) {
@@ -122392,7 +123061,7 @@ function showFileDialog({ multiple = false, onSelect }) {
 }
 __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 = {
@@ -126300,7 +126969,7 @@ function isElementInViewport(el) {
   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__default$1.Component {
+const _Clipboard = class _Clipboard extends React__default$1.Component {
   constructor() {
     super(...arguments);
     __publicField(this, "handleKeyDown", /* @__PURE__ */ __name((e) => {
@@ -126369,14 +127038,14 @@ const _Keyboard = class _Keyboard extends React__default$1.Component {
     );
   }
 };
-__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;
@@ -127392,8 +128061,14 @@ function VectorInteractionHOC(Component2) {
         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(
@@ -127418,22 +128093,12 @@ function VectorInteractionHOC(Component2) {
                 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 = {
@@ -128071,7 +128736,7 @@ function VectorInteractionHOC(Component2) {
         },
         closePanelButton,
         /* @__PURE__ */ React__default$1.createElement(
-          Keyboard,
+          Clipboard,
           {
             value: selectedBps,
             onCopy: this.handleCopy,
@@ -146244,27 +146909,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");
@@ -146277,13 +146930,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,
@@ -146292,19 +146943,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(
@@ -146319,31 +146961,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");