npm - @ni/nimble-components - Versions diffs - 24.1.13 → 24.1.14 - Mend

@ni/nimble-components 24.1.13 → 24.1.14

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 (74) hide show

package/dist/all-components-bundle.js CHANGED Viewed

@@ -16333,7 +16333,7 @@
   /**
    * Do not edit directly
-   * Generated on Wed, 10 Apr 2024 21:43:42 GMT
+   * Generated on Mon, 15 Apr 2024 17:21:28 GMT
    */
   const Information100DarkUi = "#a46eff";
@@ -28524,6 +28524,8 @@
       return found;
   }
+  function isTagRule(rule) { return rule.tag != null; }
+  function isStyleRule(rule) { return rule.style != null; }
   /**
   A DOM parser represents a strategy for parsing DOM content into a
   ProseMirror document conforming to a given schema. Its behavior is
@@ -28555,9 +28557,9 @@
           */
           this.styles = [];
           rules.forEach(rule => {
-              if (rule.tag)
+              if (isTagRule(rule))
                   this.tags.push(rule);
-              else if (rule.style)
+              else if (isStyleRule(rule))
                   this.styles.push(rule);
           });
           // Only normalize list elements when lists in the schema can't directly contain themselves
@@ -32551,6 +32553,9 @@
       range.setStart(node, from || 0);
       return range;
   };
+  const clearReusedRange = function () {
+      reusedRange = null;
+  };
   // Scans forward and backward through DOM positions equivalent to the
   // given one to see if the two are in the same place (i.e. after a
   // text node vs at the end of that text node)
@@ -32585,6 +32590,44 @@
   function nodeSize(node) {
       return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
   }
+  function textNodeBefore$1(node, offset) {
+      for (;;) {
+          if (node.nodeType == 3 && offset)
+              return node;
+          if (node.nodeType == 1 && offset > 0) {
+              if (node.contentEditable == "false")
+                  return null;
+              node = node.childNodes[offset - 1];
+              offset = nodeSize(node);
+          }
+          else if (node.parentNode && !hasBlockDesc(node)) {
+              offset = domIndex(node);
+              node = node.parentNode;
+          }
+          else {
+              return null;
+          }
+      }
+  }
+  function textNodeAfter$1(node, offset) {
+      for (;;) {
+          if (node.nodeType == 3 && offset < node.nodeValue.length)
+              return node;
+          if (node.nodeType == 1 && offset < node.childNodes.length) {
+              if (node.contentEditable == "false")
+                  return null;
+              node = node.childNodes[offset];
+              offset = 0;
+          }
+          else if (node.parentNode && !hasBlockDesc(node)) {
+              offset = domIndex(node) + 1;
+              node = node.parentNode;
+          }
+          else {
+              return null;
+          }
+      }
+  }
   function isOnEdge(node, offset, parent) {
       for (let atStart = offset == 0, atEnd = offset == nodeSize(node); atStart || atEnd;) {
           if (node == parent)
@@ -32661,6 +32704,12 @@
   const webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
   function windowRect(doc) {
+      let vp = doc.defaultView && doc.defaultView.visualViewport;
+      if (vp)
+          return {
+              left: 0, right: vp.width,
+              top: 0, bottom: vp.height
+          };
       return { left: 0, right: doc.documentElement.clientWidth,
           top: 0, bottom: doc.documentElement.clientHeight };
   }
@@ -33596,6 +33645,7 @@
       }
       get domAtom() { return false; }
       get ignoreForCoords() { return false; }
+      isText(text) { return false; }
   }
   // A widget desc represents a widget decoration, which is a DOM node
   // drawn between the document nodes.
@@ -33858,8 +33908,7 @@
           let { from, to } = view.state.selection;
           if (!(view.state.selection instanceof TextSelection) || from < pos || to > pos + this.node.content.size)
               return null;
-          let sel = view.domSelectionRange();
-          let textNode = nearbyTextNode(sel.focusNode, sel.focusOffset);
+          let textNode = view.input.compositionNode;
           if (!textNode || !this.dom.contains(textNode.parentNode))
               return null;
           if (this.node.inlineContent) {
@@ -34001,6 +34050,7 @@
               this.dirty = NODE_DIRTY;
       }
       get domAtom() { return false; }
+      isText(text) { return this.node.text == text; }
   }
   // A dummy desc used to tag trailing BR or IMG nodes created to work
   // around contentEditable terribleness.
@@ -34570,25 +34620,6 @@
           dom.style.cssText = oldCSS;
       }
   }
-  function nearbyTextNode(node, offset) {
-      for (;;) {
-          if (node.nodeType == 3)
-              return node;
-          if (node.nodeType == 1 && offset > 0) {
-              if (node.childNodes.length > offset && node.childNodes[offset].nodeType == 3)
-                  return node.childNodes[offset];
-              node = node.childNodes[offset - 1];
-              offset = nodeSize(node);
-          }
-          else if (node.nodeType == 1 && offset < node.childNodes.length) {
-              node = node.childNodes[offset];
-              offset = 0;
-          }
-          else {
-              return null;
-          }
-      }
-  }
   // Find a piece of text in an inline fragment, overlapping from-to
   function findTextInFragment(frag, text, from, to) {
       for (let i = 0, pos = 0; i < frag.childCount && pos <= to;) {
@@ -35493,6 +35524,7 @@
           this.lastTouch = 0;
           this.lastAndroidDelete = 0;
           this.composing = false;
+          this.compositionNode = null;
           this.composingTimeout = -1;
           this.compositionNodes = [];
           this.compositionEndedAt = -2e8;
@@ -35929,6 +35961,7 @@
           view.input.composing = false;
           view.input.compositionEndedAt = event.timeStamp;
           view.input.compositionPendingChanges = view.domObserver.pendingRecords().length ? view.input.compositionID : 0;
+          view.input.compositionNode = null;
           if (view.input.compositionPendingChanges)
               Promise.resolve().then(() => view.domObserver.flush());
           view.input.compositionID++;
@@ -35948,6 +35981,25 @@
       while (view.input.compositionNodes.length > 0)
           view.input.compositionNodes.pop().markParentsDirty();
   }
+  function findCompositionNode(view) {
+      let sel = view.domSelectionRange();
+      if (!sel.focusNode)
+          return null;
+      let textBefore = textNodeBefore$1(sel.focusNode, sel.focusOffset);
+      let textAfter = textNodeAfter$1(sel.focusNode, sel.focusOffset);
+      if (textBefore && textAfter && textBefore != textAfter) {
+          let descAfter = textAfter.pmViewDesc;
+          if (!descAfter || !descAfter.isText(textAfter.nodeValue)) {
+              return textAfter;
+          }
+          else if (view.input.compositionNode == textAfter) {
+              let descBefore = textBefore.pmViewDesc;
+              if (!(!descBefore || !descBefore.isText(textBefore.nodeValue)))
+                  return textAfter;
+          }
+      }
+      return textBefore;
+  }
   function timestampFromCustomEvent() {
       let event = document.createEvent("Event");
       event.initEvent("event", true, true);
@@ -37182,9 +37234,25 @@
           cssCheckWarned = true;
       }
   }
+  function rangeToSelectionRange(view, range) {
+      let anchorNode = range.startContainer, anchorOffset = range.startOffset;
+      let focusNode = range.endContainer, focusOffset = range.endOffset;
+      let currentAnchor = view.domAtPos(view.state.selection.anchor);
+      // Since such a range doesn't distinguish between anchor and head,
+      // use a heuristic that flips it around if its end matches the
+      // current anchor.
+      if (isEquivalentPosition(currentAnchor.node, currentAnchor.offset, focusNode, focusOffset))
+          [anchorNode, anchorOffset, focusNode, focusOffset] = [focusNode, focusOffset, anchorNode, anchorOffset];
+      return { anchorNode, anchorOffset, focusNode, focusOffset };
+  }
   // Used to work around a Safari Selection/shadow DOM bug
   // Based on https://github.com/codemirror/dev/issues/414 fix
-  function safariShadowSelectionRange(view) {
+  function safariShadowSelectionRange(view, selection) {
+      if (selection.getComposedRanges) {
+          let range = selection.getComposedRanges(view.root)[0];
+          if (range)
+              return rangeToSelectionRange(view, range);
+      }
       let found;
       function read(event) {
           event.preventDefault();
@@ -37199,15 +37267,7 @@
       view.dom.addEventListener("beforeinput", read, true);
       document.execCommand("indent");
       view.dom.removeEventListener("beforeinput", read, true);
-      let anchorNode = found.startContainer, anchorOffset = found.startOffset;
-      let focusNode = found.endContainer, focusOffset = found.endOffset;
-      let currentAnchor = view.domAtPos(view.state.selection.anchor);
-      // Since such a range doesn't distinguish between anchor and head,
-      // use a heuristic that flips it around if its end matches the
-      // current anchor.
-      if (isEquivalentPosition(currentAnchor.node, currentAnchor.offset, focusNode, focusOffset))
-          [anchorNode, anchorOffset, focusNode, focusOffset] = [focusNode, focusOffset, anchorNode, anchorOffset];
-      return { anchorNode, anchorOffset, focusNode, focusOffset };
+      return found ? rangeToSelectionRange(view, found) : null;
   }
   // Note that all referencing and parsing is done with the
@@ -37350,13 +37410,6 @@
               return;
           }
       }
-      // Chrome sometimes leaves the cursor before the inserted text when
-      // composing after a cursor wrapper. This moves it forward.
-      if (chrome && view.cursorWrapper && parse.sel && parse.sel.anchor == view.cursorWrapper.deco.from &&
-          parse.sel.head == parse.sel.anchor) {
-          let size = change.endB - change.start;
-          parse.sel = { anchor: parse.sel.anchor + size, head: parse.sel.anchor + size };
-      }
       view.input.domChangeCount++;
       // Handle the case where overwriting a selection by typing matches
       // the start or end of the selected content, creating a change
@@ -37402,7 +37455,7 @@
       }
       // Same for backspace
       if (view.state.selection.anchor > change.start &&
-          looksLikeJoin(doc, change.start, change.endA, $from, $to) &&
+          looksLikeBackspace(doc, change.start, change.endA, $from, $to) &&
           view.someProp("handleKeyDown", f => f(view, keyEvent(8, "Backspace")))) {
           if (android && chrome)
               view.domObserver.suppressSelectionUpdates(); // #820
@@ -37514,14 +37567,18 @@
       if (Fragment.from(updated).eq(cur))
           return { mark, type };
   }
-  function looksLikeJoin(old, start, end, $newStart, $newEnd) {
-      if (!$newStart.parent.isTextblock ||
-          // The content must have shrunk
-          end - start <= $newEnd.pos - $newStart.pos ||
+  function looksLikeBackspace(old, start, end, $newStart, $newEnd) {
+      if ( // The content must have shrunk
+      end - start <= $newEnd.pos - $newStart.pos ||
           // newEnd must point directly at or after the end of the block that newStart points into
           skipClosingAndOpening($newStart, true, false) < $newEnd.pos)
           return false;
       let $start = old.resolve(start);
+      // Handle the case where, rather than joining blocks, the change just removed an entire block
+      if (!$newStart.parent.isTextblock) {
+          let after = $start.nodeAfter;
+          return after != null && end == start + after.nodeSize;
+      }
       // Start must be at the end of a block
       if ($start.parentOffset < $start.parent.content.size || !$start.parent.isTextblock)
           return false;
@@ -37759,8 +37816,10 @@
                   // tracks that and forces a selection reset when our update
                   // did write to the node.
                   let chromeKludge = chrome ? (this.trackWrites = this.domSelectionRange().focusNode) : null;
+                  if (this.composing)
+                      this.input.compositionNode = findCompositionNode(this);
                   if (redraw || !this.docView.update(state.doc, outerDeco, innerDeco, this)) {
-                      this.docView.updateOuterDeco([]);
+                      this.docView.updateOuterDeco(outerDeco);
                       this.docView.destroy();
                       this.docView = docViewDesc(state.doc, outerDeco, innerDeco, this.dom, this);
                   }
@@ -38037,6 +38096,7 @@
           }
           this.docView.destroy();
           this.docView = null;
+          clearReusedRange();
       }
       /**
       This is true when the view has been
@@ -38072,8 +38132,9 @@
       @internal
       */
       domSelectionRange() {
-          return safari && this.root.nodeType === 11 && deepActiveElement(this.dom.ownerDocument) == this.dom
-              ? safariShadowSelectionRange(this) : this.domSelection();
+          let sel = this.domSelection();
+          return safari && this.root.nodeType === 11 &&
+              deepActiveElement(this.dom.ownerDocument) == this.dom && safariShadowSelectionRange(this, sel) || sel;
       }
       /**
       @internal
@@ -39737,6 +39798,23 @@
                   if (stored) {
                       return stored;
                   }
+                  // if InputRule is triggered by insertContent()
+                  const simulatedInputMeta = tr.getMeta('applyInputRules');
+                  const isSimulatedInput = !!simulatedInputMeta;
+                  if (isSimulatedInput) {
+                      setTimeout(() => {
+                          const { from, text } = simulatedInputMeta;
+                          const to = from + text.length;
+                          run$1$1({
+                              editor,
+                              from,
+                              to,
+                              text,
+                              rules,
+                              plugin,
+                          });
+                      });
+                  }
                   return tr.selectionSet || tr.docChanged ? null : prev;
               },
           },
@@ -39868,6 +39946,14 @@
       const success = handlers.every(handler => handler !== null);
       return success;
   }
+  const createClipboardPasteEvent = (text) => {
+      var _a;
+      const event = new ClipboardEvent('paste', {
+          clipboardData: new DataTransfer(),
+      });
+      (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.setData('text/html', text);
+      return event;
+  };
   /**
    * Create an paste rules plugin. When enabled, it will cause pasted
    * text that matches any of the given rules to trigger the rule’s
@@ -39880,6 +39966,28 @@
       let isDroppedFromProseMirror = false;
       let pasteEvent = typeof ClipboardEvent !== 'undefined' ? new ClipboardEvent('paste') : null;
       let dropEvent = typeof DragEvent !== 'undefined' ? new DragEvent('drop') : null;
+      const processEvent = ({ state, from, to, rule, pasteEvt, }) => {
+          const tr = state.tr;
+          const chainableState = createChainableState({
+              state,
+              transaction: tr,
+          });
+          const handler = run$2({
+              editor,
+              state: chainableState,
+              from: Math.max(from - 1, 0),
+              to: to.b - 1,
+              rule,
+              pasteEvent: pasteEvt,
+              dropEvent,
+          });
+          if (!handler || !tr.steps.length) {
+              return;
+          }
+          dropEvent = typeof DragEvent !== 'undefined' ? new DragEvent('drop') : null;
+          pasteEvent = typeof ClipboardEvent !== 'undefined' ? new ClipboardEvent('paste') : null;
+          return tr;
+      };
       const plugins = rules.map(rule => {
           return new Plugin({
               // we register a global drag handler to track the current drag source element
@@ -39917,38 +40025,39 @@
                   const transaction = transactions[0];
                   const isPaste = transaction.getMeta('uiEvent') === 'paste' && !isPastedFromProseMirror;
                   const isDrop = transaction.getMeta('uiEvent') === 'drop' && !isDroppedFromProseMirror;
-                  if (!isPaste && !isDrop) {
+                  // if PasteRule is triggered by insertContent()
+                  const simulatedPasteMeta = transaction.getMeta('applyPasteRules');
+                  const isSimulatedPaste = !!simulatedPasteMeta;
+                  if (!isPaste && !isDrop && !isSimulatedPaste) {
                       return;
                   }
-                  // stop if there is no changed range
+                  // Handle simulated paste
+                  if (isSimulatedPaste) {
+                      const { from, text } = simulatedPasteMeta;
+                      const to = from + text.length;
+                      const pasteEvt = createClipboardPasteEvent(text);
+                      return processEvent({
+                          rule,
+                          state,
+                          from,
+                          to: { b: to },
+                          pasteEvt,
+                      });
+                  }
+                  // handle actual paste/drop
                   const from = oldState.doc.content.findDiffStart(state.doc.content);
                   const to = oldState.doc.content.findDiffEnd(state.doc.content);
+                  // stop if there is no changed range
                   if (!isNumber$1(from) || !to || from === to.b) {
                       return;
                   }
-                  // build a chainable state
-                  // so we can use a single transaction for all paste rules
-                  const tr = state.tr;
-                  const chainableState = createChainableState({
-                      state,
-                      transaction: tr,
-                  });
-                  const handler = run$2({
-                      editor,
-                      state: chainableState,
-                      from: Math.max(from - 1, 0),
-                      to: to.b - 1,
+                  return processEvent({
                       rule,
-                      pasteEvent,
-                      dropEvent,
+                      state,
+                      from,
+                      to,
+                      pasteEvt: pasteEvent,
                   });
-                  // stop if there are no changes
-                  if (!handler || !tr.steps.length) {
-                      return;
-                  }
-                  dropEvent = typeof DragEvent !== 'undefined' ? new DragEvent('drop') : null;
-                  pasteEvent = typeof ClipboardEvent !== 'undefined' ? new ClipboardEvent('paste') : null;
-                  return tr;
               },
           });
       });
@@ -40292,8 +40401,10 @@
                       range,
                   });
               }
+              // do not descend into child nodes when there exists a serializer
+              return false;
           }
-          else if (node.isText) {
+          if (node.isText) {
               text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos); // eslint-disable-line
               separated = false;
           }
@@ -40313,6 +40424,11 @@
   const ClipboardTextSerializer = Extension.create({
       name: 'clipboardTextSerializer',
+      addOptions() {
+          return {
+              blockSeparator: undefined,
+          };
+      },
       addProseMirrorPlugins() {
           return [
               new Plugin({
@@ -40328,6 +40444,9 @@
                           const textSerializers = getTextSerializersFromSchema(schema);
                           const range = { from, to };
                           return getTextBetween(doc, range, {
+                              ...(this.options.blockSeparator !== undefined
+                                  ? { blockSeparator: this.options.blockSeparator }
+                                  : {}),
                               textSerializers,
                           });
                       },
@@ -40734,6 +40853,8 @@
           options = {
               parseOptions: {},
               updateSelection: true,
+              applyInputRules: false,
+              applyPasteRules: false,
               ...options,
           };
           const content = createNodeFromContent(value, editor.schema, {
@@ -40769,28 +40890,37 @@
                   to += 1;
               }
           }
+          let newContent;
           // if there is only plain text we have to use `insertText`
           // because this will keep the current marks
           if (isOnlyTextContent) {
               // if value is string, we can use it directly
               // otherwise if it is an array, we have to join it
               if (Array.isArray(value)) {
-                  tr.insertText(value.map(v => v.text || '').join(''), from, to);
+                  newContent = value.map(v => v.text || '').join('');
               }
               else if (typeof value === 'object' && !!value && !!value.text) {
-                  tr.insertText(value.text, from, to);
+                  newContent = value.text;
               }
               else {
-                  tr.insertText(value, from, to);
+                  newContent = value;
               }
+              tr.insertText(newContent, from, to);
           }
           else {
-              tr.replaceWith(from, to, content);
+              newContent = content;
+              tr.replaceWith(from, to, newContent);
           }
           // set cursor at end of inserted content
           if (options.updateSelection) {
               selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
           }
+          if (options.applyInputRules) {
+              tr.setMeta('applyInputRules', { from, text: newContent });
+          }
+          if (options.applyPasteRules) {
+              tr.setMeta('applyPasteRules', { from, text: newContent });
+          }
       }
       return true;
   };
@@ -42117,7 +42247,7 @@
                   const { selection, doc } = tr;
                   const { empty, $anchor } = selection;
                   const { pos, parent } = $anchor;
-                  const $parentPos = $anchor.parent.isTextblock ? tr.doc.resolve(pos - 1) : $anchor;
+                  const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
                   const parentIsIsolating = $parentPos.parent.type.spec.isolating;
                   const parentPos = $anchor.pos - $anchor.parentOffset;
                   const isAtStart = (parentIsIsolating && $parentPos.parent.childCount === 1)
@@ -42233,16 +42363,6 @@
       },
   });
-  var extensions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ClipboardTextSerializer: ClipboardTextSerializer,
-    Commands: Commands,
-    Editable: Editable,
-    FocusEvents: FocusEvents,
-    Keymap: Keymap,
-    Tabindex: Tabindex
-  });
   class NodePos {
       constructor(pos, editor, isBlock = false, node = null) {
           this.currentNode = null;
@@ -42337,7 +42457,7 @@
           const children = [];
           this.node.content.forEach((node, offset) => {
               const isBlock = node.isBlock && !node.isTextblock;
-              const targetPos = this.pos + offset + (isBlock ? 0 : 1);
+              const targetPos = this.pos + offset + 1;
               const $pos = this.resolvedPos.doc.resolve(targetPos);
               if (!isBlock && $pos.depth <= this.depth) {
                   return;
@@ -42386,7 +42506,7 @@
       querySelectorAll(selector, attributes = {}, firstItemOnly = false) {
           let nodes = [];
           // iterate through children recursively finding all nodes which match the selector with the node name
-          if (this.isBlock || !this.children || this.children.length === 0) {
+          if (!this.children || this.children.length === 0) {
               return nodes;
           }
           this.children.forEach(childPos => {
@@ -42523,6 +42643,7 @@ img.ProseMirror-separator {
               editable: true,
               editorProps: {},
               parseOptions: {},
+              coreExtensionOptions: {},
               enableInputRules: true,
               enablePasteRules: true,
               enableCoreExtensions: true,
@@ -42668,7 +42789,17 @@ img.ProseMirror-separator {
        * Creates an extension manager.
        */
       createExtensionManager() {
-          const coreExtensions = this.options.enableCoreExtensions ? Object.values(extensions) : [];
+          var _a, _b;
+          const coreExtensions = this.options.enableCoreExtensions ? [
+              Editable,
+              ClipboardTextSerializer.configure({
+                  blockSeparator: (_b = (_a = this.options.coreExtensionOptions) === null || _a === void 0 ? void 0 : _a.clipboardTextSerializer) === null || _b === void 0 ? void 0 : _b.blockSeparator,
+              }),
+              Commands,
+              FocusEvents,
+              Keymap,
+              Tabindex,
+          ] : [];
           const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
               return ['extension', 'node', 'mark'].includes(extension === null || extension === void 0 ? void 0 : extension.type);
           });
