@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.js
    CHANGED
    
    | @@ -29325,20 +29325,19 @@ function createField(structure2) { | |
| 29325 29325 | 
             
                _proto.shouldComponentUpdate = /* @__PURE__ */ __name(function shouldComponentUpdate(nextProps, nextState) {
         | 
| 29326 29326 | 
             
                  return shallowCompare$1(this, nextProps, nextState);
         | 
| 29327 29327 | 
             
                }, "shouldComponentUpdate");
         | 
| 29328 | 
            -
                _proto. | 
| 29329 | 
            -
                  var  | 
| 29330 | 
            -
                  var  | 
| 29331 | 
            -
                  var newName = prefixName(this.props, this.props.name);
         | 
| 29328 | 
            +
                _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 29329 | 
            +
                  var oldName = prefixName(this.props, this.props.name);
         | 
| 29330 | 
            +
                  var newName = prefixName(nextProps, nextProps.name);
         | 
| 29332 29331 | 
             
                  if (oldName !== newName || // use deepEqual here because they could be a function or an array of functions
         | 
| 29333 | 
            -
                  !plain.deepEqual( | 
| 29332 | 
            +
                  !plain.deepEqual(this.props.validate, nextProps.validate) || !plain.deepEqual(this.props.warn, nextProps.warn)) {
         | 
| 29334 29333 | 
             
                    this.props._reduxForm.unregister(oldName);
         | 
| 29335 29334 | 
             
                    this.props._reduxForm.register(newName, "Field", function() {
         | 
| 29336 | 
            -
                      return  | 
| 29335 | 
            +
                      return nextProps.validate;
         | 
| 29337 29336 | 
             
                    }, function() {
         | 
| 29338 | 
            -
                      return  | 
| 29337 | 
            +
                      return nextProps.warn;
         | 
| 29339 29338 | 
             
                    });
         | 
| 29340 29339 | 
             
                  }
         | 
| 29341 | 
            -
                }, " | 
| 29340 | 
            +
                }, "UNSAFE_componentWillReceiveProps");
         | 
| 29342 29341 | 
             
                _proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
         | 
| 29343 29342 | 
             
                  this.props._reduxForm.unregister(this.name);
         | 
| 29344 29343 | 
             
                }, "componentWillUnmount");
         | 
| @@ -30311,14 +30310,14 @@ function createFieldArray(structure2) { | |
| 30311 30310 | 
             
                    return wrapError(_this2.props.warn, "_warning");
         | 
| 30312 30311 | 
             
                  });
         | 
| 30313 30312 | 
             
                }, "componentDidMount");
         | 
| 30314 | 
            -
                _proto. | 
| 30315 | 
            -
                  var oldName = prefixName( | 
| 30316 | 
            -
                  var newName = prefixName( | 
| 30313 | 
            +
                _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 30314 | 
            +
                  var oldName = prefixName(this.props, this.props.name);
         | 
| 30315 | 
            +
                  var newName = prefixName(nextProps, nextProps.name);
         | 
| 30317 30316 | 
             
                  if (oldName !== newName) {
         | 
| 30318 30317 | 
             
                    this.props._reduxForm.unregister(oldName);
         | 
| 30319 30318 | 
             
                    this.props._reduxForm.register(newName, "FieldArray");
         | 
| 30320 30319 | 
             
                  }
         | 
| 30321 | 
            -
                }, " | 
| 30320 | 
            +
                }, "UNSAFE_componentWillReceiveProps");
         | 
| 30322 30321 | 
             
                _proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
         | 
| 30323 30322 | 
             
                  this.props._reduxForm.unregister(this.name);
         | 
| 30324 30323 | 
             
                }, "componentWillUnmount");
         | 
| @@ -31013,8 +31012,8 @@ var getDisplayName$2 = /* @__PURE__ */ __name(function getDisplayName(Comp) { | |
| 31013 31012 | 
             
            }, "getDisplayName");
         | 
| 31014 31013 | 
             
            const getDisplayName$3 = getDisplayName$2;
         | 
