@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.
Files changed (4) hide show
  1. package/index.js +549 -464
  2. package/index.mjs +549 -464
  3. package/index.umd.js +549 -464
  4. 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.componentDidUpdate = /* @__PURE__ */ __name(function componentDidUpdate(prevProps) {
29329
- var _this3 = this;
29330
- var oldName = prefixName(prevProps, prevProps.name);
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(prevProps.validate, this.props.validate) || !plain.deepEqual(prevProps.warn, this.props.warn)) {
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 _this3.props.validate;
29335
+ return nextProps.validate;
29337
29336
  }, function() {
29338
- return _this3.props.warn;
29337
+ return nextProps.warn;
29339
29338
  });
29340
29339
  }
29341
- }, "componentDidUpdate");
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.componentDidUpdate = /* @__PURE__ */ __name(function componentDidUpdate(prevProps) {
30315
- var oldName = prefixName(prevProps, prevProps.name);
30316
- var newName = prefixName(this.props, this.props.name);
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
- }, "componentDidUpdate");
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 = typeof module !== "undefined" && module;
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
- var isValueReset = this.initIfNeeded(nextProps);
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
- if (this.initializedOnLoad)
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 _iobject;
39467
- var hasRequired_iobject;
39468
- function require_iobject() {
39469
- if (hasRequired_iobject)
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 = require_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
- var hasRequired_objectPie;
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 = require_objectPie();
39582
+ var pIE2 = _objectPie;
39604
39583
  var toObject2 = _toObject;
39605
- var IObject2 = require_iobject();
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 = require_objectPie();
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 = require_objectPie();
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
- require_objectPie().f = $propertyIsEnumerable;
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 isAlreadySpecialEditor = isAlreadyProteinEditor || isAlreadyRnaEditor || isAlreadyOligoEditor;
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: true,
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) => [getDevMessage(message), "color: #00C584; font-size: 1.2em; font-weight: bold;", "line-height: 1.5", "color: #723874;"], "getFormattedMessage");
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(axis.line, moveRelativeTo.marginBox[axis.end] + distanceFromStartToBorderBoxCenter(axis, isMoving), getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving));
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(axis.line, moveRelativeTo.marginBox[axis.start] - distanceFromEndToBorderBoxCenter(axis, isMoving), getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving));
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 = [last2, withViewportScroll, withDroppableScroll2];
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(previousPageBorderBoxCenter[destination.axis.line] <= moveRelativeTo.page.borderBox.center[destination.axis.line]);
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(candidate.axis.line, pageBorderBox.center[axis.line], candidate.page.borderBox.center[axis.crossAxisLine]);
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(style$n(styleMarshal), dimensionMarshalStopper(dimensionMarshal), lift(dimensionMarshal), drop, dropAnimationFinish, dropAnimationFlushOnScroll, pendingDrop$1, autoScroll(autoScroller), scrollListener$1, focus2(focusMarshal), responders(getResponders, announce))));
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((id2) => registry.draggable.getById(id2).getDimension(origin)).sort((a2, b3) => a2.descriptor.index - b3.descriptor.index);
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
- x: scrollWidth,
140577
- y: scrollHeight
140578
- }, {
140579
- x: width,
140580
- y: height2
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(memoizeOne((proposed) => {
141499
- const el = dynamicRef.current;
141500
- !el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
141501
- el.textContent = proposed;
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 _a2;
141559
- return ((_a2 = el == null ? void 0 : el.ownerDocument) == null ? void 0 : _a2.defaultView) || window;
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
- eventName: "mousemove",
142122
- fn: (event) => {
142123
- const {
142124
- button,
142125
- clientX,
142126
- clientY
142127
- } = event;
142128
- if (button !== primaryButton) {
142129
- return;
142130
- }
142131
- const point2 = {
142132
- x: clientX,
142133
- y: clientY
142134
- };
142135
- const phase = getPhase();
142136
- if (phase.type === "DRAGGING") {
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.move(point2);
142139
- return;
142140
- }
142141
- !(phase.type === "PENDING") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot be IDLE") : invariant$1(false) : void 0;
142142
- const pending = phase.point;
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
- event.preventDefault();
142162
- phase.actions.drop({
142163
- shouldBlockNextClick: true
142164
- });
142165
- completed();
142166
- }
142167
- }, {
142168
- eventName: "mousedown",
142169
- fn: (event) => {
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
- cancel();
142174
- }
142175
- }, {
142176
- eventName: "keydown",
142177
- fn: (event) => {
142178
- const phase = getPhase();
142179
- if (phase.type === "PENDING") {
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
- if (event.keyCode === escape$1) {
142184
- event.preventDefault();
142185
- cancel();
142186
- return;
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
- fn: () => {
142200
- if (getPhase().type === "PENDING") {
142201
- cancel();
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
- eventName: "webkitmouseforcedown",
142206
- fn: (event) => {
142207
- const phase = getPhase();
142208
- !(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Unexpected phase") : invariant$1(false) : void 0;
142209
- if (phase.actions.shouldRespectForcePress()) {
142210
- cancel();
142211
- return;
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
- event.preventDefault();
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
- eventName: "mousedown",
142226
- fn: /* @__PURE__ */ __name(function onMouseDown3(event) {
142227
- if (event.defaultPrevented) {
142228
- return;
142229
- }
142230
- if (event.button !== primaryButton) {
142231
- return;
142232
- }
142233
- if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
142234
- return;
142235
- }
142236
- const draggableId = api.findClosestDraggableId(event);
142237
- if (!draggableId) {
142238
- return;
142239
- }
142240
- const actions2 = api.tryGetLock(draggableId, stop, {
142241
- sourceEvent: event
142242
- });
142243
- if (!actions2) {
142244
- return;
142245
- }
142246
- event.preventDefault();
142247
- const point2 = {
142248
- x: event.clientX,
142249
- y: event.clientY
142250
- };
142251
- unbindEventsRef.current();
142252
- startPendingDrag(actions2, point2);
142253
- }, "onMouseDown")
142254
- }), [api]);
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
- eventName: "keydown",
142360
- fn: (event) => {
142361
- if (event.keyCode === escape$1) {
142362
- event.preventDefault();
142363
- cancel();
142364
- return;
142365
- }
142366
- if (event.keyCode === space) {
142367
- event.preventDefault();
142368
- drop2();
142369
- return;
142370
- }
142371
- if (event.keyCode === arrowDown) {
142372
- event.preventDefault();
142373
- actions2.moveDown();
142374
- return;
142375
- }
142376
- if (event.keyCode === arrowUp) {
142377
- event.preventDefault();
142378
- actions2.moveUp();
142379
- return;
142380
- }
142381
- if (event.keyCode === arrowRight) {
142382
- event.preventDefault();
142383
- actions2.moveRight();
142384
- return;
142385
- }
142386
- if (event.keyCode === arrowLeft) {
142387
- event.preventDefault();
142388
- actions2.moveLeft();
142389
- return;
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
- if (scrollJumpKeys[event.keyCode]) {
142392
- event.preventDefault();
142393
- return;
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
- preventStandardKeyEvents(event);
142396
- }
142397
- }, {
142398
- eventName: "mousedown",
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
- eventName: "keydown",
142428
- fn: /* @__PURE__ */ __name(function onKeyDown(event) {
142429
- if (event.defaultPrevented) {
142430
- return;
142431
- }
142432
- if (event.keyCode !== space) {
142433
- return;
142434
- }
142435
- const draggableId = api.findClosestDraggableId(event);
142436
- if (!draggableId) {
142437
- return;
142438
- }
142439
- const preDrag = api.tryGetLock(draggableId, stop, {
142440
- sourceEvent: event
142441
- });
142442
- if (!preDrag) {
142443
- return;
142444
- }
142445
- event.preventDefault();
142446
- let isCapturing = true;
142447
- const actions2 = preDrag.snapLift();
142448
- unbindEventsRef.current();
142449
- function stop() {
142450
- !isCapturing ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot stop capturing a keyboard drag when not capturing") : invariant$1(false) : void 0;
142451
- isCapturing = false;
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
- listenForCapture();
142454
- }
142455
- __name(stop, "stop");
142456
- unbindEventsRef.current = bindEvents(window, getDraggingBindings(actions2, stop), {
142457
- capture: true,
142458
- passive: false
142459
- });
142460
- }, "onKeyDown")
142461
- }), [api]);
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
- eventName: "orientationchange",
142489
- fn: cancel
142490
- }, {
142491
- eventName: "resize",
142492
- fn: cancel
142493
- }, {
142494
- eventName: "contextmenu",
142495
- fn: (event) => {
142496
- event.preventDefault();
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
- cancel();
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
- eventName: "touchmove",
142524
- options: {
142525
- capture: false
142526
- },
142527
- fn: (event) => {
142528
- const phase = getPhase();
142529
- if (phase.type !== "DRAGGING") {
142530
- cancel();
142531
- return;
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
- phase.hasMoved = true;
142534
- const {
142535
- clientX,
142536
- clientY
142537
- } = event.touches[0];
142538
- const point2 = {
142539
- x: clientX,
142540
- y: clientY
142541
- };
142542
- event.preventDefault();
142543
- phase.actions.move(point2);
142544
- }
142545
- }, {
142546
- eventName: "touchend",
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
- event.preventDefault();
142554
- phase.actions.drop({
142555
- shouldBlockNextClick: true
142556
- });
142557
- completed();
142558
- }
142559
- }, {
142560
- eventName: "touchcancel",
142561
- fn: (event) => {
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
- const shouldRespect = phase.actions.shouldRespectForcePress();
142583
- if (phase.type === "PENDING") {
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
- cancel();
142595
- return;
142669
+ event.preventDefault();
142596
142670
  }
142597
- event.preventDefault();
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
- eventName: "touchstart",
142616
- fn: /* @__PURE__ */ __name(function onTouchStart(event) {
142617
- if (event.defaultPrevented) {
142618
- return;
142619
- }
142620
- const draggableId = api.findClosestDraggableId(event);
142621
- if (!draggableId) {
142622
- return;
142623
- }
142624
- const actions2 = api.tryGetLock(draggableId, stop, {
142625
- sourceEvent: event
142626
- });
142627
- if (!actions2) {
142628
- return;
142629
- }
142630
- const touch3 = event.touches[0];
142631
- const {
142632
- clientX,
142633
- clientY
142634
- } = touch3;
142635
- const point2 = {
142636
- x: clientX,
142637
- y: clientY
142638
- };
142639
- unbindEventsRef.current();
142640
- startPendingDrag(actions2, point2);
142641
- }, "onTouchStart")
142642
- }), [api]);
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(makeMapStateToProps$1, mapDispatchToProps$1, null, {
143826
- context: StoreContext,
143827
- areStatePropsEqual: isStrictEqual
143828
- })(Draggable$1$1);
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("scroll", onClosestScroll, getListenerOptions(dragging.scrollOptions));
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 ownPropsWithDefaultProps = attachDefaultPropsToOwnProps(ownProps);
144676
- const id2 = ownPropsWithDefaultProps.droppableId;
144677
- const type2 = ownPropsWithDefaultProps.type;
144678
- const isEnabled = !ownPropsWithDefaultProps.isDropDisabled;
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
- const ConnectedDroppable = connect(makeMapStateToProps, mapDispatchToProps, (stateProps, dispatchProps, ownProps) => {
144721
- return __spreadValues(__spreadValues(__spreadValues({}, attachDefaultPropsToOwnProps(ownProps)), stateProps), dispatchProps);
144722
- }, {
144723
- context: StoreContext,
144724
- areStatePropsEqual: isStrictEqual
144725
- })(Droppable$1);
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.3";
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
- onclick: "this.select()",
173545
+ onClick: this.select,
173461
173546
  style: {
173462
173547
  whiteSpace: "pre",
173463
173548
  overflowWrap: "normal",