@@ -45272,7 +45403,7 @@ img.ProseMirror-separator {
   // Currently without astral characters support.
   function isPunctChar (ch) {
-    return P.test(ch)
+    return P.test(ch) || regex.test(ch)
   }
   // Markdown ASCII punctuation characters.
@@ -45461,7 +45592,6 @@ img.ProseMirror-separator {
     const result = {
       ok: false,
       pos: 0,
-      lines: 0,
       str: ''
     };
@@ -45532,52 +45662,66 @@ img.ProseMirror-separator {
   //
-  function parseLinkTitle (str, start, max) {
-    let code, marker;
-    let lines = 0;
+  // Parse link title within `str` in [start, max] range,
+  // or continue previous parsing if `prev_state` is defined (equal to result of last execution).
+  //
+  function parseLinkTitle (str, start, max, prev_state) {
+    let code;
     let pos = start;
-    const result = {
+    const state = {
+      // if `true`, this is a valid link title
       ok: false,
+      // if `true`, this link can be continued on the next line
+      can_continue: false,
+      // if `ok`, it's the position of the first character after the closing marker
       pos: 0,
-      lines: 0,
-      str: ''
+      // if `ok`, it's the unescaped title
+      str: '',
+      // expected closing marker character code
+      marker: 0
     };
-    if (pos >= max) { return result }
+    if (prev_state) {
+      // this is a continuation of a previous parseLinkTitle call on the next line,
+      // used in reference links only
+      state.str = prev_state.str;
+      state.marker = prev_state.marker;
+    } else {
+      if (pos >= max) { return state }
-    marker = str.charCodeAt(pos);
+      let marker = str.charCodeAt(pos);
+      if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return state }
-    if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return result }
+      start++;
+      pos++;
-    pos++;
+      // if opening marker is "(", switch it to closing marker ")"
+      if (marker === 0x28) { marker = 0x29; }
-    // if opening marker is "(", switch it to closing marker ")"
-    if (marker === 0x28) { marker = 0x29; }
+      state.marker = marker;
+    }
     while (pos < max) {
       code = str.charCodeAt(pos);
-      if (code === marker) {
-        result.pos = pos + 1;
-        result.lines = lines;
-        result.str = unescapeAll(str.slice(start + 1, pos));
-        result.ok = true;
-        return result
-      } else if (code === 0x28 /* ( */ && marker === 0x29 /* ) */) {
-        return result
-      } else if (code === 0x0A) {
-        lines++;
+      if (code === state.marker) {
+        state.pos = pos + 1;
+        state.str += unescapeAll(str.slice(start, pos));
+        state.ok = true;
+        return state
+      } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {
+        return state
       } else if (code === 0x5C /* \ */ && pos + 1 < max) {
         pos++;
-        if (str.charCodeAt(pos) === 0x0A) {
-          lines++;
-        }
       }
       pos++;
     }
-    return result
+    // no closing marker found, but this link title may continue on the next line (for references)
+    state.can_continue = true;
+    state.str += unescapeAll(str.slice(start, pos));
+    return state
   }
   // Just a shortcut for bulk export
@@ -45727,7 +45871,7 @@ img.ProseMirror-separator {
      * }
      * ```
      *
-     * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
+     * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
      * for more details and examples.
      **/
     this.rules = assign$2({}, default_rules);
@@ -47240,6 +47384,14 @@ img.ProseMirror-separator {
   // GFM table, https://github.github.com/gfm/#tables-extension-
+  // Limit the amount of empty autocompleted cells in a table,
+  // see https://github.com/markdown-it/markdown-it/issues/1000,
+  //
+  // Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.
+  // We set it to 65k, which can expand user input by a factor of x370
+  // (256x256 square is 1.8kB expanded into 650kB).
+  const MAX_AUTOCOMPLETED_CELLS = 0x10000;
   function getLine (state, line) {
     const pos = state.bMarks[line] + state.tShift[line];
     const max = state.eMarks[line];
@@ -47395,6 +47547,7 @@ img.ProseMirror-separator {
     state.push('thead_close', 'thead', -1);
     let tbodyLines;
+    let autocompletedCells = 0;
     for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
       if (state.sCount[nextLine] < state.blkIndent) { break }
@@ -47415,6 +47568,11 @@ img.ProseMirror-separator {
       if (columns.length && columns[0] === '') columns.shift();
       if (columns.length && columns[columns.length - 1] === '') columns.pop();
+      // note: autocomplete count can be negative if user specifies more columns than header,
+      // but that does not affect intended use (which is limiting expansion)
+      autocompletedCells += columnCount - columns.length;
+      if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) { break }
       if (nextLine === startLine + 2) {
         const token_tbo = state.push('tbody_open', 'tbody', 1);
         token_tbo.map = tbodyLines = [startLine + 2, 0];
@@ -48158,8 +48316,6 @@ img.ProseMirror-separator {
   }
   function reference (state, startLine, _endLine, silent) {
-    let lines = 0;
     let pos = state.bMarks[startLine] + state.tShift[startLine];
     let max = state.eMarks[startLine];
     let nextLine = startLine + 1;
@@ -48169,45 +48325,53 @@ img.ProseMirror-separator {
     if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
-    // Simple check to quickly interrupt scan on [link](url) at the start of line.
-    // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54
-    while (++pos < max) {
-      if (state.src.charCodeAt(pos) === 0x5D /* ] */ &&
-          state.src.charCodeAt(pos - 1) !== 0x5C/* \ */) {
-        if (pos + 1 === max) { return false }
-        if (state.src.charCodeAt(pos + 1) !== 0x3A/* : */) { return false }
-        break
-      }
-    }
-    const endLine = state.lineMax;
+    function getNextLine (nextLine) {
+      const endLine = state.lineMax;
-    // jump line-by-line until empty one or EOF
-    const terminatorRules = state.md.block.ruler.getRules('reference');
+      if (nextLine >= endLine || state.isEmpty(nextLine)) {
+        // empty line or end of input
+        return null
+      }
-    const oldParentType = state.parentType;
-    state.parentType = 'reference';
+      let isContinuation = false;
-    for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
       // this would be a code block normally, but after paragraph
       // it's considered a lazy continuation regardless of what's there
-      if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
+      if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true; }
       // quirk for blockquotes, this line should already be checked by that rule
-      if (state.sCount[nextLine] < 0) { continue }
+      if (state.sCount[nextLine] < 0) { isContinuation = true; }
+      if (!isContinuation) {
+        const terminatorRules = state.md.block.ruler.getRules('reference');
+        const oldParentType = state.parentType;
+        state.parentType = 'reference';
+        // Some tags can terminate paragraph without empty line.
+        let terminate = false;
+        for (let i = 0, l = terminatorRules.length; i < l; i++) {
+          if (terminatorRules[i](state, nextLine, endLine, true)) {
+            terminate = true;
+            break
+          }
+        }
-      // Some tags can terminate paragraph without empty line.
-      let terminate = false;
-      for (let i = 0, l = terminatorRules.length; i < l; i++) {
-        if (terminatorRules[i](state, nextLine, endLine, true)) {
-          terminate = true;
-          break
+        state.parentType = oldParentType;
+        if (terminate) {
+          // terminated by another block
+          return null
         }
       }
-      if (terminate) { break }
+      const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+      const max = state.eMarks[nextLine];
+      // max + 1 explicitly includes the newline
+      return state.src.slice(pos, max + 1)
     }
-    const str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
+    let str = state.src.slice(pos, max + 1);
     max = str.length;
     let labelEnd = -1;
@@ -48219,11 +48383,21 @@ img.ProseMirror-separator {
         labelEnd = pos;
         break
       } else if (ch === 0x0A /* \n */) {
-        lines++;
+        const lineContent = getNextLine(nextLine);
+        if (lineContent !== null) {
+          str += lineContent;
+          max = str.length;
+          nextLine++;
+        }
       } else if (ch === 0x5C /* \ */) {
         pos++;
         if (pos < max && str.charCodeAt(pos) === 0x0A) {
-          lines++;
+          const lineContent = getNextLine(nextLine);
+          if (lineContent !== null) {
+            str += lineContent;
+            max = str.length;
+            nextLine++;
+          }
         }
       }
     }
@@ -48235,7 +48409,12 @@ img.ProseMirror-separator {
     for (pos = labelEnd + 2; pos < max; pos++) {
       const ch = str.charCodeAt(pos);
       if (ch === 0x0A) {
-        lines++;
+        const lineContent = getNextLine(nextLine);
+        if (lineContent !== null) {
+          str += lineContent;
+          max = str.length;
+          nextLine++;
+        }
       } else if (isSpace(ch)) ; else {
         break
       }
@@ -48250,11 +48429,10 @@ img.ProseMirror-separator {
     if (!state.md.validateLink(href)) { return false }
     pos = destRes.pos;
-    lines += destRes.lines;
     // save cursor state, we could require to rollback later
     const destEndPos = pos;
-    const destEndLineNo = lines;
+    const destEndLineNo = nextLine;
     // [label]:   destination   'title'
     //                       ^^^ skipping those spaces
@@ -48262,7 +48440,12 @@ img.ProseMirror-separator {
     for (; pos < max; pos++) {
       const ch = str.charCodeAt(pos);
       if (ch === 0x0A) {
-        lines++;
+        const lineContent = getNextLine(nextLine);
+        if (lineContent !== null) {
+          str += lineContent;
+          max = str.length;
+          nextLine++;
+        }
       } else if (isSpace(ch)) ; else {
         break
       }
@@ -48270,17 +48453,25 @@ img.ProseMirror-separator {
     // [label]:   destination   'title'
     //                          ^^^^^^^ parse this
-    const titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
+    let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
+    while (titleRes.can_continue) {
+      const lineContent = getNextLine(nextLine);
+      if (lineContent === null) break
+      str += lineContent;
+      pos = max;
+      max = str.length;
+      nextLine++;
+      titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
+    }
     let title;
     if (pos < max && start !== pos && titleRes.ok) {
       title = titleRes.str;
       pos = titleRes.pos;
-      lines += titleRes.lines;
     } else {
       title = '';
       pos = destEndPos;
-      lines = destEndLineNo;
+      nextLine = destEndLineNo;
     }
     // skip trailing spaces until the rest of the line
@@ -48296,7 +48487,7 @@ img.ProseMirror-separator {
         // but it could still be a valid reference if we roll back
         title = '';
         pos = destEndPos;
-        lines = destEndLineNo;
+        nextLine = destEndLineNo;
         while (pos < max) {
           const ch = str.charCodeAt(pos);
           if (!isSpace(ch)) { break }
@@ -48327,9 +48518,7 @@ img.ProseMirror-separator {
       state.env.references[label] = { title, href };
     }
-    state.parentType = oldParentType;
-    state.line = startLine + lines + 1;
+    state.line = nextLine;
     return true
   }
@@ -48386,8 +48575,8 @@ img.ProseMirror-separator {
     'option',
     'p',
     'param',
+    'search',
     'section',
-    'source',
     'summary',
     'table',
     'tbody',
@@ -48416,9 +48605,9 @@ img.ProseMirror-separator {
   const open_tag    = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
   const close_tag   = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
-  const comment     = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
+  const comment     = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
   const processing  = '<[?][\\s\\S]*?[?]>';
-  const declaration = '<![A-Z]+\\s+[^>]*>';
+  const declaration = '<![A-Za-z][^>]*>';
   const cdata       = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
   const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
@@ -48879,9 +49068,6 @@ img.ProseMirror-separator {
   //  - canSplitWord - determine if these markers can be found inside a word
   //
   StateInline.prototype.scanDelims = function (start, canSplitWord) {
-    let can_open, can_close;
-    let left_flanking = true;
-    let right_flanking = true;
     const max = this.posMax;
     const marker = this.src.charCodeAt(start);
@@ -48902,29 +49088,13 @@ img.ProseMirror-separator {
     const isLastWhiteSpace = isWhiteSpace(lastChar);
     const isNextWhiteSpace = isWhiteSpace(nextChar);
-    if (isNextWhiteSpace) {
-      left_flanking = false;
-    } else if (isNextPunctChar) {
-      if (!(isLastWhiteSpace || isLastPunctChar)) {
-        left_flanking = false;
-      }
-    }
-    if (isLastWhiteSpace) {
-      right_flanking = false;
-    } else if (isLastPunctChar) {
-      if (!(isNextWhiteSpace || isNextPunctChar)) {
-        right_flanking = false;
-      }
-    }
+    const left_flanking =
+      !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
+    const right_flanking =
+      !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
-    if (!canSplitWord) {
-      can_open  = left_flanking  && (!right_flanking || isLastPunctChar);
-      can_close = right_flanking && (!left_flanking  || isNextPunctChar);
-    } else {
-      can_open  = left_flanking;
-      can_close = right_flanking;
-    }
+    const can_open  = left_flanking  && (canSplitWord || !right_flanking || isLastPunctChar);
+    const can_close = right_flanking && (canSplitWord || !left_flanking  || isNextPunctChar);
     return { can_open, can_close, length: count }
   };
@@ -48992,7 +49162,7 @@ img.ProseMirror-separator {
   // Alternative implementation, for memory.
   //
   // It costs 10% of performance, but allows extend terminators list, if place it
-  // to `ParcerInline` property. Probably, will switch to it sometime, such
+  // to `ParserInline` property. Probably, will switch to it sometime, such
   // flexibility required.
   /*
@@ -51916,12 +52086,12 @@ img.ProseMirror-separator {
    * MarkdownIt provides named presets as a convenience to quickly
    * enable/disable active syntax rules and options for common use cases.
    *
-   * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
+   * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -
    *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
-   * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
+   * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -
    *   similar to GFM, used when no preset name given. Enables all available rules,
    *   but still without html, typographer & autolinker.
-   * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
+   * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -
    *   all rules disabled. Useful to quickly setup your config via `.enable()`.
    *   For example, when you need only `bold` and `italic` markup and nothing else.
    *
@@ -51938,7 +52108,7 @@ img.ProseMirror-separator {
    *   Can be useful for external highlighters.
    * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
    * - __typographer__  - `false`. Set `true` to enable [some language-neutral
-   *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
+   *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +
    *   quotes beautification (smartquotes).
    * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
    *   pairs, when typographer enabled and smartquotes on. For example, you can
@@ -52064,7 +52234,7 @@ img.ProseMirror-separator {
      * md.renderer.rules['my_token'] = myToken
      * ```
      *
-     * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
+     * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
      **/
     this.renderer = new Renderer();
@@ -52072,7 +52242,7 @@ img.ProseMirror-separator {
      * MarkdownIt#linkify -> LinkifyIt
      *
      * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
-     * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
+     * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)
      * rule.
      **/
     this.linkify = new LinkifyIt();
@@ -53811,10 +53981,10 @@ img.ProseMirror-separator {
       observable
   ], RichText.prototype, "configuration", void 0);
-  const starInputRegex$1 = /(?:^|\s)((?:\*\*)((?:[^*]+))(?:\*\*))$/;
-  const starPasteRegex$1 = /(?:^|\s)((?:\*\*)((?:[^*]+))(?:\*\*))/g;
-  const underscoreInputRegex$1 = /(?:^|\s)((?:__)((?:[^__]+))(?:__))$/;
-  const underscorePasteRegex$1 = /(?:^|\s)((?:__)((?:[^__]+))(?:__))/g;
+  const starInputRegex$1 = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
+  const starPasteRegex$1 = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
+  const underscoreInputRegex$1 = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
+  const underscorePasteRegex$1 = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
   const Bold = Mark.create({
       name: 'bold',
       addOptions() {
@@ -54542,16 +54712,16 @@ img.ProseMirror-separator {
   }
   // Apply the latest event from one branch to the document and shift the event
   // onto the other branch.
-  function histTransaction(history, state, dispatch, redo) {
+  function histTransaction(history, state, redo) {
       let preserveItems = mustPreserveItems(state);
       let histOptions = historyKey.get(state).spec.config;
       let pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);
       if (!pop)
-          return;
+          return null;
       let selection = pop.selection.resolve(pop.transform.doc);
       let added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
       let newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);
-      dispatch(pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist }).scrollIntoView());
+      return pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist });
   }
   let cachedPreserveItems = false, cachedPreserveItemsPlugins = null;
   // Check whether any plugin in the given state has a
@@ -54610,28 +54780,27 @@ img.ProseMirror-separator {
           }
       });
   }