| 31015 31014 | 
             
            var isHotReloading = /* @__PURE__ */ __name(function isHotReloading2() {
         | 
| 31016 | 
            -
              var castModule =  | 
| 31017 | 
            -
              return !!(castModule && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
         | 
| 31015 | 
            +
              var castModule = module;
         | 
| 31016 | 
            +
              return !!(typeof castModule !== "undefined" && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
         | 
| 31018 31017 | 
             
            }, "isHotReloading");
         | 
| 31019 31018 | 
             
            const isHotReloading$1 = isHotReloading;
         | 
| 31020 31019 | 
             
            var isClassComponent = /* @__PURE__ */ __name(function isClassComponent2(Component) {
         | 
| @@ -31081,7 +31080,6 @@ function createReduxForm(structure2) { | |
| 31081 31080 | 
             
                      _this.lastFieldWarnerKeys = [];
         | 
| 31082 31081 | 
             
                      _this.innerOnSubmit = void 0;
         | 
| 31083 31082 | 
             
                      _this.submitPromise = void 0;
         | 
| 31084 | 
            -
                      _this.initializedOnLoad = false;
         | 
| 31085 31083 | 
             
                      _this.initIfNeeded = function(nextProps) {
         | 
| 31086 31084 | 
             
                        var enableReinitialize = _this.props.enableReinitialize;
         | 
| 31087 31085 | 
             
                        if (nextProps) {
         | 
| @@ -31092,16 +31090,13 @@ function createReduxForm(structure2) { | |
| 31092 31090 | 
             
                              lastInitialValues: _this.props.initialValues,
         | 
| 31093 31091 | 
             
                              updateUnregisteredFields: nextProps.updateUnregisteredFields
         | 
| 31094 31092 | 
             
                            });
         | 
| 31095 | 
            -
                            return true;
         | 
| 31096 31093 | 
             
                          }
         | 
| 31097 31094 | 
             
                        } else if (_this.props.initialValues && (!_this.props.initialized || enableReinitialize)) {
         | 
| 31098 31095 | 
             
                          _this.props.initialize(_this.props.initialValues, _this.props.keepDirtyOnReinitialize, {
         | 
| 31099 31096 | 
             
                            keepValues: _this.props.keepValues,
         | 
| 31100 31097 | 
             
                            updateUnregisteredFields: _this.props.updateUnregisteredFields
         | 
| 31101 31098 | 
             
                          });
         | 
| 31102 | 
            -
                          return true;
         | 
| 31103 31099 | 
             
                        }
         | 
| 31104 | 
            -
                        return false;
         | 
| 31105 31100 | 
             
                      };
         | 
| 31106 31101 | 
             
                      _this.updateSyncErrorsIfNeeded = function(nextSyncErrors, nextError, lastSyncErrors) {
         | 
| 31107 31102 | 
             
                        var _this$props = _this.props, error2 = _this$props.error, updateSyncErrors3 = _this$props.updateSyncErrors;
         | 
| @@ -31371,18 +31366,20 @@ function createReduxForm(structure2) { | |
| 31371 31366 | 
             
                      _this.reset = function() {
         | 
| 31372 31367 | 
             
                        return _this.props.reset();
         | 
| 31373 31368 | 
             
                      };
         | 
| 31374 | 
            -
                      if (!isHotReloading$1()) {
         | 
| 31375 | 
            -
                        _this.initializedOnLoad = _this.initIfNeeded();
         | 
| 31376 | 
            -
                      }
         | 
| 31377 | 
            -
                      invariant$4(_this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
         | 
| 31378 31369 | 
             
                      return _this;
         | 
| 31379 31370 | 
             
                    }
         | 
| 31380 31371 | 
             
                    __name(Form2, "Form");
         | 
| 31381 31372 | 
             
                    var _proto = Form2.prototype;
         | 
| 31373 | 
            +
                    _proto.UNSAFE_componentWillMount = /* @__PURE__ */ __name(function UNSAFE_componentWillMount() {
         | 
| 31374 | 
            +
                      if (!isHotReloading$1()) {
         | 
| 31375 | 
            +
                        this.initIfNeeded();
         | 
| 31376 | 
            +
                        this.validateIfNeeded();
         | 
| 31377 | 
            +
                        this.warnIfNeeded();
         | 
| 31378 | 
            +
                      }
         | 
| 31379 | 
            +
                      invariant$4(this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
         | 
| 31380 | 
            +
                    }, "UNSAFE_componentWillMount");
         | 
| 31382 31381 | 
             
                    _proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
         | 
| 31383 | 
            -
                       | 
| 31384 | 
            -
                      if (isValueReset)
         | 
| 31385 | 
            -
                        return;
         | 
| 31382 | 
            +
                      this.initIfNeeded(nextProps);
         | 
| 31386 31383 | 
             
                      this.validateIfNeeded(nextProps);
         | 
| 31387 31384 | 
             
                      this.warnIfNeeded(nextProps);
         | 
| 31388 31385 | 
             
                      this.clearSubmitPromiseIfNeeded(nextProps);
         | 
| @@ -31406,8 +31403,7 @@ function createReduxForm(structure2) { | |
| 31406 31403 | 
             
                    }, "shouldComponentUpdate");
         | 
| 31407 31404 | 
             
                    _proto.componentDidMount = /* @__PURE__ */ __name(function componentDidMount() {
         | 
| 31408 31405 | 
             
                      if (!isHotReloading$1()) {
         | 
| 31409 | 
            -
                         | 
| 31410 | 
            -
                          return;
         | 
| 31406 | 
            +
                        this.initIfNeeded(this.props);
         | 
| 31411 31407 | 
             
                        this.validateIfNeeded();
         | 
| 31412 31408 | 
             
                        this.warnIfNeeded();
         | 
| 31413 31409 | 
             
                      }
         | 
| @@ -39463,25 +39459,16 @@ var toString$4 = {}.toString; | |
| 39463 39459 | 
             
            var _cof = /* @__PURE__ */ __name(function(it) {
         | 
| 39464 39460 | 
             
              return toString$4.call(it).slice(8, -1);
         | 
| 39465 39461 | 
             
            }, "_cof");
         | 
| 39466 | 
            -
            var  | 
| 39467 | 
            -
            var  | 
| 39468 | 
            -
             | 
| 39469 | 
            -
             | 
| 39470 | 
            -
                return _iobject;
         | 
| 39471 | 
            -
              hasRequired_iobject = 1;
         | 
| 39472 | 
            -
              var cof2 = _cof;
         | 
| 39473 | 
            -
              _iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
         | 
| 39474 | 
            -
                return cof2(it) == "String" ? it.split("") : Object(it);
         | 
| 39475 | 
            -
              };
         | 
| 39476 | 
            -
              return _iobject;
         | 
| 39477 | 
            -
            }
         | 
| 39478 | 
            -
            __name(require_iobject, "require_iobject");
         | 
| 39462 | 
            +
            var cof$2 = _cof;
         | 
| 39463 | 
            +
            var _iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
         | 
| 39464 | 
            +
              return cof$2(it) == "String" ? it.split("") : Object(it);
         | 
| 39465 | 
            +
            };
         | 
| 39479 39466 | 
             
            var _defined = /* @__PURE__ */ __name(function(it) {
         | 
| 39480 39467 | 
             
              if (it == void 0)
         | 
| 39481 39468 | 
             
                throw TypeError("Can't call method on  " + it);
         | 
| 39482 39469 | 
             
              return it;
         | 
| 39483 39470 | 
             
            }, "_defined");
         | 
| 39484 | 
            -
            var IObject =  | 
| 39471 | 
            +
            var IObject = _iobject;
         | 
| 39485 39472 | 
             
            var defined$2 = _defined;
         | 
| 39486 39473 | 
             
            var _toIobject = /* @__PURE__ */ __name(function(it) {
         | 
| 39487 39474 | 
             
              return IObject(defined$2(it));
         | 
| @@ -39578,15 +39565,7 @@ var _objectKeys = Object.keys || /* @__PURE__ */ __name(function keys2(O2) { | |
| 39578 39565 | 
             
            var _objectGops = {};
         | 
| 39579 39566 | 
             
            _objectGops.f = Object.getOwnPropertySymbols;
         | 
| 39580 39567 | 
             
            var _objectPie = {};
         | 
| 39581 | 
            -
             | 
| 39582 | 
            -
            function require_objectPie() {
         | 
| 39583 | 
            -
              if (hasRequired_objectPie)
         | 
| 39584 | 
            -
                return _objectPie;
         | 
| 39585 | 
            -
              hasRequired_objectPie = 1;
         | 
| 39586 | 
            -
              _objectPie.f = {}.propertyIsEnumerable;
         | 
| 39587 | 
            -
              return _objectPie;
         | 
| 39588 | 
            -
            }
         | 
| 39589 | 
            -
            __name(require_objectPie, "require_objectPie");
         | 
| 39568 | 
            +
            _objectPie.f = {}.propertyIsEnumerable;
         | 
| 39590 39569 | 
             
            var defined$1 = _defined;
         | 
| 39591 39570 | 
             
            var _toObject = /* @__PURE__ */ __name(function(it) {
         | 
| 39592 39571 | 
             
              return Object(defined$1(it));
         | 
| @@ -39600,9 +39579,9 @@ function require_objectAssign() { | |
| 39600 39579 | 
             
              var DESCRIPTORS2 = _descriptors;
         | 
| 39601 39580 | 
             
              var getKeys2 = _objectKeys;
         | 
| 39602 39581 | 
             
              var gOPS2 = _objectGops;
         | 
| 39603 | 
            -
              var pIE2 =  | 
| 39582 | 
            +
              var pIE2 = _objectPie;
         | 
| 39604 39583 | 
             
              var toObject2 = _toObject;
         | 
| 39605 | 
            -
              var IObject2 =  | 
| 39584 | 
            +
              var IObject2 = _iobject;
         | 
| 39606 39585 | 
             
              var $assign = Object.assign;
         | 
| 39607 39586 | 
             
              _objectAssign = !$assign || _fails(function() {
         | 
| 39608 39587 | 
             
                var A2 = {};
         | 
| @@ -40237,7 +40216,7 @@ var _wksDefine = /* @__PURE__ */ __name(function(name2) { | |
| 40237 40216 | 
             
            }, "_wksDefine");
         | 
| 40238 40217 | 
             
            var getKeys = _objectKeys;
         | 
| 40239 40218 | 
             
            var gOPS$1 = _objectGops;
         | 
| 40240 | 
            -
            var pIE$1 =  | 
| 40219 | 
            +
            var pIE$1 = _objectPie;
         | 
| 40241 40220 | 
             
            var _enumKeys = /* @__PURE__ */ __name(function(it) {
         | 
| 40242 40221 | 
             
              var result = getKeys(it);
         | 
| 40243 40222 | 
             
              var getSymbols2 = gOPS$1.f;
         | 
| @@ -40278,7 +40257,7 @@ _objectGopnExt.f = /* @__PURE__ */ __name(function getOwnPropertyNames2(it) { | |
| 40278 40257 | 
             
              return windowNames && toString$3.call(it) == "[object Window]" ? getWindowNames(it) : gOPN$1(toIObject$2(it));
         | 
| 40279 40258 | 
             
            }, "getOwnPropertyNames");
         | 
| 40280 40259 | 
             
            var _objectGopd = {};
         | 
| 40281 | 
            -
            var pIE =  | 
| 40260 | 
            +
            var pIE = _objectPie;
         | 
| 40282 40261 | 
             
            var createDesc$1 = _propertyDesc;
         | 
| 40283 40262 | 
             
            var toIObject$1 = _toIobject;
         | 
| 40284 40263 | 
             
            var toPrimitive$1 = _toPrimitive$1;
         | 
| @@ -40458,7 +40437,7 @@ if (!USE_NATIVE) { | |
| 40458 40437 | 
             
              $GOPD.f = $getOwnPropertyDescriptor;
         | 
| 40459 40438 | 
             
              $DP.f = $defineProperty;
         | 
| 40460 40439 | 
             
              _objectGopn.f = gOPNExt.f = $getOwnPropertyNames;
         | 
| 40461 | 
            -
               | 
| 40440 | 
            +
              _objectPie.f = $propertyIsEnumerable;
         | 
| 40462 40441 | 
             
              $GOPS.f = $getOwnPropertySymbols;
         | 
| 40463 40442 | 
             
              if (DESCRIPTORS && !_library) {
         | 
| 40464 40443 | 
             
                redefine(ObjectProto, "propertyIsEnumerable", $propertyIsEnumerable);
         | 
| @@ -120189,6 +120168,9 @@ function genbankToJson(string2, options = {}) { | |
| 120189 120168 | 
             
                      options.isProtein = false;
         | 
| 120190 120169 | 
             
                    }
         | 
| 120191 120170 | 
             
                    options.sequenceTypeFromLocus = item;
         | 
| 120171 | 
            +
                    if (item.match(/ss-dna/i)) {
         | 
| 120172 | 
            +
                      options.isSingleStrandedDNA = true;
         | 
| 120173 | 
            +
                    }
         | 
| 120192 120174 | 
             
                  }
         | 
| 120193 120175 | 
             
                  if (typeof lineArr[j] === "string" && gbDivisions[lineArr[j].toUpperCase()]) {
         | 
| 120194 120176 | 
             
                    gbDivision = lineArr[j].toUpperCase();
         | 
| @@ -120199,6 +120181,7 @@ function genbankToJson(string2, options = {}) { | |
| 120199 120181 | 
             
                }
         | 
| 120200 120182 | 
             
                result.parsedSequence.gbDivision = gbDivision;
         | 
| 120201 120183 | 
             
                result.parsedSequence.sequenceTypeFromLocus = options.sequenceTypeFromLocus;
         | 
| 120184 | 
            +
                result.parsedSequence.isSingleStrandedDNA = options.isSingleStrandedDNA;
         | 
| 120202 120185 | 
             
                result.parsedSequence.date = date;
         | 
| 120203 120186 | 
             
                result.parsedSequence.circular = circular2;
         | 
| 120204 120187 | 
             
              }
         | 
| @@ -132219,6 +132202,7 @@ function jsonToGenbank(_serSeq, options) { | |
| 132219 132202 | 
             
            }
         | 
| 132220 132203 | 
             
            __name(jsonToGenbank, "jsonToGenbank");
         | 
| 132221 132204 | 
             
            function createGenbankLocus(serSeq, options) {
         | 
| 132205 | 
            +
              var _a2;
         | 
| 132222 132206 | 
             
              if (serSeq.sequence.symbols) {
         | 
| 132223 132207 | 
             
                serSeq.sequence = serSeq.sequence.symbols.split("");
         | 
| 132224 132208 | 
             
              }
         | 
| @@ -132229,7 +132213,7 @@ function createGenbankLocus(serSeq, options) { | |
| 132229 132213 | 
             
              } else if (serSeq.type === "RNA") {
         | 
| 132230 132214 | 
             
                dnaType = "RNA";
         | 
| 132231 132215 | 
             
              } else {
         | 
| 132232 | 
            -
                dnaType = "DNA";
         | 
| 132216 | 
            +
                dnaType = (_a2 = serSeq == null ? void 0 : serSeq.sequenceTypeFromLocus) != null ? _a2 : "DNA";
         | 
| 132233 132217 | 
             
              }
         | 
| 132234 132218 | 
             
              const date = getCurrentDateString();
         | 
| 132235 132219 | 
             
              let line = StringUtil.rpad("LOCUS", " ", 12);
         | 
| @@ -135769,6 +135753,7 @@ function showAddOrEditAnnotationDialog({ | |
| 135769 135753 | 
             
            }
         | 
| 135770 135754 | 
             
            __name(showAddOrEditAnnotationDialog, "showAddOrEditAnnotationDialog");
         | 
| 135771 135755 | 
             
            function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { convertAnnotationsFromAAIndices } = {}) {
         | 
| 135756 | 
            +
              var _a2;
         | 
| 135772 135757 | 
             
              const {
         | 
| 135773 135758 | 
             
                sequenceData: sequenceData2,
         | 
| 135774 135759 | 
             
                annotationVisibility: annotationVisibility2,
         | 
| @@ -135780,7 +135765,9 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { | |
| 135780 135765 | 
             
              const isAlreadyProteinEditor = currentEditor.sequenceData && currentEditor.sequenceData.isProtein;
         | 
| 135781 135766 | 
             
              const isAlreadyRnaEditor = currentEditor.sequenceData && currentEditor.sequenceData.isRna;
         | 
| 135782 135767 | 
             
              const isAlreadyOligoEditor = currentEditor.sequenceData && currentEditor.sequenceData.isOligo;
         | 
| 135783 | 
            -
              const  | 
| 135768 | 
            +
              const reverseSequenceShouldBeUpdate = ((_a2 = currentEditor.sequenceData) == null ? void 0 : _a2.isSingleStrandedDNA) !== (sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA);
         | 
| 135769 | 
            +
              const annotationVisibilityUpdated = !lodashExports.isEqual(annotationVisibility2, currentEditor.annotationVisibility) || !lodashExports.isEqual(annotationsToSupport2, currentEditor.annotationsToSupport);
         | 
| 135770 | 
            +
              const isAlreadySpecialEditor = isAlreadyProteinEditor || isAlreadyRnaEditor || isAlreadyOligoEditor || reverseSequenceShouldBeUpdate || annotationVisibilityUpdated;
         | 
| 135784 135771 | 
             
              let toSpread = {};
         | 
| 135785 135772 | 
             
              let payload;
         | 
| 135786 135773 | 
             
              if (justPassingPartialSeqData) {
         | 
| @@ -135886,7 +135873,7 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { | |
| 135886 135873 | 
             
                      }, annotationVisibility2), {
         | 
| 135887 135874 | 
             
                        //we spread this here to allow the user to override this .. if they must!
         | 
| 135888 135875 | 
             
                        sequence: true,
         | 
| 135889 | 
            -
                        reverseSequence:  | 
| 135876 | 
            +
                        reverseSequence: !(sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA),
         | 
| 135890 135877 | 
             
                        translations: false,
         | 
| 135891 135878 | 
             
                        aminoAcidNumbers: false,
         | 
| 135892 135879 | 
             
                        primaryProteinSequence: false
         | 
| @@ -137220,7 +137207,12 @@ const getDevMessage = /* @__PURE__ */ __name((message) => clean$2(` | |
| 137220 137207 |  | 
| 137221 137208 | 
             
              %c👷 This is a development only message. It will be removed in production builds.
         | 
| 137222 137209 | 
             
            `), "getDevMessage");
         | 
| 137223 | 
            -
            const getFormattedMessage = /* @__PURE__ */ __name((message) => [ | 
| 137210 | 
            +
            const getFormattedMessage = /* @__PURE__ */ __name((message) => [
         | 
| 137211 | 
            +
              getDevMessage(message),
         | 
| 137212 | 
            +
              "color: #00C584; font-size: 1.2em; font-weight: bold;",
         | 
| 137213 | 
            +
              "line-height: 1.5",
         | 
| 137214 | 
            +
              "color: #723874;"
         | 
| 137215 | 
            +
            ], "getFormattedMessage");
         | 
| 137224 137216 | 
             
            const isDisabledFlag = "__@hello-pangea/dnd-disable-dev-warnings";
         | 
| 137225 137217 | 
             
            function log$2(type2, message) {
         | 
| 137226 137218 | 
             
              if (isProduction$1) {
         | 
| @@ -138046,7 +138038,11 @@ const goAfter = /* @__PURE__ */ __name((_ref) => { | |
| 138046 138038 | 
             
                moveRelativeTo,
         | 
| 138047 138039 | 
             
                isMoving
         | 
| 138048 138040 | 
             
              } = _ref;
         | 
| 138049 | 
            -
              return patch( | 
| 138041 | 
            +
              return patch(
         | 
| 138042 | 
            +
                axis.line,
         | 
| 138043 | 
            +
                moveRelativeTo.marginBox[axis.end] + distanceFromStartToBorderBoxCenter(axis, isMoving),
         | 
| 138044 | 
            +
                getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
         | 
| 138045 | 
            +
              );
         | 
| 138050 138046 | 
             
            }, "goAfter");
         | 
| 138051 138047 | 
             
            const goBefore = /* @__PURE__ */ __name((_ref2) => {
         | 
| 138052 138048 | 
             
              let {
         | 
| @@ -138054,7 +138050,11 @@ const goBefore = /* @__PURE__ */ __name((_ref2) => { | |
| 138054 138050 | 
             
                moveRelativeTo,
         | 
| 138055 138051 | 
             
                isMoving
         | 
| 138056 138052 | 
             
              } = _ref2;
         | 
| 138057 | 
            -
              return patch( | 
| 138053 | 
            +
              return patch(
         | 
| 138054 | 
            +
                axis.line,
         | 
| 138055 | 
            +
                moveRelativeTo.marginBox[axis.start] - distanceFromEndToBorderBoxCenter(axis, isMoving),
         | 
| 138056 | 
            +
                getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
         | 
| 138057 | 
            +
              );
         | 
| 138058 138058 | 
             
            }, "goBefore");
         | 
| 138059 138059 | 
             
            const goIntoStart = /* @__PURE__ */ __name((_ref3) => {
         | 
| 138060 138060 | 
             
              let {
         | 
| @@ -138231,7 +138231,11 @@ var speculativelyIncrease = /* @__PURE__ */ __name((_ref) => { | |
| 138231 138231 | 
             
              });
         | 
| 138232 138232 | 
             
              const invisible = {};
         | 
| 138233 138233 | 
             
              const visible = {};
         | 
| 138234 | 
            -
              const groups = [ | 
| 138234 | 
            +
              const groups = [
         | 
| 138235 | 
            +
                last2,
         | 
| 138236 | 
            +
                withViewportScroll,
         | 
| 138237 | 
            +
                withDroppableScroll2
         | 
| 138238 | 
            +
              ];
         | 
| 138235 138239 | 
             
              last2.all.forEach((id2) => {
         | 
| 138236 138240 | 
             
                const displacement = tryGetVisible(id2, groups);
         | 
| 138237 138241 | 
             
                if (displacement) {
         | 
| @@ -138588,7 +138592,9 @@ var moveToNewDroppable = /* @__PURE__ */ __name((_ref) => { | |
| 138588 138592 | 
             
                });
         | 
| 138589 138593 | 
             
                return isVisibleInNewLocation ? proposed : null;
         | 
| 138590 138594 | 
             
              }
         | 
| 138591 | 
            -
              const isGoingBeforeTarget = Boolean( | 
| 138595 | 
            +
              const isGoingBeforeTarget = Boolean(
         | 
| 138596 | 
            +
                previousPageBorderBoxCenter[destination.axis.line] <= moveRelativeTo.page.borderBox.center[destination.axis.line]
         | 
| 138597 | 
            +
              );
         | 
| 138592 138598 | 
             
              const proposedIndex = (() => {
         | 
| 138593 138599 | 
             
                const relativeTo = moveRelativeTo.descriptor.index;
         | 
| 138594 138600 | 
             
                if (moveRelativeTo.descriptor.id === draggable2.descriptor.id) {
         | 
| @@ -138751,7 +138757,11 @@ function getFurthestAway(_ref) { | |
| 138751 138757 | 
             
              const startCenter = draggable2.page.borderBox.center;
         | 
| 138752 138758 | 
             
              const sorted = candidates.map((candidate) => {
         | 
| 138753 138759 | 
             
                const axis = candidate.axis;
         | 
| 138754 | 
            -
                const target = patch( | 
| 138760 | 
            +
                const target = patch(
         | 
| 138761 | 
            +
                  candidate.axis.line,
         | 
| 138762 | 
            +
                  pageBorderBox.center[axis.line],
         | 
| 138763 | 
            +
                  candidate.page.borderBox.center[axis.crossAxisLine]
         | 
| 138764 | 
            +
                );
         | 
| 138755 138765 | 
             
                return {
         | 
| 138756 138766 | 
             
                  id: candidate.descriptor.id,
         | 
| 138757 138767 | 
             
                  distance: distance$1(startCenter, target)
         | 
| @@ -140486,7 +140496,19 @@ var createStore$1 = /* @__PURE__ */ __name((_ref) => { | |
| 140486 140496 | 
             
                announce,
         | 
| 140487 140497 | 
             
                autoScroller
         | 
| 140488 140498 | 
             
              } = _ref;
         | 
| 140489 | 
            -
              return createStore$2(reducer, composeEnhancers(applyMiddleware( | 
| 140499 | 
            +
              return createStore$2(reducer, composeEnhancers(applyMiddleware(
         | 
| 140500 | 
            +
                style$n(styleMarshal),
         | 
| 140501 | 
            +
                dimensionMarshalStopper(dimensionMarshal),
         | 
| 140502 | 
            +
                lift(dimensionMarshal),
         | 
| 140503 | 
            +
                drop,
         | 
| 140504 | 
            +
                dropAnimationFinish,
         | 
| 140505 | 
            +
                dropAnimationFlushOnScroll,
         | 
| 140506 | 
            +
                pendingDrop$1,
         | 
| 140507 | 
            +
                autoScroll(autoScroller),
         | 
| 140508 | 
            +
                scrollListener$1,
         | 
| 140509 | 
            +
                focus2(focusMarshal),
         | 
| 140510 | 
            +
                responders(getResponders, announce)
         | 
| 140511 | 
            +
              )));
         | 
| 140490 140512 | 
             
            }, "createStore$1");
         | 
| 140491 140513 | 
             
            const clean$1 = /* @__PURE__ */ __name(() => ({
         | 
| 140492 140514 | 
             
              additions: {},
         | 
| @@ -140513,7 +140535,9 @@ function createPublisher(_ref) { | |
| 140513 140535 | 
             
                    removals,
         | 
| 140514 140536 | 
             
                    modified: modified2
         | 
| 140515 140537 | 
             
                  } = staging;
         | 
| 140516 | 
            -
                  const added2 = Object.keys(additions).map( | 
| 140538 | 
            +
                  const added2 = Object.keys(additions).map(
         | 
| 140539 | 
            +
                    (id2) => registry.draggable.getById(id2).getDimension(origin)
         | 
| 140540 | 
            +
                  ).sort((a2, b3) => a2.descriptor.index - b3.descriptor.index);
         | 
| 140517 140541 | 
             
                  const updated = Object.keys(modified2).map((id2) => {
         | 
| 140518 140542 | 
             
                    const entry = registry.droppable.getById(id2);
         | 
| 140519 140543 | 
             
                    const scroll2 = entry.callbacks.getScrollWhileDragging();
         | 
| @@ -140572,13 +140596,16 @@ var getMaxScroll = /* @__PURE__ */ __name((_ref) => { | |
| 140572 140596 | 
             
                height: height2,
         | 
| 140573 140597 | 
             
                width
         | 
| 140574 140598 | 
             
              } = _ref;
         | 
| 140575 | 
            -
              const maxScroll = subtract( | 
| 140576 | 
            -
                 | 
| 140577 | 
            -
             | 
| 140578 | 
            -
             | 
| 140579 | 
            -
                 | 
| 140580 | 
            -
                 | 
| 140581 | 
            -
             | 
| 140599 | 
            +
              const maxScroll = subtract(
         | 
| 140600 | 
            +
                {
         | 
| 140601 | 
            +
                  x: scrollWidth,
         | 
| 140602 | 
            +
                  y: scrollHeight
         | 
| 140603 | 
            +
                },
         | 
| 140604 | 
            +
                {
         | 
| 140605 | 
            +
                  x: width,
         | 
| 140606 | 
            +
                  y: height2
         | 
| 140607 | 
            +
                }
         | 
| 140608 | 
            +
              );
         | 
| 140582 140609 | 
             
              const adjustedMaxScroll = {
         | 
| 140583 140610 | 
             
                x: Math.max(0, maxScroll.x),
         | 
| 140584 140611 | 
             
                y: Math.max(0, maxScroll.y)
         | 
| @@ -141495,11 +141522,14 @@ function useStyleMarshal(contextId, nonce) { | |
| 141495 141522 | 
             
              const styles2 = useMemo(() => getStyles$1(contextId), [contextId]);
         | 
| 141496 141523 | 
             
              const alwaysRef = React$3.useRef(null);
         | 
| 141497 141524 | 
             
              const dynamicRef = React$3.useRef(null);
         | 
| 141498 | 
            -
              const setDynamicStyle = useCallback( | 
| 141499 | 
            -
                 | 
| 141500 | 
            -
             | 
| 141501 | 
            -
             | 
| 141502 | 
            -
             | 
| 141525 | 
            +
              const setDynamicStyle = useCallback(
         | 
| 141526 | 
            +
                memoizeOne((proposed) => {
         | 
| 141527 | 
            +
                  const el = dynamicRef.current;
         | 
| 141528 | 
            +
                  !el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
         | 
| 141529 | 
            +
                  el.textContent = proposed;
         | 
| 141530 | 
            +
                }),
         | 
| 141531 | 
            +
                []
         | 
| 141532 | 
            +
              );
         | 
| 141503 141533 | 
             
              const setAlwaysStyle = useCallback((proposed) => {
         | 
| 141504 141534 | 
             
                const el = alwaysRef.current;
         | 
| 141505 141535 | 
             
                !el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
         | 
| @@ -141555,8 +141585,8 @@ function querySelectorAll(parentNode, selector) { | |
| 141555 141585 | 
             
            }
         | 
| 141556 141586 | 
             
            __name(querySelectorAll, "querySelectorAll");
         | 
| 141557 141587 | 
             
            var getWindowFromEl = /* @__PURE__ */ __name((el) => {
         | 
| 141558 | 
            -
              var  | 
| 141559 | 
            -
              return ( | 
| 141588 | 
            +
              var _el$ownerDocument;
         | 
| 141589 | 
            +
              return (el == null ? void 0 : (_el$ownerDocument = el.ownerDocument) == null ? void 0 : _el$ownerDocument.defaultView) || window;
         | 
| 141560 141590 | 
             
            }, "getWindowFromEl");
         | 
| 141561 141591 | 
             
            function isHtmlElement(el) {
         | 
| 141562 141592 | 
             
              return el instanceof getWindowFromEl(el).HTMLElement;
         | 
| @@ -142117,141 +142147,157 @@ function getCaptureBindings(_ref) { | |
| 142117 142147 | 
             
                getPhase,
         | 
| 142118 142148 | 
             
                setPhase
         | 
| 142119 142149 | 
             
              } = _ref;
         | 
| 142120 | 
            -
              return [ | 
| 142121 | 
            -
                 | 
| 142122 | 
            -
             | 
| 142123 | 
            -
                   | 
| 142124 | 
            -
                     | 
| 142125 | 
            -
             | 
| 142126 | 
            -
             | 
| 142127 | 
            -
             | 
| 142128 | 
            -
             | 
| 142129 | 
            -
                     | 
| 142130 | 
            -
             | 
| 142131 | 
            -
             | 
| 142132 | 
            -
                     | 
| 142133 | 
            -
             | 
| 142134 | 
            -
             | 
| 142135 | 
            -
             | 
| 142136 | 
            -
             | 
| 142150 | 
            +
              return [
         | 
| 142151 | 
            +
                {
         | 
| 142152 | 
            +
                  eventName: "mousemove",
         | 
| 142153 | 
            +
                  fn: (event) => {
         | 
| 142154 | 
            +
                    const {
         | 
| 142155 | 
            +
                      button,
         | 
| 142156 | 
            +
                      clientX,
         | 
| 142157 | 
            +
                      clientY
         | 
| 142158 | 
            +
                    } = event;
         | 
| 142159 | 
            +
                    if (button !== primaryButton) {
         | 
| 142160 | 
            +
                      return;
         | 
| 142161 | 
            +
                    }
         | 
| 142162 | 
            +
                    const point2 = {
         | 
| 142163 | 
            +
                      x: clientX,
         | 
| 142164 | 
            +
                      y: clientY
         | 
| 142165 | 
            +
                    };
         | 
| 142166 | 
            +
                    const phase = getPhase();
         | 
| 142167 | 
            +
                    if (phase.type === "DRAGGING") {
         | 
| 142168 | 
            +
                      event.preventDefault();
         | 
| 142169 | 
            +
                      phase.actions.move(point2);
         | 
| 142170 | 
            +
                      return;
         | 
| 142171 | 
            +
                    }
         | 
| 142172 | 
            +
                    !(phase.type === "PENDING") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot be IDLE") : invariant$1(false) : void 0;
         | 
| 142173 | 
            +
                    const pending = phase.point;
         | 
| 142174 | 
            +
                    if (!isSloppyClickThresholdExceeded(pending, point2)) {
         | 
| 142175 | 
            +
                      return;
         | 
| 142176 | 
            +
                    }
         | 
| 142137 142177 | 
             
                    event.preventDefault();
         | 
| 142138 | 
            -
                    phase.actions. | 
| 142139 | 
            -
                     | 
| 142140 | 
            -
             | 
| 142141 | 
            -
             | 
| 142142 | 
            -
             | 
| 142143 | 
            -
                  if (!isSloppyClickThresholdExceeded(pending, point2)) {
         | 
| 142144 | 
            -
                    return;
         | 
| 142145 | 
            -
                  }
         | 
| 142146 | 
            -
                  event.preventDefault();
         | 
| 142147 | 
            -
                  const actions2 = phase.actions.fluidLift(point2);
         | 
| 142148 | 
            -
                  setPhase({
         | 
| 142149 | 
            -
                    type: "DRAGGING",
         | 
| 142150 | 
            -
                    actions: actions2
         | 
| 142151 | 
            -
                  });
         | 
| 142152 | 
            -
                }
         | 
| 142153 | 
            -
              }, {
         | 
| 142154 | 
            -
                eventName: "mouseup",
         | 
| 142155 | 
            -
                fn: (event) => {
         | 
| 142156 | 
            -
                  const phase = getPhase();
         | 
| 142157 | 
            -
                  if (phase.type !== "DRAGGING") {
         | 
| 142158 | 
            -
                    cancel();
         | 
| 142159 | 
            -
                    return;
         | 
| 142178 | 
            +
                    const actions2 = phase.actions.fluidLift(point2);
         | 
| 142179 | 
            +
                    setPhase({
         | 
| 142180 | 
            +
                      type: "DRAGGING",
         | 
| 142181 | 
            +
                      actions: actions2
         | 
| 142182 | 
            +
                    });
         | 
| 142160 142183 | 
             
                  }
         | 
| 142161 | 
            -
             | 
| 142162 | 
            -
             | 
| 142163 | 
            -
             | 
| 142164 | 
            -
                   | 
| 142165 | 
            -
             | 
| 142166 | 
            -
             | 
| 142167 | 
            -
             | 
| 142168 | 
            -
             | 
| 142169 | 
            -
             | 
| 142170 | 
            -
                  if (getPhase().type === "DRAGGING") {
         | 
| 142184 | 
            +
                },
         | 
| 142185 | 
            +
                {
         | 
| 142186 | 
            +
                  eventName: "mouseup",
         | 
| 142187 | 
            +
                  fn: (event) => {
         | 
| 142188 | 
            +
                    const phase = getPhase();
         | 
| 142189 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142190 | 
            +
                      cancel();
         | 
| 142191 | 
            +
                      return;
         | 
| 142192 | 
            +
                    }
         | 
| 142171 142193 | 
             
                    event.preventDefault();
         | 
| 142194 | 
            +
                    phase.actions.drop({
         | 
| 142195 | 
            +
                      shouldBlockNextClick: true
         | 
| 142196 | 
            +
                    });
         | 
| 142197 | 
            +
                    completed();
         | 
| 142172 142198 | 
             
                  }
         | 
| 142173 | 
            -
             | 
| 142174 | 
            -
                 | 
| 142175 | 
            -
             | 
| 142176 | 
            -
             | 
| 142177 | 
            -
             | 
| 142178 | 
            -
             | 
| 142179 | 
            -
             | 
| 142199 | 
            +
                },
         | 
| 142200 | 
            +
                {
         | 
| 142201 | 
            +
                  eventName: "mousedown",
         | 
| 142202 | 
            +
                  fn: (event) => {
         | 
| 142203 | 
            +
                    if (getPhase().type === "DRAGGING") {
         | 
| 142204 | 
            +
                      event.preventDefault();
         | 
| 142205 | 
            +
                    }
         | 
| 142180 142206 | 
             
                    cancel();
         | 
| 142181 | 
            -
                    return;
         | 
| 142182 142207 | 
             
                  }
         | 
| 142183 | 
            -
             | 
| 142184 | 
            -
             | 
| 142185 | 
            -
             | 
| 142186 | 
            -
             | 
| 142208 | 
            +
                },
         | 
| 142209 | 
            +
                {
         | 
| 142210 | 
            +
                  eventName: "keydown",
         | 
| 142211 | 
            +
                  fn: (event) => {
         | 
| 142212 | 
            +
                    const phase = getPhase();
         | 
| 142213 | 
            +
                    if (phase.type === "PENDING") {
         | 
| 142214 | 
            +
                      cancel();
         | 
| 142215 | 
            +
                      return;
         | 
| 142216 | 
            +
                    }
         | 
| 142217 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142218 | 
            +
                      event.preventDefault();
         | 
| 142219 | 
            +
                      cancel();
         | 
| 142220 | 
            +
                      return;
         | 
| 142221 | 
            +
                    }
         | 
| 142222 | 
            +
                    preventStandardKeyEvents(event);
         | 
| 142187 142223 | 
             
                  }
         | 
| 142188 | 
            -
                  preventStandardKeyEvents(event);
         | 
| 142189 | 
            -
                }
         | 
| 142190 | 
            -
              }, {
         | 
| 142191 | 
            -
                eventName: "resize",
         | 
| 142192 | 
            -
                fn: cancel
         | 
| 142193 | 
            -
              }, {
         | 
| 142194 | 
            -
                eventName: "scroll",
         | 
| 142195 | 
            -
                options: {
         | 
| 142196 | 
            -
                  passive: true,
         | 
| 142197 | 
            -
                  capture: false
         | 
| 142198 142224 | 
             
                },
         | 
| 142199 | 
            -
                 | 
| 142200 | 
            -
                   | 
| 142201 | 
            -
             | 
| 142225 | 
            +
                {
         | 
| 142226 | 
            +
                  eventName: "resize",
         | 
| 142227 | 
            +
                  fn: cancel
         | 
| 142228 | 
            +
                },
         | 
| 142229 | 
            +
                {
         | 
| 142230 | 
            +
                  eventName: "scroll",
         | 
| 142231 | 
            +
                  options: {
         | 
| 142232 | 
            +
                    passive: true,
         | 
| 142233 | 
            +
                    capture: false
         | 
| 142234 | 
            +
                  },
         | 
| 142235 | 
            +
                  fn: () => {
         | 
| 142236 | 
            +
                    if (getPhase().type === "PENDING") {
         | 
| 142237 | 
            +
                      cancel();
         | 
| 142238 | 
            +
                    }
         | 
| 142202 142239 | 
             
                  }
         | 
| 142203 | 
            -
                }
         | 
| 142204 | 
            -
             | 
| 142205 | 
            -
             | 
| 142206 | 
            -
             | 
| 142207 | 
            -
             | 
| 142208 | 
            -
             | 
| 142209 | 
            -
             | 
| 142210 | 
            -
             | 
| 142211 | 
            -
             | 
| 142240 | 
            +
                },
         | 
| 142241 | 
            +
                {
         | 
| 142242 | 
            +
                  eventName: "webkitmouseforcedown",
         | 
| 142243 | 
            +
                  fn: (event) => {
         | 
| 142244 | 
            +
                    const phase = getPhase();
         | 
| 142245 | 
            +
                    !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Unexpected phase") : invariant$1(false) : void 0;
         | 
| 142246 | 
            +
                    if (phase.actions.shouldRespectForcePress()) {
         | 
| 142247 | 
            +
                      cancel();
         | 
| 142248 | 
            +
                      return;
         | 
| 142249 | 
            +
                    }
         | 
| 142250 | 
            +
                    event.preventDefault();
         | 
| 142212 142251 | 
             
                  }
         | 
| 142213 | 
            -
             | 
| 142252 | 
            +
                },
         | 
| 142253 | 
            +
                {
         | 
| 142254 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142255 | 
            +
                  fn: cancel
         | 
| 142214 142256 | 
             
                }
         | 
| 142215 | 
            -
               | 
| 142216 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142217 | 
            -
                fn: cancel
         | 
| 142218 | 
            -
              }];
         | 
| 142257 | 
            +
              ];
         | 
| 142219 142258 | 
             
            }
         | 
| 142220 142259 | 
             
            __name(getCaptureBindings, "getCaptureBindings");
         | 
| 142221 142260 | 
             
            function useMouseSensor(api) {
         | 
| 142222 142261 | 
             
              const phaseRef = React$3.useRef(idle$1);
         | 
| 142223 142262 | 
             
              const unbindEventsRef = React$3.useRef(noop$2);
         | 
| 142224 | 
            -
              const startCaptureBinding = useMemo( | 
| 142225 | 
            -
                 | 
| 142226 | 
            -
             | 
| 142227 | 
            -
                   | 
| 142228 | 
            -
                     | 
| 142229 | 
            -
             | 
| 142230 | 
            -
             | 
| 142231 | 
            -
                     | 
| 142232 | 
            -
             | 
| 142233 | 
            -
             | 
| 142234 | 
            -
                     | 
| 142235 | 
            -
             | 
| 142236 | 
            -
             | 
| 142237 | 
            -
             | 
| 142238 | 
            -
                     | 
| 142239 | 
            -
             | 
| 142240 | 
            -
             | 
| 142241 | 
            -
                     | 
| 142242 | 
            -
             | 
| 142243 | 
            -
             | 
| 142244 | 
            -
             | 
| 142245 | 
            -
             | 
| 142246 | 
            -
             | 
| 142247 | 
            -
             | 
| 142248 | 
            -
                     | 
| 142249 | 
            -
             | 
| 142250 | 
            -
             | 
| 142251 | 
            -
             | 
| 142252 | 
            -
             | 
| 142253 | 
            -
             | 
| 142254 | 
            -
             | 
| 142263 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142264 | 
            +
                () => ({
         | 
| 142265 | 
            +
                  eventName: "mousedown",
         | 
| 142266 | 
            +
                  fn: /* @__PURE__ */ __name(function onMouseDown3(event) {
         | 
| 142267 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142268 | 
            +
                      return;
         | 
| 142269 | 
            +
                    }
         | 
| 142270 | 
            +
                    if (event.button !== primaryButton) {
         | 
| 142271 | 
            +
                      return;
         | 
| 142272 | 
            +
                    }
         | 
| 142273 | 
            +
                    if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
         | 
| 142274 | 
            +
                      return;
         | 
| 142275 | 
            +
                    }
         | 
| 142276 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142277 | 
            +
                    if (!draggableId) {
         | 
| 142278 | 
            +
                      return;
         | 
| 142279 | 
            +
                    }
         | 
| 142280 | 
            +
                    const actions2 = api.tryGetLock(
         | 
| 142281 | 
            +
                      draggableId,
         | 
| 142282 | 
            +
                      stop,
         | 
| 142283 | 
            +
                      {
         | 
| 142284 | 
            +
                        sourceEvent: event
         | 
| 142285 | 
            +
                      }
         | 
| 142286 | 
            +
                    );
         | 
| 142287 | 
            +
                    if (!actions2) {
         | 
| 142288 | 
            +
                      return;
         | 
| 142289 | 
            +
                    }
         | 
| 142290 | 
            +
                    event.preventDefault();
         | 
| 142291 | 
            +
                    const point2 = {
         | 
| 142292 | 
            +
                      x: event.clientX,
         | 
| 142293 | 
            +
                      y: event.clientY
         | 
| 142294 | 
            +
                    };
         | 
| 142295 | 
            +
                    unbindEventsRef.current();
         | 
| 142296 | 
            +
                    startPendingDrag(actions2, point2);
         | 
| 142297 | 
            +
                  }, "onMouseDown")
         | 
| 142298 | 
            +
                }),
         | 
| 142299 | 
            +
                [api]
         | 
| 142300 | 
            +
              );
         | 
| 142255 142301 | 
             
              const preventForcePressBinding = useMemo(() => ({
         | 
| 142256 142302 | 
             
                eventName: "webkitmouseforcewillbegin",
         | 
| 142257 142303 | 
             
                fn: (event) => {
         | 
| @@ -142355,110 +142401,126 @@ function getDraggingBindings(actions2, stop) { | |
| 142355 142401 | 
             
                actions2.drop();
         | 
| 142356 142402 | 
             
              }
         | 
| 142357 142403 | 
             
              __name(drop2, "drop");
         | 
| 142358 | 
            -
              return [ | 
| 142359 | 
            -
                 | 
| 142360 | 
            -
             | 
| 142361 | 
            -
                   | 
| 142362 | 
            -
                    event. | 
| 142363 | 
            -
             | 
| 142364 | 
            -
             | 
| 142365 | 
            -
             | 
| 142366 | 
            -
             | 
| 142367 | 
            -
                    event. | 
| 142368 | 
            -
             | 
| 142369 | 
            -
             | 
| 142370 | 
            -
             | 
| 142371 | 
            -
             | 
| 142372 | 
            -
                    event. | 
| 142373 | 
            -
             | 
| 142374 | 
            -
             | 
| 142375 | 
            -
             | 
| 142376 | 
            -
             | 
| 142377 | 
            -
                    event. | 
| 142378 | 
            -
             | 
| 142379 | 
            -
             | 
| 142380 | 
            -
             | 
| 142381 | 
            -
             | 
| 142382 | 
            -
                    event. | 
| 142383 | 
            -
             | 
| 142384 | 
            -
             | 
| 142385 | 
            -
             | 
| 142386 | 
            -
             | 
| 142387 | 
            -
                    event. | 
| 142388 | 
            -
             | 
| 142389 | 
            -
             | 
| 142404 | 
            +
              return [
         | 
| 142405 | 
            +
                {
         | 
| 142406 | 
            +
                  eventName: "keydown",
         | 
| 142407 | 
            +
                  fn: (event) => {
         | 
| 142408 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142409 | 
            +
                      event.preventDefault();
         | 
| 142410 | 
            +
                      cancel();
         | 
| 142411 | 
            +
                      return;
         | 
| 142412 | 
            +
                    }
         | 
| 142413 | 
            +
                    if (event.keyCode === space) {
         | 
| 142414 | 
            +
                      event.preventDefault();
         | 
| 142415 | 
            +
                      drop2();
         | 
| 142416 | 
            +
                      return;
         | 
| 142417 | 
            +
                    }
         | 
| 142418 | 
            +
                    if (event.keyCode === arrowDown) {
         | 
| 142419 | 
            +
                      event.preventDefault();
         | 
| 142420 | 
            +
                      actions2.moveDown();
         | 
| 142421 | 
            +
                      return;
         | 
| 142422 | 
            +
                    }
         | 
| 142423 | 
            +
                    if (event.keyCode === arrowUp) {
         | 
| 142424 | 
            +
                      event.preventDefault();
         | 
| 142425 | 
            +
                      actions2.moveUp();
         | 
| 142426 | 
            +
                      return;
         | 
| 142427 | 
            +
                    }
         | 
| 142428 | 
            +
                    if (event.keyCode === arrowRight) {
         | 
| 142429 | 
            +
                      event.preventDefault();
         | 
| 142430 | 
            +
                      actions2.moveRight();
         | 
| 142431 | 
            +
                      return;
         | 
| 142432 | 
            +
                    }
         | 
| 142433 | 
            +
                    if (event.keyCode === arrowLeft) {
         | 
| 142434 | 
            +
                      event.preventDefault();
         | 
| 142435 | 
            +
                      actions2.moveLeft();
         | 
| 142436 | 
            +
                      return;
         | 
| 142437 | 
            +
                    }
         | 
| 142438 | 
            +
                    if (scrollJumpKeys[event.keyCode]) {
         | 
| 142439 | 
            +
                      event.preventDefault();
         | 
| 142440 | 
            +
                      return;
         | 
| 142441 | 
            +
                    }
         | 
| 142442 | 
            +
                    preventStandardKeyEvents(event);
         | 
| 142390 142443 | 
             
                  }
         | 
| 142391 | 
            -
             | 
| 142392 | 
            -
             | 
| 142393 | 
            -
             | 
| 142444 | 
            +
                },
         | 
| 142445 | 
            +
                {
         | 
| 142446 | 
            +
                  eventName: "mousedown",
         | 
| 142447 | 
            +
                  fn: cancel
         | 
| 142448 | 
            +
                },
         | 
| 142449 | 
            +
                {
         | 
| 142450 | 
            +
                  eventName: "mouseup",
         | 
| 142451 | 
            +
                  fn: cancel
         | 
| 142452 | 
            +
                },
         | 
| 142453 | 
            +
                {
         | 
| 142454 | 
            +
                  eventName: "click",
         | 
| 142455 | 
            +
                  fn: cancel
         | 
| 142456 | 
            +
                },
         | 
| 142457 | 
            +
                {
         | 
| 142458 | 
            +
                  eventName: "touchstart",
         | 
| 142459 | 
            +
                  fn: cancel
         | 
| 142460 | 
            +
                },
         | 
| 142461 | 
            +
                {
         | 
| 142462 | 
            +
                  eventName: "resize",
         | 
| 142463 | 
            +
                  fn: cancel
         | 
| 142464 | 
            +
                },
         | 
| 142465 | 
            +
                {
         | 
| 142466 | 
            +
                  eventName: "wheel",
         | 
| 142467 | 
            +
                  fn: cancel,
         | 
| 142468 | 
            +
                  options: {
         | 
| 142469 | 
            +
                    passive: true
         | 
| 142394 142470 | 
             
                  }
         | 
| 142395 | 
            -
             | 
| 142396 | 
            -
                 | 
| 142397 | 
            -
             | 
| 142398 | 
            -
             | 
| 142399 | 
            -
                fn: cancel
         | 
| 142400 | 
            -
              }, {
         | 
| 142401 | 
            -
                eventName: "mouseup",
         | 
| 142402 | 
            -
                fn: cancel
         | 
| 142403 | 
            -
              }, {
         | 
| 142404 | 
            -
                eventName: "click",
         | 
| 142405 | 
            -
                fn: cancel
         | 
| 142406 | 
            -
              }, {
         | 
| 142407 | 
            -
                eventName: "touchstart",
         | 
| 142408 | 
            -
                fn: cancel
         | 
| 142409 | 
            -
              }, {
         | 
| 142410 | 
            -
                eventName: "resize",
         | 
| 142411 | 
            -
                fn: cancel
         | 
| 142412 | 
            -
              }, {
         | 
| 142413 | 
            -
                eventName: "wheel",
         | 
| 142414 | 
            -
                fn: cancel,
         | 
| 142415 | 
            -
                options: {
         | 
| 142416 | 
            -
                  passive: true
         | 
| 142471 | 
            +
                },
         | 
| 142472 | 
            +
                {
         | 
| 142473 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142474 | 
            +
                  fn: cancel
         | 
| 142417 142475 | 
             
                }
         | 
| 142418 | 
            -
               | 
| 142419 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142420 | 
            -
                fn: cancel
         | 
| 142421 | 
            -
              }];
         | 
| 142476 | 
            +
              ];
         | 
| 142422 142477 | 
             
            }
         | 
| 142423 142478 | 
             
            __name(getDraggingBindings, "getDraggingBindings");
         | 
| 142424 142479 | 
             
            function useKeyboardSensor(api) {
         | 
| 142425 142480 | 
             
              const unbindEventsRef = React$3.useRef(noop$1$1);
         | 
| 142426 | 
            -
              const startCaptureBinding = useMemo( | 
| 142427 | 
            -
                 | 
| 142428 | 
            -
             | 
| 142429 | 
            -
                   | 
| 142430 | 
            -
                     | 
| 142431 | 
            -
             | 
| 142432 | 
            -
             | 
| 142433 | 
            -
                     | 
| 142434 | 
            -
             | 
| 142435 | 
            -
             | 
| 142436 | 
            -
             | 
| 142437 | 
            -
                     | 
| 142438 | 
            -
             | 
| 142439 | 
            -
             | 
| 142440 | 
            -
                     | 
| 142441 | 
            -
             | 
| 142442 | 
            -
             | 
| 142443 | 
            -
             | 
| 142444 | 
            -
             | 
| 142445 | 
            -
             | 
| 142446 | 
            -
             | 
| 142447 | 
            -
             | 
| 142448 | 
            -
             | 
| 142449 | 
            -
             | 
| 142450 | 
            -
                     | 
| 142451 | 
            -
                    isCapturing =  | 
| 142481 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142482 | 
            +
                () => ({
         | 
| 142483 | 
            +
                  eventName: "keydown",
         | 
| 142484 | 
            +
                  fn: /* @__PURE__ */ __name(function onKeyDown(event) {
         | 
| 142485 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142486 | 
            +
                      return;
         | 
| 142487 | 
            +
                    }
         | 
| 142488 | 
            +
                    if (event.keyCode !== space) {
         | 
| 142489 | 
            +
                      return;
         | 
| 142490 | 
            +
                    }
         | 
| 142491 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142492 | 
            +
                    if (!draggableId) {
         | 
| 142493 | 
            +
                      return;
         | 
| 142494 | 
            +
                    }
         | 
| 142495 | 
            +
                    const preDrag = api.tryGetLock(
         | 
| 142496 | 
            +
                      draggableId,
         | 
| 142497 | 
            +
                      stop,
         | 
| 142498 | 
            +
                      {
         | 
| 142499 | 
            +
                        sourceEvent: event
         | 
| 142500 | 
            +
                      }
         | 
| 142501 | 
            +
                    );
         | 
| 142502 | 
            +
                    if (!preDrag) {
         | 
| 142503 | 
            +
                      return;
         | 
| 142504 | 
            +
                    }
         | 
| 142505 | 
            +
                    event.preventDefault();
         | 
| 142506 | 
            +
                    let isCapturing = true;
         | 
| 142507 | 
            +
                    const actions2 = preDrag.snapLift();
         | 
| 142452 142508 | 
             
                    unbindEventsRef.current();
         | 
| 142453 | 
            -
                     | 
| 142454 | 
            -
             | 
| 142455 | 
            -
             | 
| 142456 | 
            -
             | 
| 142457 | 
            -
             | 
| 142458 | 
            -
                     | 
| 142459 | 
            -
             | 
| 142460 | 
            -
             | 
| 142461 | 
            -
             | 
| 142509 | 
            +
                    function stop() {
         | 
| 142510 | 
            +
                      !isCapturing ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot stop capturing a keyboard drag when not capturing") : invariant$1(false) : void 0;
         | 
| 142511 | 
            +
                      isCapturing = false;
         | 
| 142512 | 
            +
                      unbindEventsRef.current();
         | 
| 142513 | 
            +
                      listenForCapture();
         | 
| 142514 | 
            +
                    }
         | 
| 142515 | 
            +
                    __name(stop, "stop");
         | 
| 142516 | 
            +
                    unbindEventsRef.current = bindEvents(window, getDraggingBindings(actions2, stop), {
         | 
| 142517 | 
            +
                      capture: true,
         | 
| 142518 | 
            +
                      passive: false
         | 
| 142519 | 
            +
                    });
         | 
| 142520 | 
            +
                  }, "onKeyDown")
         | 
| 142521 | 
            +
                }),
         | 
| 142522 | 
            +
                [api]
         | 
| 142523 | 
            +
              );
         | 
| 142462 142524 | 
             
              const listenForCapture = useCallback(/* @__PURE__ */ __name(function tryStartCapture() {
         | 
| 142463 142525 | 
             
                const options = {
         | 
| 142464 142526 | 
             
                  passive: false,
         | 
| @@ -142484,33 +142546,39 @@ function getWindowBindings(_ref) { | |
| 142484 142546 | 
             
                cancel,
         | 
| 142485 142547 | 
             
                getPhase
         | 
| 142486 142548 | 
             
              } = _ref;
         | 
| 142487 | 
            -
              return [ | 
| 142488 | 
            -
                 | 
| 142489 | 
            -
             | 
| 142490 | 
            -
             | 
| 142491 | 
            -
                 | 
| 142492 | 
            -
                 | 
| 142493 | 
            -
             | 
| 142494 | 
            -
             | 
| 142495 | 
            -
                 | 
| 142496 | 
            -
             | 
| 142497 | 
            -
             | 
| 142498 | 
            -
             | 
| 142499 | 
            -
                eventName: "keydown",
         | 
| 142500 | 
            -
                fn: (event) => {
         | 
| 142501 | 
            -
                  if (getPhase().type !== "DRAGGING") {
         | 
| 142502 | 
            -
                    cancel();
         | 
| 142503 | 
            -
                    return;
         | 
| 142504 | 
            -
                  }
         | 
| 142505 | 
            -
                  if (event.keyCode === escape$1) {
         | 
| 142549 | 
            +
              return [
         | 
| 142550 | 
            +
                {
         | 
| 142551 | 
            +
                  eventName: "orientationchange",
         | 
| 142552 | 
            +
                  fn: cancel
         | 
| 142553 | 
            +
                },
         | 
| 142554 | 
            +
                {
         | 
| 142555 | 
            +
                  eventName: "resize",
         | 
| 142556 | 
            +
                  fn: cancel
         | 
| 142557 | 
            +
                },
         | 
| 142558 | 
            +
                {
         | 
| 142559 | 
            +
                  eventName: "contextmenu",
         | 
| 142560 | 
            +
                  fn: (event) => {
         | 
| 142506 142561 | 
             
                    event.preventDefault();
         | 
| 142507 142562 | 
             
                  }
         | 
| 142508 | 
            -
             | 
| 142563 | 
            +
                },
         | 
| 142564 | 
            +
                {
         | 
| 142565 | 
            +
                  eventName: "keydown",
         | 
| 142566 | 
            +
                  fn: (event) => {
         | 
| 142567 | 
            +
                    if (getPhase().type !== "DRAGGING") {
         | 
| 142568 | 
            +
                      cancel();
         | 
| 142569 | 
            +
                      return;
         | 
| 142570 | 
            +
                    }
         | 
| 142571 | 
            +
                    if (event.keyCode === escape$1) {
         | 
| 142572 | 
            +
                      event.preventDefault();
         | 
| 142573 | 
            +
                    }
         | 
| 142574 | 
            +
                    cancel();
         | 
| 142575 | 
            +
                  }
         | 
| 142576 | 
            +
                },
         | 
| 142577 | 
            +
                {
         | 
| 142578 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142579 | 
            +
                  fn: cancel
         | 
| 142509 142580 | 
             
                }
         | 
| 142510 | 
            -
               | 
| 142511 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142512 | 
            -
                fn: cancel
         | 
| 142513 | 
            -
              }];
         | 
| 142581 | 
            +
              ];
         | 
| 142514 142582 | 
             
            }
         | 
| 142515 142583 | 
             
            __name(getWindowBindings, "getWindowBindings");
         | 
| 142516 142584 | 
             
            function getHandleBindings(_ref2) {
         | 
| @@ -142519,87 +142587,93 @@ function getHandleBindings(_ref2) { | |
| 142519 142587 | 
             
                completed,
         | 
| 142520 142588 | 
             
                getPhase
         | 
| 142521 142589 | 
             
              } = _ref2;
         | 
| 142522 | 
            -
              return [ | 
| 142523 | 
            -
                 | 
| 142524 | 
            -
             | 
| 142525 | 
            -
                   | 
| 142526 | 
            -
             | 
| 142527 | 
            -
             | 
| 142528 | 
            -
                   | 
| 142529 | 
            -
             | 
| 142530 | 
            -
                     | 
| 142531 | 
            -
             | 
| 142590 | 
            +
              return [
         | 
| 142591 | 
            +
                {
         | 
| 142592 | 
            +
                  eventName: "touchmove",
         | 
| 142593 | 
            +
                  options: {
         | 
| 142594 | 
            +
                    capture: false
         | 
| 142595 | 
            +
                  },
         | 
| 142596 | 
            +
                  fn: (event) => {
         | 
| 142597 | 
            +
                    const phase = getPhase();
         | 
| 142598 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142599 | 
            +
                      cancel();
         | 
| 142600 | 
            +
                      return;
         | 
| 142601 | 
            +
                    }
         | 
| 142602 | 
            +
                    phase.hasMoved = true;
         | 
| 142603 | 
            +
                    const {
         | 
| 142604 | 
            +
                      clientX,
         | 
| 142605 | 
            +
                      clientY
         | 
| 142606 | 
            +
                    } = event.touches[0];
         | 
| 142607 | 
            +
                    const point2 = {
         | 
| 142608 | 
            +
                      x: clientX,
         | 
| 142609 | 
            +
                      y: clientY
         | 
| 142610 | 
            +
                    };
         | 
| 142611 | 
            +
                    event.preventDefault();
         | 
| 142612 | 
            +
                    phase.actions.move(point2);
         | 
| 142532 142613 | 
             
                  }
         | 
| 142533 | 
            -
             | 
| 142534 | 
            -
             | 
| 142535 | 
            -
             | 
| 142536 | 
            -
             | 
| 142537 | 
            -
             | 
| 142538 | 
            -
             | 
| 142539 | 
            -
             | 
| 142540 | 
            -
             | 
| 142541 | 
            -
             | 
| 142542 | 
            -
             | 
| 142543 | 
            -
             | 
| 142544 | 
            -
             | 
| 142545 | 
            -
             | 
| 142546 | 
            -
             | 
| 142547 | 
            -
                fn: (event) => {
         | 
| 142548 | 
            -
                  const phase = getPhase();
         | 
| 142549 | 
            -
                  if (phase.type !== "DRAGGING") {
         | 
| 142550 | 
            -
                    cancel();
         | 
| 142551 | 
            -
                    return;
         | 
| 142614 | 
            +
                },
         | 
| 142615 | 
            +
                {
         | 
| 142616 | 
            +
                  eventName: "touchend",
         | 
| 142617 | 
            +
                  fn: (event) => {
         | 
| 142618 | 
            +
                    const phase = getPhase();
         | 
| 142619 | 
            +
                    if (phase.type !== "DRAGGING") {
         | 
| 142620 | 
            +
                      cancel();
         | 
| 142621 | 
            +
                      return;
         | 
| 142622 | 
            +
                    }
         | 
| 142623 | 
            +
                    event.preventDefault();
         | 
| 142624 | 
            +
                    phase.actions.drop({
         | 
| 142625 | 
            +
                      shouldBlockNextClick: true
         | 
| 142626 | 
            +
                    });
         | 
| 142627 | 
            +
                    completed();
         | 
| 142552 142628 | 
             
                  }
         | 
| 142553 | 
            -
             | 
| 142554 | 
            -
             | 
| 142555 | 
            -
             | 
| 142556 | 
            -
                   | 
| 142557 | 
            -
             | 
| 142558 | 
            -
             | 
| 142559 | 
            -
             | 
| 142560 | 
            -
             | 
| 142561 | 
            -
             | 
| 142562 | 
            -
                  if (getPhase().type !== "DRAGGING") {
         | 
| 142629 | 
            +
                },
         | 
| 142630 | 
            +
                {
         | 
| 142631 | 
            +
                  eventName: "touchcancel",
         | 
| 142632 | 
            +
                  fn: (event) => {
         | 
| 142633 | 
            +
                    if (getPhase().type !== "DRAGGING") {
         | 
| 142634 | 
            +
                      cancel();
         | 
| 142635 | 
            +
                      return;
         | 
| 142636 | 
            +
                    }
         | 
| 142637 | 
            +
                    event.preventDefault();
         | 
| 142563 142638 | 
             
                    cancel();
         | 
| 142564 | 
            -
                    return;
         | 
| 142565 | 
            -
                  }
         | 
| 142566 | 
            -
                  event.preventDefault();
         | 
| 142567 | 
            -
                  cancel();
         | 
| 142568 | 
            -
                }
         | 
| 142569 | 
            -
              }, {
         | 
| 142570 | 
            -
                eventName: "touchforcechange",
         | 
| 142571 | 
            -
                fn: (event) => {
         | 
| 142572 | 
            -
                  const phase = getPhase();
         | 
| 142573 | 
            -
                  !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
         | 
| 142574 | 
            -
                  const touch3 = event.touches[0];
         | 
| 142575 | 
            -
                  if (!touch3) {
         | 
| 142576 | 
            -
                    return;
         | 
| 142577 | 
            -
                  }
         | 
| 142578 | 
            -
                  const isForcePress = touch3.force >= forcePressThreshold;
         | 
| 142579 | 
            -
                  if (!isForcePress) {
         | 
| 142580 | 
            -
                    return;
         | 
| 142581 142639 | 
             
                  }
         | 
| 142582 | 
            -
             | 
| 142583 | 
            -
             | 
| 142640 | 
            +
                },
         | 
| 142641 | 
            +
                {
         | 
| 142642 | 
            +
                  eventName: "touchforcechange",
         | 
| 142643 | 
            +
                  fn: (event) => {
         | 
| 142644 | 
            +
                    const phase = getPhase();
         | 
| 142645 | 
            +
                    !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
         | 
| 142646 | 
            +
                    const touch3 = event.touches[0];
         | 
| 142647 | 
            +
                    if (!touch3) {
         | 
| 142648 | 
            +
                      return;
         | 
| 142649 | 
            +
                    }
         | 
| 142650 | 
            +
                    const isForcePress = touch3.force >= forcePressThreshold;
         | 
| 142651 | 
            +
                    if (!isForcePress) {
         | 
| 142652 | 
            +
                      return;
         | 
| 142653 | 
            +
                    }
         | 
| 142654 | 
            +
                    const shouldRespect = phase.actions.shouldRespectForcePress();
         | 
| 142655 | 
            +
                    if (phase.type === "PENDING") {
         | 
| 142656 | 
            +
                      if (shouldRespect) {
         | 
| 142657 | 
            +
                        cancel();
         | 
| 142658 | 
            +
                      }
         | 
| 142659 | 
            +
                      return;
         | 
| 142660 | 
            +
                    }
         | 
| 142584 142661 | 
             
                    if (shouldRespect) {
         | 
| 142662 | 
            +
                      if (phase.hasMoved) {
         | 
| 142663 | 
            +
                        event.preventDefault();
         | 
| 142664 | 
            +
                        return;
         | 
| 142665 | 
            +
                      }
         | 
| 142585 142666 | 
             
                      cancel();
         | 
| 142586 | 
            -
                    }
         | 
| 142587 | 
            -
                    return;
         | 
| 142588 | 
            -
                  }
         | 
| 142589 | 
            -
                  if (shouldRespect) {
         | 
| 142590 | 
            -
                    if (phase.hasMoved) {
         | 
| 142591 | 
            -
                      event.preventDefault();
         | 
| 142592 142667 | 
             
                      return;
         | 
| 142593 142668 | 
             
                    }
         | 
| 142594 | 
            -
                     | 
| 142595 | 
            -
                    return;
         | 
| 142669 | 
            +
                    event.preventDefault();
         | 
| 142596 142670 | 
             
                  }
         | 
| 142597 | 
            -
             | 
| 142671 | 
            +
                },
         | 
| 142672 | 
            +
                {
         | 
| 142673 | 
            +
                  eventName: supportedPageVisibilityEventName,
         | 
| 142674 | 
            +
                  fn: cancel
         | 
| 142598 142675 | 
             
                }
         | 
| 142599 | 
            -
               | 
| 142600 | 
            -
                eventName: supportedPageVisibilityEventName,
         | 
| 142601 | 
            -
                fn: cancel
         | 
| 142602 | 
            -
              }];
         | 
| 142676 | 
            +
              ];
         | 
| 142603 142677 | 
             
            }
         | 
| 142604 142678 | 
             
            __name(getHandleBindings, "getHandleBindings");
         | 
| 142605 142679 | 
             
            function useTouchSensor(api) {
         | 
| @@ -142611,35 +142685,42 @@ function useTouchSensor(api) { | |
| 142611 142685 | 
             
              const setPhase = useCallback(/* @__PURE__ */ __name(function setPhase2(phase) {
         | 
| 142612 142686 | 
             
                phaseRef.current = phase;
         | 
| 142613 142687 | 
             
              }, "setPhase"), []);
         | 
| 142614 | 
            -
              const startCaptureBinding = useMemo( | 
| 142615 | 
            -
                 | 
| 142616 | 
            -
             | 
| 142617 | 
            -
                   | 
| 142618 | 
            -
                     | 
| 142619 | 
            -
             | 
| 142620 | 
            -
             | 
| 142621 | 
            -
             | 
| 142622 | 
            -
                     | 
| 142623 | 
            -
             | 
| 142624 | 
            -
             | 
| 142625 | 
            -
                     | 
| 142626 | 
            -
             | 
| 142627 | 
            -
             | 
| 142628 | 
            -
             | 
| 142629 | 
            -
             | 
| 142630 | 
            -
             | 
| 142631 | 
            -
             | 
| 142632 | 
            -
                     | 
| 142633 | 
            -
             | 
| 142634 | 
            -
             | 
| 142635 | 
            -
             | 
| 142636 | 
            -
                     | 
| 142637 | 
            -
             | 
| 142638 | 
            -
             | 
| 142639 | 
            -
             | 
| 142640 | 
            -
             | 
| 142641 | 
            -
             | 
| 142642 | 
            -
             | 
| 142688 | 
            +
              const startCaptureBinding = useMemo(
         | 
| 142689 | 
            +
                () => ({
         | 
| 142690 | 
            +
                  eventName: "touchstart",
         | 
| 142691 | 
            +
                  fn: /* @__PURE__ */ __name(function onTouchStart(event) {
         | 
| 142692 | 
            +
                    if (event.defaultPrevented) {
         | 
| 142693 | 
            +
                      return;
         | 
| 142694 | 
            +
                    }
         | 
| 142695 | 
            +
                    const draggableId = api.findClosestDraggableId(event);
         | 
| 142696 | 
            +
                    if (!draggableId) {
         | 
| 142697 | 
            +
                      return;
         | 
| 142698 | 
            +
                    }
         | 
| 142699 | 
            +
                    const actions2 = api.tryGetLock(
         | 
| 142700 | 
            +
                      draggableId,
         | 
| 142701 | 
            +
                      stop,
         | 
| 142702 | 
            +
                      {
         | 
| 142703 | 
            +
                        sourceEvent: event
         | 
| 142704 | 
            +
                      }
         | 
| 142705 | 
            +
                    );
         | 
| 142706 | 
            +
                    if (!actions2) {
         | 
| 142707 | 
            +
                      return;
         | 
| 142708 | 
            +
                    }
         | 
| 142709 | 
            +
                    const touch3 = event.touches[0];
         | 
| 142710 | 
            +
                    const {
         | 
| 142711 | 
            +
                      clientX,
         | 
| 142712 | 
            +
                      clientY
         | 
| 142713 | 
            +
                    } = touch3;
         | 
| 142714 | 
            +
                    const point2 = {
         | 
| 142715 | 
            +
                      x: clientX,
         | 
| 142716 | 
            +
                      y: clientY
         | 
| 142717 | 
            +
                    };
         | 
| 142718 | 
            +
                    unbindEventsRef.current();
         | 
| 142719 | 
            +
                    startPendingDrag(actions2, point2);
         | 
| 142720 | 
            +
                  }, "onTouchStart")
         | 
| 142721 | 
            +
                }),
         | 
| 142722 | 
            +
                [api]
         | 
| 142723 | 
            +
              );
         | 
| 142643 142724 | 
             
              const listenForCapture = useCallback(/* @__PURE__ */ __name(function listenForCapture2() {
         | 
| 142644 142725 | 
             
                const options = {
         | 
| 142645 142726 | 
             
                  capture: true,
         | 
| @@ -143822,10 +143903,15 @@ const makeMapStateToProps$1 = /* @__PURE__ */ __name(() => { | |
| 143822 143903 | 
             
            const mapDispatchToProps$1 = {
         | 
| 143823 143904 | 
             
              dropAnimationFinished
         | 
| 143824 143905 | 
             
            };
         | 
| 143825 | 
            -
            const ConnectedDraggable = connect( | 
| 143826 | 
            -
               | 
| 143827 | 
            -
               | 
| 143828 | 
            -
             | 
| 143906 | 
            +
            const ConnectedDraggable = connect(
         | 
| 143907 | 
            +
              makeMapStateToProps$1,
         | 
| 143908 | 
            +
              mapDispatchToProps$1,
         | 
| 143909 | 
            +
              null,
         | 
| 143910 | 
            +
              {
         | 
| 143911 | 
            +
                context: StoreContext,
         | 
| 143912 | 
            +
                areStatePropsEqual: isStrictEqual
         | 
| 143913 | 
            +
              }
         | 
| 143914 | 
            +
            )(Draggable$1$1);
         | 
| 143829 143915 | 
             
            var ConnectedDraggable$1 = ConnectedDraggable;
         | 
| 143830 143916 | 
             
            function PrivateDraggable(props) {
         | 
| 143831 143917 | 
             
              const droppableContext = useRequiredContext(DroppableContext);
         | 
| @@ -144180,7 +144266,11 @@ function useDroppablePublisher(args) { | |
| 144180 144266 | 
             
                }
         | 
| 144181 144267 | 
             
                scheduleScrollUpdate.cancel();
         | 
| 144182 144268 | 
             
                closest2.removeAttribute(scrollContainer.contextId);
         | 
| 144183 | 
            -
                closest2.removeEventListener( | 
| 144269 | 
            +
                closest2.removeEventListener(
         | 
| 144270 | 
            +
                  "scroll",
         | 
| 144271 | 
            +
                  onClosestScroll,
         | 
| 144272 | 
            +
                  getListenerOptions(dragging.scrollOptions)
         | 
| 144273 | 
            +
                );
         | 
| 144184 144274 | 
             
              }, [onClosestScroll, scheduleScrollUpdate]);
         | 
| 144185 144275 | 
             
              const scroll2 = useCallback((change3) => {
         | 
| 144186 144276 | 
             
                const dragging = whileDraggingRef.current;
         | 
| @@ -144579,33 +144669,6 @@ const Droppable = /* @__PURE__ */ __name((props) => { | |
| 144579 144669 | 
             
              }, children(provided, snapshot), getClone());
         | 
| 144580 144670 | 
             
            }, "Droppable");
         | 
| 144581 144671 | 
             
            var Droppable$1 = Droppable;
         | 
| 144582 | 
            -
            function getBody() {
         | 
| 144583 | 
            -
              !document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
         | 
| 144584 | 
            -
              return document.body;
         | 
| 144585 | 
            -
            }
         | 
| 144586 | 
            -
            __name(getBody, "getBody");
         | 
| 144587 | 
            -
            const defaultProps = {
         | 
| 144588 | 
            -
              mode: "standard",
         | 
| 144589 | 
            -
              type: "DEFAULT",
         | 
| 144590 | 
            -
              direction: "vertical",
         | 
| 144591 | 
            -
              isDropDisabled: false,
         | 
| 144592 | 
            -
              isCombineEnabled: false,
         | 
| 144593 | 
            -
              ignoreContainerClipping: false,
         | 
| 144594 | 
            -
              renderClone: null,
         | 
| 144595 | 
            -
              getContainerForClone: getBody
         | 
| 144596 | 
            -
            };
         | 
| 144597 | 
            -
            const attachDefaultPropsToOwnProps = /* @__PURE__ */ __name((ownProps) => {
         | 
| 144598 | 
            -
              let mergedProps = __spreadValues({}, ownProps);
         | 
| 144599 | 
            -
              let defaultPropKey;
         | 
| 144600 | 
            -
              for (defaultPropKey in defaultProps) {
         | 
| 144601 | 
            -
                if (ownProps[defaultPropKey] === void 0) {
         | 
| 144602 | 
            -
                  mergedProps = __spreadProps(__spreadValues({}, mergedProps), {
         | 
| 144603 | 
            -
                    [defaultPropKey]: defaultProps[defaultPropKey]
         | 
| 144604 | 
            -
                  });
         | 
| 144605 | 
            -
                }
         | 
| 144606 | 
            -
              }
         | 
| 144607 | 
            -
              return mergedProps;
         | 
| 144608 | 
            -
            }, "attachDefaultPropsToOwnProps");
         | 
| 144609 144672 | 
             
            const isMatchingType = /* @__PURE__ */ __name((type2, critical) => type2 === critical.droppable.type, "isMatchingType");
         | 
| 144610 144673 | 
             
            const getDraggable = /* @__PURE__ */ __name((critical, dimensions) => dimensions.draggables[critical.draggable.id], "getDraggable");
         | 
| 144611 144674 | 
             
            const makeMapStateToProps = /* @__PURE__ */ __name(() => {
         | 
| @@ -144672,11 +144735,10 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => { | |
| 144672 144735 | 
             
                };
         | 
| 144673 144736 | 
             
              });
         | 
| 144674 144737 | 
             
              const selector = /* @__PURE__ */ __name((state2, ownProps) => {
         | 
| 144675 | 
            -
                const  | 
| 144676 | 
            -
                const  | 
| 144677 | 
            -
                const  | 
| 144678 | 
            -
                const  | 
| 144679 | 
            -
                const renderClone = ownPropsWithDefaultProps.renderClone;
         | 
| 144738 | 
            +
                const id2 = ownProps.droppableId;
         | 
| 144739 | 
            +
                const type2 = ownProps.type;
         | 
| 144740 | 
            +
                const isEnabled = !ownProps.isDropDisabled;
         | 
| 144741 | 
            +
                const renderClone = ownProps.renderClone;
         | 
| 144680 144742 | 
             
                if (isDragging(state2)) {
         | 
| 144681 144743 | 
             
                  const critical = state2.critical;
         | 
| 144682 144744 | 
             
                  if (!isMatchingType(type2, critical)) {
         | 
| @@ -144717,12 +144779,31 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => { | |
| 144717 144779 | 
             
            const mapDispatchToProps = {
         | 
| 144718 144780 | 
             
              updateViewportMaxScroll
         | 
| 144719 144781 | 
             
            };
         | 
| 144720 | 
            -
             | 
| 144721 | 
            -
               | 
| 144722 | 
            -
             | 
| 144723 | 
            -
             | 
| 144724 | 
            -
             | 
| 144725 | 
            -
             | 
| 144782 | 
            +
            function getBody() {
         | 
| 144783 | 
            +
              !document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
         | 
| 144784 | 
            +
              return document.body;
         | 
| 144785 | 
            +
            }
         | 
| 144786 | 
            +
            __name(getBody, "getBody");
         | 
| 144787 | 
            +
            const defaultProps = {
         | 
| 144788 | 
            +
              mode: "standard",
         | 
| 144789 | 
            +
              type: "DEFAULT",
         | 
| 144790 | 
            +
              direction: "vertical",
         | 
| 144791 | 
            +
              isDropDisabled: false,
         | 
| 144792 | 
            +
              isCombineEnabled: false,
         | 
| 144793 | 
            +
              ignoreContainerClipping: false,
         | 
| 144794 | 
            +
              renderClone: null,
         | 
| 144795 | 
            +
              getContainerForClone: getBody
         | 
| 144796 | 
            +
            };
         | 
| 144797 | 
            +
            const ConnectedDroppable = connect(
         | 
| 144798 | 
            +
              makeMapStateToProps,
         | 
| 144799 | 
            +
              mapDispatchToProps,
         | 
| 144800 | 
            +
              null,
         | 
| 144801 | 
            +
              {
         | 
| 144802 | 
            +
                context: StoreContext,
         | 
| 144803 | 
            +
                areStatePropsEqual: isStrictEqual
         | 
| 144804 | 
            +
              }
         | 
| 144805 | 
            +
            )(Droppable$1);
         | 
| 144806 | 
            +
            ConnectedDroppable.defaultProps = defaultProps;
         | 
| 144726 144807 | 
             
            var ConnectedDroppable$1 = ConnectedDroppable;
         | 
| 144727 144808 | 
             
            var clipboard = { exports: {} };
         | 
| 144728 144809 | 
             
            /*!
         | 
| @@ -153126,7 +153207,7 @@ function showFileDialog({ multiple = false, onSelect }) { | |
| 153126 153207 | 
             
            }
         | 
| 153127 153208 | 
             
            __name(showFileDialog, "showFileDialog");
         | 
| 153128 153209 | 
             
            const name = "@teselagen/ove";
         | 
| 153129 | 
            -
            const version = "0.0. | 
| 153210 | 
            +
            const version = "0.0.4";
         | 
| 153130 153211 | 
             
            const main = "./index.js";
         | 
| 153131 153212 | 
             
            const types$1 = "./index.d.ts";
         | 
| 153132 153213 | 
             
            const type = "commonjs";
         | 
| @@ -173420,6 +173501,10 @@ class GenbankView extends React$3.Component { | |
| 173420 173501 | 
             
                __publicField(this, "state", {
         | 
| 173421 173502 | 
             
                  fileTypeToView: "genbank"
         | 
| 173422 173503 | 
             
                });
         | 
| 173504 | 
            +
                __publicField(this, "select", /* @__PURE__ */ __name(() => {
         | 
| 173505 | 
            +
                  var _a2;
         | 
| 173506 | 
            +
                  return (_a2 = this._input) == null ? void 0 : _a2.select();
         | 
| 173507 | 
            +
                }, "select"));
         | 
| 173423 173508 | 
             
              }
         | 
| 173424 173509 | 
             
              render() {
         | 
| 173425 173510 | 
             
                const { sequenceData: sequenceData2 = {} } = this.props;
         | 
| @@ -173457,7 +173542,7 @@ class GenbankView extends React$3.Component { | |
| 173457 173542 | 
             
                  {
         | 
| 173458 173543 | 
             
                    "data-test": "ve-genbank-text",
         | 
| 173459 173544 | 
             
                    readOnly: true,
         | 
| 173460 | 
            -
                     | 
| 173545 | 
            +
                    onClick: this.select,
         | 
| 173461 173546 | 
             
                    style: {
         | 
| 173462 173547 | 
             
                      whiteSpace: "pre",
         | 
| 173463 173548 | 
             
                      overflowWrap: "normal",
         |