@teselagen/ove 0.0.4 → 0.0.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/index.js +549 -464
- package/index.mjs +549 -464
- package/index.umd.js +549 -464
- package/package.json +1 -1
    
        package/index.mjs
    CHANGED
    
    | @@ -29307,20 +29307,19 @@ function createField(structure2) { | |
| 29307 29307 | 
             
                _proto.shouldComponentUpdate = /* @__PURE__ */ __name(function shouldComponentUpdate(nextProps, nextState) {
         | 
| 29308 29308 | 
             
                  return shallowCompare$1(this, nextProps, nextState);
         | 
| 29309 29309 | 
             
                }, "shouldComponentUpdate");
         | 
| 29310 | 
            -
                _proto. | 
| 29311 | 
            -
                  var  | 
| 29312 | 
            -
                  var  | 
| 29313 | 
            -
                  var newName = prefixName(this.props, this.props.name);
         | 
| 29310 | 
            +
                _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 29311 | 
            +
                  var oldName = prefixName(this.props, this.props.name);
         | 
| 29312 | 
            +
                  var newName = prefixName(nextProps, nextProps.name);
         | 
| 29314 29313 | 
             
                  if (oldName !== newName || // use deepEqual here because they could be a function or an array of functions
         | 
| 29315 | 
            -
                  !plain.deepEqual( | 
| 29314 | 
            +
                  !plain.deepEqual(this.props.validate, nextProps.validate) || !plain.deepEqual(this.props.warn, nextProps.warn)) {
         | 
| 29316 29315 | 
             
                    this.props._reduxForm.unregister(oldName);
         | 
| 29317 29316 | 
             
                    this.props._reduxForm.register(newName, "Field", function() {
         | 
| 29318 | 
            -
                      return  | 
| 29317 | 
            +
                      return nextProps.validate;
         | 
| 29319 29318 | 
             
                    }, function() {
         | 
| 29320 | 
            -
                      return  | 
| 29319 | 
            +
                      return nextProps.warn;
         | 
| 29321 29320 | 
             
                    });
         | 
| 29322 29321 | 
             
                  }
         | 
| 29323 | 
            -
                }, " | 
| 29322 | 
            +
                }, "UNSAFE_componentWillReceiveProps");
         | 
| 29324 29323 | 
             
                _proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
         | 
| 29325 29324 | 
             
                  this.props._reduxForm.unregister(this.name);
         | 
| 29326 29325 | 
             
                }, "componentWillUnmount");
         | 
| @@ -30293,14 +30292,14 @@ function createFieldArray(structure2) { | |
| 30293 30292 | 
             
                    return wrapError(_this2.props.warn, "_warning");
         | 
| 30294 30293 | 
             
                  });
         | 
| 30295 30294 | 
             
                }, "componentDidMount");
         | 
| 30296 | 
            -
                _proto. | 
| 30297 | 
            -
                  var oldName = prefixName( | 
| 30298 | 
            -
                  var newName = prefixName( | 
| 30295 | 
            +
                _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 30296 | 
            +
                  var oldName = prefixName(this.props, this.props.name);
         | 
| 30297 | 
            +
                  var newName = prefixName(nextProps, nextProps.name);
         | 
| 30299 30298 | 
             
                  if (oldName !== newName) {
         | 
| 30300 30299 | 
             
                    this.props._reduxForm.unregister(oldName);
         | 
| 30301 30300 | 
             
                    this.props._reduxForm.register(newName, "FieldArray");
         | 
| 30302 30301 | 
             
                  }
         | 
| 30303 | 
            -
                }, " | 
| 30302 | 
            +
                }, "UNSAFE_componentWillReceiveProps");
         | 
| 30304 30303 | 
             
                _proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
         | 
| 30305 30304 | 
             
                  this.props._reduxForm.unregister(this.name);
         | 
| 30306 30305 | 
             
                }, "componentWillUnmount");
         | 
| @@ -30995,8 +30994,8 @@ var getDisplayName$2 = /* @__PURE__ */ __name(function getDisplayName(Comp) { | |
| 30995 30994 | 
             
            }, "getDisplayName");
         | 
| 30996 30995 | 
             
            const getDisplayName$3 = getDisplayName$2;
         | 