+  function buildCommand(redo, scroll) {
+      return (state, dispatch) => {
+          let hist = historyKey.getState(state);
+          if (!hist || (redo ? hist.undone : hist.done).eventCount == 0)
+              return false;
+          if (dispatch) {
+              let tr = histTransaction(hist, state, redo);
+              if (tr)
+                  dispatch(scroll ? tr.scrollIntoView() : tr);
+          }
+          return true;
+      };
+  }
   /**
   A command function that undoes the last change, if any.
   */
-  const undo = (state, dispatch) => {
-      let hist = historyKey.getState(state);
-      if (!hist || hist.done.eventCount == 0)
-          return false;
-      if (dispatch)
-          histTransaction(hist, state, dispatch, false);
-      return true;
-  };
+  const undo = buildCommand(false, true);
   /**
   A command function that redoes the last undone change, if any.
   */
-  const redo = (state, dispatch) => {
-      let hist = historyKey.getState(state);
-      if (!hist || hist.undone.eventCount == 0)
-          return false;
-      if (dispatch)
-          histTransaction(hist, state, dispatch, true);
-      return true;
-  };
+  const redo = buildCommand(true, true);
   const History = Extension.create({
       name: 'history',
@@ -54668,10 +54837,10 @@ img.ProseMirror-separator {
       },
   });
