@ni/nimble-components 24.1.12 → 24.1.14

package/dist/all-components-bundle.js

@@ -16333,7 +16333,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Wed, 10 Apr 2024 19:20:19 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();
@@ -53413,22 +53583,16 @@ img.ProseMirror-separator {
    */
   class MentionInternals {
       constructor(options, mentionUpdateEmitter) {
-          /**
-           * Whether this mention has a valid configuration.
-           */
-          this.validConfiguration = true;
           this.iconTemplate = html `<${options.icon} slot="start"></${options.icon}>`;
           this.character = options.character;
           this.viewElement = options.viewElement;
+          this.validator = options.validator;
           this.mentionUpdateEmitter = mentionUpdateEmitter;
       }
   }
   __decorate$1([
       observable
   ], MentionInternals.prototype, "mappingConfigs", void 0);
-  __decorate$1([
-      observable
-  ], MentionInternals.prototype, "validConfiguration", void 0);
   __decorate$1([
       observable
   ], MentionInternals.prototype, "pattern", void 0);
@@ -53449,8 +53613,6 @@ img.ProseMirror-separator {
               this.emitMentionUpdate(filter);
           });
           /** @internal */
-          this.validator = this.createValidator();
-          /** @internal */
           this.mappingNotifiers = [];
           /** @internal */
           this.mappingElements = [];
@@ -53459,13 +53621,13 @@ img.ProseMirror-separator {
        * @public
        */
       checkValidity() {
-          return this.mentionInternals.validConfiguration;
+          return this.mentionInternals.validator.isValid();
       }
       /**
        * @public
        */
       get validity() {
-          return this.validator.getValidity();
+          return this.mentionInternals.validator.getValidity();
       }
       /**
        * @internal
@@ -53499,8 +53661,8 @@ img.ProseMirror-separator {
           return mappingConfigs;
       }
       updateMappingConfigs() {
-          this.validator.validate(this.mappingElements, this.pattern);
-          this.mentionInternals.mappingConfigs = this.validator.isValid()
+          this.mentionInternals.validator.validate(this.mappingElements, this.pattern);
+          this.mentionInternals.mappingConfigs = this.mentionInternals.validator.isValid()
               ? this.getMappingConfigs()
               : undefined;
       }
@@ -53509,7 +53671,7 @@ img.ProseMirror-separator {
           this.observeMappingElements();
       }
       patternChanged() {
-          this.validator.validate(this.mappingElements, this.pattern);
+          this.mentionInternals.validator.validate(this.mappingElements, this.pattern);
           this.mentionInternals.pattern = this.pattern;
       }
       buttonLabelChanged() {
@@ -53573,7 +53735,7 @@ img.ProseMirror-separator {
       constructor(mentionElements) {
           this.parserMentionConfig = [];
           this.isValid = true;
-          this.isValid = mentionElements.every(mentionElement => mentionElement.mentionInternals.validConfiguration);
+          this.isValid = mentionElements.every(mentionElement => mentionElement.mentionInternals.validator.isValid());
           this.parserMentionConfig = this.isValid
               ? mentionElements.map(mentionElement => new MarkdownParserMentionConfiguration(mentionElement.mentionInternals))
               : [];
@@ -53714,7 +53876,7 @@ img.ProseMirror-separator {
           this.validateMentionConfigurations(mentions);
       }
       validateMentionConfigurations(mentions) {
-          this.invalidMentionConfiguration = mentions.some(x => !x.mentionInternals.validConfiguration);
+          this.invalidMentionConfiguration = mentions.some(x => !x.mentionInternals.validator.isValid());
           return !this.invalidMentionConfiguration;
       }
       validateDuplicateMentionConfigurations(mentions) {
@@ -53819,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() {
@@ -54550,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
@@ -54618,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',
@@ -54676,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() {
@@ -56495,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'),
@@ -56533,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 => ({
@@ -56580,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;
                   }
@@ -56754,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) {
@@ -57129,7 +57317,7 @@ img.ProseMirror-separator {
                           text: state.text,
                           items: [],
                           command: commandProps => {
-                              command({
+                              return command({
                                   editor,
                                   range: state.range,
                                   props: commandProps,
@@ -57283,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}`,
                   ];
               },
@@ -57379,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') {
@@ -57417,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;
                       }
                   });
@@ -60020,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?
@@ -60107,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();
@@ -60166,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;
   }
 
@@ -60423,92 +60665,803 @@ 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 => {
+      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;
           }
@@ -60676,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();
+          column.toggleVisibility == null || column.toggleVisibility(e.target.checked);
         };
       };
-      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();
-        };
-      };
-    }
-  };
-
-  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) {
@@ -61117,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();
+        };
+      };
     }
   };
 
@@ -61411,7 +61948,7 @@ img.ProseMirror-separator {
     pageIndex: defaultPageIndex,
     pageSize: defaultPageSize
   });
-  const Pagination = {
+  const RowPagination = {
     getInitialState: state => {
       return {
         ...state,
@@ -61558,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]);
@@ -61666,7 +62149,7 @@ img.ProseMirror-separator {
         });
       };
       row.getCanPin = () => {
-        var _ref4;
+        var _ref3;
         const {
           enableRowPinning,
           enablePinning
@@ -61674,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];
@@ -61690,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;
@@ -62260,7 +62701,7 @@ img.ProseMirror-separator {
 
   //
 
-  const Sorting = {
+  const RowSorting = {
     getInitialState: state => {
       return {
         sorting: [],
@@ -62467,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));
@@ -62585,7 +62951,7 @@ img.ProseMirror-separator {
     const queued = [];
     let queuedTimeout = false;
     const coreInstance = {
-      _features: features,
+      _features,
       options: {
         ...defaultOptions,
         ...options
@@ -62721,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 = {
@@ -62867,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() {
@@ -63083,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 = {
@@ -65073,6 +65344,7 @@ img.ProseMirror-separator {
           measureElement,
           initialRect: { width: 0, height: 0 },
           scrollMargin: 0,
+          gap: 0,
           scrollingDelay: 150,
           indexAttribute: "data-index",
           initialMeasurementsCache: [],
@@ -65216,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;
@@ -65308,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);
             }
@@ -65476,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);