@ni/nimble-components 21.3.1 → 21.3.3

package/dist/all-components-bundle.js

@@ -16301,7 +16301,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Fri, 09 Feb 2024 01:47:11 GMT
+   * Generated on Tue, 13 Feb 2024 21:07:13 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -27804,7 +27804,7 @@
   ProseMirror document conforming to a given schema. Its behavior is
   defined by an array of [rules](https://prosemirror.net/docs/ref/#model.ParseRule).
   */
-  class DOMParser {
+  let DOMParser$1 = class DOMParser {
       /**
       Create a parser that targets the given schema, using the given
       parsing rules.
@@ -27949,7 +27949,7 @@
           return schema.cached.domParser ||
               (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
       }
-  }
+  };
   const blockTags = {
       address: true, article: true, aside: true, blockquote: true, canvas: true,
       dd: true, div: true, dl: true, fieldset: true, figcaption: true, figure: true,
@@ -34488,7 +34488,7 @@
               dom = child;
           }
       if (!slice) {
-          let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+          let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
           slice = parser.parseSlice(dom, {
               preserveWhitespace: !!(asText || sliceData),
               context: $context,
@@ -36412,7 +36412,7 @@
           }
       }
       let startDoc = view.state.doc;
-      let parser = view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+      let parser = view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
       let $from = startDoc.resolve(from);
       let sel = null, doc = parser.parse(parent, {
           topNode: $from.parent,
@@ -37597,6 +37597,60 @@
       }
       return false;
   };
+  /**
+  A more limited form of [`joinBackward`]($commands.joinBackward)
+  that only tries to join the current textblock to the one before
+  it, if the cursor is at the start of a textblock.
+  */
+  const joinTextblockBackward$1 = (state, dispatch, view) => {
+      let $cursor = atBlockStart(state, view);
+      if (!$cursor)
+          return false;
+      let $cut = findCutBefore($cursor);
+      return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+  };
+  /**
+  A more limited form of [`joinForward`]($commands.joinForward)
+  that only tries to join the current textblock to the one after
+  it, if the cursor is at the end of a textblock.
+  */
+  const joinTextblockForward$1 = (state, dispatch, view) => {
+      let $cursor = atBlockEnd(state, view);
+      if (!$cursor)
+          return false;
+      let $cut = findCutAfter($cursor);
+      return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+  };
+  function joinTextblocksAround(state, $cut, dispatch) {
+      let before = $cut.nodeBefore, beforeText = before, beforePos = $cut.pos - 1;
+      for (; !beforeText.isTextblock; beforePos--) {
+          if (beforeText.type.spec.isolating)
+              return false;
+          let child = beforeText.lastChild;
+          if (!child)
+              return false;
+          beforeText = child;
+      }
+      let after = $cut.nodeAfter, afterText = after, afterPos = $cut.pos + 1;
+      for (; !afterText.isTextblock; afterPos++) {
+          if (afterText.type.spec.isolating)
+              return false;
+          let child = afterText.firstChild;
+          if (!child)
+              return false;
+          afterText = child;
+      }
+      let step = replaceStep(state.doc, beforePos, afterPos, Slice.empty);
+      if (!step || step.from != beforePos ||
+          step instanceof ReplaceStep && step.slice.size >= afterPos - beforePos)
+          return false;
+      if (dispatch) {
+          let tr = state.tr.step(step);
+          tr.setSelection(TextSelection.create(tr.doc, beforePos));
+          dispatch(tr.scrollIntoView());
+      }
+      return true;
+  }
   function textblockAt(node, side, only = false) {
       for (let scan = node; scan; scan = (side == "start" ? scan.firstChild : scan.lastChild)) {
           if (scan.isTextblock)
@@ -38177,7 +38231,6 @@
           ...state,
           apply: state.apply.bind(state),
           applyTransaction: state.applyTransaction.bind(state),
-          filterTransaction: state.filterTransaction,
           plugins: state.plugins,
           schema: state.schema,
           reconfigure: state.reconfigure.bind(state),
@@ -38892,11 +38945,11 @@
           this.handler = config.handler;
       }
   }
-  const pasteRuleMatcherHandler = (text, find) => {
+  const pasteRuleMatcherHandler = (text, find, event) => {
       if (isRegExp$1(find)) {
           return [...text.matchAll(find)];
       }
-      const matches = find(text);
+      const matches = find(text, event);
       if (!matches) {
           return [];
       }
@@ -38928,7 +38981,7 @@
           const resolvedFrom = Math.max(from, pos);
           const resolvedTo = Math.min(to, pos + node.content.size);
           const textToMatch = node.textBetween(resolvedFrom - pos, resolvedTo - pos, undefined, '\ufffc');
-          const matches = pasteRuleMatcherHandler(textToMatch, rule.find);
+          const matches = pasteRuleMatcherHandler(textToMatch, rule.find, pasteEvent);
           matches.forEach(match => {
               if (match.index === undefined) {
                   return;
@@ -39309,7 +39362,7 @@
               ...config,
           };
           this.name = this.config.name;
-          if (config.defaultOptions) {
+          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
               console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           // TODO: remove `addOptions` fallback
@@ -39339,7 +39392,7 @@
           return extension;
       }
       extend(extendedConfig = {}) {
-          const extension = new Extension(extendedConfig);
+          const extension = new Extension({ ...this.config, ...extendedConfig });
           extension.parent = this;
           this.child = extension;
           extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
@@ -39746,10 +39799,24 @@
       return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
   };
 
+  const removeWhitespaces = (node) => {
+      const children = node.childNodes;
+      for (let i = children.length - 1; i >= 0; i -= 1) {
+          const child = children[i];
+          if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
+              node.removeChild(child);
+          }
+          else if (child.nodeType === 1) {
+              removeWhitespaces(child);
+          }
+      }
+      return node;
+  };
   function elementFromString(value) {
       // add a wrapper to preserve leading and trailing whitespace
       const wrappedValue = `<body>${value}</body>`;
-      return new window.DOMParser().parseFromString(wrappedValue, 'text/html').body;
+      const html = new window.DOMParser().parseFromString(wrappedValue, 'text/html').body;
+      return removeWhitespaces(html);
   }
 
   function createNodeFromContent(content, schema, options) {
@@ -39771,7 +39838,7 @@
           }
       }
       if (typeof content === 'string') {
-          const parser = DOMParser.fromSchema(schema);
+          const parser = DOMParser$1.fromSchema(schema);
           return options.slice
               ? parser.parseSlice(elementFromString(content), options.parseOptions).content
               : parser.parse(elementFromString(content), options.parseOptions);
@@ -39915,6 +39982,14 @@
       }
   };
 
+  const joinTextblockBackward = () => ({ state, dispatch }) => {
+      return joinTextblockBackward$1(state, dispatch);
+  };
+
+  const joinTextblockForward = () => ({ state, dispatch }) => {
+      return joinTextblockForward$1(state, dispatch);
+  };
+
   function isMacOS() {
       return typeof navigator !== 'undefined'
           ? /Mac/.test(navigator.platform)
@@ -40387,6 +40462,9 @@
       }
       else {
           doc.nodesBetween(from, to, (node, pos) => {
+              if (!node || (node === null || node === void 0 ? void 0 : node.nodeSize) === undefined) {
+                  return;
+              }
               marks.push(...node.marks.map(mark => ({
                   from: pos,
                   to: pos + node.nodeSize,
@@ -41078,6 +41156,8 @@
     joinForward: joinForward,
     joinItemBackward: joinItemBackward,
     joinItemForward: joinItemForward,
+    joinTextblockBackward: joinTextblockBackward,
+    joinTextblockForward: joinTextblockForward,
     keyboardShortcut: keyboardShortcut,
     lift: lift,
     liftEmptyBlock: liftEmptyBlock,
@@ -41303,6 +41383,180 @@
     Tabindex: Tabindex
   });
 
+  class NodePos {
+      constructor(pos, editor, isBlock = false, node = null) {
+          this.currentNode = null;
+          this.actualDepth = null;
+          this.isBlock = isBlock;
+          this.resolvedPos = pos;
+          this.editor = editor;
+          this.currentNode = node;
+      }
+      get name() {
+          return this.node.type.name;
+      }
+      get node() {
+          return this.currentNode || this.resolvedPos.node();
+      }
+      get element() {
+          return this.editor.view.domAtPos(this.pos).node;
+      }
+      get depth() {
+          var _a;
+          return (_a = this.actualDepth) !== null && _a !== void 0 ? _a : this.resolvedPos.depth;
+      }
+      get pos() {
+          return this.resolvedPos.pos;
+      }
+      get content() {
+          return this.node.content;
+      }
+      set content(content) {
+          let from = this.from;
+          let to = this.to;
+          if (this.isBlock) {
+              if (this.content.size === 0) {
+                  console.error(`You can’t set content on a block node. Tried to set content on ${this.name} at ${this.pos}`);
+                  return;
+              }
+              from = this.from + 1;
+              to = this.to - 1;
+          }
+          this.editor.commands.insertContentAt({ from, to }, content);
+      }
+      get attributes() {
+          return this.node.attrs;
+      }
+      get textContent() {
+          return this.node.textContent;
+      }
+      get size() {
+          return this.node.nodeSize;
+      }
+      get from() {
+          if (this.isBlock) {
+              return this.pos;
+          }
+          return this.resolvedPos.start(this.resolvedPos.depth);
+      }
+      get range() {
+          return {
+              from: this.from,
+              to: this.to,
+          };
+      }
+      get to() {
+          if (this.isBlock) {
+              return this.pos + this.size;
+          }
+          return this.resolvedPos.end(this.resolvedPos.depth) + (this.node.isText ? 0 : 1);
+      }
+      get parent() {
+          if (this.depth === 0) {
+              return null;
+          }
+          const parentPos = this.resolvedPos.start(this.resolvedPos.depth - 1);
+          const $pos = this.resolvedPos.doc.resolve(parentPos);
+          return new NodePos($pos, this.editor);
+      }
+      get before() {
+          let $pos = this.resolvedPos.doc.resolve(this.from - (this.isBlock ? 1 : 2));
+          if ($pos.depth !== this.depth) {
+              $pos = this.resolvedPos.doc.resolve(this.from - 3);
+          }
+          return new NodePos($pos, this.editor);
+      }
+      get after() {
+          let $pos = this.resolvedPos.doc.resolve(this.to + (this.isBlock ? 2 : 1));
+          if ($pos.depth !== this.depth) {
+              $pos = this.resolvedPos.doc.resolve(this.to + 3);
+          }
+          return new NodePos($pos, this.editor);
+      }
+      get children() {
+          const children = [];
+          this.node.content.forEach((node, offset) => {
+              const isBlock = node.isBlock && !node.isTextblock;
+              const targetPos = this.pos + offset + (isBlock ? 0 : 1);
+              const $pos = this.resolvedPos.doc.resolve(targetPos);
+              if (!isBlock && $pos.depth <= this.depth) {
+                  return;
+              }
+              const childNodePos = new NodePos($pos, this.editor, isBlock, isBlock ? node : null);
+              if (isBlock) {
+                  childNodePos.actualDepth = this.depth + 1;
+              }
+              children.push(new NodePos($pos, this.editor, isBlock, isBlock ? node : null));
+          });
+          return children;
+      }
+      get firstChild() {
+          return this.children[0] || null;
+      }
+      get lastChild() {
+          const children = this.children;
+          return children[children.length - 1] || null;
+      }
+      closest(selector, attributes = {}) {
+          let node = null;
+          let currentNode = this.parent;
+          while (currentNode && !node) {
+              if (currentNode.node.type.name === selector) {
+                  if (Object.keys(attributes).length > 0) {
+                      const nodeAttributes = currentNode.node.attrs;
+                      const attrKeys = Object.keys(attributes);
+                      for (let index = 0; index < attrKeys.length; index += 1) {
+                          const key = attrKeys[index];
+                          if (nodeAttributes[key] !== attributes[key]) {
+                              break;
+                          }
+                      }
+                  }
+                  else {
+                      node = currentNode;
+                  }
+              }
+              currentNode = currentNode.parent;
+          }
+          return node;
+      }
+      querySelector(selector, attributes = {}) {
+          return this.querySelectorAll(selector, attributes, true)[0] || null;
+      }
+      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) {
+              return nodes;
+          }
+          this.children.forEach(childPos => {
+              if (childPos.node.type.name === selector) {
+                  if (Object.keys(attributes).length > 0) {
+                      const nodeAttributes = childPos.node.attrs;
+                      const attrKeys = Object.keys(attributes);
+                      for (let index = 0; index < attrKeys.length; index += 1) {
+                          const key = attrKeys[index];
+                          if (nodeAttributes[key] !== attributes[key]) {
+                              return;
+                          }
+                      }
+                  }
+                  nodes.push(childPos);
+                  if (firstItemOnly) {
+                      return;
+                  }
+              }
+              nodes = nodes.concat(childPos.querySelectorAll(selector));
+          });
+          return nodes;
+      }
+      setAttribute(attributes) {
+          const oldSelection = this.editor.state.selection;
+          this.editor.chain().setTextSelection(this.from).updateAttributes(this.node.type.name, attributes).setTextSelection(oldSelection.from)
+              .run();
+      }
+  }
+
   const style = `.ProseMirror {
   position: relative;
 }
@@ -41748,6 +42002,21 @@ img.ProseMirror-separator {
           // @ts-ignore
           return !((_a = this.view) === null || _a === void 0 ? void 0 : _a.docView);
       }
+      $node(selector, attributes) {
+          var _a;
+          return ((_a = this.$doc) === null || _a === void 0 ? void 0 : _a.querySelector(selector, attributes)) || null;
+      }
+      $nodes(selector, attributes) {
+          var _a;
+          return ((_a = this.$doc) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector, attributes)) || null;
+      }
+      $pos(pos) {
+          const $pos = this.state.doc.resolve(pos);
+          return new NodePos($pos, this);
+      }
+      get $doc() {
+          return this.$pos(0);
+      }
   }
 
   /**
@@ -41860,7 +42129,7 @@ img.ProseMirror-separator {
               ...config,
           };
           this.name = this.config.name;
-          if (config.defaultOptions) {
+          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
               console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           // TODO: remove `addOptions` fallback
@@ -41890,7 +42159,7 @@ img.ProseMirror-separator {
           return extension;
       }
       extend(extendedConfig = {}) {
-          const extension = new Mark(extendedConfig);
+          const extension = new Mark({ ...this.config, ...extendedConfig });
           extension.parent = this;
           this.child = extension;
           extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
@@ -41943,7 +42212,7 @@ img.ProseMirror-separator {
               ...config,
           };
           this.name = this.config.name;
-          if (config.defaultOptions) {
+          if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
               console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
           }
           // TODO: remove `addOptions` fallback
@@ -41973,7 +42242,7 @@ img.ProseMirror-separator {
           return extension;
       }
       extend(extendedConfig = {}) {
-          const extension = new Node(extendedConfig);
+          const extension = new Node({ ...this.config, ...extendedConfig });
           extension.parent = this;
           this.child = extension;
           extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
@@ -53527,11 +53796,8 @@ img.ProseMirror-separator {
       addKeyboardShortcuts() {
           return {
               'Mod-z': () => this.editor.commands.undo(),
-              'Mod-Z': () => this.editor.commands.undo(),
-              'Mod-y': () => this.editor.commands.redo(),
-              'Mod-Y': () => this.editor.commands.redo(),
               'Shift-Mod-z': () => this.editor.commands.redo(),
-              'Shift-Mod-Z': () => this.editor.commands.redo(),
+              'Mod-y': () => this.editor.commands.redo(),
               // Russian keyboard layouts
               'Mod-я': () => this.editor.commands.undo(),
               'Shift-Mod-я': () => this.editor.commands.redo(),
@@ -55438,8 +55704,13 @@ img.ProseMirror-separator {
                   if (event.button !== 0) {
                       return false;
                   }
-                  const eventTarget = event.target;
-                  if (eventTarget.nodeName !== 'A') {
+                  let a = event.target;
+                  const els = [];
+                  while (a.nodeName !== 'DIV') {
+                      els.push(a);
+                      a = a.parentNode;
+                  }
+                  if (!els.find(value => value.nodeName === 'A')) {
                       return false;
                   }
                   const attrs = getAttributes(view.state, options.type.name);
@@ -55447,9 +55718,7 @@ img.ProseMirror-separator {
                   const href = (_a = link === null || link === void 0 ? void 0 : link.href) !== null && _a !== void 0 ? _a : attrs.href;
                   const target = (_b = link === null || link === void 0 ? void 0 : link.target) !== null && _b !== void 0 ? _b : attrs.target;
                   if (link && href) {
-                      if (view.editable) {
-                          window.open(href, target);
-                      }
+                      window.open(href, target);
                       return true;
                   }
                   return false;
@@ -55463,7 +55732,6 @@ img.ProseMirror-separator {
           key: new PluginKey('handlePasteLink'),
           props: {
               handlePaste: (view, event, slice) => {
-                  var _a;
                   const { state } = view;
                   const { selection } = state;
                   const { empty } = selection;
@@ -55478,19 +55746,14 @@ img.ProseMirror-separator {
                   if (!textContent || !link) {
                       return false;
                   }
-                  const html = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
-                  const hrefRegex = /href="([^"]*)"/;
-                  const existingLink = html === null || html === void 0 ? void 0 : html.match(hrefRegex);
-                  const url = existingLink ? existingLink[1] : link.href;
                   options.editor.commands.setMark(options.type, {
-                      href: url,
+                      href: link.href,
                   });
                   return true;
               },
           },
       });
   }
-
   const Link = Mark.create({
       name: 'link',
       priority: 1000,
@@ -55575,32 +55838,44 @@ img.ProseMirror-separator {
       addPasteRules() {
           return [
               markPasteRule({
-                  find: text => find$1(text)
-                      .filter(link => {
-                      if (this.options.validate) {
-                          return this.options.validate(link.value);
+                  find: (text, event) => {
+                      var _a;
+                      const html = (_a = event === null || event === void 0 ? void 0 : event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
+                      const foundLinks = [];
+                      if (html) {
+                          const dom = new DOMParser().parseFromString(html, 'text/html');
+                          const anchors = dom.querySelectorAll('a');
+                          if (anchors.length) {
+                              [...anchors].forEach(anchor => (foundLinks.push({
+                                  text: anchor.innerText,
+                                  data: {
+                                      href: anchor.getAttribute('href'),
+                                  },
+                                  // get the index of the anchor inside the text
+                                  // and add the length of the anchor text
+                                  index: dom.body.innerText.indexOf(anchor.innerText) + anchor.innerText.length,
+                              })));
+                          }
                       }
-                      return true;
-                  })
-                      .filter(link => link.isLink)
-                      .map(link => ({
-                      text: link.value,
-                      index: link.start,
-                      data: link,
-                  })),
-                  type: this.type,
-                  getAttributes: (match, pasteEvent) => {
-                      var _a, _b;
-                      const html = (_a = pasteEvent === null || pasteEvent === void 0 ? void 0 : pasteEvent.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/html');
-                      const hrefRegex = /href="([^"]*)"/;
-                      const existingLink = html === null || html === void 0 ? void 0 : html.match(hrefRegex);
-                      if (existingLink) {
-                          return {
-                              href: existingLink[1],
-                          };
+                      if (text) {
+                          const links = find$1(text).filter(item => item.isLink);
+                          if (links.length) {
+                              links.forEach(link => (foundLinks.push({
+                                  text: link.value,
+                                  data: {
+                                      href: link.href,
+                                  },
+                                  index: link.start,
+                              })));
+                          }
                       }
+                      return foundLinks;
+                  },
+                  type: this.type,
+                  getAttributes: match => {
+                      var _a;
                       return {
-                          href: (_b = match.data) === null || _b === void 0 ? void 0 : _b.href,
+                          href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href,
                       };
                   },
               }),
@@ -55846,6 +56121,7 @@ img.ProseMirror-separator {
               emptyNodeClass: 'is-empty',
               placeholder: 'Write something …',
               showOnlyWhenEditable: true,
+              considerAnyAsEmpty: false,
               showOnlyCurrent: true,
               includeChildren: false,
           };
@@ -55856,6 +56132,7 @@ img.ProseMirror-separator {
                   key: new PluginKey('placeholder'),
                   props: {
                       decorations: ({ doc, selection }) => {
+                          var _a;
                           const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;
                           const { anchor } = selection;
                           const decorations = [];
@@ -55863,15 +56140,22 @@ img.ProseMirror-separator {
                               return null;
                           }
                           // only calculate isEmpty once due to its performance impacts (see issue #3360)
-                          const emptyDocInstance = doc.type.createAndFill();
-                          const isEditorEmpty = (emptyDocInstance === null || emptyDocInstance === void 0 ? void 0 : emptyDocInstance.sameMarkup(doc))
-                              && emptyDocInstance.content.findDiffStart(doc.content) === null;
+                          const { firstChild } = doc.content;
+                          const isLeaf = firstChild && firstChild.type.isLeaf;
+                          const isAtom = firstChild && firstChild.isAtom;
+                          const isValidNode = this.options.considerAnyAsEmpty
+                              ? true
+                              : firstChild && firstChild.type.name === ((_a = doc.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.name);
+                          const isEmptyDoc = doc.content.childCount <= 1
+                              && firstChild
+                              && isValidNode
+                              && (firstChild.nodeSize <= 2 && (!isLeaf || !isAtom));
                           doc.descendants((node, pos) => {
                               const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
                               const isEmpty = !node.isLeaf && !node.childCount;
                               if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
                                   const classes = [this.options.emptyNodeClass];
-                                  if (isEditorEmpty) {
+                                  if (isEmptyDoc) {
                                       classes.push(this.options.emptyEditorClass);
                                   }
                                   const decoration = Decoration.node(pos, pos + node.nodeSize, {
@@ -56133,10 +56417,18 @@ img.ProseMirror-separator {
       addOptions() {
           return {
               HTMLAttributes: {},
-              renderLabel({ options, node }) {
+              renderText({ options, node }) {
                   var _a;
                   return `${options.suggestion.char}${(_a = node.attrs.label) !== null && _a !== void 0 ? _a : node.attrs.id}`;
               },
+              renderHTML({ options, node }) {
+                  var _a;
+                  return [
+                      'span',
+                      this.HTMLAttributes,
+                      `${options.suggestion.char}${(_a = node.attrs.label) !== null && _a !== void 0 ? _a : node.attrs.id}`,
+                  ];
+              },
               suggestion: {
                   char: '@',
                   pluginKey: MentionPluginKey,
@@ -56214,17 +56506,39 @@ img.ProseMirror-separator {
           ];
       },
       renderHTML({ node, HTMLAttributes }) {
-          return [
-              'span',
-              mergeAttributes({ 'data-type': this.name }, this.options.HTMLAttributes, HTMLAttributes),
-              this.options.renderLabel({
-                  options: this.options,
-                  node,
-              }),
-          ];
+          if (this.options.renderLabel !== undefined) {
+              console.warn('renderLabel is deprecated use renderText and renderHTML instead');
+              return [
+                  'span',
+                  mergeAttributes({ 'data-type': this.name }, this.options.HTMLAttributes, HTMLAttributes),
+                  this.options.renderLabel({
+                      options: this.options,
+                      node,
+                  }),
+              ];
+          }
+          const html = this.options.renderHTML({
+              options: this.options,
+              node,
+          });
+          if (typeof html === 'string') {
+              return [
+                  'span',
+                  mergeAttributes({ 'data-type': this.name }, this.options.HTMLAttributes, HTMLAttributes),
+                  html,
+              ];
+          }
+          return html;
       },
       renderText({ node }) {
-          return this.options.renderLabel({
+          if (this.options.renderLabel !== undefined) {
+              console.warn('renderLabel is deprecated use renderText and renderHTML instead');
+              return this.options.renderLabel({
+                  options: this.options,
+                  node,
+              });
+          }
+          return this.options.renderText({
               options: this.options,
               node,
           });
@@ -56416,7 +56730,7 @@ img.ProseMirror-separator {
               return [
                   config.viewElement,
                   mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
-                  this.options.renderLabel({
+                  this.options.renderText({
                       options: this.options,
                       node
                   })
@@ -65379,24 +65693,11 @@ img.ProseMirror-separator {
               : TableRowSelectionState.notSelected;
       }
       getGroupedRowSelectionState(groupedRow) {
-          const leafRows = groupedRow.getLeafRows() ?? [];
+          const leafRows = groupedRow.getLeafRows().filter(x => !x.getIsGrouped()) ?? [];
           let foundSelectedRow = false;
           let foundNotSelectedRow = false;
           for (const row of leafRows) {
-              if (row.getIsGrouped()) {
-                  const subGroupRowSelectionState = this.getGroupedRowSelectionState(row);
-                  switch (subGroupRowSelectionState) {
-                      case TableRowSelectionState.notSelected:
-                          foundNotSelectedRow = true;
-                          break;
-                      case TableRowSelectionState.selected:
-                          foundSelectedRow = true;
-                          break;
-                      default:
-                          return TableRowSelectionState.partiallySelected;
-                  }
-              }
-              else if (row.getIsSelected()) {
+              if (row.getIsSelected()) {
                   foundSelectedRow = true;
               }
               else {