-  const starInputRegex = /(?:^|\s)((?:\*)((?:[^*]+))(?:\*))$/;
-  const starPasteRegex = /(?:^|\s)((?:\*)((?:[^*]+))(?:\*))/g;
-  const underscoreInputRegex = /(?:^|\s)((?:_)((?:[^_]+))(?:_))$/;
-  const underscorePasteRegex = /(?:^|\s)((?:_)((?:[^_]+))(?:_))/g;
+  const starInputRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/;
+  const starPasteRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g;
+  const underscoreInputRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/;
+  const underscorePasteRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g;
   const Italic = Mark.create({
       name: 'italic',
       addOptions() {
@@ -56487,6 +56656,25 @@ img.ProseMirror-separator {
     return filtered;
   }
+  /**
+   * Check if the provided tokens form a valid link structure, which can either be a single link token
+   * or a link token surrounded by parentheses or square brackets.
+   *
+   * This ensures that only complete and valid text is hyperlinked, preventing cases where a valid
+   * top-level domain (TLD) is immediately followed by an invalid character, like a number. For
+   * example, with the `find` method from Linkify, entering `example.com1` would result in
+   * `example.com` being linked and the trailing `1` left as plain text. By using the `tokenize`
+   * method, we can perform more comprehensive validation on the input text.
+   */
+  function isValidLinkStructure(tokens) {
+      if (tokens.length === 1) {
+          return tokens[0].isLink;
+      }
+      if (tokens.length === 3 && tokens[1].isLink) {
+          return ['()', '[]'].includes(tokens[0].value + tokens[2].value);
+      }
+      return false;
+  }
   function autolink(options) {
       return new Plugin({
           key: new PluginKey('autolink'),
@@ -56525,7 +56713,11 @@ img.ProseMirror-separator {
                       if (!lastWordBeforeSpace) {
                           return false;
                       }
-                      find$1(lastWordBeforeSpace)
+                      const linksBeforeSpace = tokenize(lastWordBeforeSpace).map(t => t.toObject());
+                      if (!isValidLinkStructure(linksBeforeSpace)) {
+                          return false;
+                      }
+                      linksBeforeSpace
                           .filter(link => link.isLink)
                           // Calculate link position.
                           .map(link => ({
@@ -56572,6 +56764,9 @@ img.ProseMirror-separator {
           props: {
               handleClick: (view, pos, event) => {
                   var _a, _b;
+                  if (options.whenNotEditable && view.editable) {
+                      return false;
+                  }
                   if (event.button !== 0) {
                       return false;
                   }
@@ -56746,6 +56941,7 @@ img.ProseMirror-separator {
           if (this.options.openOnClick) {
               plugins.push(clickHandler({
                   type: this.type,
+                  whenNotEditable: this.options.openOnClick === 'whenNotEditable',
               }));
           }
           if (this.options.linkOnPaste) {
@@ -57121,7 +57317,7 @@ img.ProseMirror-separator {
                           text: state.text,
                           items: [],
                           command: commandProps => {
-                              command({
+                              return command({
                                   editor,
                                   range: state.range,
                                   props: commandProps,
@@ -57275,11 +57471,12 @@ img.ProseMirror-separator {
                   var _a;
                   return `${options.suggestion.char}${(_a = node.attrs.label) !== null && _a !== void 0 ? _a : node.attrs.id}`;
               },
+              deleteTriggerWithBackspace: false,
               renderHTML({ options, node }) {
                   var _a;
                   return [
                       'span',
-                      this.HTMLAttributes,
+                      mergeAttributes(this.HTMLAttributes, options.HTMLAttributes),
                       `${options.suggestion.char}${(_a = node.attrs.label) !== null && _a !== void 0 ? _a : node.attrs.id}`,
                   ];
               },
@@ -57371,8 +57568,10 @@ img.ProseMirror-separator {
                   }),
               ];
           }
+          const mergedOptions = { ...this.options };
+          mergedOptions.HTMLAttributes = mergeAttributes({ 'data-type': this.name }, this.options.HTMLAttributes, HTMLAttributes);
           const html = this.options.renderHTML({
-              options: this.options,
+              options: mergedOptions,
               node,
           });
           if (typeof html === 'string') {
@@ -57409,7 +57608,7 @@ img.ProseMirror-separator {
                   state.doc.nodesBetween(anchor - 1, anchor, (node, pos) => {
                       if (node.type.name === this.name) {
                           isMention = true;
-                          tr.insertText(this.options.suggestion.char || '', pos, pos + node.nodeSize);
+                          tr.insertText(this.options.deleteTriggerWithBackspace ? '' : this.options.suggestion.char || '', pos, pos + node.nodeSize);
                           return false;
                       }
                   });
@@ -60012,6 +60211,31 @@ img.ProseMirror-separator {
      *
      * @license MIT
      */
+  // type Person = {
+  //   firstName: string
+  //   lastName: string
+  //   age: number
+  //   visits: number
+  //   status: string
+  //   progress: number
+  //   createdAt: Date
+  //   nested: {
+  //     foo: [
+  //       {
+  //         bar: 'bar'
+  //       }
+  //     ]
+  //     bar: { subBar: boolean }[]
+  //     baz: {
+  //       foo: 'foo'
+  //       bar: {
+  //         baz: 'baz'
+  //       }
+  //     }
+  //   }
+  // }
   // Is this type a tuple?
   // If this type is a tuple, what indices are allowed?
@@ -60099,6 +60323,32 @@ img.ProseMirror-separator {
     };
   }
+  function createCell(table, row, column, columnId) {
+    const getRenderValue = () => {
+      var _cell$getValue;
+      return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue;
+    };
+    const cell = {
+      id: `${row.id}_${column.id}`,
+      row,
+      column,
+      getValue: () => row.getValue(columnId),
+      renderValue: getRenderValue,
+      getContext: memo$1(() => [table, column, row, cell], (table, column, row, cell) => ({
+        table,
+        column,
+        row,
+        cell: cell,
+        getValue: cell.getValue,
+        renderValue: cell.renderValue
+      }), getMemoOptions(table.options, 'debugCells', 'cell.getContext'))
+    };
+    table._features.forEach(feature => {
+      feature.createCell == null || feature.createCell(cell, column, row, table);
+    }, {});
+    return cell;
+  }
   function createColumn(table, columnDef, depth, parent) {
     var _ref, _resolvedColumnDef$id;
     const defaultColumn = table._getDefaultColumnDef();
@@ -60158,7 +60408,7 @@ img.ProseMirror-separator {
       feature.createColumn == null || feature.createColumn(column, table);
     }
-    // Yes, we have to convert table to uknown, because we know more than the compiler here.
+    // Yes, we have to convert table to unknown, because we know more than the compiler here.
     return column;
   }
@@ -60415,98 +60665,809 @@ img.ProseMirror-separator {
     return headerGroups;
   }
-  //
+  const createRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
+    let row = {
+      id,
+      index: rowIndex,
+      original,
+      depth,
+      parentId,
+      _valuesCache: {},
+      _uniqueValuesCache: {},
+      getValue: columnId => {
+        if (row._valuesCache.hasOwnProperty(columnId)) {
+          return row._valuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.accessorFn)) {
+          return undefined;
+        }
+        row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex);
+        return row._valuesCache[columnId];
+      },
+      getUniqueValues: columnId => {
+        if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
+          return row._uniqueValuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.accessorFn)) {
+          return undefined;
+        }
+        if (!column.columnDef.getUniqueValues) {
+          row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
+          return row._uniqueValuesCache[columnId];
+        }
+        row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex);
+        return row._uniqueValuesCache[columnId];
+      },
+      renderValue: columnId => {
+        var _row$getValue;
+        return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
+      },
+      subRows: subRows != null ? subRows : [],
+      getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
+      getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : undefined,
+      getParentRows: () => {
+        let parentRows = [];
+        let currentRow = row;
+        while (true) {
+          const parentRow = currentRow.getParentRow();
+          if (!parentRow) break;
+          parentRows.push(parentRow);
+          currentRow = parentRow;
+        }
+        return parentRows.reverse();
+      },
+      getAllCells: memo$1(() => [table.getAllLeafColumns()], leafColumns => {
+        return leafColumns.map(column => {
+          return createCell(table, row, column, column.id);
+        });
+      }, getMemoOptions(table.options, 'debugRows', 'getAllCells')),
+      _getAllCellsByColumnId: memo$1(() => [row.getAllCells()], allCells => {
+        return allCells.reduce((acc, cell) => {
+          acc[cell.column.id] = cell;
+          return acc;
+        }, {});
+      }, getMemoOptions(table.options, 'debugRows', 'getAllCellsByColumnId'))
+    };
+    for (let i = 0; i < table._features.length; i++) {
+      const feature = table._features[i];
+      feature == null || feature.createRow == null || feature.createRow(row, table);
+    }
+    return row;
+  };
   //
-  const defaultColumnSizing = {
-    size: 150,
-    minSize: 20,
-    maxSize: Number.MAX_SAFE_INTEGER
+  const ColumnFaceting = {
+    createColumn: (column, table) => {
+      column._getFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id);
+      column.getFacetedRowModel = () => {
+        if (!column._getFacetedRowModel) {
+          return table.getPreFilteredRowModel();
+        }
+        return column._getFacetedRowModel();
+      };
+      column._getFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id);
+      column.getFacetedUniqueValues = () => {
+        if (!column._getFacetedUniqueValues) {
+          return new Map();
+        }
+        return column._getFacetedUniqueValues();
+      };
+      column._getFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id);
+      column.getFacetedMinMaxValues = () => {
+        if (!column._getFacetedMinMaxValues) {
+          return undefined;
+        }
+        return column._getFacetedMinMaxValues();
+      };
+    }
   };
-  const getDefaultColumnSizingInfoState = () => ({
-    startOffset: null,
-    startSize: null,
-    deltaOffset: null,
-    deltaPercentage: null,
-    isResizingColumn: false,
-    columnSizingStart: []
-  });
-  const ColumnSizing = {
+  const includesString = (row, columnId, filterValue) => {
+    var _row$getValue;
+    const search = filterValue.toLowerCase();
+    return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search));
+  };
+  includesString.autoRemove = val => testFalsey(val);
+  const includesStringSensitive = (row, columnId, filterValue) => {
+    var _row$getValue2;
+    return Boolean((_row$getValue2 = row.getValue(columnId)) == null || (_row$getValue2 = _row$getValue2.toString()) == null ? void 0 : _row$getValue2.includes(filterValue));
+  };
+  includesStringSensitive.autoRemove = val => testFalsey(val);
+  const equalsString = (row, columnId, filterValue) => {
+    var _row$getValue3;
+    return ((_row$getValue3 = row.getValue(columnId)) == null || (_row$getValue3 = _row$getValue3.toString()) == null ? void 0 : _row$getValue3.toLowerCase()) === (filterValue == null ? void 0 : filterValue.toLowerCase());
+  };
+  equalsString.autoRemove = val => testFalsey(val);
+  const arrIncludes = (row, columnId, filterValue) => {
+    var _row$getValue4;
+    return (_row$getValue4 = row.getValue(columnId)) == null ? void 0 : _row$getValue4.includes(filterValue);
+  };
+  arrIncludes.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const arrIncludesAll = (row, columnId, filterValue) => {
+    return !filterValue.some(val => {
+      var _row$getValue5;
+      return !((_row$getValue5 = row.getValue(columnId)) != null && _row$getValue5.includes(val));
+    });
+  };
+  arrIncludesAll.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const arrIncludesSome = (row, columnId, filterValue) => {
+    return filterValue.some(val => {
+      var _row$getValue6;
+      return (_row$getValue6 = row.getValue(columnId)) == null ? void 0 : _row$getValue6.includes(val);
+    });
+  };
+  arrIncludesSome.autoRemove = val => testFalsey(val) || !(val != null && val.length);
+  const equals = (row, columnId, filterValue) => {
+    return row.getValue(columnId) === filterValue;
+  };
+  equals.autoRemove = val => testFalsey(val);
+  const weakEquals = (row, columnId, filterValue) => {
+    return row.getValue(columnId) == filterValue;
+  };
+  weakEquals.autoRemove = val => testFalsey(val);
+  const inNumberRange = (row, columnId, filterValue) => {
+    let [min, max] = filterValue;
+    const rowValue = row.getValue(columnId);
+    return rowValue >= min && rowValue <= max;
+  };
+  inNumberRange.resolveFilterValue = val => {
+    let [unsafeMin, unsafeMax] = val;
+    let parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
+    let parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
+    let min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
+    let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
+    if (min > max) {
+      const temp = min;
+      min = max;
+      max = temp;
+    }
+    return [min, max];
+  };
+  inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
+  // Export
+  const filterFns = {
+    includesString,
+    includesStringSensitive,
+    equalsString,
+    arrIncludes,
+    arrIncludesAll,
+    arrIncludesSome,
+    equals,
+    weakEquals,
+    inNumberRange
+  };
+  // Utils
+  function testFalsey(val) {
+    return val === undefined || val === null || val === '';
+  }
+  //
+  const ColumnFiltering = {
     getDefaultColumnDef: () => {
-      return defaultColumnSizing;
+      return {
+        filterFn: 'auto'
+      };
     },
     getInitialState: state => {
       return {
-        columnSizing: {},
-        columnSizingInfo: getDefaultColumnSizingInfoState(),
+        columnFilters: [],
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        columnResizeMode: 'onEnd',
-        columnResizeDirection: 'ltr',
-        onColumnSizingChange: makeStateUpdater('columnSizing', table),
-        onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table)
+        onColumnFiltersChange: makeStateUpdater('columnFilters', table),
+        filterFromLeafRows: false,
+        maxLeafRowFilterDepth: 100
       };
     },
     createColumn: (column, table) => {
-      column.getSize = () => {
-        var _column$columnDef$min, _ref, _column$columnDef$max;
-        const columnSize = table.getState().columnSizing[column.id];
-        return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize);
-      };
-      column.getStart = memo$1(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(0, column.getIndex(position)).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getStart'));
-      column.getAfter = memo$1(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(column.getIndex(position) + 1).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getAfter'));
-      column.resetSize = () => {
-        table.setColumnSizing(_ref2 => {
-          let {
-            [column.id]: _,
-            ...rest
-          } = _ref2;
-          return rest;
-        });
+      column.getAutoFilterFn = () => {
+        const firstRow = table.getCoreRowModel().flatRows[0];
+        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
+        if (typeof value === 'string') {
+          return filterFns.includesString;
+        }
+        if (typeof value === 'number') {
+          return filterFns.inNumberRange;
+        }
+        if (typeof value === 'boolean') {
+          return filterFns.equals;
+        }
+        if (value !== null && typeof value === 'object') {
+          return filterFns.equals;
+        }
+        if (Array.isArray(value)) {
+          return filterFns.arrIncludes;
+        }
+        return filterFns.weakEquals;
       };
-      column.getCanResize = () => {
-        var _column$columnDef$ena, _table$options$enable;
-        return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true);
+      column.getFilterFn = () => {
+        var _table$options$filter, _table$options$filter2;
+        return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : // @ts-ignore
+        (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn];
       };
-      column.getIsResizing = () => {
-        return table.getState().columnSizingInfo.isResizingColumn === column.id;
+      column.getCanFilter = () => {
+        var _column$columnDef$ena, _table$options$enable, _table$options$enable2;
+        return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn;
       };
-    },
-    createHeader: (header, table) => {
-      header.getSize = () => {
-        let sum = 0;
-        const recurse = header => {
-          if (header.subHeaders.length) {
-            header.subHeaders.forEach(recurse);
-          } else {
-            var _header$column$getSiz;
-            sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
-          }
-        };
-        recurse(header);
-        return sum;
+      column.getIsFiltered = () => column.getFilterIndex() > -1;
+      column.getFilterValue = () => {
+        var _table$getState$colum;
+        return (_table$getState$colum = table.getState().columnFilters) == null || (_table$getState$colum = _table$getState$colum.find(d => d.id === column.id)) == null ? void 0 : _table$getState$colum.value;
       };
-      header.getStart = () => {
-        if (header.index > 0) {
-          const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
-          return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
-        }
-        return 0;
+      column.getFilterIndex = () => {
+        var _table$getState$colum2, _table$getState$colum3;
+        return (_table$getState$colum2 = (_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex(d => d.id === column.id)) != null ? _table$getState$colum2 : -1;
       };
-      header.getResizeHandler = _contextDocument => {
-        const column = table.getColumn(header.column.id);
-        const canResize = column == null ? void 0 : column.getCanResize();
-        return e => {
-          if (!column || !canResize) {
-            return;
-          }
-          e.persist == null || e.persist();
-          if (isTouchStartEvent(e)) {
-            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
+      column.setFilterValue = value => {
+        table.setColumnFilters(old => {
+          const filterFn = column.getFilterFn();
+          const previousFilter = old == null ? void 0 : old.find(d => d.id === column.id);
+          const newFilter = functionalUpdate(value, previousFilter ? previousFilter.value : undefined);
+          //
+          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
+            var _old$filter;
+            return (_old$filter = old == null ? void 0 : old.filter(d => d.id !== column.id)) != null ? _old$filter : [];
+          }
+          const newFilterObj = {
+            id: column.id,
+            value: newFilter
+          };
+          if (previousFilter) {
+            var _old$map;
+            return (_old$map = old == null ? void 0 : old.map(d => {
+              if (d.id === column.id) {
+                return newFilterObj;
+              }
+              return d;
+            })) != null ? _old$map : [];
+          }
+          if (old != null && old.length) {
+            return [...old, newFilterObj];
+          }
+          return [newFilterObj];
+        });
+      };
+    },
+    createRow: (row, _table) => {
+      row.columnFilters = {};
+      row.columnFiltersMeta = {};
+    },
+    createTable: table => {
+      table.setColumnFilters = updater => {
+        const leafColumns = table.getAllLeafColumns();
+        const updateFn = old => {
+          var _functionalUpdate;
+          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(filter => {
+            const column = leafColumns.find(d => d.id === filter.id);
+            if (column) {
+              const filterFn = column.getFilterFn();
+              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
+                return false;
+              }
+            }
+            return true;
+          });
+        };
+        table.options.onColumnFiltersChange == null || table.options.onColumnFiltersChange(updateFn);
+      };
+      table.resetColumnFilters = defaultState => {
+        var _table$initialState$c, _table$initialState;
+        table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []);
+      };
+      table.getPreFilteredRowModel = () => table.getCoreRowModel();
+      table.getFilteredRowModel = () => {
+        if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
+          table._getFilteredRowModel = table.options.getFilteredRowModel(table);
+        }
+        if (table.options.manualFiltering || !table._getFilteredRowModel) {
+          return table.getPreFilteredRowModel();
+        }
+        return table._getFilteredRowModel();
+      };
+    }
+  };
+  function shouldAutoRemoveFilter(filterFn, value, column) {
+    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
+  }
+  const sum = (columnId, _leafRows, childRows) => {
+    // It's faster to just add the aggregations together instead of
+    // process leaf nodes individually
+    return childRows.reduce((sum, next) => {
+      const nextValue = next.getValue(columnId);
+      return sum + (typeof nextValue === 'number' ? nextValue : 0);
+    }, 0);
+  };
+  const min = (columnId, _leafRows, childRows) => {
+    let min;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null && (min > value || min === undefined && value >= value)) {
+        min = value;
+      }
+    });
+    return min;
+  };
+  const max = (columnId, _leafRows, childRows) => {
+    let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null && (max < value || max === undefined && value >= value)) {
+        max = value;
+      }
+    });
+    return max;
+  };
+  const extent = (columnId, _leafRows, childRows) => {
+    let min;
+    let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
+      if (value != null) {
+        if (min === undefined) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    });
+    return [min, max];
+  };
+  const mean = (columnId, leafRows) => {
+    let count = 0;
+    let sum = 0;
+    leafRows.forEach(row => {
+      let value = row.getValue(columnId);
+      if (value != null && (value = +value) >= value) {
+        ++count, sum += value;
+      }
+    });
+    if (count) return sum / count;
+    return;
+  };
+  const median = (columnId, leafRows) => {
+    if (!leafRows.length) {
+      return;
+    }
+    const values = leafRows.map(row => row.getValue(columnId));
+    if (!isNumberArray$1(values)) {
+      return;
+    }
+    if (values.length === 1) {
+      return values[0];
+    }
+    const mid = Math.floor(values.length / 2);
+    const nums = values.sort((a, b) => a - b);
+    return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+  };
+  const unique = (columnId, leafRows) => {
+    return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values());
+  };
+  const uniqueCount = (columnId, leafRows) => {
+    return new Set(leafRows.map(d => d.getValue(columnId))).size;
+  };
+  const count = (_columnId, leafRows) => {
+    return leafRows.length;
+  };
+  const aggregationFns = {
+    sum,
+    min,
+    max,
+    extent,
+    mean,
+    median,
+    unique,
+    uniqueCount,
+    count
+  };
+  //
+  const ColumnGrouping = {
+    getDefaultColumnDef: () => {
+      return {
+        aggregatedCell: props => {
+          var _toString, _props$getValue;
+          return (_toString = (_props$getValue = props.getValue()) == null || _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null;
+        },
+        aggregationFn: 'auto'
+      };
+    },
+    getInitialState: state => {
+      return {
+        grouping: [],
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onGroupingChange: makeStateUpdater('grouping', table),
+        groupedColumnMode: 'reorder'
+      };
+    },
+    createColumn: (column, table) => {
+      column.toggleGrouping = () => {
+        table.setGrouping(old => {
+          // Find any existing grouping for this column
+          if (old != null && old.includes(column.id)) {
+            return old.filter(d => d !== column.id);
+          }
+          return [...(old != null ? old : []), column.id];
+        });
+      };
+      column.getCanGroup = () => {
+        var _column$columnDef$ena, _table$options$enable;
+        return ((_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableGrouping) != null ? _table$options$enable : true) && (!!column.accessorFn || !!column.columnDef.getGroupingValue);
+      };
+      column.getIsGrouped = () => {
+        var _table$getState$group;
+        return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id);
+      };
+      column.getGroupedIndex = () => {
+        var _table$getState$group2;
+        return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id);
+      };
+      column.getToggleGroupingHandler = () => {
+        const canGroup = column.getCanGroup();
+        return () => {
+          if (!canGroup) return;
+          column.toggleGrouping();
+        };
+      };
+      column.getAutoAggregationFn = () => {
+        const firstRow = table.getCoreRowModel().flatRows[0];
+        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
+        if (typeof value === 'number') {
+          return aggregationFns.sum;
+        }
+        if (Object.prototype.toString.call(value) === '[object Date]') {
+          return aggregationFns.extent;
+        }
+      };
+      column.getAggregationFn = () => {
+        var _table$options$aggreg, _table$options$aggreg2;
+        if (!column) {
+          throw new Error();
+        }
+        return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn];
+      };
+    },
+    createTable: table => {
+      table.setGrouping = updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater);
+      table.resetGrouping = defaultState => {
+        var _table$initialState$g, _table$initialState;
+        table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []);
+      };
+      table.getPreGroupedRowModel = () => table.getFilteredRowModel();
+      table.getGroupedRowModel = () => {
+        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
+          table._getGroupedRowModel = table.options.getGroupedRowModel(table);
+        }
+        if (table.options.manualGrouping || !table._getGroupedRowModel) {
+          return table.getPreGroupedRowModel();
+        }
+        return table._getGroupedRowModel();
+      };
+    },
+    createRow: (row, table) => {
+      row.getIsGrouped = () => !!row.groupingColumnId;
+      row.getGroupingValue = columnId => {
+        if (row._groupingValuesCache.hasOwnProperty(columnId)) {
+          return row._groupingValuesCache[columnId];
+        }
+        const column = table.getColumn(columnId);
+        if (!(column != null && column.columnDef.getGroupingValue)) {
+          return row.getValue(columnId);
+        }
+        row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(row.original);
+        return row._groupingValuesCache[columnId];
+      };
+      row._groupingValuesCache = {};
+    },
+    createCell: (cell, column, row, table) => {
+      cell.getIsGrouped = () => column.getIsGrouped() && column.id === row.groupingColumnId;
+      cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped();
+      cell.getIsAggregated = () => {
+        var _row$subRows;
+        return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+      };
+    }
+  };
+  function orderColumns(leafColumns, grouping, groupedColumnMode) {
+    if (!(grouping != null && grouping.length) || !groupedColumnMode) {
+      return leafColumns;
+    }
+    const nonGroupingColumns = leafColumns.filter(col => !grouping.includes(col.id));
+    if (groupedColumnMode === 'remove') {
+      return nonGroupingColumns;
+    }
+    const groupingColumns = grouping.map(g => leafColumns.find(col => col.id === g)).filter(Boolean);
+    return [...groupingColumns, ...nonGroupingColumns];
+  }
+  //
+  const ColumnOrdering = {
+    getInitialState: state => {
+      return {
+        columnOrder: [],
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onColumnOrderChange: makeStateUpdater('columnOrder', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.getIndex = memo$1(position => [_getVisibleLeafColumns(table, position)], columns => columns.findIndex(d => d.id === column.id), getMemoOptions(table.options, 'debugColumns', 'getIndex'));
+      column.getIsFirstColumn = position => {
+        var _columns$;
+        const columns = _getVisibleLeafColumns(table, position);
+        return ((_columns$ = columns[0]) == null ? void 0 : _columns$.id) === column.id;
+      };
+      column.getIsLastColumn = position => {
+        var _columns;
+        const columns = _getVisibleLeafColumns(table, position);
+        return ((_columns = columns[columns.length - 1]) == null ? void 0 : _columns.id) === column.id;
+      };
+    },
+    createTable: table => {
+      table.setColumnOrder = updater => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater);
+      table.resetColumnOrder = defaultState => {
+        var _table$initialState$c;
+        table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []);
+      };
+      table._getOrderColumnsFn = memo$1(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => {
+        // Sort grouped columns to the start of the column list
+        // before the headers are built
+        let orderedColumns = [];
+        // If there is no order, return the normal columns
+        if (!(columnOrder != null && columnOrder.length)) {
+          orderedColumns = columns;
+        } else {
+          const columnOrderCopy = [...columnOrder];
+          // If there is an order, make a copy of the columns
+          const columnsCopy = [...columns];
+          // And make a new ordered array of the columns
+          // Loop over the columns and place them in order into the new array
+          while (columnsCopy.length && columnOrderCopy.length) {
+            const targetColumnId = columnOrderCopy.shift();
+            const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId);
+            if (foundIndex > -1) {
+              orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]);
+            }
+          }
+          // If there are any columns left, add them to the end
+          orderedColumns = [...orderedColumns, ...columnsCopy];
+        }
+        return orderColumns(orderedColumns, grouping, groupedColumnMode);
+      }, getMemoOptions(table.options, 'debugTable', '_getOrderColumnsFn'));
+    }
+  };
+  //
+  const getDefaultColumnPinningState = () => ({
+    left: [],
+    right: []
+  });
+  const ColumnPinning = {
+    getInitialState: state => {
+      return {
+        columnPinning: getDefaultColumnPinningState(),
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        onColumnPinningChange: makeStateUpdater('columnPinning', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.pin = position => {
+        const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean);
+        table.setColumnPinning(old => {
+          var _old$left3, _old$right3;
+          if (position === 'right') {
+            var _old$left, _old$right;
+            return {
+              left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+              right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
+            };
+          }
+          if (position === 'left') {
+            var _old$left2, _old$right2;
+            return {
+              left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
+              right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+            };
+          }
+          return {
+            left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter(d => !(columnIds != null && columnIds.includes(d))),
+            right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
+          };
+        });
+      };
+      column.getCanPin = () => {
+        const leafColumns = column.getLeafColumns();
+        return leafColumns.some(d => {
+          var _d$columnDef$enablePi, _ref, _table$options$enable;
+          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true);
+        });
+      };
+      column.getIsPinned = () => {
+        const leafColumnIds = column.getLeafColumns().map(d => d.id);
+        const {
+          left,
+          right
+        } = table.getState().columnPinning;
+        const isLeft = leafColumnIds.some(d => left == null ? void 0 : left.includes(d));
+        const isRight = leafColumnIds.some(d => right == null ? void 0 : right.includes(d));
+        return isLeft ? 'left' : isRight ? 'right' : false;
+      };
+      column.getPinnedIndex = () => {
+        var _table$getState$colum, _table$getState$colum2;
+        const position = column.getIsPinned();
+        return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null || (_table$getState$colum2 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0;
+      };
+    },
+    createRow: (row, table) => {
+      row.getCenterVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
+        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+        return allCells.filter(d => !leftAndRight.includes(d.column.id));
+      }, getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells'));
+      row.getLeftVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.left], (allCells, left) => {
+        const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
+          position: 'left'
+        }));
+        return cells;
+      }, getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells'));
+      row.getRightVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
+        const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
+          ...d,
+          position: 'right'
+        }));
+        return cells;
+      }, getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells'));
+    },
+    createTable: table => {
+      table.setColumnPinning = updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater);
+      table.resetColumnPinning = defaultState => {
+        var _table$initialState$c, _table$initialState;
+        return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState());
+      };
+      table.getIsSomeColumnsPinned = position => {
+        var _pinningState$positio;
+        const pinningState = table.getState().columnPinning;
+        if (!position) {
+          var _pinningState$left, _pinningState$right;
+          return Boolean(((_pinningState$left = pinningState.left) == null ? void 0 : _pinningState$left.length) || ((_pinningState$right = pinningState.right) == null ? void 0 : _pinningState$right.length));
+        }
+        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
+      };
+      table.getLeftLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => {
+        return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+      }, getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns'));
+      table.getRightLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => {
+        return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
+      }, getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns'));
+      table.getCenterLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => {
+        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
+        return allColumns.filter(d => !leftAndRight.includes(d.id));
+      }, getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns'));
+    }
+  };
+  //
+  //
+  const defaultColumnSizing = {
+    size: 150,
+    minSize: 20,
+    maxSize: Number.MAX_SAFE_INTEGER
+  };
+  const getDefaultColumnSizingInfoState = () => ({
+    startOffset: null,
+    startSize: null,
+    deltaOffset: null,
+    deltaPercentage: null,
+    isResizingColumn: false,
+    columnSizingStart: []
+  });
+  const ColumnSizing = {
+    getDefaultColumnDef: () => {
+      return defaultColumnSizing;
+    },
+    getInitialState: state => {
+      return {
+        columnSizing: {},
+        columnSizingInfo: getDefaultColumnSizingInfoState(),
+        ...state
+      };
+    },
+    getDefaultOptions: table => {
+      return {
+        columnResizeMode: 'onEnd',
+        columnResizeDirection: 'ltr',
+        onColumnSizingChange: makeStateUpdater('columnSizing', table),
+        onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table)
+      };
+    },
+    createColumn: (column, table) => {
+      column.getSize = () => {
+        var _column$columnDef$min, _ref, _column$columnDef$max;
+        const columnSize = table.getState().columnSizing[column.id];
+        return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize);
+      };
+      column.getStart = memo$1(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(0, column.getIndex(position)).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getStart'));
+      column.getAfter = memo$1(position => [position, _getVisibleLeafColumns(table, position), table.getState().columnSizing], (position, columns) => columns.slice(column.getIndex(position) + 1).reduce((sum, column) => sum + column.getSize(), 0), getMemoOptions(table.options, 'debugColumns', 'getAfter'));
+      column.resetSize = () => {
+        table.setColumnSizing(_ref2 => {
+          let {
+            [column.id]: _,
+            ...rest
+          } = _ref2;
+          return rest;
+        });
+      };
+      column.getCanResize = () => {
+        var _column$columnDef$ena, _table$options$enable;
+        return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true);
+      };
+      column.getIsResizing = () => {
+        return table.getState().columnSizingInfo.isResizingColumn === column.id;
+      };
+    },
+    createHeader: (header, table) => {
+      header.getSize = () => {
+        let sum = 0;
+        const recurse = header => {
+          if (header.subHeaders.length) {
+            header.subHeaders.forEach(recurse);
+          } else {
+            var _header$column$getSiz;
+            sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
+          }
+        };
+        recurse(header);
+        return sum;
+      };
+      header.getStart = () => {
+        if (header.index > 0) {
+          const prevSiblingHeader = header.headerGroup.headers[header.index - 1];
+          return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
+        }
+        return 0;
+      };
+      header.getResizeHandler = _contextDocument => {
+        const column = table.getColumn(header.column.id);
+        const canResize = column == null ? void 0 : column.getCanResize();
+        return e => {
+          if (!column || !canResize) {
+            return;
+          }
+          e.persist == null || e.persist();
+          if (isTouchStartEvent(e)) {
+            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
             if (e.touches && e.touches.length > 1) {
               return;
             }
@@ -60668,424 +61629,90 @@ img.ProseMirror-separator {
   //
-  const Expanding = {
+  const ColumnVisibility = {
     getInitialState: state => {
       return {
-        expanded: {},
+        columnVisibility: {},
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onExpandedChange: makeStateUpdater('expanded', table),
-        paginateExpandedRows: true
+        onColumnVisibilityChange: makeStateUpdater('columnVisibility', table)
       };
     },
-    createTable: table => {
-      let registered = false;
-      let queued = false;
-      table._autoResetExpanded = () => {
-        var _ref, _table$options$autoRe;
-        if (!registered) {
-          table._queue(() => {
-            registered = true;
-          });
-          return;
-        }
-        if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) {
-          if (queued) return;
-          queued = true;
-          table._queue(() => {
-            table.resetExpanded();
-            queued = false;
-          });
-        }
-      };
-      table.setExpanded = updater => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater);
-      table.toggleAllRowsExpanded = expanded => {
-        if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) {
-          table.setExpanded(true);
-        } else {
-          table.setExpanded({});
+    createColumn: (column, table) => {
+      column.toggleVisibility = value => {
+        if (column.getCanHide()) {
+          table.setColumnVisibility(old => ({
+            ...old,
+            [column.id]: value != null ? value : !column.getIsVisible()
+          }));
         }
       };
-      table.resetExpanded = defaultState => {
-        var _table$initialState$e, _table$initialState;
-        table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {});
+      column.getIsVisible = () => {
+        var _ref, _table$getState$colum;
+        const childColumns = column.columns;
+        return (_ref = childColumns.length ? childColumns.some(c => c.getIsVisible()) : (_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) != null ? _ref : true;
       };
-      table.getCanSomeRowsExpand = () => {
-        return table.getPrePaginationRowModel().flatRows.some(row => row.getCanExpand());
+      column.getCanHide = () => {
+        var _column$columnDef$ena, _table$options$enable;
+        return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true);
       };
-      table.getToggleAllRowsExpandedHandler = () => {
+      column.getToggleVisibilityHandler = () => {
         return e => {
-          e.persist == null || e.persist();
-          table.toggleAllRowsExpanded();
-        };
-      };
-      table.getIsSomeRowsExpanded = () => {
-        const expanded = table.getState().expanded;
-        return expanded === true || Object.values(expanded).some(Boolean);
-      };
-      table.getIsAllRowsExpanded = () => {
-        const expanded = table.getState().expanded;
-        // If expanded is true, save some cycles and return true
-        if (typeof expanded === 'boolean') {
-          return expanded === true;
-        }
-        if (!Object.keys(expanded).length) {
-          return false;
-        }
-        // If any row is not expanded, return false
-        if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
-          return false;
-        }
-        // They must all be expanded :shrug:
-        return true;
-      };
-      table.getExpandedDepth = () => {
-        let maxDepth = 0;
-        const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded);
-        rowIds.forEach(id => {
-          const splitId = id.split('.');
-          maxDepth = Math.max(maxDepth, splitId.length);
-        });
-        return maxDepth;
-      };
-      table.getPreExpandedRowModel = () => table.getSortedRowModel();
-      table.getExpandedRowModel = () => {
-        if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
-          table._getExpandedRowModel = table.options.getExpandedRowModel(table);
-        }
-        if (table.options.manualExpanding || !table._getExpandedRowModel) {
-          return table.getPreExpandedRowModel();
-        }
-        return table._getExpandedRowModel();
-      };
-    },
-    createRow: (row, table) => {
-      row.toggleExpanded = expanded => {
-        table.setExpanded(old => {
-          var _expanded;
-          const exists = old === true ? true : !!(old != null && old[row.id]);
-          let oldExpanded = {};
-          if (old === true) {
-            Object.keys(table.getRowModel().rowsById).forEach(rowId => {
-              oldExpanded[rowId] = true;
-            });
-          } else {
-            oldExpanded = old;
-          }
-          expanded = (_expanded = expanded) != null ? _expanded : !exists;
-          if (!exists && expanded) {
-            return {
-              ...oldExpanded,
-              [row.id]: true
-            };
-          }
-          if (exists && !expanded) {
-            const {
-              [row.id]: _,
-              ...rest
-            } = oldExpanded;
-            return rest;
-          }
-          return old;
-        });
-      };
-      row.getIsExpanded = () => {
-        var _table$options$getIsR;
-        const expanded = table.getState().expanded;
-        return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id]));
-      };
-      row.getCanExpand = () => {
-        var _table$options$getRow, _table$options$enable, _row$subRows;
-        return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
-      };
-      row.getIsAllParentsExpanded = () => {
-        let isFullyExpanded = true;
-        let currentRow = row;
-        while (isFullyExpanded && currentRow.parentId) {
-          currentRow = table.getRow(currentRow.parentId, true);
-          isFullyExpanded = currentRow.getIsExpanded();
-        }
-        return isFullyExpanded;
-      };
-      row.getToggleExpandedHandler = () => {
-        const canExpand = row.getCanExpand();
-        return () => {
-          if (!canExpand) return;
-          row.toggleExpanded();
+          column.toggleVisibility == null || column.toggleVisibility(e.target.checked);
         };
       };
-    }
-  };
-  const includesString = (row, columnId, filterValue) => {
-    var _row$getValue;
-    const search = filterValue.toLowerCase();
-    return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search));
-  };
-  includesString.autoRemove = val => testFalsey(val);
-  const includesStringSensitive = (row, columnId, filterValue) => {
-    var _row$getValue2;
-    return Boolean((_row$getValue2 = row.getValue(columnId)) == null || (_row$getValue2 = _row$getValue2.toString()) == null ? void 0 : _row$getValue2.includes(filterValue));
-  };
-  includesStringSensitive.autoRemove = val => testFalsey(val);
-  const equalsString = (row, columnId, filterValue) => {
-    var _row$getValue3;
-    return ((_row$getValue3 = row.getValue(columnId)) == null || (_row$getValue3 = _row$getValue3.toString()) == null ? void 0 : _row$getValue3.toLowerCase()) === (filterValue == null ? void 0 : filterValue.toLowerCase());
-  };
-  equalsString.autoRemove = val => testFalsey(val);
-  const arrIncludes = (row, columnId, filterValue) => {
-    var _row$getValue4;
-    return (_row$getValue4 = row.getValue(columnId)) == null ? void 0 : _row$getValue4.includes(filterValue);
-  };
-  arrIncludes.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const arrIncludesAll = (row, columnId, filterValue) => {
-    return !filterValue.some(val => {
-      var _row$getValue5;
-      return !((_row$getValue5 = row.getValue(columnId)) != null && _row$getValue5.includes(val));
-    });
-  };
-  arrIncludesAll.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const arrIncludesSome = (row, columnId, filterValue) => {
-    return filterValue.some(val => {
-      var _row$getValue6;
-      return (_row$getValue6 = row.getValue(columnId)) == null ? void 0 : _row$getValue6.includes(val);
-    });
-  };
-  arrIncludesSome.autoRemove = val => testFalsey(val) || !(val != null && val.length);
-  const equals = (row, columnId, filterValue) => {
-    return row.getValue(columnId) === filterValue;
-  };
-  equals.autoRemove = val => testFalsey(val);
-  const weakEquals = (row, columnId, filterValue) => {
-    return row.getValue(columnId) == filterValue;
-  };
-  weakEquals.autoRemove = val => testFalsey(val);
-  const inNumberRange = (row, columnId, filterValue) => {
-    let [min, max] = filterValue;
-    const rowValue = row.getValue(columnId);
-    return rowValue >= min && rowValue <= max;
-  };
-  inNumberRange.resolveFilterValue = val => {
-    let [unsafeMin, unsafeMax] = val;
-    let parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin;
-    let parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax;
-    let min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin;
-    let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax;
-    if (min > max) {
-      const temp = min;
-      min = max;
-      max = temp;
-    }
-    return [min, max];
-  };
-  inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]);
-  // Export
-  const filterFns = {
-    includesString,
-    includesStringSensitive,
-    equalsString,
-    arrIncludes,
-    arrIncludesAll,
-    arrIncludesSome,
-    equals,
-    weakEquals,
-    inNumberRange
-  };
-  // Utils
-  function testFalsey(val) {
-    return val === undefined || val === null || val === '';
-  }
-  //
-  const Filters = {
-    getDefaultColumnDef: () => {
-      return {
-        filterFn: 'auto'
-      };
-    },
-    getInitialState: state => {
-      return {
-        columnFilters: [],
-        globalFilter: undefined,
-        // filtersProgress: 1,
-        // facetProgress: {},
-        ...state
-      };
-    },
-    getDefaultOptions: table => {
-      return {
-        onColumnFiltersChange: makeStateUpdater('columnFilters', table),
-        onGlobalFilterChange: makeStateUpdater('globalFilter', table),
-        filterFromLeafRows: false,
-        maxLeafRowFilterDepth: 100,
-        globalFilterFn: 'auto',
-        getColumnCanGlobalFilter: column => {
-          var _table$getCoreRowMode;
-          const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null || (_table$getCoreRowMode = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode.getValue();
-          return typeof value === 'string' || typeof value === 'number';
-        }
-      };
-    },
-    createColumn: (column, table) => {
-      column.getAutoFilterFn = () => {
-        const firstRow = table.getCoreRowModel().flatRows[0];
-        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
-        if (typeof value === 'string') {
-          return filterFns.includesString;
-        }
-        if (typeof value === 'number') {
-          return filterFns.inNumberRange;
-        }
-        if (typeof value === 'boolean') {
-          return filterFns.equals;
-        }
-        if (value !== null && typeof value === 'object') {
-          return filterFns.equals;
-        }
-        if (Array.isArray(value)) {
-          return filterFns.arrIncludes;
-        }
-        return filterFns.weakEquals;
-      };
-      column.getFilterFn = () => {
-        var _table$options$filter, _table$options$filter2;
-        return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : // @ts-ignore
-        (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn];
-      };
-      column.getCanFilter = () => {
-        var _column$columnDef$ena, _table$options$enable, _table$options$enable2;
-        return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn;
-      };
-      column.getCanGlobalFilter = () => {
-        var _column$columnDef$ena2, _table$options$enable3, _table$options$enable4, _table$options$getCol;
-        return ((_column$columnDef$ena2 = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena2 : true) && ((_table$options$enable3 = table.options.enableGlobalFilter) != null ? _table$options$enable3 : true) && ((_table$options$enable4 = table.options.enableFilters) != null ? _table$options$enable4 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn;
-      };
-      column.getIsFiltered = () => column.getFilterIndex() > -1;
-      column.getFilterValue = () => {
-        var _table$getState$colum;
-        return (_table$getState$colum = table.getState().columnFilters) == null || (_table$getState$colum = _table$getState$colum.find(d => d.id === column.id)) == null ? void 0 : _table$getState$colum.value;
-      };
-      column.getFilterIndex = () => {
-        var _table$getState$colum2, _table$getState$colum3;
-        return (_table$getState$colum2 = (_table$getState$colum3 = table.getState().columnFilters) == null ? void 0 : _table$getState$colum3.findIndex(d => d.id === column.id)) != null ? _table$getState$colum2 : -1;
-      };
-      column.setFilterValue = value => {
-        table.setColumnFilters(old => {
-          const filterFn = column.getFilterFn();
-          const previousfilter = old == null ? void 0 : old.find(d => d.id === column.id);
-          const newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined);
-          //
-          if (shouldAutoRemoveFilter(filterFn, newFilter, column)) {
-            var _old$filter;
-            return (_old$filter = old == null ? void 0 : old.filter(d => d.id !== column.id)) != null ? _old$filter : [];
-          }
-          const newFilterObj = {
-            id: column.id,
-            value: newFilter
-          };
-          if (previousfilter) {
-            var _old$map;
-            return (_old$map = old == null ? void 0 : old.map(d => {
-              if (d.id === column.id) {
-                return newFilterObj;
-              }
-              return d;
-            })) != null ? _old$map : [];
-          }
-          if (old != null && old.length) {
-            return [...old, newFilterObj];
-          }
-          return [newFilterObj];
-        });
-      };
-      column._getFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id);
-      column.getFacetedRowModel = () => {
-        if (!column._getFacetedRowModel) {
-          return table.getPreFilteredRowModel();
-        }
-        return column._getFacetedRowModel();
-      };
-      column._getFacetedUniqueValues = table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id);
-      column.getFacetedUniqueValues = () => {
-        if (!column._getFacetedUniqueValues) {
-          return new Map();
-        }
-        return column._getFacetedUniqueValues();
-      };
-      column._getFacetedMinMaxValues = table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id);
-      column.getFacetedMinMaxValues = () => {
-        if (!column._getFacetedMinMaxValues) {
-          return undefined;
-        }
-        return column._getFacetedMinMaxValues();
-      };
-      // () => [column.getFacetedRowModel()],
-      // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id),
     },
     createRow: (row, table) => {
-      row.columnFilters = {};
-      row.columnFiltersMeta = {};
+      row._getAllVisibleCells = memo$1(() => [row.getAllCells(), table.getState().columnVisibility], cells => {
+        return cells.filter(cell => cell.column.getIsVisible());
+      }, getMemoOptions(table.options, 'debugRows', '_getAllVisibleCells'));
+      row.getVisibleCells = memo$1(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], getMemoOptions(table.options, 'debugRows', 'getVisibleCells'));
     },
     createTable: table => {
-      table.getGlobalAutoFilterFn = () => {
-        return filterFns.includesString;
-      };
-      table.getGlobalFilterFn = () => {
-        var _table$options$filter3, _table$options$filter4;
-        const {
-          globalFilterFn: globalFilterFn
-        } = table.options;
-        return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === 'auto' ? table.getGlobalAutoFilterFn() : // @ts-ignore
-        (_table$options$filter3 = (_table$options$filter4 = table.options.filterFns) == null ? void 0 : _table$options$filter4[globalFilterFn]) != null ? _table$options$filter3 : filterFns[globalFilterFn];
-      };
-      table.setColumnFilters = updater => {
-        const leafColumns = table.getAllLeafColumns();
-        const updateFn = old => {
-          var _functionalUpdate;
-          return (_functionalUpdate = functionalUpdate(updater, old)) == null ? void 0 : _functionalUpdate.filter(filter => {
-            const column = leafColumns.find(d => d.id === filter.id);
-            if (column) {
-              const filterFn = column.getFilterFn();
-              if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {
-                return false;
-              }
-            }
-            return true;
-          });
-        };
-        table.options.onColumnFiltersChange == null || table.options.onColumnFiltersChange(updateFn);
-      };
-      table.setGlobalFilter = updater => {
-        table.options.onGlobalFilterChange == null || table.options.onGlobalFilterChange(updater);
-      };
-      table.resetGlobalFilter = defaultState => {
-        table.setGlobalFilter(defaultState ? undefined : table.initialState.globalFilter);
+      const makeVisibleColumnsMethod = (key, getColumns) => {
+        return memo$1(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => {
+          return columns.filter(d => d.getIsVisible == null ? void 0 : d.getIsVisible());
+        }, getMemoOptions(table.options, 'debugColumns', key));
       };
-      table.resetColumnFilters = defaultState => {
-        var _table$initialState$c, _table$initialState;
-        table.setColumnFilters(defaultState ? [] : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnFilters) != null ? _table$initialState$c : []);
+      table.getVisibleFlatColumns = makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns());
+      table.getVisibleLeafColumns = makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns());
+      table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns());
+      table.getRightVisibleLeafColumns = makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns());
+      table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns());
+      table.setColumnVisibility = updater => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater);
+      table.resetColumnVisibility = defaultState => {
+        var _table$initialState$c;
+        table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {});
       };