| 30997 30996 | 
             
            var isHotReloading = /* @__PURE__ */ __name(function isHotReloading2() {
         | 
| 30998 | 
            -
              var castModule =  | 
| 30999 | 
            -
              return !!(castModule && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
         | 
| 30997 | 
            +
              var castModule = module;
         | 
| 30998 | 
            +
              return !!(typeof castModule !== "undefined" && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
         | 
| 31000 30999 | 
             
            }, "isHotReloading");
         | 
| 31001 31000 | 
             
            const isHotReloading$1 = isHotReloading;
         | 
| 31002 31001 | 
             
            var isClassComponent = /* @__PURE__ */ __name(function isClassComponent2(Component2) {
         | 
| @@ -31063,7 +31062,6 @@ function createReduxForm(structure2) { | |
| 31063 31062 | 
             
                      _this.lastFieldWarnerKeys = [];
         | 
| 31064 31063 | 
             
                      _this.innerOnSubmit = void 0;
         | 
| 31065 31064 | 
             
                      _this.submitPromise = void 0;
         | 
| 31066 | 
            -
                      _this.initializedOnLoad = false;
         | 
| 31067 31065 | 
             
                      _this.initIfNeeded = function(nextProps) {
         | 
| 31068 31066 | 
             
                        var enableReinitialize = _this.props.enableReinitialize;
         | 
| 31069 31067 | 
             
                        if (nextProps) {
         | 
| @@ -31074,16 +31072,13 @@ function createReduxForm(structure2) { | |
| 31074 31072 | 
             
                              lastInitialValues: _this.props.initialValues,
         | 
| 31075 31073 | 
             
                              updateUnregisteredFields: nextProps.updateUnregisteredFields
         | 
| 31076 31074 | 
             
                            });
         | 
| 31077 | 
            -
                            return true;
         | 
| 31078 31075 | 
             
                          }
         | 
| 31079 31076 | 
             
                        } else if (_this.props.initialValues && (!_this.props.initialized || enableReinitialize)) {
         | 
| 31080 31077 | 
             
                          _this.props.initialize(_this.props.initialValues, _this.props.keepDirtyOnReinitialize, {
         | 
| 31081 31078 | 
             
                            keepValues: _this.props.keepValues,
         | 
| 31082 31079 | 
             
                            updateUnregisteredFields: _this.props.updateUnregisteredFields
         | 
| 31083 31080 | 
             
                          });
         | 
| 31084 | 
            -
                          return true;
         | 
| 31085 31081 | 
             
                        }
         | 
| 31086 | 
            -
                        return false;
         | 
| 31087 31082 | 
             
                      };
         | 
| 31088 31083 | 
             
                      _this.updateSyncErrorsIfNeeded = function(nextSyncErrors, nextError, lastSyncErrors) {
         | 
| 31089 31084 | 
             
                        var _this$props = _this.props, error2 = _this$props.error, updateSyncErrors3 = _this$props.updateSyncErrors;
         | 
| @@ -31353,18 +31348,20 @@ function createReduxForm(structure2) { | |
| 31353 31348 | 
             
                      _this.reset = function() {
         | 
| 31354 31349 | 
             
                        return _this.props.reset();
         | 
| 31355 31350 | 
             
                      };
         | 
| 31356 | 
            -
                      if (!isHotReloading$1()) {
         | 
| 31357 | 
            -
                        _this.initializedOnLoad = _this.initIfNeeded();
         | 
| 31358 | 
            -
                      }
         | 
| 31359 | 
            -
                      invariant$4(_this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
         | 
| 31360 31351 | 
             
                      return _this;
         | 
| 31361 31352 | 
             
                    }
         | 
| 31362 31353 | 
             
                    __name(Form2, "Form");
         | 
| 31363 31354 | 
             
                    var _proto = Form2.prototype;
         | 
| 31355 | 
            +
                    _proto.UNSAFE_componentWillMount = /* @__PURE__ */ __name(function UNSAFE_componentWillMount() {
         | 
| 31356 | 
            +
                      if (!isHotReloading$1()) {
         | 
| 31357 | 
            +
                        this.initIfNeeded();
         | 
| 31358 | 
            +
                        this.validateIfNeeded();
         | 
| 31359 | 
            +
                        this.warnIfNeeded();
         | 
| 31360 | 
            +
                      }
         | 
| 31361 | 
            +
                      invariant$4(this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
         | 
| 31362 | 
            +
                    }, "UNSAFE_componentWillMount");
         | 
| 31364 31363 | 
             
                    _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 31365 | 
            -
                       | 
| 31366 | 
            -
                      if (isValueReset)
         | 
| 31367 | 
            -
                        return;
         | 
| 31364 | 
            +
                      this.initIfNeeded(nextProps);
         | 
| 31368 31365 | 
             
                      this.validateIfNeeded(nextProps);
         | 
| 31369 31366 | 
             
                      this.warnIfNeeded(nextProps);
         | 
| 31370 31367 | 
             
                      this.clearSubmitPromiseIfNeeded(nextProps);
         | 
| @@ -31388,8 +31385,7 @@ function createReduxForm(structure2) { | |
| 31388 31385 | 
             
                    }, "shouldComponentUpdate");
         | 
| 31389 31386 | 
             
                    _proto.componentDidMount = /* @__PURE__ */ __name(function componentDidMount() {
         | 
| 31390 31387 | 
             
                      if (!isHotReloading$1()) {
         | 
| 31391 | 
            -
                         | 
| 31392 | 
            -
                          return;
         | 
| 31388 | 
            +
                        this.initIfNeeded(this.props);
         | 
| 31393 31389 | 
             
                        this.validateIfNeeded();
         | 
| 31394 31390 | 
             
                        this.warnIfNeeded();
         | 
| 31395 31391 | 
             
                      }
         | 
| @@ -39445,25 +39441,16 @@ var toString$4 = {}.toString; | |
| 39445 39441 | 
             
            var _cof = /* @__PURE__ */ __name(function(it) {
         | 
| 39446 39442 | 
             
              return toString$4.call(it).slice(8, -1);
         | 
| 39447 39443 | 
             
            }, "_cof");
         | 
| 39448 | 
            -
            var  | 
| 39449 | 
            -
            var  | 
| 39450 | 
            -
             | 
| 39451 | 
            -
             | 
| 39452 | 
            -
                return _iobject;
         | 
| 39453 | 
            -
              hasRequired_iobject = 1;
         | 
| 39454 | 
            -
              var cof2 = _cof;
         | 
| 39455 | 
            -
              _iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
         | 
| 39456 | 
            -
                return cof2(it) == "String" ? it.split("") : Object(it);
         | 
| 39457 | 
            -
              };
         | 
| 39458 | 
            -
              return _iobject;
         | 
| 39459 | 
            -
            }
         | 
| 39460 | 
            -
            __name(require_iobject, "require_iobject");
         | 
| 39444 | 
            +
            var cof$2 = _cof;
         | 
| 39445 | 
            +
            var _iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
         | 
| 39446 | 
            +
              return cof$2(it) == "String" ? it.split("") : Object(it);
         | 
| 39447 | 
            +
            };
         | 
| 39461 39448 | 
             
            var _defined = /* @__PURE__ */ __name(function(it) {
         | 
| 39462 39449 | 
             
              if (it == void 0)
         | 
| 39463 39450 | 
             
                throw TypeError("Can't call method on  " + it);
         | 
| 39464 39451 | 
             
              return it;
         | 
| 39465 39452 | 
             
            }, "_defined");
         | 
| 39466 | 
            -
            var IObject =  | 
| 39453 | 
            +
            var IObject = _iobject;
         | 
| 39467 39454 | 
             
            var defined$2 = _defined;
         | 
| 39468 39455 | 
             
            var _toIobject = /* @__PURE__ */ __name(function(it) {
         | 
| 39469 39456 | 
             
              return IObject(defined$2(it));
         | 
| @@ -39560,15 +39547,7 @@ var _objectKeys = Object.keys || /* @__PURE__ */ __name(function keys2(O2) { | |
| 39560 39547 | 
             
            var _objectGops = {};
         | 
| 39561 39548 | 
             
            _objectGops.f = Object.getOwnPropertySymbols;
         | 
| 39562 39549 | 
             
            var _objectPie = {};
         | 
| 39563 | 
            -
             | 
| 39564 | 
            -
            function require_objectPie() {
         | 
| 39565 | 
            -
              if (hasRequired_objectPie)
         | 
| 39566 | 
            -
                return _objectPie;
         | 
| 39567 | 
            -
              hasRequired_objectPie = 1;
         | 
| 39568 | 
            -
              _objectPie.f = {}.propertyIsEnumerable;
         | 
| 39569 | 
            -
              return _objectPie;
         | 
| 39570 | 
            -
            }
         | 
| 39571 | 
            -
            __name(require_objectPie, "require_objectPie");
         | 
| 39550 | 
            +
            _objectPie.f = {}.propertyIsEnumerable;
         | 
| 39572 39551 | 
             
            var defined$1 = _defined;
         | 
| 39573 39552 | 
             
            var _toObject = /* @__PURE__ */ __name(function(it) {
         | 
| 39574 39553 | 
             
              return Object(defined$1(it));
         | 
| @@ -39582,9 +39561,9 @@ function require_objectAssign() { | |
| 39582 39561 | 
             
              var DESCRIPTORS2 = _descriptors;
         | 
| 39583 39562 | 
             
              var getKeys2 = _objectKeys;
         | 
| 39584 39563 | 
             
              var gOPS2 = _objectGops;
         | 
| 39585 | 
            -
              var pIE2 =  | 
| 39564 | 
            +
              var pIE2 = _objectPie;
         | 
| 39586 39565 | 
             
              var toObject2 = _toObject;
         | 
| 39587 | 
            -
              var IObject2 =  | 
| 39566 | 
            +
              var IObject2 = _iobject;
         | 
| 39588 39567 | 
             
              var $assign = Object.assign;
         | 
| 39589 39568 | 
             
              _objectAssign = !$assign || _fails(function() {
         | 
| 39590 39569 | 
             
                var A2 = {};
         | 
| @@ -40219,7 +40198,7 @@ var _wksDefine = /* @__PURE__ */ __name(function(name2) { | |
| 40219 40198 | 
             
            }, "_wksDefine");
         | 
| 40220 40199 | 
             
            var getKeys = _objectKeys;
         | 
| 40221 40200 | 
             
            var gOPS$1 = _objectGops;
         | 
| 40222 | 
            -
            var pIE$1 =  | 
| 40201 | 
            +
            var pIE$1 = _objectPie;
         | 
| 40223 40202 | 
             
            var _enumKeys = /* @__PURE__ */ __name(function(it) {
         | 
| 40224 40203 | 
             
              var result = getKeys(it);
         | 
| 40225 40204 | 
             
              var getSymbols2 = gOPS$1.f;
         | 
| @@ -40260,7 +40239,7 @@ _objectGopnExt.f = /* @__PURE__ */ __name(function getOwnPropertyNames2(it) { | |
| 40260 40239 | 
             
              return windowNames && toString$3.call(it) == "[object Window]" ? getWindowNames(it) : gOPN$1(toIObject$2(it));
         | 
| 40261 40240 | 
             
            }, "getOwnPropertyNames");
         | 
| 40262 40241 | 
             
            var _objectGopd = {};
         | 
| 40263 | 
            -
            var pIE =  | 
| 40242 | 
            +
            var pIE = _objectPie;
         | 
| 40264 40243 | 
             
            var createDesc$1 = _propertyDesc;
         | 
| 40265 40244 | 
             
            var toIObject$1 = _toIobject;
         | 
| 40266 40245 | 
             
            var toPrimitive$1 = _toPrimitive$1;
         | 
| @@ -40440,7 +40419,7 @@ if (!USE_NATIVE) { | |
| 40440 40419 | 
             
              $GOPD.f = $getOwnPropertyDescriptor;
         | 
| 40441 40420 | 
             
              $DP.f = $defineProperty;
         | 
| 40442 40421 | 
             
              _objectGopn.f = gOPNExt.f = $getOwnPropertyNames;
         | 
| 40443 | 
            -
               | 
| 40422 | 
            +
              _objectPie.f = $propertyIsEnumerable;
         | 
| 40444 40423 | 
             
              $GOPS.f = $getOwnPropertySymbols;
         | 
| 40445 40424 | 
             
              if (DESCRIPTORS && !_library) {
         | 
| 40446 40425 | 
             
                redefine(ObjectProto, "propertyIsEnumerable", $propertyIsEnumerable);
         | 
| @@ -120171,6 +120150,9 @@ function genbankToJson(string2, options = {}) { | |
| 120171 120150 | 
             
                      options.isProtein = false;
         | 
| 120172 120151 | 
             
                    }
         | 
| 120173 120152 | 
             
                    options.sequenceTypeFromLocus = item;
         | 
| 120153 | 
            +
                    if (item.match(/ss-dna/i)) {
         | 
| 120154 | 
            +
                      options.isSingleStrandedDNA = true;
         | 
| 120155 | 
            +
                    }
         | 
| 120174 120156 | 
             
                  }
         | 
| 120175 120157 | 
             
                  if (typeof lineArr[j] === "string" && gbDivisions[lineArr[j].toUpperCase()]) {
         | 
| 120176 120158 | 
             
                    gbDivision = lineArr[j].toUpperCase();
         | 
| @@ -120181,6 +120163,7 @@ function genbankToJson(string2, options = {}) { | |
| 120181 120163 | 
             
                }
         | 
| 120182 120164 | 
             
                result.parsedSequence.gbDivision = gbDivision;
         | 
| 120183 120165 | 
             
                result.parsedSequence.sequenceTypeFromLocus = options.sequenceTypeFromLocus;
         | 
| 120166 | 
            +
                result.parsedSequence.isSingleStrandedDNA = options.isSingleStrandedDNA;
         | 
| 120184 120167 | 
             
                result.parsedSequence.date = date;
         | 
| 120185 120168 | 
             
                result.parsedSequence.circular = circular2;
         | 
| 120186 120169 | 
             
              }
         | 
| @@ -132201,6 +132184,7 @@ function jsonToGenbank(_serSeq, options) { | |
| 132201 132184 | 
             
            }
         | 
| 132202 132185 | 
             
            __name(jsonToGenbank, "jsonToGenbank");
         | 
| 132203 132186 | 
             
            function createGenbankLocus(serSeq, options) {
         | 
| 132187 | 
            +
              var _a2;
         | 
| 132204 132188 | 
             
              if (serSeq.sequence.symbols) {
         | 
| 132205 132189 | 
             
                serSeq.sequence = serSeq.sequence.symbols.split("");
         | 
| 132206 132190 | 
             
              }
         | 
| @@ -132211,7 +132195,7 @@ function createGenbankLocus(serSeq, options) { | |
| 132211 132195 | 
             
              } else if (serSeq.type === "RNA") {
         | 
| 132212 132196 | 
             
                dnaType = "RNA";
         | 
| 132213 132197 | 
             
              } else {
         | 
| 132214 | 
            -
                dnaType = "DNA";
         | 
| 132198 | 
            +
                dnaType = (_a2 = serSeq == null ? void 0 : serSeq.sequenceTypeFromLocus) != null ? _a2 : "DNA";
         | 
| 132215 132199 | 
             
              }
         | 
| 132216 132200 | 
             
              const date = getCurrentDateString();
         | 
| 132217 132201 | 
             
              let line = StringUtil.rpad("LOCUS", " ", 12);
         | 
| @@ -135751,6 +135735,7 @@ function showAddOrEditAnnotationDialog({ | |
| 135751 135735 | 
             
            }
         | 
| 135752 135736 | 
             
            __name(showAddOrEditAnnotationDialog, "showAddOrEditAnnotationDialog");
         | 
| 135753 135737 | 
             
            function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { convertAnnotationsFromAAIndices } = {}) {
         | 
| 135738 | 
            +
              var _a2;
         | 
| 135754 135739 | 
             
              const {
         | 
| 135755 135740 | 
             
                sequenceData: sequenceData2,
         | 
| 135756 135741 | 
             
                annotationVisibility: annotationVisibility2,
         | 
| @@ -135762,7 +135747,9 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { | |
| 135762 135747 | 
             
              const isAlreadyProteinEditor = currentEditor.sequenceData && currentEditor.sequenceData.isProtein;
         | 
| 135763 135748 | 
             
              const isAlreadyRnaEditor = currentEditor.sequenceData && currentEditor.sequenceData.isRna;
         | 
| 135764 135749 | 
             
              const isAlreadyOligoEditor = currentEditor.sequenceData && currentEditor.sequenceData.isOligo;
         | 
| 135765 | 
            -
              const  | 
| 135750 | 
            +
              const reverseSequenceShouldBeUpdate = ((_a2 = currentEditor.sequenceData) == null ? void 0 : _a2.isSingleStrandedDNA) !== (sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA);
         | 
| 135751 | 
            +
              const annotationVisibilityUpdated = !lodashExports.isEqual(annotationVisibility2, currentEditor.annotationVisibility) || !lodashExports.isEqual(annotationsToSupport2, currentEditor.annotationsToSupport);
         | 
| 135752 | 
            +
              const isAlreadySpecialEditor = isAlreadyProteinEditor || isAlreadyRnaEditor || isAlreadyOligoEditor || reverseSequenceShouldBeUpdate || annotationVisibilityUpdated;
         | 
| 135766 135753 | 
             
              let toSpread = {};
         | 
| 135767 135754 | 
             
              let payload;
         | 
| 135768 135755 | 
             
              if (justPassingPartialSeqData) {
         | 
| @@ -135868,7 +135855,7 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { | |
| 135868 135855 | 
             
                      }, annotationVisibility2), {
         | 
| 135869 135856 | 
             
                        //we spread this here to allow the user to override this .. if they must!
         | 
| 135870 135857 | 
             
                        sequence: true,
         | 
| 135871 | 
            -
                        reverseSequence:  | 
| 135858 | 
            +
                        reverseSequence: !(sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA),
         | 
| 135872 135859 | 
             
                        translations: false,
         | 
| 135873 135860 | 
             
                        aminoAcidNumbers: false,
         | 
| 135874 135861 | 
             
                        primaryProteinSequence: false
         | 
| @@ -137202,7 +137189,12 @@ const getDevMessage = /* @__PURE__ */ __name((message) => clean$2(` | |
| 137202 137189 |  | 
| 137203 137190 | 
             
              %c👷 This is a development only message. It will be removed in production builds.
         | 
| 137204 137191 | 
             
            `), "getDevMessage");
         | 
| 137205 | 
            -
            const getFormattedMessage = /* @__PURE__ */ __name((message) => [ | 
| 137192 | 
            +
            const getFormattedMessage = /* @__PURE__ */ __name((message) => [
         | 
| 137193 | 
            +
              getDevMessage(message),
         | 
| 137194 | 
            +
              "color: #00C584; font-size: 1.2em; font-weight: bold;",
         | 
| 137195 | 
            +
              "line-height: 1.5",
         | 
| 137196 | 
            +
              "color: #723874;"
         | 
| 137197 | 
            +
            ], "getFormattedMessage");
         | 
| 137206 137198 | 
             
            const isDisabledFlag = "__@hello-pangea/dnd-disable-dev-warnings";
         | 
| 137207 137199 | 
             
            function log$2(type2, message) {
         | 
| 137208 137200 | 
             
              if (isProduction$1) {
         | 
| @@ -138028,7 +138020,11 @@ const goAfter = /* @__PURE__ */ __name((_ref) => { | |
| 138028 138020 | 
             
                moveRelativeTo,
         | 
| 138029 138021 | 
             
                isMoving
         | 
| 138030 138022 | 
             
              } = _ref;
         | 
| 138031 | 
            -
              return patch( | 
| 138023 | 
            +
              return patch(
         | 
| 138024 | 
            +
                axis.line,
         | 
| 138025 | 
            +
                moveRelativeTo.marginBox[axis.end] + distanceFromStartToBorderBoxCenter(axis, isMoving),
         | 
| 138026 | 
            +
                getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
         | 
| 138027 | 
            +
              );
         | 
| 138032 138028 | 
             
            }, "goAfter");
         | 
| 138033 138029 | 
             
            const goBefore = /* @__PURE__ */ __name((_ref2) => {
         | 
| 138034 138030 | 
             
              let {
         | 
| @@ -138036,7 +138032,11 @@ const goBefore = /* @__PURE__ */ __name((_ref2) => { | |
| 138036 138032 | 
             
                moveRelativeTo,
         | 
| 138037 138033 | 
             
                isMoving
         | 
| 138038 138034 | 
             
              } = _ref2;
         | 
| 138039 | 
            -
              return patch( | 
| 138035 | 
            +
              return patch(
         | 
| 138036 | 
            +
                axis.line,
         | 
| 138037 | 
            +
                moveRelativeTo.marginBox[axis.start] - distanceFromEndToBorderBoxCenter(axis, isMoving),
         | 
| 138038 | 
            +
                getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
         | 
| 138039 | 
            +
              );
         | 
| 138040 138040 | 
             
            }, "goBefore");
         | 
| 138041 138041 | 
             
            const goIntoStart = /* @__PURE__ */ __name((_ref3) => {
         | 
| 138042 138042 | 
             
              let {
         | 
| @@ -138213,7 +138213,11 @@ var speculativelyIncrease = /* @__PURE__ */ __name((_ref) => { | |
| 138213 138213 | 
             
              });
         | 
| 138214 138214 | 
             
              const invisible = {};
         | 
| 138215 138215 | 
             
              const visible = {};
         | 
| 138216 | 
            -
              const groups = [ | 
| 138216 | 
            +
              const groups = [
         | 
| 138217 | 
            +
                last2,
         | 
| 138218 | 
            +
                withViewportScroll,
         | 
| 138219 | 
            +
                withDroppableScroll2
         | 
| 138220 | 
            +
              ];
         | 
| 138217 138221 | 
             
              last2.all.forEach((id2) => {
         | 
| 138218 138222 | 
             
                const displacement = tryGetVisible(id2, groups);
         | 
| 138219 138223 | 
             
                if (displacement) {
         | 
| @@ -138570,7 +138574,9 @@ var moveToNewDroppable = /* @__PURE__ */ __name((_ref) => { | |
| 138570 138574 | 
             
                });
         | 
| 138571 138575 | 
             
                return isVisibleInNewLocation ? proposed : null;
         | 
| 138572 138576 | 
             
              }
         | 
| 138573 | 
            -
              const isGoingBeforeTarget = Boolean( | 
| 138577 | 
            +
              const isGoingBeforeTarget = Boolean(
         | 
| 138578 | 
            +
                previousPageBorderBoxCenter[destination.axis.line] <= moveRelativeTo.page.borderBox.center[destination.axis.line]
         | 
| 138579 | 
            +
              );
         | 
| 138574 138580 | 
             
              const proposedIndex = (() => {
         | 
| 138575 138581 | 
             
                const relativeTo = moveRelativeTo.descriptor.index;
         | 
| 138576 138582 | 
             
                if (moveRelativeTo.descriptor.id === draggable2.descriptor.id) {
         | 
| @@ -138733,7 +138739,11 @@ function getFurthestAway(_ref) { | |
| 138733 138739 | 
             
              const startCenter = draggable2.page.borderBox.center;
         | 
| 138734 138740 | 
             
              const sorted = candidates.map((candidate) => {
         | 
| 138735 138741 | 
             
                const axis = candidate.axis;
         | 
| 138736 | 
            -
                const target = patch( | 
| 138742 | 
            +
                const target = patch(
         | 
| 138743 | 
            +
                  candidate.axis.line,
         | 
| 138744 | 
            +
                  pageBorderBox.center[axis.line],
         | 
| 138745 | 
            +
                  candidate.page.borderBox.center[axis.crossAxisLine]
         | 
| 138746 | 
            +
                );
         | 
| 138737 138747 | 
             
                return {
         | 
| 138738 138748 | 
             
                  id: candidate.descriptor.id,
         | 
| 138739 138749 | 
             
                  distance: distance$1(startCenter, target)
         | 
| @@ -140468,7 +140478,19 @@ var createStore$1 = /* @__PURE__ */ __name((_ref) => { | |
| 140468 140478 | 
             
                announce,
         | 
| 140469 140479 | 
             
                autoScroller
         | 
| 140470 140480 | 
             
              } = _ref;
         | 
| 140471 | 
            -
              return createStore$2(reducer, composeEnhancers(applyMiddleware( | 
| 140481 | 
            +
              return createStore$2(reducer, composeEnhancers(applyMiddleware(
         | 
| 140482 | 
            +
                style$n(styleMarshal),
         | 
| 140483 | 
            +
                dimensionMarshalStopper(dimensionMarshal),
         | 
| 140484 | 
            +
                lift(dimensionMarshal),
         | 
| 140485 | 
            +
                drop,
         | 
| 140486 | 
            +
                dropAnimationFinish,
         | 
| 140487 | 
            +
                dropAnimationFlushOnScroll,
         | 
| 140488 | 
            +
                pendingDrop$1,
         | 
| 140489 | 
            +
                autoScroll(autoScroller),
         | 
| 140490 | 
            +
                scrollListener$1,
         | 
| 140491 | 
            +
                focus2(focusMarshal),
         | 
| 140492 | 
            +
                responders(getResponders, announce)
         | 
| 140493 | 
            +
              )));
         | 
| 140472 140494 | 
             
            }, "createStore$1");
         | 
| 140473 140495 | 
             
            const clean$1 = /* @__PURE__ */ __name(() => ({
         | 
| 140474 140496 | 
             
              additions: {},
         | 
| @@ -140495,7 +140517,9 @@ function createPublisher(_ref) { | |
| 140495 140517 | 
             
                    removals,
         | 
| 140496 140518 | 
             
                    modified: modified2
         | 
| 140497 140519 | 
             
                  } = staging;
         | 
| 140498 | 
            -
                  const added2 = Object.keys(additions).map( | 
| 140520 | 
            +
                  const added2 = Object.keys(additions).map(
         | 
| 140521 | 
            +
                    (id2) => registry.draggable.getById(id2).getDimension(origin)
         | 
| 140522 | 
            +
                  ).sort((a2, b3) => a2.descriptor.index - b3.descriptor.index);
         | 
| 140499 140523 | 
             
                  const updated = Object.keys(modified2).map((id2) => {
         | 
| 140500 140524 | 
             
                    const entry = registry.droppable.getById(id2);
         | 
| 140501 140525 | 
             
                    const scroll2 = entry.callbacks.getScrollWhileDragging();
         | 
| @@ -140554,13 +140578,16 @@ var getMaxScroll = /* @__PURE__ */ __name((_ref) => { | |
| 140554 140578 | 
             
                height: height2,
         | 
| 140555 140579 | 
             
                width
         | 
| 140556 140580 | 
             
              } = _ref;
         | 
| 140557 | 
            -
              const maxScroll = subtract( | 
| 140558 | 
            -
                 | 
| 140559 | 
            -
             | 
| 140560 | 
            -
             | 
| 140561 | 
            -
                 | 
| 140562 | 
            -
                 | 
| 140563 | 
            -
             | 
| 140581 | 
            +
              const maxScroll = subtract(
         | 
| 140582 | 
            +
                {
         | 
| 140583 | 
            +
                  x: scrollWidth,
         | 
| 140584 | 
            +
                  y: scrollHeight
         | 
| 140585 | 
            +
                },
         | 
| 140586 | 
            +
                {
         | 
| 140587 | 
            +
                  x: width,
         | 
| 140588 | 
            +
                  y: height2
         | 
| 140589 | 
            +
                }
         | 
| 140590 | 
            +
              );
         | 
| 140564 140591 | 
             
              const adjustedMaxScroll = {
         | 
| 140565 140592 | 
             
                x: Math.max(0, maxScroll.x),
         | 
| 140566 140593 | 
             
                y: Math.max(0, maxScroll.y)
         | 
| @@ -141477,11 +141504,14 @@ function useStyleMarshal(contextId, nonce) { | |
| 141477 141504 | 
             
              const styles2 = useMemo(() => getStyles$1(contextId), [contextId]);
         | 
| 141478 141505 | 
             
              const alwaysRef = useRef(null);
         | 
| 141479 141506 | 
             
              const dynamicRef = useRef(null);
         | 
| 141480 | 
            -
              const setDynamicStyle = useCallback( | 
| 141481 | 
            -
                 | 
| 141482 | 
            -
             | 
| 141483 | 
            -
             | 
| 141484 | 
            -
             | 
| 141507 | 
            +
              const setDynamicStyle = useCallback(
         | 
| 141508 | 
            +
                memoizeOne((proposed) => {
         | 
| 141509 | 
            +
                  const el = dynamicRef.current;
         | 
| 141510 | 
            +
                  !el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
         | 
| 141511 | 
            +
                  el.textContent = proposed;
         | 
| 141512 | 
            +
                }),
         | 
| 141513 | 
            +
                []
         | 
| 141514 | 
            +
              );
         | 
| 141485 141515 | 
             
              const setAlwaysStyle = useCallback((proposed) => {
         | 
| 141486 141516 | 
             
                const el = alwaysRef.current;
         | 
| 141487 141517 | 
             
                !el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
         | 
| @@ -141537,8 +141567,8 @@ function querySelectorAll(parentNode, selector) { | |
| 141537 141567 | 
             
            }
         | 
| 141538 141568 | 
             
            __name(querySelectorAll, "querySelectorAll");
         | 
| 141539 141569 | 
             
            var getWindowFromEl = /* @__PURE__ */ __name((el) => {
         | 
| 141540 | 
            -
              var  | 
| 141541 | 
            -
              return ( | 
| 141570 | 
            +
              var _el$ownerDocument;
         | 
| 141571 | 
            +
              return (el == null ? void 0 : (_el$ownerDocument = el.ownerDocument) == null ? void 0 : _el$ownerDocument.defaultView) || window;
         | 
| 141542 141572 | 
             
            }, "getWindowFromEl");
         | 
| 141543 141573 | 
             
            function isHtmlElement(el) {
         | 
| 141544 141574 | 
             
              return el instanceof getWindowFromEl(el).HTMLElement;
         | 
| @@ -142099,141 +142129,157 @@ function getCaptureBindings(_ref) { | |
| 142099 142129 | 
             
                getPhase,
         | 
| 142100 142130 | 
             
                setPhase
         | 
| 142101 142131 | 
             
              } = _ref;
         | 
| 142102 | 
            -
              return [ | 
| 142103 | 
            -
                 | 
| 142104 | 
            -
             | 
| 142105 | 
            -
                   | 
| 142106 | 
            -
                     | 
| 142107 | 
            -
             | 
| 142108 | 
            -
             | 
| 142109 | 
            -
             | 
| 142110 | 
            -
             | 
| 142111 | 
            -
                     | 
| 142112 | 
            -
             | 
| 142113 | 
            -
             | 
| 142114 | 
            -
                     | 
| 142115 | 
            -
             | 
| 142116 | 
            -
             | 
| 142117 | 
            -
             | 
| 142118 | 
            -
             | 
| 142132 | 
            +
              return [
         | 
| 142133 | 
            +
                {
         | 
| 142134 | 
            +
                  eventName: "mousemove",
         | 
| 142135 | 
            +
                  fn: (event) => {
         | 
| 142136 | 
            +
                    const {
         | 
| 142137 | 
            +
                      button,
         | 
| 142138 | 
            +
                      clientX,
         | 
| 142139 | 
            +
                      clientY
         | 
| 142140 | 
            +
                    } = event;
         | 
| 142141 | 
            +
                    if (button !== primaryButton) {
         | 
| 142142 | 
            +
                      return;
         | 
| 142143 | 
            +
                    }
         | 
| 142144 | 
            +
                    const point2 = {
         | 
| 142145 | 
            +
                      x: clientX,
         | 
| 142146 | 
            +
                      y: clientY
         | 
| 142147 | 
            +
                    };
         | 
| 142148 | 
            +
                    const phase = getPhase();
         | 
| 142149 | 
            +
                    if (phase.type === "DRAGGING") {
         | 
| 142150 | 
            +
                      event.preventDefault();
         | 
| 142151 | 
            +
                      phase.actions.move(point2);
         | 
| 142152 | 
            +
                      return;
         | 
| 142153 | 
            +
                    }
         | 
| 142154 | 
            +
                    !(phase.type === "PENDING") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot be IDLE") : invariant$1(false) : void 0;
         | 
| 142155 | 
            +
                    const pending = phase.point;
         | 
| 142156 | 
            +
                    if (!isSloppyClickThresholdExceeded(pending, point2)) {
         | 
| 142157 | 
            +
                      return;
         | 
| 142158 | 
            +
                    }
         | 
| 142119 142159 | 
             
                    event.preventDefault();
         | 
| 142120 | 
            -
                    phase.actions. | 
| 142121 | 
            -
                     | 
| 142122 | 
            -
             | 
| 142123 | 
            -
             | 
| 142124 | 
            -
             | 
| 142125 | 
            -
                  if (!isSloppyClickThresholdExceeded(pending, point2)) {
         | 
| 142126 | 
            -
                    return;
         | 
| 142127 | 
            -
                  }
         | 
| 142128 | 
            -
                  event.preventDefault();
         | 
| 142129 | 
            -
                  const actions2 = phase.actions.fluidLift(point2);
         | 
| 142130 | 
            -
                  setPhase({
         | 
| 142131 | 
            -
                    type: "DRAGGING",
         | 
| 142132 | 
            -
                    actions: actions2
         | 
| 142133 | 
            -
                  });
         | 
| 142134 | 
            -
                }
         | 
| 142135 | 
            -
              }, {
         | 
| 142136 | 
            -
                eventName: "mouseup",
         | 
| 142137 | 
            -
                fn: (event) => {
         | 
| 142138 | 
            -
                  const phase = getPhase();
         | 
| 142139 | 
            -
                  if (phase.type !== "DRAGGING") {
         | 
| 142140 | 
            -
                    cancel();
         | 
| 142141 | 
            -
                    return;
         | 
| 142160 | 
            +
                    const actions2 = phase.actions.fluidLift(point2);
         | 
| 142161 | 
            +
                    setPhase({
         | 
| 142162 | 
            +
                      type: "DRAGGING",
         | 
| 142163 | 
            +
                      actions: actions2
         | 
| 142164 | 
            +
                    });
         | 
| 142142 142165 | 
             
                  }
         | 
| 142143 | 
            -
             | 
| 142144 | 
            -
             | 
| 142145 | 
            -
             | 
| 142146 | 
            -
                   | 
| 142147 | 
            -
             | 
| 142148 | 
            -
             | 
| 142149 | 
            -
             | 
| 142150 | 
            -
             | 
| 142151 | 
            -
             | 
| 142152 | 
            -
                  if (getPhase().type === "DRAGGING") {
         | 
| 142166 | 
            +
                },
         | 
| 142167 | 
            +
                {
         | 
| 142168 | 
            +
                  eventName: "mouseup",
         | 
| 142169 | 
            +
                  fn: (event) => {
         | 
| 142170 | 
            +
                    const phase = getPhase();
         | 
| 142171 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142172 | 
            +
                      cancel();
         | 
| 142173 | 
            +
                      return;
         | 
| 142174 | 
            +
                    }
         | 
| 142153 142175 | 
             
                    event.preventDefault();
         | 
| 142176 | 
            +
                    phase.actions.drop({
         | 
| 142177 | 
            +
                      shouldBlockNextClick: true
         | 
| 142178 | 
            +
                    });
         | 
| 142179 | 
            +
                    completed();
         | 
| 142154 142180 | 
             
                  }
         | 
| 142155 | 
            -
             | 
| 142156 | 
            -
                 | 
| 142157 | 
            -
             | 
| 142158 | 
            -
             | 
| 142159 | 
            -
             | 
| 142160 | 
            -
             | 
| 142161 | 
            -
             | 
| 142181 | 
            +
                },
         | 
| 142182 | 
            +
                {
         | 
| 142183 | 
            +
                  eventName: "mousedown",
         | 
| 142184 | 
            +
                  fn: (event) => {
         | 
| 142185 | 
            +
                    if (getPhase().type === "DRAGGING") {
         | 
| 142186 | 
            +
                      event.preventDefault();
         | 
| 142187 | 
            +
                    }
         | 
| 142162 142188 | 
             
                    cancel();
         | 
| 142163 | 
            -
                    return;
         | 
| 142164 142189 | 
             
                  }
         | 
| 142165 | 
            -
             | 
| 142166 | 
            -
             | 
| 142167 | 
            -
             | 
| 142168 | 
            -
             | 
| 142190 | 
            +
                },
         | 
| 142191 | 
            +
                {
         | 
| 142192 | 
            +
                  eventName: "keydown",
         | 
| 142193 | 
            +
                  fn: (event) => {
         | 
| 142194 | 
            +
                    const phase = getPhase();
         | 
| 142195 | 
            +
                    if (phase.type === "PENDING") {
         | 
| 142196 | 
            +
                      cancel();
         | 
| 142197 | 
            +
                      return;
         | 
| 142198 | 
            +
                    }
         | 
| 142199 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142200 | 
            +
                      event.preventDefault();
         | 
| 142201 | 
            +
                      cancel();
         | 
| 142202 | 
            +
                      return;
         | 
| 142203 | 
            +
                    }
         | 
| 142204 | 
            +
                    preventStandardKeyEvents(event);
         | 
| 142169 142205 | 
             
                  }
         | 
| 142170 | 
            -
                  preventStandardKeyEvents(event);
         | 
| 142171 | 
            -
                }
         | 
| 142172 | 
            -
              }, {
         | 
| 142173 | 
            -
                eventName: "resize",
         | 
| 142174 | 
            -
                fn: cancel
         | 
| 142175 | 
            -
              }, {
         | 
| 142176 | 
            -
                eventName: "scroll",
         | 
| 142177 | 
            -
                options: {
         | 
| 142178 | 
            -
                  passive: true,
         | 
| 142179 | 
            -
                  capture: false
         | 
| 142180 142206 | 
             
                },
         | 
| 142181 | 
            -
                 | 
| 142182 | 
            -
                   | 
| 142183 | 
            -
             | 
| 142207 | 
            +
                {
         | 
| 142208 | 
            +
                  eventName: "resize",
         | 
| 142209 | 
            +
                  fn: cancel
         | 
| 142210 | 
            +
                },
         | 
| 142211 | 
            +
                {
         | 
| 142212 | 
            +
                  eventName: "scroll",
         | 
| 142213 | 
            +
                  options: {
         | 
| 142214 | 
            +
                    passive: true,
         | 
| 142215 | 
            +
                    capture: false
         | 
| 142216 | 
            +
                  },
         | 
| 142217 | 
            +
                  fn: () => {
         | 
| 142218 | 
            +
                    if (getPhase().type === "PENDING") {
         | 
| 142219 | 
            +
                      cancel();
         | 
| 142220 | 
            +
                    }
         | 
| 142184 142221 | 
             
                  }
         | 
| 142185 | 
            -
                }
         | 
| 142186 | 
            -
             | 
| 142187 | 
            -
             | 
| 142188 | 
            -
             | 
| 142189 | 
            -
             | 
| 142190 | 
            -
             | 
| 142191 | 
            -
             | 
| 142192 | 
            -
             | 
| 142193 | 
            -
             | 
| 142222 | 
            +
                },
         | 
| 142223 | 
            +
                {
         | 
| 142224 | 
            +
                  eventName: "webkitmouseforcedown",
         | 
| 142225 | 
            +
                  fn: (event) => {
         | 
| 142226 | 
            +
                    const phase = getPhase();
         | 
| 142227 | 
            +
                    !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Unexpected phase") : invariant$1(false) : void 0;
         | 
| 142228 | 
            +
                    if (phase.actions.shouldRespectForcePress()) {
         | 
| 142229 | 
            +
                      cancel();
         | 
| 142230 | 
            +
                      return;
         | 
| 142231 | 
            +
                    }
         | 
| 142232 | 
            +
                    event.preventDefault();
         | 
| 142194 142233 | 
             
                  }
         | 
| 142195 | 
            -
             | 
| 142234 | 
            +
                },
         | 
| 142235 | 
            +
                {
         | 
| 142236 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142237 | 
            +
                  fn: cancel
         | 
| 142196 142238 | 
             
                }
         | 
| 142197 | 
            -
               | 
| 142198 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142199 | 
            -
                fn: cancel
         | 
| 142200 | 
            -
              }];
         | 
| 142239 | 
            +
              ];
         | 
| 142201 142240 | 
             
            }
         | 
| 142202 142241 | 
             
            __name(getCaptureBindings, "getCaptureBindings");
         | 
| 142203 142242 | 
             
            function useMouseSensor(api) {
         | 
| 142204 142243 | 
             
              const phaseRef = useRef(idle$1);
         | 
| 142205 142244 | 
             
              const unbindEventsRef = useRef(noop$2);
         | 
| 142206 | 
            -
              const startCaptureBinding = useMemo( | 
| 142207 | 
            -
                 | 
| 142208 | 
            -
             | 
| 142209 | 
            -
                   | 
| 142210 | 
            -
                     | 
| 142211 | 
            -
             | 
| 142212 | 
            -
             | 
| 142213 | 
            -
                     | 
| 142214 | 
            -
             | 
| 142215 | 
            -
             | 
| 142216 | 
            -
                     | 
| 142217 | 
            -
             | 
| 142218 | 
            -
             | 
| 142219 | 
            -
             | 
| 142220 | 
            -
                     | 
| 142221 | 
            -
             | 
| 142222 | 
            -
             | 
| 142223 | 
            -
                     | 
| 142224 | 
            -
             | 
| 142225 | 
            -
             | 
| 142226 | 
            -
             | 
| 142227 | 
            -
             | 
| 142228 | 
            -
             | 
| 142229 | 
            -
             | 
| 142230 | 
            -
                     | 
| 142231 | 
            -
             | 
| 142232 | 
            -
             | 
| 142233 | 
            -
             | 
| 142234 | 
            -
             | 
| 142235 | 
            -
             | 
| 142236 | 
            -
             | 
| 142245 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142246 | 
            +
                () => ({
         | 
| 142247 | 
            +
                  eventName: "mousedown",
         | 
| 142248 | 
            +
                  fn: /* @__PURE__ */ __name(function onMouseDown3(event) {
         | 
| 142249 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142250 | 
            +
                      return;
         | 
| 142251 | 
            +
                    }
         | 
| 142252 | 
            +
                    if (event.button !== primaryButton) {
         | 
| 142253 | 
            +
                      return;
         | 
| 142254 | 
            +
                    }
         | 
| 142255 | 
            +
                    if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
         | 
| 142256 | 
            +
                      return;
         | 
| 142257 | 
            +
                    }
         | 
| 142258 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142259 | 
            +
                    if (!draggableId) {
         | 
| 142260 | 
            +
                      return;
         | 
| 142261 | 
            +
                    }
         | 
| 142262 | 
            +
                    const actions2 = api.tryGetLock(
         | 
| 142263 | 
            +
                      draggableId,
         | 
| 142264 | 
            +
                      stop,
         | 
| 142265 | 
            +
                      {
         | 
| 142266 | 
            +
                        sourceEvent: event
         | 
| 142267 | 
            +
                      }
         | 
| 142268 | 
            +
                    );
         | 
| 142269 | 
            +
                    if (!actions2) {
         | 
| 142270 | 
            +
                      return;
         | 
| 142271 | 
            +
                    }
         | 
| 142272 | 
            +
                    event.preventDefault();
         | 
| 142273 | 
            +
                    const point2 = {
         | 
| 142274 | 
            +
                      x: event.clientX,
         | 
| 142275 | 
            +
                      y: event.clientY
         | 
| 142276 | 
            +
                    };
         | 
| 142277 | 
            +
                    unbindEventsRef.current();
         | 
| 142278 | 
            +
                    startPendingDrag(actions2, point2);
         | 
| 142279 | 
            +
                  }, "onMouseDown")
         | 
| 142280 | 
            +
                }),
         | 
| 142281 | 
            +
                [api]
         | 
| 142282 | 
            +
              );
         | 
| 142237 142283 | 
             
              const preventForcePressBinding = useMemo(() => ({
         | 
| 142238 142284 | 
             
                eventName: "webkitmouseforcewillbegin",
         | 
| 142239 142285 | 
             
                fn: (event) => {
         | 
| @@ -142337,110 +142383,126 @@ function getDraggingBindings(actions2, stop) { | |
| 142337 142383 | 
             
                actions2.drop();
         | 
| 142338 142384 | 
             
              }
         | 
| 142339 142385 | 
             
              __name(drop2, "drop");
         | 
| 142340 | 
            -
              return [ | 
| 142341 | 
            -
                 | 
| 142342 | 
            -
             | 
| 142343 | 
            -
                   | 
| 142344 | 
            -
                    event. | 
| 142345 | 
            -
             | 
| 142346 | 
            -
             | 
| 142347 | 
            -
             | 
| 142348 | 
            -
             | 
| 142349 | 
            -
                    event. | 
| 142350 | 
            -
             | 
| 142351 | 
            -
             | 
| 142352 | 
            -
             | 
| 142353 | 
            -
             | 
| 142354 | 
            -
                    event. | 
| 142355 | 
            -
             | 
| 142356 | 
            -
             | 
| 142357 | 
            -
             | 
| 142358 | 
            -
             | 
| 142359 | 
            -
                    event. | 
| 142360 | 
            -
             | 
| 142361 | 
            -
             | 
| 142362 | 
            -
             | 
| 142363 | 
            -
             | 
| 142364 | 
            -
                    event. | 
| 142365 | 
            -
             | 
| 142366 | 
            -
             | 
| 142367 | 
            -
             | 
| 142368 | 
            -
             | 
| 142369 | 
            -
                    event. | 
| 142370 | 
            -
             | 
| 142371 | 
            -
             | 
| 142386 | 
            +
              return [
         | 
| 142387 | 
            +
                {
         | 
| 142388 | 
            +
                  eventName: "keydown",
         | 
| 142389 | 
            +
                  fn: (event) => {
         | 
| 142390 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142391 | 
            +
                      event.preventDefault();
         | 
| 142392 | 
            +
                      cancel();
         | 
| 142393 | 
            +
                      return;
         | 
| 142394 | 
            +
                    }
         | 
| 142395 | 
            +
                    if (event.keyCode === space) {
         | 
| 142396 | 
            +
                      event.preventDefault();
         | 
| 142397 | 
            +
                      drop2();
         | 
| 142398 | 
            +
                      return;
         | 
| 142399 | 
            +
                    }
         | 
| 142400 | 
            +
                    if (event.keyCode === arrowDown) {
         | 
| 142401 | 
            +
                      event.preventDefault();
         | 
| 142402 | 
            +
                      actions2.moveDown();
         | 
| 142403 | 
            +
                      return;
         | 
| 142404 | 
            +
                    }
         | 
| 142405 | 
            +
                    if (event.keyCode === arrowUp) {
         | 
| 142406 | 
            +
                      event.preventDefault();
         | 
| 142407 | 
            +
                      actions2.moveUp();
         | 
| 142408 | 
            +
                      return;
         | 
| 142409 | 
            +
                    }
         | 
| 142410 | 
            +
                    if (event.keyCode === arrowRight) {
         | 
| 142411 | 
            +
                      event.preventDefault();
         | 
| 142412 | 
            +
                      actions2.moveRight();
         | 
| 142413 | 
            +
                      return;
         | 
| 142414 | 
            +
                    }
         | 
| 142415 | 
            +
                    if (event.keyCode === arrowLeft) {
         | 
| 142416 | 
            +
                      event.preventDefault();
         | 
| 142417 | 
            +
                      actions2.moveLeft();
         | 
| 142418 | 
            +
                      return;
         | 
| 142419 | 
            +
                    }
         | 
| 142420 | 
            +
                    if (scrollJumpKeys[event.keyCode]) {
         | 
| 142421 | 
            +
                      event.preventDefault();
         | 
| 142422 | 
            +
                      return;
         | 
| 142423 | 
            +
                    }
         | 
| 142424 | 
            +
                    preventStandardKeyEvents(event);
         | 
| 142372 142425 | 
             
                  }
         | 
| 142373 | 
            -
             | 
| 142374 | 
            -
             | 
| 142375 | 
            -
             | 
| 142426 | 
            +
                },
         | 
| 142427 | 
            +
                {
         | 
| 142428 | 
            +
                  eventName: "mousedown",
         | 
| 142429 | 
            +
                  fn: cancel
         | 
| 142430 | 
            +
                },
         | 
| 142431 | 
            +
                {
         | 
| 142432 | 
            +
                  eventName: "mouseup",
         | 
| 142433 | 
            +
                  fn: cancel
         | 
| 142434 | 
            +
                },
         | 
| 142435 | 
            +
                {
         | 
| 142436 | 
            +
                  eventName: "click",
         | 
| 142437 | 
            +
                  fn: cancel
         | 
| 142438 | 
            +
                },
         | 
| 142439 | 
            +
                {
         | 
| 142440 | 
            +
                  eventName: "touchstart",
         | 
| 142441 | 
            +
                  fn: cancel
         | 
| 142442 | 
            +
                },
         | 
| 142443 | 
            +
                {
         | 
| 142444 | 
            +
                  eventName: "resize",
         | 
| 142445 | 
            +
                  fn: cancel
         | 
| 142446 | 
            +
                },
         | 
| 142447 | 
            +
                {
         | 
| 142448 | 
            +
                  eventName: "wheel",
         | 
| 142449 | 
            +
                  fn: cancel,
         | 
| 142450 | 
            +
                  options: {
         | 
| 142451 | 
            +
                    passive: true
         | 
| 142376 142452 | 
             
                  }
         | 
| 142377 | 
            -
             | 
| 142378 | 
            -
                 | 
| 142379 | 
            -
             | 
| 142380 | 
            -
             | 
| 142381 | 
            -
                fn: cancel
         | 
| 142382 | 
            -
              }, {
         | 
| 142383 | 
            -
                eventName: "mouseup",
         | 
| 142384 | 
            -
                fn: cancel
         | 
| 142385 | 
            -
              }, {
         | 
| 142386 | 
            -
                eventName: "click",
         | 
| 142387 | 
            -
                fn: cancel
         | 
| 142388 | 
            -
              }, {
         | 
| 142389 | 
            -
                eventName: "touchstart",
         | 
| 142390 | 
            -
                fn: cancel
         | 
| 142391 | 
            -
              }, {
         | 
| 142392 | 
            -
                eventName: "resize",
         | 
| 142393 | 
            -
                fn: cancel
         | 
| 142394 | 
            -
              }, {
         | 
| 142395 | 
            -
                eventName: "wheel",
         | 
| 142396 | 
            -
                fn: cancel,
         | 
| 142397 | 
            -
                options: {
         | 
| 142398 | 
            -
                  passive: true
         | 
| 142453 | 
            +
                },
         | 
| 142454 | 
            +
                {
         | 
| 142455 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142456 | 
            +
                  fn: cancel
         | 
| 142399 142457 | 
             
                }
         | 
| 142400 | 
            -
               | 
| 142401 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142402 | 
            -
                fn: cancel
         | 
| 142403 | 
            -
              }];
         | 
| 142458 | 
            +
              ];
         | 
| 142404 142459 | 
             
            }
         | 
| 142405 142460 | 
             
            __name(getDraggingBindings, "getDraggingBindings");
         | 
| 142406 142461 | 
             
            function useKeyboardSensor(api) {
         | 
| 142407 142462 | 
             
              const unbindEventsRef = useRef(noop$1$1);
         | 
| 142408 | 
            -
              const startCaptureBinding = useMemo( | 
| 142409 | 
            -
                 | 
| 142410 | 
            -
             | 
| 142411 | 
            -
                   | 
| 142412 | 
            -
                     | 
| 142413 | 
            -
             | 
| 142414 | 
            -
             | 
| 142415 | 
            -
                     | 
| 142416 | 
            -
             | 
| 142417 | 
            -
             | 
| 142418 | 
            -
             | 
| 142419 | 
            -
                     | 
| 142420 | 
            -
             | 
| 142421 | 
            -
             | 
| 142422 | 
            -
                     | 
| 142423 | 
            -
             | 
| 142424 | 
            -
             | 
| 142425 | 
            -
             | 
| 142426 | 
            -
             | 
| 142427 | 
            -
             | 
| 142428 | 
            -
             | 
| 142429 | 
            -
             | 
| 142430 | 
            -
             | 
| 142431 | 
            -
             | 
| 142432 | 
            -
                     | 
| 142433 | 
            -
                    isCapturing =  | 
| 142463 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142464 | 
            +
                () => ({
         | 
| 142465 | 
            +
                  eventName: "keydown",
         | 
| 142466 | 
            +
                  fn: /* @__PURE__ */ __name(function onKeyDown(event) {
         | 
| 142467 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142468 | 
            +
                      return;
         | 
| 142469 | 
            +
                    }
         | 
| 142470 | 
            +
                    if (event.keyCode !== space) {
         | 
| 142471 | 
            +
                      return;
         | 
| 142472 | 
            +
                    }
         | 
| 142473 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142474 | 
            +
                    if (!draggableId) {
         | 
| 142475 | 
            +
                      return;
         | 
| 142476 | 
            +
                    }
         | 
| 142477 | 
            +
                    const preDrag = api.tryGetLock(
         | 
| 142478 | 
            +
                      draggableId,
         | 
| 142479 | 
            +
                      stop,
         | 
| 142480 | 
            +
                      {
         | 
| 142481 | 
            +
                        sourceEvent: event
         | 
| 142482 | 
            +
                      }
         | 
| 142483 | 
            +
                    );
         | 
| 142484 | 
            +
                    if (!preDrag) {
         | 
| 142485 | 
            +
                      return;
         | 
| 142486 | 
            +
                    }
         | 
| 142487 | 
            +
                    event.preventDefault();
         | 
| 142488 | 
            +
                    let isCapturing = true;
         | 
| 142489 | 
            +
                    const actions2 = preDrag.snapLift();
         | 
| 142434 142490 | 
             
                    unbindEventsRef.current();
         | 
| 142435 | 
            -
                     | 
| 142436 | 
            -
             | 
| 142437 | 
            -
             | 
| 142438 | 
            -
             | 
| 142439 | 
            -
             | 
| 142440 | 
            -
                     | 
| 142441 | 
            -
             | 
| 142442 | 
            -
             | 
| 142443 | 
            -
             | 
| 142491 | 
            +
                    function stop() {
         | 
| 142492 | 
            +
                      !isCapturing ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot stop capturing a keyboard drag when not capturing") : invariant$1(false) : void 0;
         | 
| 142493 | 
            +
                      isCapturing = false;
         | 
| 142494 | 
            +
                      unbindEventsRef.current();
         | 
| 142495 | 
            +
                      listenForCapture();
         | 
| 142496 | 
            +
                    }
         | 
| 142497 | 
            +
                    __name(stop, "stop");
         | 
| 142498 | 
            +
                    unbindEventsRef.current = bindEvents(window, getDraggingBindings(actions2, stop), {
         | 
| 142499 | 
            +
                      capture: true,
         | 
| 142500 | 
            +
                      passive: false
         | 
| 142501 | 
            +
                    });
         | 
| 142502 | 
            +
                  }, "onKeyDown")
         | 
| 142503 | 
            +
                }),
         | 
| 142504 | 
            +
                [api]
         | 
| 142505 | 
            +
              );
         | 
| 142444 142506 | 
             
              const listenForCapture = useCallback(/* @__PURE__ */ __name(function tryStartCapture() {
         | 
| 142445 142507 | 
             
                const options = {
         | 
| 142446 142508 | 
             
                  passive: false,
         | 
| @@ -142466,33 +142528,39 @@ function getWindowBindings(_ref) { | |
| 142466 142528 | 
             
                cancel,
         | 
| 142467 142529 | 
             
                getPhase
         | 
| 142468 142530 | 
             
              } = _ref;
         | 
| 142469 | 
            -
              return [ | 
| 142470 | 
            -
                 | 
| 142471 | 
            -
             | 
| 142472 | 
            -
             | 
| 142473 | 
            -
                 | 
| 142474 | 
            -
                 | 
| 142475 | 
            -
             | 
| 142476 | 
            -
             | 
| 142477 | 
            -
                 | 
| 142478 | 
            -
             | 
| 142479 | 
            -
             | 
| 142480 | 
            -
             | 
| 142481 | 
            -
                eventName: "keydown",
         | 
| 142482 | 
            -
                fn: (event) => {
         | 
| 142483 | 
            -
                  if (getPhase().type !== "DRAGGING") {
         | 
| 142484 | 
            -
                    cancel();
         | 
| 142485 | 
            -
                    return;
         | 
| 142486 | 
            -
                  }
         | 
| 142487 | 
            -
                  if (event.keyCode === escape$1) {
         | 
| 142531 | 
            +
              return [
         | 
| 142532 | 
            +
                {
         | 
| 142533 | 
            +
                  eventName: "orientationchange",
         | 
| 142534 | 
            +
                  fn: cancel
         | 
| 142535 | 
            +
                },
         | 
| 142536 | 
            +
                {
         | 
| 142537 | 
            +
                  eventName: "resize",
         | 
| 142538 | 
            +
                  fn: cancel
         | 
| 142539 | 
            +
                },
         | 
| 142540 | 
            +
                {
         | 
| 142541 | 
            +
                  eventName: "contextmenu",
         | 
| 142542 | 
            +
                  fn: (event) => {
         | 
| 142488 142543 | 
             
                    event.preventDefault();
         | 
| 142489 142544 | 
             
                  }
         | 
| 142490 | 
            -
             | 
| 142545 | 
            +
                },
         | 
| 142546 | 
            +
                {
         | 
| 142547 | 
            +
                  eventName: "keydown",
         | 
| 142548 | 
            +
                  fn: (event) => {
         | 
| 142549 | 
            +
                    if (getPhase().type !== "DRAGGING") {
         | 
| 142550 | 
            +
                      cancel();
         | 
| 142551 | 
            +
                      return;
         | 
| 142552 | 
            +
                    }
         | 
| 142553 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142554 | 
            +
                      event.preventDefault();
         | 
| 142555 | 
            +
                    }
         | 
| 142556 | 
            +
                    cancel();
         | 
| 142557 | 
            +
                  }
         | 
| 142558 | 
            +
                },
         | 
| 142559 | 
            +
                {
         | 
| 142560 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142561 | 
            +
                  fn: cancel
         | 
| 142491 142562 | 
             
                }
         | 
| 142492 | 
            -
               | 
| 142493 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142494 | 
            -
                fn: cancel
         | 
| 142495 | 
            -
              }];
         | 
| 142563 | 
            +
              ];
         | 
| 142496 142564 | 
             
            }
         | 
| 142497 142565 | 
             
            __name(getWindowBindings, "getWindowBindings");
         | 
| 142498 142566 | 
             
            function getHandleBindings(_ref2) {
         | 
| @@ -142501,87 +142569,93 @@ function getHandleBindings(_ref2) { | |
| 142501 142569 | 
             
                completed,
         | 
| 142502 142570 | 
             
                getPhase
         | 
| 142503 142571 | 
             
              } = _ref2;
         | 
| 142504 | 
            -
              return [ | 
| 142505 | 
            -
                 | 
| 142506 | 
            -
             | 
| 142507 | 
            -
                   | 
| 142508 | 
            -
             | 
| 142509 | 
            -
             | 
| 142510 | 
            -
                   | 
| 142511 | 
            -
             | 
| 142512 | 
            -
                     | 
| 142513 | 
            -
             | 
| 142572 | 
            +
              return [
         | 
| 142573 | 
            +
                {
         | 
| 142574 | 
            +
                  eventName: "touchmove",
         | 
| 142575 | 
            +
                  options: {
         | 
| 142576 | 
            +
                    capture: false
         | 
| 142577 | 
            +
                  },
         | 
| 142578 | 
            +
                  fn: (event) => {
         | 
| 142579 | 
            +
                    const phase = getPhase();
         | 
| 142580 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142581 | 
            +
                      cancel();
         | 
| 142582 | 
            +
                      return;
         | 
| 142583 | 
            +
                    }
         | 
| 142584 | 
            +
                    phase.hasMoved = true;
         | 
| 142585 | 
            +
                    const {
         | 
| 142586 | 
            +
                      clientX,
         | 
| 142587 | 
            +
                      clientY
         | 
| 142588 | 
            +
                    } = event.touches[0];
         | 
| 142589 | 
            +
                    const point2 = {
         | 
| 142590 | 
            +
                      x: clientX,
         | 
| 142591 | 
            +
                      y: clientY
         | 
| 142592 | 
            +
                    };
         | 
| 142593 | 
            +
                    event.preventDefault();
         | 
| 142594 | 
            +
                    phase.actions.move(point2);
         | 
| 142514 142595 | 
             
                  }
         | 
| 142515 | 
            -
             | 
| 142516 | 
            -
             | 
| 142517 | 
            -
             | 
| 142518 | 
            -
             | 
| 142519 | 
            -
             | 
| 142520 | 
            -
             | 
| 142521 | 
            -
             | 
| 142522 | 
            -
             | 
| 142523 | 
            -
             | 
| 142524 | 
            -
             | 
| 142525 | 
            -
             | 
| 142526 | 
            -
             | 
| 142527 | 
            -
             | 
| 142528 | 
            -
             | 
| 142529 | 
            -
                fn: (event) => {
         | 
| 142530 | 
            -
                  const phase = getPhase();
         | 
| 142531 | 
            -
                  if (phase.type !== "DRAGGING") {
         | 
| 142532 | 
            -
                    cancel();
         | 
| 142533 | 
            -
                    return;
         | 
| 142596 | 
            +
                },
         | 
| 142597 | 
            +
                {
         | 
| 142598 | 
            +
                  eventName: "touchend",
         | 
| 142599 | 
            +
                  fn: (event) => {
         | 
| 142600 | 
            +
                    const phase = getPhase();
         | 
| 142601 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142602 | 
            +
                      cancel();
         | 
| 142603 | 
            +
                      return;
         | 
| 142604 | 
            +
                    }
         | 
| 142605 | 
            +
                    event.preventDefault();
         | 
| 142606 | 
            +
                    phase.actions.drop({
         | 
| 142607 | 
            +
                      shouldBlockNextClick: true
         | 
| 142608 | 
            +
                    });
         | 
| 142609 | 
            +
                    completed();
         | 
| 142534 142610 | 
             
                  }
         | 
| 142535 | 
            -
             | 
| 142536 | 
            -
             | 
| 142537 | 
            -
             | 
| 142538 | 
            -
                   | 
| 142539 | 
            -
             | 
| 142540 | 
            -
             | 
| 142541 | 
            -
             | 
| 142542 | 
            -
             | 
| 142543 | 
            -
             | 
| 142544 | 
            -
                  if (getPhase().type !== "DRAGGING") {
         | 
| 142611 | 
            +
                },
         | 
| 142612 | 
            +
                {
         | 
| 142613 | 
            +
                  eventName: "touchcancel",
         | 
| 142614 | 
            +
                  fn: (event) => {
         | 
| 142615 | 
            +
                    if (getPhase().type !== "DRAGGING") {
         | 
| 142616 | 
            +
                      cancel();
         | 
| 142617 | 
            +
                      return;
         | 
| 142618 | 
            +
                    }
         | 
| 142619 | 
            +
                    event.preventDefault();
         | 
| 142545 142620 | 
             
                    cancel();
         | 
| 142546 | 
            -
                    return;
         | 
| 142547 | 
            -
                  }
         | 
| 142548 | 
            -
                  event.preventDefault();
         | 
| 142549 | 
            -
                  cancel();
         | 
| 142550 | 
            -
                }
         | 
| 142551 | 
            -
              }, {
         | 
| 142552 | 
            -
                eventName: "touchforcechange",
         | 
| 142553 | 
            -
                fn: (event) => {
         | 
| 142554 | 
            -
                  const phase = getPhase();
         | 
| 142555 | 
            -
                  !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
         | 
| 142556 | 
            -
                  const touch3 = event.touches[0];
         | 
| 142557 | 
            -
                  if (!touch3) {
         | 
| 142558 | 
            -
                    return;
         | 
| 142559 | 
            -
                  }
         | 
| 142560 | 
            -
                  const isForcePress = touch3.force >= forcePressThreshold;
         | 
| 142561 | 
            -
                  if (!isForcePress) {
         | 
| 142562 | 
            -
                    return;
         | 
| 142563 142621 | 
             
                  }
         | 
| 142564 | 
            -
             | 
| 142565 | 
            -
             | 
| 142622 | 
            +
                },
         | 
| 142623 | 
            +
                {
         | 
| 142624 | 
            +
                  eventName: "touchforcechange",
         | 
| 142625 | 
            +
                  fn: (event) => {
         | 
| 142626 | 
            +
                    const phase = getPhase();
         | 
| 142627 | 
            +
                    !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
         | 
| 142628 | 
            +
                    const touch3 = event.touches[0];
         | 
| 142629 | 
            +
                    if (!touch3) {
         | 
| 142630 | 
            +
                      return;
         | 
| 142631 | 
            +
                    }
         | 
| 142632 | 
            +
                    const isForcePress = touch3.force >= forcePressThreshold;
         | 
| 142633 | 
            +
                    if (!isForcePress) {
         | 
| 142634 | 
            +
                      return;
         | 
| 142635 | 
            +
                    }
         | 
| 142636 | 
            +
                    const shouldRespect = phase.actions.shouldRespectForcePress();
         | 
| 142637 | 
            +
                    if (phase.type === "PENDING") {
         | 
| 142638 | 
            +
                      if (shouldRespect) {
         | 
| 142639 | 
            +
                        cancel();
         | 
| 142640 | 
            +
                      }
         | 
| 142641 | 
            +
                      return;
         | 
| 142642 | 
            +
                    }
         | 
| 142566 142643 | 
             
                    if (shouldRespect) {
         | 
| 142644 | 
            +
                      if (phase.hasMoved) {
         | 
| 142645 | 
            +
                        event.preventDefault();
         | 
| 142646 | 
            +
                        return;
         | 
| 142647 | 
            +
                      }
         | 
| 142567 142648 | 
             
                      cancel();
         | 
| 142568 | 
            -
                    }
         | 
| 142569 | 
            -
                    return;
         | 
| 142570 | 
            -
                  }
         | 
| 142571 | 
            -
                  if (shouldRespect) {
         | 
| 142572 | 
            -
                    if (phase.hasMoved) {
         | 
| 142573 | 
            -
                      event.preventDefault();
         | 
| 142574 142649 | 
             
                      return;
         | 
| 142575 142650 | 
             
                    }
         | 
| 142576 | 
            -
                     | 
| 142577 | 
            -
                    return;
         | 
| 142651 | 
            +
                    event.preventDefault();
         | 
| 142578 142652 | 
             
                  }
         | 
| 142579 | 
            -
             | 
| 142653 | 
            +
                },
         | 
| 142654 | 
            +
                {
         | 
| 142655 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142656 | 
            +
                  fn: cancel
         | 
| 142580 142657 | 
             
                }
         | 
| 142581 | 
            -
               | 
| 142582 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142583 | 
            -
                fn: cancel
         | 
| 142584 | 
            -
              }];
         | 
| 142658 | 
            +
              ];
         | 
| 142585 142659 | 
             
            }
         | 
| 142586 142660 | 
             
            __name(getHandleBindings, "getHandleBindings");
         | 
| 142587 142661 | 
             
            function useTouchSensor(api) {
         | 
| @@ -142593,35 +142667,42 @@ function useTouchSensor(api) { | |
| 142593 142667 | 
             
              const setPhase = useCallback(/* @__PURE__ */ __name(function setPhase2(phase) {
         | 
| 142594 142668 | 
             
                phaseRef.current = phase;
         | 
| 142595 142669 | 
             
              }, "setPhase"), []);
         | 
| 142596 | 
            -
              const startCaptureBinding = useMemo( | 
| 142597 | 
            -
                 | 
| 142598 | 
            -
             | 
| 142599 | 
            -
                   | 
| 142600 | 
            -
                     | 
| 142601 | 
            -
             | 
| 142602 | 
            -
             | 
| 142603 | 
            -
             | 
| 142604 | 
            -
                     | 
| 142605 | 
            -
             | 
| 142606 | 
            -
             | 
| 142607 | 
            -
                     | 
| 142608 | 
            -
             | 
| 142609 | 
            -
             | 
| 142610 | 
            -
             | 
| 142611 | 
            -
             | 
| 142612 | 
            -
             | 
| 142613 | 
            -
             | 
| 142614 | 
            -
                     | 
| 142615 | 
            -
             | 
| 142616 | 
            -
             | 
| 142617 | 
            -
             | 
| 142618 | 
            -
                     | 
| 142619 | 
            -
             | 
| 142620 | 
            -
             | 
| 142621 | 
            -
             | 
| 142622 | 
            -
             | 
| 142623 | 
            -
             | 
| 142624 | 
            -
             | 
| 142670 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142671 | 
            +
                () => ({
         | 
| 142672 | 
            +
                  eventName: "touchstart",
         | 
| 142673 | 
            +
                  fn: /* @__PURE__ */ __name(function onTouchStart(event) {
         | 
| 142674 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142675 | 
            +
                      return;
         | 
| 142676 | 
            +
                    }
         | 
| 142677 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142678 | 
            +
                    if (!draggableId) {
         | 
| 142679 | 
            +
                      return;
         | 
| 142680 | 
            +
                    }
         | 
| 142681 | 
            +
                    const actions2 = api.tryGetLock(
         | 
| 142682 | 
            +
                      draggableId,
         | 
| 142683 | 
            +
                      stop,
         | 
| 142684 | 
            +
                      {
         | 
| 142685 | 
            +
                        sourceEvent: event
         | 
| 142686 | 
            +
                      }
         | 
| 142687 | 
            +
                    );
         | 
| 142688 | 
            +
                    if (!actions2) {
         | 
| 142689 | 
            +
                      return;
         | 
| 142690 | 
            +
                    }
         | 
| 142691 | 
            +
                    const touch3 = event.touches[0];
         | 
| 142692 | 
            +
                    const {
         | 
| 142693 | 
            +
                      clientX,
         | 
| 142694 | 
            +
                      clientY
         | 
| 142695 | 
            +
                    } = touch3;
         | 
| 142696 | 
            +
                    const point2 = {
         | 
| 142697 | 
            +
                      x: clientX,
         | 
| 142698 | 
            +
                      y: clientY
         | 
| 142699 | 
            +
                    };
         | 
| 142700 | 
            +
                    unbindEventsRef.current();
         | 
| 142701 | 
            +
                    startPendingDrag(actions2, point2);
         | 
| 142702 | 
            +
                  }, "onTouchStart")
         | 
| 142703 | 
            +
                }),
         | 
| 142704 | 
            +
                [api]
         | 
| 142705 | 
            +
              );
         | 
| 142625 142706 | 
             
              const listenForCapture = useCallback(/* @__PURE__ */ __name(function listenForCapture2() {
         | 
| 142626 142707 | 
             
                const options = {
         | 
| 142627 142708 | 
             
                  capture: true,
         | 
| @@ -143804,10 +143885,15 @@ const makeMapStateToProps$1 = /* @__PURE__ */ __name(() => { | |
| 143804 143885 | 
             
            const mapDispatchToProps$1 = {
         | 
| 143805 143886 | 
             
              dropAnimationFinished
         | 
| 143806 143887 | 
             
            };
         | 
| 143807 | 
            -
            const ConnectedDraggable = connect( | 
| 143808 | 
            -
               | 
| 143809 | 
            -
               | 
| 143810 | 
            -
             | 
| 143888 | 
            +
            const ConnectedDraggable = connect(
         | 
| 143889 | 
            +
              makeMapStateToProps$1,
         | 
| 143890 | 
            +
              mapDispatchToProps$1,
         | 
| 143891 | 
            +
              null,
         | 
| 143892 | 
            +
              {
         | 
| 143893 | 
            +
                context: StoreContext,
         | 
| 143894 | 
            +
                areStatePropsEqual: isStrictEqual
         | 
| 143895 | 
            +
              }
         | 
| 143896 | 
            +
            )(Draggable$1$1);
         | 
| 143811 143897 | 
             
            var ConnectedDraggable$1 = ConnectedDraggable;
         | 
| 143812 143898 | 
             
            function PrivateDraggable(props) {
         | 
| 143813 143899 | 
             
              const droppableContext = useRequiredContext(DroppableContext);
         | 
| @@ -144162,7 +144248,11 @@ function useDroppablePublisher(args) { | |
| 144162 144248 | 
             
                }
         | 
| 144163 144249 | 
             
                scheduleScrollUpdate.cancel();
         | 
| 144164 144250 | 
             
                closest2.removeAttribute(scrollContainer.contextId);
         | 
| 144165 | 
            -
                closest2.removeEventListener( | 
| 144251 | 
            +
                closest2.removeEventListener(
         | 
| 144252 | 
            +
                  "scroll",
         | 
| 144253 | 
            +
                  onClosestScroll,
         | 
| 144254 | 
            +
                  getListenerOptions(dragging.scrollOptions)
         | 
| 144255 | 
            +
                );
         | 
| 144166 144256 | 
             
              }, [onClosestScroll, scheduleScrollUpdate]);
         | 
| 144167 144257 | 
             
              const scroll2 = useCallback((change3) => {
         | 
| 144168 144258 | 
             
                const dragging = whileDraggingRef.current;
         | 
| @@ -144561,33 +144651,6 @@ const Droppable = /* @__PURE__ */ __name((props) => { | |
| 144561 144651 | 
             
              }, children(provided, snapshot), getClone());
         | 
| 144562 144652 | 
             
            }, "Droppable");
         | 
| 144563 144653 | 
             
            var Droppable$1 = Droppable;
         | 
| 144564 | 
            -
            function getBody() {
         | 
| 144565 | 
            -
              !document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
         | 
| 144566 | 
            -
              return document.body;
         | 
| 144567 | 
            -
            }
         | 
| 144568 | 
            -
            __name(getBody, "getBody");
         | 
| 144569 | 
            -
            const defaultProps = {
         | 
| 144570 | 
            -
              mode: "standard",
         | 
| 144571 | 
            -
              type: "DEFAULT",
         | 
| 144572 | 
            -
              direction: "vertical",
         | 
| 144573 | 
            -
              isDropDisabled: false,
         | 
| 144574 | 
            -
              isCombineEnabled: false,
         | 
| 144575 | 
            -
              ignoreContainerClipping: false,
         | 
| 144576 | 
            -
              renderClone: null,
         | 
| 144577 | 
            -
              getContainerForClone: getBody
         | 
| 144578 | 
            -
            };
         | 
| 144579 | 
            -
            const attachDefaultPropsToOwnProps = /* @__PURE__ */ __name((ownProps) => {
         | 
| 144580 | 
            -
              let mergedProps = __spreadValues({}, ownProps);
         | 
| 144581 | 
            -
              let defaultPropKey;
         | 
| 144582 | 
            -
              for (defaultPropKey in defaultProps) {
         | 
| 144583 | 
            -
                if (ownProps[defaultPropKey] === void 0) {
         | 
| 144584 | 
            -
                  mergedProps = __spreadProps(__spreadValues({}, mergedProps), {
         | 
| 144585 | 
            -
                    [defaultPropKey]: defaultProps[defaultPropKey]
         | 
| 144586 | 
            -
                  });
         | 
| 144587 | 
            -
                }
         | 
| 144588 | 
            -
              }
         | 
| 144589 | 
            -
              return mergedProps;
         | 
| 144590 | 
            -
            }, "attachDefaultPropsToOwnProps");
         | 
| 144591 144654 | 
             
            const isMatchingType = /* @__PURE__ */ __name((type2, critical) => type2 === critical.droppable.type, "isMatchingType");
         | 
| 144592 144655 | 
             
            const getDraggable = /* @__PURE__ */ __name((critical, dimensions) => dimensions.draggables[critical.draggable.id], "getDraggable");
         | 
| 144593 144656 | 
             
            const makeMapStateToProps = /* @__PURE__ */ __name(() => {
         | 
| @@ -144654,11 +144717,10 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => { | |
| 144654 144717 | 
             
                };
         | 
| 144655 144718 | 
             
              });
         | 
| 144656 144719 | 
             
              const selector = /* @__PURE__ */ __name((state2, ownProps) => {
         | 
| 144657 | 
            -
                const  | 
| 144658 | 
            -
                const  | 
| 144659 | 
            -
                const  | 
| 144660 | 
            -
                const  | 
| 144661 | 
            -
                const renderClone = ownPropsWithDefaultProps.renderClone;
         | 
| 144720 | 
            +
                const id2 = ownProps.droppableId;
         | 
| 144721 | 
            +
                const type2 = ownProps.type;
         | 
| 144722 | 
            +
                const isEnabled = !ownProps.isDropDisabled;
         | 
| 144723 | 
            +
                const renderClone = ownProps.renderClone;
         | 
| 144662 144724 | 
             
                if (isDragging(state2)) {
         | 
| 144663 144725 | 
             
                  const critical = state2.critical;
         | 
| 144664 144726 | 
             
                  if (!isMatchingType(type2, critical)) {
         | 
| @@ -144699,12 +144761,31 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => { | |
| 144699 144761 | 
             
            const mapDispatchToProps = {
         | 
| 144700 144762 | 
             
              updateViewportMaxScroll
         | 
| 144701 144763 | 
             
            };
         | 
| 144702 | 
            -
             | 
| 144703 | 
            -
               | 
| 144704 | 
            -
             | 
| 144705 | 
            -
             | 
| 144706 | 
            -
             | 
| 144707 | 
            -
             | 
| 144764 | 
            +
            function getBody() {
         | 
| 144765 | 
            +
              !document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
         | 
| 144766 | 
            +
              return document.body;
         | 
| 144767 | 
            +
            }
         | 
| 144768 | 
            +
            __name(getBody, "getBody");
         | 
| 144769 | 
            +
            const defaultProps = {
         | 
| 144770 | 
            +
              mode: "standard",
         | 
| 144771 | 
            +
              type: "DEFAULT",
         | 
| 144772 | 
            +
              direction: "vertical",
         | 
| 144773 | 
            +
              isDropDisabled: false,
         | 
| 144774 | 
            +
              isCombineEnabled: false,
         | 
| 144775 | 
            +
              ignoreContainerClipping: false,
         | 
| 144776 | 
            +
              renderClone: null,
         | 
| 144777 | 
            +
              getContainerForClone: getBody
         | 
| 144778 | 
            +
            };
         | 
| 144779 | 
            +
            const ConnectedDroppable = connect(
         | 
| 144780 | 
            +
              makeMapStateToProps,
         | 
| 144781 | 
            +
              mapDispatchToProps,
         | 
| 144782 | 
            +
              null,
         | 
| 144783 | 
            +
              {
         | 
| 144784 | 
            +
                context: StoreContext,
         | 
| 144785 | 
            +
                areStatePropsEqual: isStrictEqual
         | 
| 144786 | 
            +
              }
         | 
| 144787 | 
            +
            )(Droppable$1);
         | 
| 144788 | 
            +
            ConnectedDroppable.defaultProps = defaultProps;
         | 
| 144708 144789 | 
             
            var ConnectedDroppable$1 = ConnectedDroppable;
         | 
| 144709 144790 | 
             
            var clipboard = { exports: {} };
         | 
| 144710 144791 | 
             
            /*!
         | 
| @@ -153108,7 +153189,7 @@ function showFileDialog({ multiple = false, onSelect }) { | |
| 153108 153189 | 
             
            }
         | 
| 153109 153190 | 
             
            __name(showFileDialog, "showFileDialog");
         | 
| 153110 153191 | 
             
            const name = "@teselagen/ove";
         | 
| 153111 | 
            -
            const version = "0.0. | 
| 153192 | 
            +
            const version = "0.0.4";
         | 
| 153112 153193 | 
             
            const main = "./index.js";
         | 
| 153113 153194 | 
             
            const types$1 = "./index.d.ts";
         | 
| 153114 153195 | 
             
            const type = "commonjs";
         | 
| @@ -173402,6 +173483,10 @@ class GenbankView extends React__default$1.Component { | |
| 173402 173483 | 
             
                __publicField(this, "state", {
         | 
| 173403 173484 | 
             
                  fileTypeToView: "genbank"
         | 
| 173404 173485 | 
             
                });
         | 
| 173486 | 
            +
                __publicField(this, "select", /* @__PURE__ */ __name(() => {
         | 
| 173487 | 
            +
                  var _a2;
         | 
| 173488 | 
            +
                  return (_a2 = this._input) == null ? void 0 : _a2.select();
         | 
| 173489 | 
            +
                }, "select"));
         | 
| 173405 173490 | 
             
              }
         | 
| 173406 173491 | 
             
              render() {
         | 
| 173407 173492 | 
             
                const { sequenceData: sequenceData2 = {} } = this.props;
         | 
| @@ -173439,7 +173524,7 @@ class GenbankView extends React__default$1.Component { | |
| 173439 173524 | 
             
                  {
         | 
| 173440 173525 | 
             
                    "data-test": "ve-genbank-text",
         | 
| 173441 173526 | 
             
                    readOnly: true,
         | 
| 173442 | 
            -
                     | 
| 173527 | 
            +
                    onClick: this.select,
         | 
| 173443 173528 | 
             
                    style: {
         | 
| 173444 173529 | 
             
                      whiteSpace: "pre",
         | 
| 173445 173530 | 
             
                      overflowWrap: "normal",
         |