-      table.getPreFilteredRowModel = () => table.getCoreRowModel();
-      table.getFilteredRowModel = () => {
-        if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {
-          table._getFilteredRowModel = table.options.getFilteredRowModel(table);
-        }
-        if (table.options.manualFiltering || !table._getFilteredRowModel) {
-          return table.getPreFilteredRowModel();
-        }
-        return table._getFilteredRowModel();
+      table.toggleAllColumnsVisible = value => {
+        var _value;
+        value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible();
+        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
+          ...obj,
+          [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
+        }), {}));
+      };
+      table.getIsAllColumnsVisible = () => !table.getAllLeafColumns().some(column => !(column.getIsVisible != null && column.getIsVisible()));
+      table.getIsSomeColumnsVisible = () => table.getAllLeafColumns().some(column => column.getIsVisible == null ? void 0 : column.getIsVisible());
+      table.getToggleAllColumnsVisibilityHandler = () => {
+        return e => {
+          var _target;
+          table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
+        };
       };
+    }
+  };
+  function _getVisibleLeafColumns(table, position) {
+    return !position ? table.getVisibleLeafColumns() : position === 'center' ? table.getCenterVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns();
+  }
+  //
+  const GlobalFaceting = {
+    createTable: table => {
       table._getGlobalFacetedRowModel = table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, '__global__');
       table.getGlobalFacetedRowModel = () => {
         if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {
@@ -61109,289 +61736,207 @@ img.ProseMirror-separator {
       };
     }
   };
-  function shouldAutoRemoveFilter(filterFn, value, column) {
-    return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
-  }
-  const sum = (columnId, _leafRows, childRows) => {
-    // It's faster to just add the aggregations together instead of
-    // process leaf nodes individually
-    return childRows.reduce((sum, next) => {
-      const nextValue = next.getValue(columnId);
-      return sum + (typeof nextValue === 'number' ? nextValue : 0);
-    }, 0);
-  };
-  const min = (columnId, _leafRows, childRows) => {
-    let min;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null && (min > value || min === undefined && value >= value)) {
-        min = value;
-      }
-    });
-    return min;
-  };
-  const max = (columnId, _leafRows, childRows) => {
-    let max;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null && (max < value || max === undefined && value >= value)) {
-        max = value;
-      }
-    });
-    return max;
-  };
-  const extent = (columnId, _leafRows, childRows) => {
-    let min;
-    let max;
-    childRows.forEach(row => {
-      const value = row.getValue(columnId);
-      if (value != null) {
-        if (min === undefined) {
-          if (value >= value) min = max = value;
-        } else {
-          if (min > value) min = value;
-          if (max < value) max = value;
-        }
-      }
-    });
-    return [min, max];
-  };
-  const mean = (columnId, leafRows) => {
-    let count = 0;
-    let sum = 0;
-    leafRows.forEach(row => {
-      let value = row.getValue(columnId);
-      if (value != null && (value = +value) >= value) {
-        ++count, sum += value;
-      }
-    });
-    if (count) return sum / count;
-    return;
-  };
-  const median = (columnId, leafRows) => {
-    if (!leafRows.length) {
-      return;
-    }
-    const values = leafRows.map(row => row.getValue(columnId));
-    if (!isNumberArray$1(values)) {
-      return;
-    }
-    if (values.length === 1) {
-      return values[0];
-    }
-    const mid = Math.floor(values.length / 2);
-    const nums = values.sort((a, b) => a - b);
-    return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
-  };
-  const unique = (columnId, leafRows) => {
-    return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values());
-  };
-  const uniqueCount = (columnId, leafRows) => {
-    return new Set(leafRows.map(d => d.getValue(columnId))).size;
-  };
-  const count = (_columnId, leafRows) => {
-    return leafRows.length;
-  };
-  const aggregationFns = {
-    sum,
-    min,
-    max,
-    extent,
-    mean,
-    median,
-    unique,
-    uniqueCount,
-    count
-  };
   //
-  const Grouping = {
-    getDefaultColumnDef: () => {
-      return {
-        aggregatedCell: props => {
-          var _toString, _props$getValue;
-          return (_toString = (_props$getValue = props.getValue()) == null || _props$getValue.toString == null ? void 0 : _props$getValue.toString()) != null ? _toString : null;
-        },
-        aggregationFn: 'auto'
-      };
-    },
+  const GlobalFiltering = {
     getInitialState: state => {
       return {
-        grouping: [],
+        globalFilter: undefined,
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onGroupingChange: makeStateUpdater('grouping', table),
-        groupedColumnMode: 'reorder'
+        onGlobalFilterChange: makeStateUpdater('globalFilter', table),
+        globalFilterFn: 'auto',
+        getColumnCanGlobalFilter: column => {
+          var _table$getCoreRowMode;
+          const value = (_table$getCoreRowMode = table.getCoreRowModel().flatRows[0]) == null || (_table$getCoreRowMode = _table$getCoreRowMode._getAllCellsByColumnId()[column.id]) == null ? void 0 : _table$getCoreRowMode.getValue();
+          return typeof value === 'string' || typeof value === 'number';
+        }
       };
     },
     createColumn: (column, table) => {
-      column.toggleGrouping = () => {
-        table.setGrouping(old => {
-          // Find any existing grouping for this column
-          if (old != null && old.includes(column.id)) {
-            return old.filter(d => d !== column.id);
-          }
-          return [...(old != null ? old : []), column.id];
-        });
-      };
-      column.getCanGroup = () => {
-        var _ref, _ref2, _ref3, _column$columnDef$ena;
-        return (_ref = (_ref2 = (_ref3 = (_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) != null ? _ref3 : table.options.enableGrouping) != null ? _ref2 : true) != null ? _ref : !!column.accessorFn;
-      };
-      column.getIsGrouped = () => {
-        var _table$getState$group;
-        return (_table$getState$group = table.getState().grouping) == null ? void 0 : _table$getState$group.includes(column.id);
-      };
-      column.getGroupedIndex = () => {
-        var _table$getState$group2;
-        return (_table$getState$group2 = table.getState().grouping) == null ? void 0 : _table$getState$group2.indexOf(column.id);
-      };
-      column.getToggleGroupingHandler = () => {
-        const canGroup = column.getCanGroup();
-        return () => {
-          if (!canGroup) return;
-          column.toggleGrouping();
-        };
-      };
-      column.getAutoAggregationFn = () => {
-        const firstRow = table.getCoreRowModel().flatRows[0];
-        const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
-        if (typeof value === 'number') {
-          return aggregationFns.sum;
-        }
-        if (Object.prototype.toString.call(value) === '[object Date]') {
-          return aggregationFns.extent;
-        }
-      };
-      column.getAggregationFn = () => {
-        var _table$options$aggreg, _table$options$aggreg2;
-        if (!column) {
-          throw new Error();
-        }
-        return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = (_table$options$aggreg2 = table.options.aggregationFns) == null ? void 0 : _table$options$aggreg2[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn];
+      column.getCanGlobalFilter = () => {
+        var _column$columnDef$ena, _table$options$enable, _table$options$enable2, _table$options$getCol;
+        return ((_column$columnDef$ena = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableGlobalFilter) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter == null ? void 0 : table.options.getColumnCanGlobalFilter(column)) != null ? _table$options$getCol : true) && !!column.accessorFn;
       };
     },
     createTable: table => {
-      table.setGrouping = updater => table.options.onGroupingChange == null ? void 0 : table.options.onGroupingChange(updater);
-      table.resetGrouping = defaultState => {
-        var _table$initialState$g, _table$initialState;
-        table.setGrouping(defaultState ? [] : (_table$initialState$g = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.grouping) != null ? _table$initialState$g : []);
+      table.getGlobalAutoFilterFn = () => {
+        return filterFns.includesString;
       };
-      table.getPreGroupedRowModel = () => table.getFilteredRowModel();
-      table.getGroupedRowModel = () => {
-        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
-          table._getGroupedRowModel = table.options.getGroupedRowModel(table);
-        }
-        if (table.options.manualGrouping || !table._getGroupedRowModel) {
-          return table.getPreGroupedRowModel();
-        }
-        return table._getGroupedRowModel();
+      table.getGlobalFilterFn = () => {
+        var _table$options$filter, _table$options$filter2;
+        const {
+          globalFilterFn: globalFilterFn
+        } = table.options;
+        return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === 'auto' ? table.getGlobalAutoFilterFn() : (_table$options$filter = (_table$options$filter2 = table.options.filterFns) == null ? void 0 : _table$options$filter2[globalFilterFn]) != null ? _table$options$filter : filterFns[globalFilterFn];
       };
-    },
-    createRow: (row, table) => {
-      row.getIsGrouped = () => !!row.groupingColumnId;
-      row.getGroupingValue = columnId => {
-        if (row._groupingValuesCache.hasOwnProperty(columnId)) {
-          return row._groupingValuesCache[columnId];
-        }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.columnDef.getGroupingValue)) {
-          return row.getValue(columnId);
-        }
-        row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(row.original);
-        return row._groupingValuesCache[columnId];
+      table.setGlobalFilter = updater => {
+        table.options.onGlobalFilterChange == null || table.options.onGlobalFilterChange(updater);
       };
-      row._groupingValuesCache = {};
-    },
-    createCell: (cell, column, row, table) => {
-      cell.getIsGrouped = () => column.getIsGrouped() && column.id === row.groupingColumnId;
-      cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped();
-      cell.getIsAggregated = () => {
-        var _row$subRows;
-        return !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+      table.resetGlobalFilter = defaultState => {
+        table.setGlobalFilter(defaultState ? undefined : table.initialState.globalFilter);
       };
     }
   };
-  function orderColumns(leafColumns, grouping, groupedColumnMode) {
-    if (!(grouping != null && grouping.length) || !groupedColumnMode) {
-      return leafColumns;
-    }
-    const nonGroupingColumns = leafColumns.filter(col => !grouping.includes(col.id));
-    if (groupedColumnMode === 'remove') {
-      return nonGroupingColumns;
-    }
-    const groupingColumns = grouping.map(g => leafColumns.find(col => col.id === g)).filter(Boolean);
-    return [...groupingColumns, ...nonGroupingColumns];
-  }
   //
-  const Ordering = {
+  const RowExpanding = {
     getInitialState: state => {
       return {
-        columnOrder: [],
+        expanded: {},
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onColumnOrderChange: makeStateUpdater('columnOrder', table)
-      };
-    },
-    createColumn: (column, table) => {
-      column.getIndex = memo$1(position => [_getVisibleLeafColumns(table, position)], columns => columns.findIndex(d => d.id === column.id), getMemoOptions(table.options, 'debugColumns', 'getIndex'));
-      column.getIsFirstColumn = position => {
-        var _columns$;
-        const columns = _getVisibleLeafColumns(table, position);
-        return ((_columns$ = columns[0]) == null ? void 0 : _columns$.id) === column.id;
-      };
-      column.getIsLastColumn = position => {
-        var _columns;
-        const columns = _getVisibleLeafColumns(table, position);
-        return ((_columns = columns[columns.length - 1]) == null ? void 0 : _columns.id) === column.id;
+        onExpandedChange: makeStateUpdater('expanded', table),
+        paginateExpandedRows: true
       };
     },
     createTable: table => {
-      table.setColumnOrder = updater => table.options.onColumnOrderChange == null ? void 0 : table.options.onColumnOrderChange(updater);
-      table.resetColumnOrder = defaultState => {
-        var _table$initialState$c;
-        table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []);
+      let registered = false;
+      let queued = false;
+      table._autoResetExpanded = () => {
+        var _ref, _table$options$autoRe;
+        if (!registered) {
+          table._queue(() => {
+            registered = true;
+          });
+          return;
+        }
+        if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) {
+          if (queued) return;
+          queued = true;
+          table._queue(() => {
+            table.resetExpanded();
+            queued = false;
+          });
+        }
       };
-      table._getOrderColumnsFn = memo$1(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => {
-        // Sort grouped columns to the start of the column list
-        // before the headers are built
-        let orderedColumns = [];
-        // If there is no order, return the normal columns
-        if (!(columnOrder != null && columnOrder.length)) {
-          orderedColumns = columns;
+      table.setExpanded = updater => table.options.onExpandedChange == null ? void 0 : table.options.onExpandedChange(updater);
+      table.toggleAllRowsExpanded = expanded => {
+        if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) {
+          table.setExpanded(true);
         } else {
-          const columnOrderCopy = [...columnOrder];
+          table.setExpanded({});
+        }
+      };
+      table.resetExpanded = defaultState => {
+        var _table$initialState$e, _table$initialState;
+        table.setExpanded(defaultState ? {} : (_table$initialState$e = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.expanded) != null ? _table$initialState$e : {});
+      };
+      table.getCanSomeRowsExpand = () => {
+        return table.getPrePaginationRowModel().flatRows.some(row => row.getCanExpand());
+      };
+      table.getToggleAllRowsExpandedHandler = () => {
+        return e => {
+          e.persist == null || e.persist();
+          table.toggleAllRowsExpanded();
+        };
+      };
+      table.getIsSomeRowsExpanded = () => {
+        const expanded = table.getState().expanded;
+        return expanded === true || Object.values(expanded).some(Boolean);
+      };
+      table.getIsAllRowsExpanded = () => {
+        const expanded = table.getState().expanded;
-          // If there is an order, make a copy of the columns
-          const columnsCopy = [...columns];
+        // If expanded is true, save some cycles and return true
+        if (typeof expanded === 'boolean') {
+          return expanded === true;
+        }
+        if (!Object.keys(expanded).length) {
+          return false;
+        }
-          // And make a new ordered array of the columns
+        // If any row is not expanded, return false
+        if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {
+          return false;
+        }
-          // Loop over the columns and place them in order into the new array
-          while (columnsCopy.length && columnOrderCopy.length) {
-            const targetColumnId = columnOrderCopy.shift();
-            const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId);
-            if (foundIndex > -1) {
-              orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]);
-            }
+        // They must all be expanded :shrug:
+        return true;
+      };
+      table.getExpandedDepth = () => {
+        let maxDepth = 0;
+        const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded);
+        rowIds.forEach(id => {
+          const splitId = id.split('.');
+          maxDepth = Math.max(maxDepth, splitId.length);
+        });
+        return maxDepth;
+      };
+      table.getPreExpandedRowModel = () => table.getSortedRowModel();
+      table.getExpandedRowModel = () => {
+        if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {
+          table._getExpandedRowModel = table.options.getExpandedRowModel(table);
+        }
+        if (table.options.manualExpanding || !table._getExpandedRowModel) {
+          return table.getPreExpandedRowModel();
+        }
+        return table._getExpandedRowModel();
+      };
+    },
+    createRow: (row, table) => {
+      row.toggleExpanded = expanded => {
+        table.setExpanded(old => {
+          var _expanded;
+          const exists = old === true ? true : !!(old != null && old[row.id]);
+          let oldExpanded = {};
+          if (old === true) {
+            Object.keys(table.getRowModel().rowsById).forEach(rowId => {
+              oldExpanded[rowId] = true;
+            });
+          } else {
+            oldExpanded = old;
           }
-          // If there are any columns left, add them to the end
-          orderedColumns = [...orderedColumns, ...columnsCopy];
+          expanded = (_expanded = expanded) != null ? _expanded : !exists;
+          if (!exists && expanded) {
+            return {
+              ...oldExpanded,
+              [row.id]: true
+            };
+          }
+          if (exists && !expanded) {
+            const {
+              [row.id]: _,
+              ...rest
+            } = oldExpanded;
+            return rest;
+          }
+          return old;
+        });
+      };
+      row.getIsExpanded = () => {
+        var _table$options$getIsR;
+        const expanded = table.getState().expanded;
+        return !!((_table$options$getIsR = table.options.getIsRowExpanded == null ? void 0 : table.options.getIsRowExpanded(row)) != null ? _table$options$getIsR : expanded === true || (expanded == null ? void 0 : expanded[row.id]));
+      };
+      row.getCanExpand = () => {
+        var _table$options$getRow, _table$options$enable, _row$subRows;
+        return (_table$options$getRow = table.options.getRowCanExpand == null ? void 0 : table.options.getRowCanExpand(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!((_row$subRows = row.subRows) != null && _row$subRows.length);
+      };
+      row.getIsAllParentsExpanded = () => {
+        let isFullyExpanded = true;
+        let currentRow = row;
+        while (isFullyExpanded && currentRow.parentId) {
+          currentRow = table.getRow(currentRow.parentId, true);
+          isFullyExpanded = currentRow.getIsExpanded();
         }
-        return orderColumns(orderedColumns, grouping, groupedColumnMode);
-      }, getMemoOptions(table.options, 'debugTable', '_getOrderColumnsFn'));
+        return isFullyExpanded;
+      };
+      row.getToggleExpandedHandler = () => {
+        const canExpand = row.getCanExpand();
+        return () => {
+          if (!canExpand) return;
+          row.toggleExpanded();
+        };
+      };
     }
   };
@@ -61403,7 +61948,7 @@ img.ProseMirror-separator {
     pageIndex: defaultPageIndex,
     pageSize: defaultPageSize
   });
-  const Pagination = {
+  const RowPagination = {
     getInitialState: state => {
       return {
         ...state,
@@ -61550,88 +62095,34 @@ img.ProseMirror-separator {
   //
-  const getDefaultColumnPinningState = () => ({
-    left: [],
-    right: []
-  });
   const getDefaultRowPinningState = () => ({
     top: [],
     bottom: []
   });
-  const Pinning = {
+  const RowPinning = {
     getInitialState: state => {
       return {
-        columnPinning: getDefaultColumnPinningState(),
         rowPinning: getDefaultRowPinningState(),
         ...state
       };
     },
     getDefaultOptions: table => {
       return {
-        onColumnPinningChange: makeStateUpdater('columnPinning', table),
         onRowPinningChange: makeStateUpdater('rowPinning', table)
       };
     },
-    createColumn: (column, table) => {
-      column.pin = position => {
-        const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean);
-        table.setColumnPinning(old => {
-          var _old$left3, _old$right3;
-          if (position === 'right') {
-            var _old$left, _old$right;
-            return {
-              left: ((_old$left = old == null ? void 0 : old.left) != null ? _old$left : []).filter(d => !(columnIds != null && columnIds.includes(d))),
-              right: [...((_old$right = old == null ? void 0 : old.right) != null ? _old$right : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds]
-            };
-          }
-          if (position === 'left') {
-            var _old$left2, _old$right2;
-            return {
-              left: [...((_old$left2 = old == null ? void 0 : old.left) != null ? _old$left2 : []).filter(d => !(columnIds != null && columnIds.includes(d))), ...columnIds],
-              right: ((_old$right2 = old == null ? void 0 : old.right) != null ? _old$right2 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
-            };
-          }
-          return {
-            left: ((_old$left3 = old == null ? void 0 : old.left) != null ? _old$left3 : []).filter(d => !(columnIds != null && columnIds.includes(d))),
-            right: ((_old$right3 = old == null ? void 0 : old.right) != null ? _old$right3 : []).filter(d => !(columnIds != null && columnIds.includes(d)))
-          };
-        });
-      };
-      column.getCanPin = () => {
-        const leafColumns = column.getLeafColumns();
-        return leafColumns.some(d => {
-          var _d$columnDef$enablePi, _ref, _table$options$enable;
-          return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_ref = (_table$options$enable = table.options.enableColumnPinning) != null ? _table$options$enable : table.options.enablePinning) != null ? _ref : true);
-        });
-      };
-      column.getIsPinned = () => {
-        const leafColumnIds = column.getLeafColumns().map(d => d.id);
-        const {
-          left,
-          right
-        } = table.getState().columnPinning;
-        const isLeft = leafColumnIds.some(d => left == null ? void 0 : left.includes(d));
-        const isRight = leafColumnIds.some(d => right == null ? void 0 : right.includes(d));
-        return isLeft ? 'left' : isRight ? 'right' : false;
-      };
-      column.getPinnedIndex = () => {
-        var _table$getState$colum, _table$getState$colum2;
-        const position = column.getIsPinned();
-        return position ? (_table$getState$colum = (_table$getState$colum2 = table.getState().columnPinning) == null || (_table$getState$colum2 = _table$getState$colum2[position]) == null ? void 0 : _table$getState$colum2.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0;
-      };
-    },
     createRow: (row, table) => {
       row.pin = (position, includeLeafRows, includeParentRows) => {
-        const leafRowIds = includeLeafRows ? row.getLeafRows().map(_ref2 => {
+        const leafRowIds = includeLeafRows ? row.getLeafRows().map(_ref => {
           let {
             id
-          } = _ref2;
+          } = _ref;
           return id;
         }) : [];
-        const parentRowIds = includeParentRows ? row.getParentRows().map(_ref3 => {
+        const parentRowIds = includeParentRows ? row.getParentRows().map(_ref2 => {
           let {
             id
-          } = _ref3;
+          } = _ref2;
           return id;
         }) : [];
         const rowIds = new Set([...parentRowIds, row.id, ...leafRowIds]);
@@ -61658,7 +62149,7 @@ img.ProseMirror-separator {
         });
       };
       row.getCanPin = () => {
-        var _ref4;
+        var _ref3;
         const {
           enableRowPinning,
           enablePinning
@@ -61666,7 +62157,7 @@ img.ProseMirror-separator {
         if (typeof enableRowPinning === 'function') {
           return enableRowPinning(row);
         }
-        return (_ref4 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref4 : true;
+        return (_ref3 = enableRowPinning != null ? enableRowPinning : enablePinning) != null ? _ref3 : true;
       };
       row.getIsPinned = () => {
         const rowIds = [row.id];
@@ -61682,71 +62173,29 @@ img.ProseMirror-separator {
         var _table$_getPinnedRows, _visiblePinnedRowIds$;
         const position = row.getIsPinned();
         if (!position) return -1;
-        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref5 => {
+        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref4 => {
           let {
             id
-          } = _ref5;
+          } = _ref4;
           return id;
         });
         return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1;
       };
-      row.getCenterVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => {
-        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
-        return allCells.filter(d => !leftAndRight.includes(d.column.id));
-      }, getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells'));
-      row.getLeftVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.left], (allCells, left) => {
-        const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
-          ...d,
-          position: 'left'
-        }));
-        return cells;
-      }, getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells'));
-      row.getRightVisibleCells = memo$1(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => {
-        const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({
-          ...d,
-          position: 'right'
-        }));
-        return cells;
-      }, getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells'));
     },
     createTable: table => {
-      table.setColumnPinning = updater => table.options.onColumnPinningChange == null ? void 0 : table.options.onColumnPinningChange(updater);
-      table.resetColumnPinning = defaultState => {
-        var _table$initialState$c, _table$initialState;
-        return table.setColumnPinning(defaultState ? getDefaultColumnPinningState() : (_table$initialState$c = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.columnPinning) != null ? _table$initialState$c : getDefaultColumnPinningState());
-      };
-      table.getIsSomeColumnsPinned = position => {
-        var _pinningState$positio;
-        const pinningState = table.getState().columnPinning;
-        if (!position) {
-          var _pinningState$left, _pinningState$right;
-          return Boolean(((_pinningState$left = pinningState.left) == null ? void 0 : _pinningState$left.length) || ((_pinningState$right = pinningState.right) == null ? void 0 : _pinningState$right.length));
-        }
-        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
-      };
-      table.getLeftLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => {
-        return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
-      }, getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns'));
-      table.getRightLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => {
-        return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean);
-      }, getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns'));
-      table.getCenterLeafColumns = memo$1(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => {
-        const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])];
-        return allColumns.filter(d => !leftAndRight.includes(d.id));
-      }, getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns'));
       table.setRowPinning = updater => table.options.onRowPinningChange == null ? void 0 : table.options.onRowPinningChange(updater);
       table.resetRowPinning = defaultState => {
-        var _table$initialState$r, _table$initialState2;
-        return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState2 = table.initialState) == null ? void 0 : _table$initialState2.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState());
+        var _table$initialState$r, _table$initialState;
+        return table.setRowPinning(defaultState ? getDefaultRowPinningState() : (_table$initialState$r = (_table$initialState = table.initialState) == null ? void 0 : _table$initialState.rowPinning) != null ? _table$initialState$r : getDefaultRowPinningState());
       };
       table.getIsSomeRowsPinned = position => {
-        var _pinningState$positio2;
+        var _pinningState$positio;
         const pinningState = table.getState().rowPinning;
         if (!position) {
           var _pinningState$top, _pinningState$bottom;
           return Boolean(((_pinningState$top = pinningState.top) == null ? void 0 : _pinningState$top.length) || ((_pinningState$bottom = pinningState.bottom) == null ? void 0 : _pinningState$bottom.length));
         }
-        return Boolean((_pinningState$positio2 = pinningState[position]) == null ? void 0 : _pinningState$positio2.length);
+        return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
       };
       table._getPinnedRows = memo$1(position => [table.getRowModel().rows, table.getState().rowPinning[position], position], (visibleRows, pinnedRowIds, position) => {
         var _table$options$keepPi;
@@ -62252,7 +62701,7 @@ img.ProseMirror-separator {
   //
-  const Sorting = {
+  const RowSorting = {
     getInitialState: state => {
       return {
         sorting: [],
@@ -62459,99 +62908,24 @@ img.ProseMirror-separator {
     }
   };
-  //
-  const Visibility = {
-    getInitialState: state => {
-      return {
-        columnVisibility: {},
-        ...state
-      };
-    },
-    getDefaultOptions: table => {
-      return {
-        onColumnVisibilityChange: makeStateUpdater('columnVisibility', table)
-      };
-    },
-    createColumn: (column, table) => {
-      column.toggleVisibility = value => {
-        if (column.getCanHide()) {
-          table.setColumnVisibility(old => ({
-            ...old,
-            [column.id]: value != null ? value : !column.getIsVisible()
-          }));
-        }
-      };
-      column.getIsVisible = () => {
-        var _ref, _table$getState$colum;
-        const childColumns = column.columns;
-        return (_ref = childColumns.length ? childColumns.some(c => c.getIsVisible()) : (_table$getState$colum = table.getState().columnVisibility) == null ? void 0 : _table$getState$colum[column.id]) != null ? _ref : true;
-      };
-      column.getCanHide = () => {
-        var _column$columnDef$ena, _table$options$enable;
-        return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true);
-      };
-      column.getToggleVisibilityHandler = () => {
-        return e => {
-          column.toggleVisibility == null || column.toggleVisibility(e.target.checked);
-        };
-      };
-    },
-    createRow: (row, table) => {
-      row._getAllVisibleCells = memo$1(() => [row.getAllCells(), table.getState().columnVisibility], cells => {
-        return cells.filter(cell => cell.column.getIsVisible());
-      }, getMemoOptions(table.options, 'debugRows', '_getAllVisibleCells'));
-      row.getVisibleCells = memo$1(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], getMemoOptions(table.options, 'debugRows', 'getVisibleCells'));
-    },
-    createTable: table => {
-      const makeVisibleColumnsMethod = (key, getColumns) => {
-        return memo$1(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => {
-          return columns.filter(d => d.getIsVisible == null ? void 0 : d.getIsVisible());
-        }, getMemoOptions(table.options, 'debugColumns', key));
-      };
-      table.getVisibleFlatColumns = makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns());
-      table.getVisibleLeafColumns = makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns());
-      table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns());
-      table.getRightVisibleLeafColumns = makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns());
-      table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns());
-      table.setColumnVisibility = updater => table.options.onColumnVisibilityChange == null ? void 0 : table.options.onColumnVisibilityChange(updater);
-      table.resetColumnVisibility = defaultState => {
-        var _table$initialState$c;
-        table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {});
-      };
-      table.toggleAllColumnsVisible = value => {
-        var _value;
-        value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible();
-        table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({
-          ...obj,
-          [column.id]: !value ? !(column.getCanHide != null && column.getCanHide()) : value
-        }), {}));
-      };
-      table.getIsAllColumnsVisible = () => !table.getAllLeafColumns().some(column => !(column.getIsVisible != null && column.getIsVisible()));
-      table.getIsSomeColumnsVisible = () => table.getAllLeafColumns().some(column => column.getIsVisible == null ? void 0 : column.getIsVisible());
-      table.getToggleAllColumnsVisibilityHandler = () => {
-        return e => {
-          var _target;
-          table.toggleAllColumnsVisible((_target = e.target) == null ? void 0 : _target.checked);
-        };
-      };
-    }
-  };
-  function _getVisibleLeafColumns(table, position) {
-    return !position ? table.getVisibleLeafColumns() : position === 'center' ? table.getCenterVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns();
-  }
-  const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing];
+  const builtInFeatures = [Headers, ColumnVisibility, ColumnOrdering, ColumnPinning, ColumnFaceting, ColumnFiltering, GlobalFaceting,
+  //depends on ColumnFaceting
+  GlobalFiltering,
+  //depends on ColumnFiltering
+  RowSorting, ColumnGrouping,
+  //depends on RowSorting
+  RowExpanding, RowPagination, RowPinning, RowSelection, ColumnSizing];
   //
   function createTable(options) {
-    var _options$initialState;
-    if (options.debugAll || options.debugTable) {
+    var _options$_features, _options$initialState;
+    if ((options.debugAll || options.debugTable)) {
       console.info('Creating Table Instance...');
     }
+    const _features = [...builtInFeatures, ...((_options$_features = options._features) != null ? _options$_features : [])];
     let table = {
-      _features: features
+      _features
     };
     const defaultOptions = table._features.reduce((obj, feature) => {
       return Object.assign(obj, feature.getDefaultOptions == null ? void 0 : feature.getDefaultOptions(table));
@@ -62577,7 +62951,7 @@ img.ProseMirror-separator {
     const queued = [];
     let queuedTimeout = false;
     const coreInstance = {
-      _features: features,
+      _features,
       options: {
         ...defaultOptions,
         ...options
@@ -62713,104 +63087,6 @@ img.ProseMirror-separator {
     return table;
   }
-  function createCell(table, row, column, columnId) {
-    const getRenderValue = () => {
-      var _cell$getValue;
-      return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue;
-    };
-    const cell = {
-      id: `${row.id}_${column.id}`,
-      row,
-      column,
-      getValue: () => row.getValue(columnId),
-      renderValue: getRenderValue,
-      getContext: memo$1(() => [table, column, row, cell], (table, column, row, cell) => ({
-        table,
-        column,
-        row,
-        cell: cell,
-        getValue: cell.getValue,
-        renderValue: cell.renderValue
-      }), getMemoOptions(table.options, 'debugCells', 'cell.getContext'))
-    };
-    table._features.forEach(feature => {
-      feature.createCell == null || feature.createCell(cell, column, row, table);
-    }, {});
-    return cell;
-  }
-  const createRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
-    let row = {
-      id,
-      index: rowIndex,
-      original,
-      depth,
-      parentId,
-      _valuesCache: {},
-      _uniqueValuesCache: {},
-      getValue: columnId => {
-        if (row._valuesCache.hasOwnProperty(columnId)) {
-          return row._valuesCache[columnId];
-        }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.accessorFn)) {
-          return undefined;
-        }
-        row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex);
-        return row._valuesCache[columnId];
-      },
-      getUniqueValues: columnId => {
-        if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
-          return row._uniqueValuesCache[columnId];
-        }
-        const column = table.getColumn(columnId);
-        if (!(column != null && column.accessorFn)) {
-          return undefined;
-        }
-        if (!column.columnDef.getUniqueValues) {
-          row._uniqueValuesCache[columnId] = [row.getValue(columnId)];
-          return row._uniqueValuesCache[columnId];
-        }
-        row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex);
-        return row._uniqueValuesCache[columnId];
-      },
-      renderValue: columnId => {
-        var _row$getValue;
-        return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
-      },
-      subRows: subRows != null ? subRows : [],
-      getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
-      getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : undefined,
-      getParentRows: () => {
-        let parentRows = [];
-        let currentRow = row;
-        while (true) {
-          const parentRow = currentRow.getParentRow();
-          if (!parentRow) break;
-          parentRows.push(parentRow);
-          currentRow = parentRow;
-        }
-        return parentRows.reverse();
-      },
-      getAllCells: memo$1(() => [table.getAllLeafColumns()], leafColumns => {
-        return leafColumns.map(column => {
-          return createCell(table, row, column, column.id);
-        });
-      }, getMemoOptions(table.options, 'debugRows', 'getAllCells')),
-      _getAllCellsByColumnId: memo$1(() => [row.getAllCells()], allCells => {
-        return allCells.reduce((acc, cell) => {
-          acc[cell.column.id] = cell;
-          return acc;
-        }, {});
-      }, getMemoOptions(table.options, 'debugRows', 'getAllCellsByColumnId'))
-    };
-    for (let i = 0; i < table._features.length; i++) {
-      const feature = table._features[i];
-      feature == null || feature.createRow == null || feature.createRow(row, table);
-    }
-    return row;
-  };
   function getCoreRowModel() {
     return table => memo$1(() => [table.options.data], data => {
       const rowModel = {
@@ -62859,87 +63135,33 @@ img.ProseMirror-separator {
     }, getMemoOptions(table.options, 'debugTable', 'getRowModel', () => table._autoResetPageIndex()));
   }
-  function getSortedRowModel() {
-    return table => memo$1(() => [table.getState().sorting, table.getPreSortedRowModel()], (sorting, rowModel) => {
-      if (!rowModel.rows.length || !(sorting != null && sorting.length)) {
+  function getExpandedRowModel() {
+    return table => memo$1(() => [table.getState().expanded, table.getPreExpandedRowModel(), table.options.paginateExpandedRows], (expanded, rowModel, paginateExpandedRows) => {
+      if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
         return rowModel;
       }
-      const sortingState = table.getState().sorting;
-      const sortedFlatRows = [];
-      // Filter out sortings that correspond to non existing columns
-      const availableSorting = sortingState.filter(sort => {
-        var _table$getColumn;
-        return (_table$getColumn = table.getColumn(sort.id)) == null ? void 0 : _table$getColumn.getCanSort();
-      });
-      const columnInfoById = {};
-      availableSorting.forEach(sortEntry => {
-        const column = table.getColumn(sortEntry.id);
-        if (!column) return;
-        columnInfoById[sortEntry.id] = {
-          sortUndefined: column.columnDef.sortUndefined,
-          invertSorting: column.columnDef.invertSorting,
-          sortingFn: column.getSortingFn()
-        };
-      });
-      const sortData = rows => {
-        // This will also perform a stable sorting using the row index
-        // if needed.
-        const sortedData = rows.map(row => ({
-          ...row
-        }));
-        sortedData.sort((rowA, rowB) => {
-          for (let i = 0; i < availableSorting.length; i += 1) {
-            var _sortEntry$desc;
-            const sortEntry = availableSorting[i];
-            const columnInfo = columnInfoById[sortEntry.id];
-            const isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
-            let sortInt = 0;
-            // All sorting ints should always return in ascending order
-            if (columnInfo.sortUndefined) {
-              const aValue = rowA.getValue(sortEntry.id);
-              const bValue = rowB.getValue(sortEntry.id);
-              const aUndefined = aValue === undefined;
-              const bUndefined = bValue === undefined;
-              if (aUndefined || bUndefined) {
-                sortInt = aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
-              }
-            }
-            if (sortInt === 0) {
-              sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
-            }
-            // If sorting is non-zero, take care of desc and inversion
-            if (sortInt !== 0) {
-              if (isDesc) {
-                sortInt *= -1;
-              }
-              if (columnInfo.invertSorting) {
-                sortInt *= -1;
-              }
-              return sortInt;
-            }
-          }
-          return rowA.index - rowB.index;
-        });
-        // If there are sub-rows, sort them
-        sortedData.forEach(row => {
-          var _row$subRows;
-          sortedFlatRows.push(row);
-          if ((_row$subRows = row.subRows) != null && _row$subRows.length) {
-            row.subRows = sortData(row.subRows);
-          }
-        });
-        return sortedData;
-      };
-      return {
-        rows: sortData(rowModel.rows),
-        flatRows: sortedFlatRows,
-        rowsById: rowModel.rowsById
-      };
-    }, getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () => table._autoResetPageIndex()));
+      if (!paginateExpandedRows) {
+        // Only expand rows at this point if they are being paginated
+        return rowModel;
+      }
+      return expandRows(rowModel);
+    }, getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel'));
+  }
+  function expandRows(rowModel) {
+    const expandedRows = [];
+    const handleRow = row => {
+      var _row$subRows;
+      expandedRows.push(row);
+      if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
+        row.subRows.forEach(handleRow);
+      }
+    };
+    rowModel.rows.forEach(handleRow);
+    return {
+      rows: expandedRows,
+      flatRows: rowModel.flatRows,
+      rowsById: rowModel.rowsById
+    };
   }
   function getGroupedRowModel() {
@@ -63075,33 +63297,90 @@ img.ProseMirror-separator {
     }, groupMap);
   }
-  function getExpandedRowModel() {
-    return table => memo$1(() => [table.getState().expanded, table.getPreExpandedRowModel(), table.options.paginateExpandedRows], (expanded, rowModel, paginateExpandedRows) => {
-      if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
-        return rowModel;
-      }
-      if (!paginateExpandedRows) {
-        // Only expand rows at this point if they are being paginated
+  function getSortedRowModel() {
+    return table => memo$1(() => [table.getState().sorting, table.getPreSortedRowModel()], (sorting, rowModel) => {
+      if (!rowModel.rows.length || !(sorting != null && sorting.length)) {
         return rowModel;
       }
-      return expandRows(rowModel);
-    }, getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel'));
-  }
-  function expandRows(rowModel) {
-    const expandedRows = [];
-    const handleRow = row => {
-      var _row$subRows;
-      expandedRows.push(row);
-      if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
-        row.subRows.forEach(handleRow);
-      }
-    };
-    rowModel.rows.forEach(handleRow);
-    return {
-      rows: expandedRows,
-      flatRows: rowModel.flatRows,
-      rowsById: rowModel.rowsById
-    };
+      const sortingState = table.getState().sorting;
+      const sortedFlatRows = [];
+      // Filter out sortings that correspond to non existing columns
+      const availableSorting = sortingState.filter(sort => {
+        var _table$getColumn;
+        return (_table$getColumn = table.getColumn(sort.id)) == null ? void 0 : _table$getColumn.getCanSort();
+      });
+      const columnInfoById = {};
+      availableSorting.forEach(sortEntry => {
+        const column = table.getColumn(sortEntry.id);
+        if (!column) return;
+        columnInfoById[sortEntry.id] = {
+          sortUndefined: column.columnDef.sortUndefined,
+          invertSorting: column.columnDef.invertSorting,
+          sortingFn: column.getSortingFn()
+        };
+      });
+      const sortData = rows => {
+        // This will also perform a stable sorting using the row index
+        // if needed.
+        const sortedData = rows.map(row => ({
+          ...row
+        }));
+        sortedData.sort((rowA, rowB) => {
+          for (let i = 0; i < availableSorting.length; i += 1) {
+            var _sortEntry$desc;
+            const sortEntry = availableSorting[i];
+            const columnInfo = columnInfoById[sortEntry.id];
+            const sortUndefined = columnInfo.sortUndefined;
+            const isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
+            let sortInt = 0;
+            // All sorting ints should always return in ascending order
+            if (sortUndefined) {
+              const aValue = rowA.getValue(sortEntry.id);
+              const bValue = rowB.getValue(sortEntry.id);
+              const aUndefined = aValue === undefined;
+              const bUndefined = bValue === undefined;
+              if (aUndefined || bUndefined) {
+                if (sortUndefined === 'first') return aUndefined ? -1 : 1;
+                if (sortUndefined === 'last') return aUndefined ? 1 : -1;
+                sortInt = aUndefined && bUndefined ? 0 : aUndefined ? sortUndefined : -sortUndefined;
+              }
+            }
+            if (sortInt === 0) {
+              sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
+            }
+            // If sorting is non-zero, take care of desc and inversion
+            if (sortInt !== 0) {
+              if (isDesc) {
+                sortInt *= -1;
+              }
+              if (columnInfo.invertSorting) {
+                sortInt *= -1;
+              }
+              return sortInt;
+            }
+          }
+          return rowA.index - rowB.index;
+        });
+        // If there are sub-rows, sort them
+        sortedData.forEach(row => {
+          var _row$subRows;
+          sortedFlatRows.push(row);
+          if ((_row$subRows = row.subRows) != null && _row$subRows.length) {
+            row.subRows = sortData(row.subRows);
+          }
+        });
+        return sortedData;
+      };
+      return {
+        rows: sortData(rowModel.rows),
+        flatRows: sortedFlatRows,
+        rowsById: rowModel.rowsById
+      };
+    }, getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () => table._autoResetPageIndex()));
   }
   const TableRecordDelayedHierarchyState = {
@@ -65065,6 +65344,7 @@ img.ProseMirror-separator {
           measureElement,
           initialRect: { width: 0, height: 0 },
           scrollMargin: 0,
+          gap: 0,
           scrollingDelay: 150,
           indexAttribute: "data-index",
           initialMeasurementsCache: [],
@@ -65208,7 +65488,7 @@ img.ProseMirror-separator {
           for (let i = min; i < count; i++) {
             const key = getItemKey(i);
             const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
-            const start = furthestMeasurement ? furthestMeasurement.end : paddingStart + scrollMargin;
+            const start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
             const measuredSize = itemSizeCache.get(key);
             const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
             const end = start + size;
@@ -65300,7 +65580,7 @@ img.ProseMirror-separator {
         const itemSize = this.itemSizeCache.get(item.key) ?? item.size;
         const delta = size - itemSize;
         if (delta !== 0) {
-          if (item.start < this.scrollOffset + this.scrollAdjustments) {
+          if (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.scrollOffset + this.scrollAdjustments) {
             if (this.options.debug) {
               console.info("correction", delta);
             }
@@ -65468,7 +65748,7 @@ img.ProseMirror-separator {
       };
       this.setOptions(opts);
       this.scrollRect = this.options.initialRect;
-      this.scrollOffset = this.options.initialOffset;
+      this.scrollOffset = typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset;
       this.measurementsCache = this.options.initialMeasurementsCache;
       this.measurementsCache.forEach((item) => {
         this.itemSizeCache.set(item.key, item.size);