@ni/nimble-components 29.1.3 → 29.1.4

package/dist/all-components-bundle.js

@@ -7541,41 +7541,6 @@
   let Card$1 = class Card extends FoundationElement {
   };
 
-  /**
-   * The template for the {@link @microsoft/fast-foundation#(Checkbox:class)} component.
-   * @public
-   */
-  const checkboxTemplate = (context, definition) => html `
-    <template
-        role="checkbox"
-        aria-checked="${x => x.checked}"
-        aria-required="${x => x.required}"
-        aria-disabled="${x => x.disabled}"
-        aria-readonly="${x => x.readOnly}"
-        tabindex="${x => (x.disabled ? null : 0)}"
-        @keypress="${(x, c) => x.keypressHandler(c.event)}"
-        @click="${(x, c) => x.clickHandler(c.event)}"
-        class="${x => (x.readOnly ? "readonly" : "")} ${x => x.checked ? "checked" : ""} ${x => (x.indeterminate ? "indeterminate" : "")}"
-    >
-        <div part="control" class="control">
-            <slot name="checked-indicator">
-                ${definition.checkedIndicator || ""}
-            </slot>
-            <slot name="indeterminate-indicator">
-                ${definition.indeterminateIndicator || ""}
-            </slot>
-        </div>
-        <label
-            part="label"
-            class="${x => x.defaultSlottedNodes && x.defaultSlottedNodes.length
-    ? "label"
-    : "label label__hidden"}"
-        >
-            <slot ${slotted("defaultSlottedNodes")}></slot>
-        </label>
-    </template>
-`;
-
   class _Checkbox extends FoundationElement {
   }
   /**
@@ -16339,7 +16304,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Mon, 20 May 2024 15:27:02 GMT
+   * Generated on Tue, 21 May 2024 22:41:18 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -16770,7 +16735,7 @@
       return `${prefix}${uniqueIdCounter++}`;
   }
 
-  const template$F = html `<slot></slot>`;
+  const template$H = html `<slot></slot>`;
 
   const styles$$ = css `
     ${display('contents')}
@@ -16888,7 +16853,7 @@
   const nimbleDesignSystemProvider = ThemeProvider.compose({
       baseName: 'theme-provider',
       styles: styles$$,
-      template: template$F
+      template: template$H
   });
   DesignSystem.getOrCreate()
       .withPrefix('nimble')
@@ -17152,7 +17117,7 @@
 `;
 
   // prettier-ignore
-  const template$E = (_context, definition) => html `${
+  const template$G = (_context, definition) => html `${
 /* top-container div is necessary because setting contenteditable directly on the native anchor instead
    leaves it focusable, unlike the behavior you get when the anchor is _within_ a contenteditable element.
 */ ''}<div
@@ -17169,6 +17134,7 @@
         rel="${x => x.rel}"
         target="${x => x.target}"
         type="${x => x.type}"
+        tabindex="${x => x.tabIndex}"
         aria-atomic="${x => x.ariaAtomic}"
         aria-busy="${x => x.ariaBusy}"
         aria-controls="${x => x.ariaControls}"
@@ -17244,6 +17210,9 @@
   __decorate$1([
       attr
   ], Anchor.prototype, "appearance", void 0);
+  __decorate$1([
+      attr({ attribute: 'tabindex', converter: nullableNumberConverter })
+  ], Anchor.prototype, "tabIndex", void 0);
   __decorate$1([
       attr({ attribute: 'contenteditable' })
   ], Anchor.prototype, "contentEditable", void 0);
@@ -17251,7 +17220,7 @@
   const nimbleAnchor = Anchor.compose({
       baseName: 'anchor',
       baseClass: Anchor$1,
-      template: template$E,
+      template: template$G,
       styles: styles$_,
       shadowOptions: {
           delegatesFocus: true
@@ -17654,7 +17623,7 @@
     }
 `;
 
-  const template$D = (context, definition) => html `
+  const template$F = (context, definition) => html `
     <a
         class="control"
         part="control"
@@ -17736,7 +17705,7 @@
   ], AnchorButton.prototype, "disabled", void 0);
   const nimbleAnchorButton = AnchorButton.compose({
       baseName: 'anchor-button',
-      template: template$D,
+      template: template$F,
       styles: styles$Y,
       shadowOptions: {
           delegatesFocus: true
@@ -17829,7 +17798,7 @@
     }
 `;
 
-  const template$C = (context, definition) => html `
+  const template$E = (context, definition) => html `
     <template
         role="menuitem"
         class="${x => (typeof x.startColumnCount === 'number'
@@ -17930,7 +17899,7 @@
   // FoundationAnchor already applies the StartEnd mixin, so we don't need to do it here.
   const nimbleAnchorMenuItem = AnchorMenuItem.compose({
       baseName: 'anchor-menu-item',
-      template: template$C,
+      template: template$E,
       styles: styles$X,
       shadowOptions: {
           delegatesFocus: true
@@ -18058,7 +18027,7 @@
     }
 `;
 
-  const template$B = (context, definition) => html `
+  const template$D = (context, definition) => html `
     <template slot="anchortab" role="tab" aria-disabled="${x => x.disabled}">
         <a
             download="${x => x.download}"
@@ -18110,7 +18079,7 @@
   // FoundationAnchor already applies the StartEnd mixin, so we don't need to do it here.
   const nimbleAnchorTab = AnchorTab.compose({
       baseName: 'anchor-tab',
-      template: template$B,
+      template: template$D,
       styles: styles$W,
       shadowOptions: {
           delegatesFocus: true
@@ -18140,7 +18109,7 @@
     }
 `;
 
-  const template$A = (context, definition) => html `
+  const template$C = (context, definition) => html `
     ${startSlotTemplate(context, definition)}
     <div ${ref('tablist')} class="tablist" part="tablist" role="tablist">
         <slot name="anchortab" ${slotted('tabs')}></slot>
@@ -18346,7 +18315,7 @@
   applyMixins(AnchorTabs, StartEnd);
   const nimbleAnchorTabs = AnchorTabs.compose({
       baseName: 'anchor-tabs',
-      template: template$A,
+      template: template$C,
       styles: styles$V,
       shadowOptions: {
           delegatesFocus: false
@@ -18469,7 +18438,7 @@
     }
 `;
 
-  const template$z = (context, definition) => html `
+  const template$B = (context, definition) => html `
     <template
         role="treeitem"
         slot="${x => (x.isNestedItem() ? 'item' : null)}"
@@ -18606,7 +18575,7 @@
   // FoundationAnchor already applies the StartEnd mixin, so we don't need to do it here.
   const nimbleAnchorTreeItem = AnchorTreeItem.compose({
       baseName: 'anchor-tree-item',
-      template: template$z,
+      template: template$B,
       styles: styles$U,
       shadowOptions: {
           delegatesFocus: true
@@ -18882,6 +18851,53 @@
     ${buttonAppearanceVariantStyles}
 `;
 
+  const template$A = (context, definition) => html `
+    <button
+        class="control"
+        part="control"
+        ?autofocus="${x => x.autofocus}"
+        ?disabled="${x => x.disabled}"
+        form="${x => x.formId}"
+        formaction="${x => x.formaction}"
+        formenctype="${x => x.formenctype}"
+        formmethod="${x => x.formmethod}"
+        formnovalidate="${x => x.formnovalidate}"
+        formtarget="${x => x.formtarget}"
+        name="${x => x.name}"
+        type="${x => x.type}"
+        value="${x => x.value}"
+        tabindex="${x => x.tabIndex}"
+        aria-atomic="${x => x.ariaAtomic}"
+        aria-busy="${x => x.ariaBusy}"
+        aria-controls="${x => x.ariaControls}"
+        aria-current="${x => x.ariaCurrent}"
+        aria-describedby="${x => x.ariaDescribedby}"
+        aria-details="${x => x.ariaDetails}"
+        aria-disabled="${x => x.ariaDisabled}"
+        aria-errormessage="${x => x.ariaErrormessage}"
+        aria-expanded="${x => x.ariaExpanded}"
+        aria-flowto="${x => x.ariaFlowto}"
+        aria-haspopup="${x => x.ariaHaspopup}"
+        aria-hidden="${x => x.ariaHidden}"
+        aria-invalid="${x => x.ariaInvalid}"
+        aria-keyshortcuts="${x => x.ariaKeyshortcuts}"
+        aria-label="${x => x.ariaLabel}"
+        aria-labelledby="${x => x.ariaLabelledby}"
+        aria-live="${x => x.ariaLive}"
+        aria-owns="${x => x.ariaOwns}"
+        aria-pressed="${x => x.ariaPressed}"
+        aria-relevant="${x => x.ariaRelevant}"
+        aria-roledescription="${x => x.ariaRoledescription}"
+        ${ref('control')}
+    >
+        ${startSlotTemplate(context, definition)}
+        <span class="content" part="content">
+            <slot ${slotted('defaultSlottedContent')}></slot>
+        </span>
+        ${endSlotTemplate(context, definition)}
+    </button>
+`;
+
   /**
    * A nimble-styled HTML button
    */
@@ -18911,6 +18927,9 @@
   __decorate$1([
       attr({ attribute: 'content-hidden', mode: 'boolean' })
   ], Button.prototype, "contentHidden", void 0);
+  __decorate$1([
+      attr({ attribute: 'tabindex', converter: nullableNumberConverter })
+  ], Button.prototype, "tabIndex", void 0);
   /**
    * A function that returns a nimble-button registration for configuring the component with a DesignSystem.
    * Implements {@link @microsoft/fast-foundation#buttonTemplate}
@@ -18923,7 +18942,7 @@
   const nimbleButton = Button.compose({
       baseName: 'button',
       baseClass: Button$1,
-      template: buttonTemplate,
+      template: template$A,
       styles: styles$R,
       shadowOptions: {
           delegatesFocus: true
@@ -19675,7 +19694,7 @@
   };
 
   // Avoiding any whitespace in the template because this is an inline element
-  const template$y = html `<div
+  const template$z = html `<div
     class="icon"
     aria-hidden="true"
     :innerHTML=${x => x.icon.data}
@@ -19734,7 +19753,7 @@
   const registerIcon = (baseName, iconClass) => {
       const composedIcon = iconClass.compose({
           baseName,
-          template: template$y,
+          template: template$z,
           styles: styles$Q
       });
       DesignSystem.getOrCreate().withPrefix('nimble').register(composedIcon());
@@ -19848,7 +19867,7 @@
   }).withDefault(coreLabelDefaults.filterNoResultsLabel);
 
   // prettier-ignore
-  const template$x = html `
+  const template$y = html `
     <div class="container"
         role="status"
         aria-atomic="${x => x.ariaAtomic}"
@@ -19964,7 +19983,7 @@
   applyMixins(Banner, ARIAGlobalStatesAndProperties);
   const nimbleBanner = Banner.compose({
       baseName: 'banner',
-      template: template$x,
+      template: template$y,
       styles: styles$S
   });
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleBanner());
@@ -20123,7 +20142,7 @@
     }
 `;
 
-  const template$w = html `
+  const template$x = html `
     <section aria-labelledby="title-slot">
         <span id="title-slot"><slot name="title"></slot></span>
         <slot></slot>
@@ -20138,7 +20157,7 @@
   const nimbleCard = Card.compose({
       baseName: 'card',
       baseClass: Card$1,
-      template: template$w,
+      template: template$x,
       styles: styles$N
   });
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleCard());
@@ -20418,15 +20437,56 @@
     }
 `;
 
+  const template$w = (_context, definition) => html `
+    <template
+        role="checkbox"
+        aria-checked="${x => x.checked}"
+        aria-required="${x => x.required}"
+        aria-disabled="${x => x.disabled}"
+        aria-readonly="${x => x.readOnly}"
+        tabindex="${x => x.resolvedTabindex}"
+        @keypress="${(x, c) => x.keypressHandler(c.event)}"
+        @click="${(x, c) => x.clickHandler(c.event)}"
+        class="${x => (x.readOnly ? 'readonly' : '')} ${x => (x.checked ? 'checked' : '')} ${x => (x.indeterminate ? 'indeterminate' : '')}"
+    >
+        <div part="control" class="control">
+            <slot name="checked-indicator">
+                ${definition.checkedIndicator || ''}
+            </slot>
+            <slot name="indeterminate-indicator">
+                ${definition.indeterminateIndicator || ''}
+            </slot>
+        </div>
+        <label
+            part="label"
+            class="${x => (x.defaultSlottedNodes?.length
+    ? 'label'
+    : 'label label__hidden')}"
+        >
+            <slot ${slotted('defaultSlottedNodes')}></slot>
+        </label>
+    </template>
+`;
+
   /**
    * A nimble-styled checkbox control.
    */
   class Checkbox extends Checkbox$1 {
+      /**
+       * @internal
+       */
+      get resolvedTabindex() {
+          const tabIndex = this.tabIndex ?? 0;
+          return this.disabled ? undefined : `${tabIndex}`;
+      }
   }
+  __decorate$1([
+      attr({ attribute: 'tabindex', converter: nullableNumberConverter })
+  ], Checkbox.prototype, "tabIndex", void 0);
   const nimbleCheckbox = Checkbox.compose({
       baseName: 'checkbox',
       baseClass: Checkbox$1,
-      template: checkboxTemplate,
+      template: template$w,
       styles: styles$L,
       checkedIndicator: check16X16.data,
       indeterminateIndicator: minus16X16.data
@@ -20482,23 +20542,32 @@
             }
         `));
 
+  /* eslint-disable @typescript-eslint/indent */
+  // prettier-ignore
   const template$v = (context, definition) => html `
     <div
         role="button"
         part="control"
-        tabindex="${x => (x.disabled ? null : 0)}"
+        tabindex="${x => x.resolvedTabindex}"
         @keypress="${(x, c) => x.keypressHandler(c.event)}"
         @click="${(x, c) => x.clickHandler(c.event)}"
         class="control ${x => (x.checked ? 'checked' : '')}"
-        ?disabled="${x => x.disabled}"
-        ${'' /* Configure aria-disabled, aria-readonly, and aria-pressed based on the
-    toggle button's state to keep the ARIA attributes consistent with the component's
-    state without a client having to configure ARIA attributes directly */}
+        ${''
+/**
+ * Configure aria-disabled, aria-readonly, and aria-pressed based on the
+ * toggle button's state to keep the ARIA attributes consistent with the component's
+ * state without a client having to configure ARIA attributes directly
+ */
+}
         aria-disabled="${x => x.disabled}"
         aria-readonly="${x => x.readOnly}"
         aria-pressed="${x => x.checked}"
-        ${'' /* Configure all other ARIA attributes based on the aria attributes
-    configured on the toggle button */}
+        ${''
+/**
+ * Configure all other ARIA attributes based on the aria attributes
+ * configured on the toggle button
+ */
+}
         aria-atomic="${x => x.ariaAtomic}"
         aria-busy="${x => x.ariaBusy}"
         aria-controls="${x => x.ariaControls}"
@@ -20527,6 +20596,7 @@
         ${endSlotTemplate(context, definition)}
     </div>
 `;
+  /* eslint-enable @typescript-eslint/indent */
 
   /**
    * A nimble-styled toggle button control.
@@ -20547,6 +20617,13 @@
            */
           this.contentHidden = false;
       }
+      /**
+       * @internal
+       */
+      get resolvedTabindex() {
+          const tabIndex = this.tabIndex ?? 0;
+          return this.disabled ? undefined : `${tabIndex}`;
+      }
   }
   __decorate$1([
       attr
@@ -20557,6 +20634,9 @@
   __decorate$1([
       attr({ attribute: 'content-hidden', mode: 'boolean' })
   ], ToggleButton.prototype, "contentHidden", void 0);
+  __decorate$1([
+      attr({ attribute: 'tabindex', converter: nullableNumberConverter })
+  ], ToggleButton.prototype, "tabIndex", void 0);
   applyMixins(ToggleButton, StartEnd, DelegatesARIAButton);
   const nimbleToggleButton = ToggleButton.compose({
       baseName: 'toggle-button',
@@ -25206,6 +25286,7 @@
             ?content-hidden="${x => x.contentHidden}"
             ?checked="${x => x.open}"
             ?disabled="${x => x.disabled}"
+            tabindex="${x => x.tabIndex}"
             aria-haspopup="true"
             aria-expanded="${x => x.open}"
             @change="${(x, c) => x.toggleButtonCheckedChangeHandler(c.event)}"
@@ -25423,6 +25504,9 @@
   __decorate$1([
       attr({ attribute: 'content-hidden', mode: 'boolean' })
   ], MenuButton.prototype, "contentHidden", void 0);
+  __decorate$1([
+      attr({ attribute: 'tabindex', converter: nullableNumberConverter })
+  ], MenuButton.prototype, "tabIndex", void 0);
   __decorate$1([
       attr({ mode: 'boolean' })
   ], MenuButton.prototype, "open", void 0);
@@ -28455,6 +28539,12 @@
       Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
       */
       constructor(spec) {
+          /**
+          The [linebreak
+          replacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement) node defined
+          in this schema, if any.
+          */
+          this.linebreakReplacement = null;
           /**
           An object for storing whatever values modules may want to
           compute and cache per schema. (If you want to store something
@@ -28476,6 +28566,13 @@
               type.contentMatch = contentExprCache[contentExpr] ||
                   (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
               type.inlineContent = type.contentMatch.inlineContent;
+              if (type.spec.linebreakReplacement) {
+                  if (this.linebreakReplacement)
+                      throw new RangeError("Multiple linebreak nodes defined");
+                  if (!type.isInline || !type.isLeaf)
+                      throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
+                  this.linebreakReplacement = type;
+              }
               type.markSet = markExpr == "_" ? null :
                   markExpr ? gatherMarks(this, markExpr.split(" ")) :
                       markExpr == "" || !type.inlineContent ? [] : null;
@@ -30325,7 +30422,8 @@
       }
       map(mapping) {
           let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-          let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1);
+          let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+          let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
           if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
               return null;
           return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
@@ -30437,7 +30535,7 @@
       });
       matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
   }
-  function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch) {
+  function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
       let node = tr.doc.nodeAt(pos);
       let replSteps = [], cur = pos + 1;
       for (let i = 0; i < node.childCount; i++) {
@@ -30451,7 +30549,7 @@
               for (let j = 0; j < child.marks.length; j++)
                   if (!parentType.allowsMarkType(child.marks[j].type))
                       tr.step(new RemoveMarkStep(cur, end, child.marks[j]));
-              if (child.isText && !parentType.spec.code) {
+              if (clearNewlines && child.isText && parentType.whitespace != "pre") {
                   let m, newline = /\r?\n|\r/g, slice;
                   while (m = newline.exec(child.text)) {
                       if (!slice)
@@ -30576,15 +30674,46 @@
       let mapFrom = tr.steps.length;
       tr.doc.nodesBetween(from, to, (node, pos) => {
           if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+              let convertNewlines = null;
+              if (type.schema.linebreakReplacement) {
+                  let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
+                  if (pre && !supportLinebreak)
+                      convertNewlines = false;
+                  else if (!pre && supportLinebreak)
+                      convertNewlines = true;
+              }
               // Ensure all markup that isn't allowed in the new node type is cleared
-              tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type);
+              if (convertNewlines === false)
+                  replaceLinebreaks(tr, node, pos, mapFrom);
+              clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, undefined, convertNewlines === null);
               let mapping = tr.mapping.slice(mapFrom);
               let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
               tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+              if (convertNewlines === true)
+                  replaceNewlines(tr, node, pos, mapFrom);
               return false;
           }
       });
   }
+  function replaceNewlines(tr, node, pos, mapFrom) {
+      node.forEach((child, offset) => {
+          if (child.isText) {
+              let m, newline = /\r?\n|\r/g;
+              while (m = newline.exec(child.text)) {
+                  let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset + m.index);
+                  tr.replaceWith(start, start + 1, node.type.schema.linebreakReplacement.create());
+              }
+          }
+      });
+  }
+  function replaceLinebreaks(tr, node, pos, mapFrom) {
+      node.forEach((child, offset) => {
+          if (child.type == child.type.schema.linebreakReplacement) {
+              let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset);
+              tr.replaceWith(start, start + 1, node.type.schema.text("\n"));
+          }
+      });
+  }
   function canChangeType(doc, pos, type) {
       let $pos = doc.resolve(pos), index = $pos.index();
       return $pos.parent.canReplaceWith(index, index + 1, type);
@@ -39183,6 +39312,11 @@
       };
   }
 
+  /**
+   * Takes a Transaction & Editor State and turns it into a chainable state object
+   * @param config The transaction and state to create the chainable state from
+   * @returns A chainable Editor state object
+   */
   function createChainableState(config) {
       const { state, transaction } = config;
       let { selection } = transaction;
@@ -39349,6 +39483,13 @@
       }
   }
 
+  /**
+   * Returns a field from an extension
+   * @param extension The Tiptap extension
+   * @param field The field, for example `renderHTML` or `priority`
+   * @param context The context object that should be passed as `this` into the function
+   * @returns The field value
+   */
   function getExtensionField(extension, field, context) {
       if (extension.config[field] === undefined && extension.parent) {
           return getExtensionField(extension.parent, field, context);
@@ -39593,6 +39734,12 @@
           return value !== null && value !== undefined;
       }));
   }
+  /**
+   * Creates a new Prosemirror schema based on the given extensions.
+   * @param extensions An array of Tiptap extensions
+   * @param editor The editor instance
+   * @returns A Prosemirror schema
+   */
   function getSchemaByResolvedExtensions(extensions, editor) {
       var _a;
       const allAttributes = getAttributesFromExtensions(extensions);
@@ -39694,6 +39841,12 @@
       });
   }
 
+  /**
+   * Tries to get a node or mark type by its name.
+   * @param name The name of the node or mark type
+   * @param schema The Prosemiror schema to search in
+   * @returns The node or mark type, or null if it doesn't exist
+   */
   function getSchemaTypeByName(name, schema) {
       return schema.nodes[name] || schema.marks[name] || null;
   }
@@ -39710,6 +39863,12 @@
       return enabled;
   }
 
+  /**
+   * Returns the text content of a resolved prosemirror position
+   * @param $from The resolved position to get the text content from
+   * @param maxMatch The maximum number of characters to match
+   * @returns The text content
+   */
   const getTextContentFromNodes = ($from, maxMatch = 500) => {
       let textBefore = '';
       const sliceEndPos = $from.parentOffset;
@@ -39917,6 +40076,10 @@
       return typeof value === 'number';
   }
 
+  /**
+   * Paste rules are used to react to pasted content.
+   * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
+   */
   class PasteRule {
       constructor(config) {
           this.find = config.find;
@@ -40115,57 +40278,14 @@
           this.editor = editor;
           this.extensions = ExtensionManager.resolve(extensions);
           this.schema = getSchemaByResolvedExtensions(this.extensions, editor);
-          this.extensions.forEach(extension => {
-              var _a;
-              // store extension storage in editor
-              this.editor.extensionStorage[extension.name] = extension.storage;
-              const context = {
-                  name: extension.name,
-                  options: extension.options,
-                  storage: extension.storage,
-                  editor: this.editor,
-                  type: getSchemaTypeByName(extension.name, this.schema),
-              };
-              if (extension.type === 'mark') {
-                  const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, 'keepOnSplit', context))) !== null && _a !== void 0 ? _a : true;
-                  if (keepOnSplit) {
-                      this.splittableMarks.push(extension.name);
-                  }
-              }
-              const onBeforeCreate = getExtensionField(extension, 'onBeforeCreate', context);
-              if (onBeforeCreate) {
-                  this.editor.on('beforeCreate', onBeforeCreate);
-              }
-              const onCreate = getExtensionField(extension, 'onCreate', context);
-              if (onCreate) {
-                  this.editor.on('create', onCreate);
-              }
-              const onUpdate = getExtensionField(extension, 'onUpdate', context);
-              if (onUpdate) {
-                  this.editor.on('update', onUpdate);
-              }
-              const onSelectionUpdate = getExtensionField(extension, 'onSelectionUpdate', context);
-              if (onSelectionUpdate) {
-                  this.editor.on('selectionUpdate', onSelectionUpdate);
-              }
-              const onTransaction = getExtensionField(extension, 'onTransaction', context);
-              if (onTransaction) {
-                  this.editor.on('transaction', onTransaction);
-              }
-              const onFocus = getExtensionField(extension, 'onFocus', context);
-              if (onFocus) {
-                  this.editor.on('focus', onFocus);
-              }
-              const onBlur = getExtensionField(extension, 'onBlur', context);
-              if (onBlur) {
-                  this.editor.on('blur', onBlur);
-              }
-              const onDestroy = getExtensionField(extension, 'onDestroy', context);
-              if (onDestroy) {
-                  this.editor.on('destroy', onDestroy);
-              }
-          });
+          this.setupExtensions();
       }
+      /**
+       * Returns a flattened and sorted extension list while
+       * also checking for duplicated extensions and warns the user.
+       * @param extensions An array of Tiptap extensions
+       * @returns An flattened and sorted array of Tiptap extensions
+       */
       static resolve(extensions) {
           const resolvedExtensions = ExtensionManager.sort(ExtensionManager.flatten(extensions));
           const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name));
@@ -40176,6 +40296,11 @@
           }
           return resolvedExtensions;
       }
+      /**
+       * Create a flattened array of extensions by traversing the `addExtensions` field.
+       * @param extensions An array of Tiptap extensions
+       * @returns A flattened array of Tiptap extensions
+       */
       static flatten(extensions) {
           return (extensions
               .map(extension => {
@@ -40193,6 +40318,11 @@
               // `Infinity` will break TypeScript so we set a number that is probably high enough
               .flat(10));
       }
+      /**
+       * Sort extensions by priority.
+       * @param extensions An array of Tiptap extensions
+       * @returns A sorted array of Tiptap extensions by priority
+       */
       static sort(extensions) {
           const defaultPriority = 100;
           return extensions.sort((a, b) => {
@@ -40207,6 +40337,10 @@
               return 0;
           });
       }
+      /**
+       * Get all commands from the extensions.
+       * @returns An object with all commands where the key is the command name and the value is the command function
+       */
       get commands() {
           return this.extensions.reduce((commands, extension) => {
               const context = {
@@ -40226,6 +40360,10 @@
               };
           }, {});
       }
+      /**
+       * Get all registered Prosemirror plugins from the extensions.
+       * @returns An array of Prosemirror plugins
+       */
       get plugins() {
           const { editor } = this;
           // With ProseMirror, first plugins within an array are executed first.
@@ -40288,9 +40426,17 @@
               ...allPlugins,
           ];
       }
+      /**
+       * Get all attributes from the extensions.
+       * @returns An array of attributes
+       */
       get attributes() {
           return getAttributesFromExtensions(this.extensions);
       }
+      /**
+       * Get all node views from the extensions.
+       * @returns An object with all node views where the key is the node name and the value is the node view function
+       */
       get nodeViews() {
           const { editor } = this;
           const { nodeExtensions } = splitExtensions(this.extensions);
@@ -40323,6 +40469,62 @@
               return [extension.name, nodeview];
           }));
       }
+      /**
+       * Go through all extensions, create extension storages & setup marks
+       * & bind editor event listener.
+       */
+      setupExtensions() {
+          this.extensions.forEach(extension => {
+              var _a;
+              // store extension storage in editor
+              this.editor.extensionStorage[extension.name] = extension.storage;
+              const context = {
+                  name: extension.name,
+                  options: extension.options,
+                  storage: extension.storage,
+                  editor: this.editor,
+                  type: getSchemaTypeByName(extension.name, this.schema),
+              };
+              if (extension.type === 'mark') {
+                  const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, 'keepOnSplit', context))) !== null && _a !== void 0 ? _a : true;
+                  if (keepOnSplit) {
+                      this.splittableMarks.push(extension.name);
+                  }
+              }
+              const onBeforeCreate = getExtensionField(extension, 'onBeforeCreate', context);
+              const onCreate = getExtensionField(extension, 'onCreate', context);
+              const onUpdate = getExtensionField(extension, 'onUpdate', context);
+              const onSelectionUpdate = getExtensionField(extension, 'onSelectionUpdate', context);
+              const onTransaction = getExtensionField(extension, 'onTransaction', context);
+              const onFocus = getExtensionField(extension, 'onFocus', context);
+              const onBlur = getExtensionField(extension, 'onBlur', context);
+              const onDestroy = getExtensionField(extension, 'onDestroy', context);
+              if (onBeforeCreate) {
+                  this.editor.on('beforeCreate', onBeforeCreate);
+              }
+              if (onCreate) {
+                  this.editor.on('create', onCreate);
+              }
+              if (onUpdate) {
+                  this.editor.on('update', onUpdate);
+              }
+              if (onSelectionUpdate) {
+                  this.editor.on('selectionUpdate', onSelectionUpdate);
+              }
+              if (onTransaction) {
+                  this.editor.on('transaction', onTransaction);
+              }
+              if (onFocus) {
+                  this.editor.on('focus', onFocus);
+              }
+              if (onBlur) {
+                  this.editor.on('blur', onBlur);
+              }
+              if (onDestroy) {
+                  this.editor.on('destroy', onDestroy);
+              }
+          });
+      }
   }
 
   // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
@@ -40356,6 +40558,10 @@
       return output;
   }
 
+  /**
+   * The Extension class is the base class for all extensions.
+   * @see https://tiptap.dev/api/extensions#create-a-new-extension
+   */
   class Extension {
       constructor(config = {}) {
           this.type = 'extension';
@@ -40393,6 +40599,7 @@
           // return a new instance so we can use the same extension
           // with different calls of `configure`
           const extension = this.extend();
+          extension.parent = this.parent;
           extension.options = mergeDeep(this.options, options);
           extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
               name: extension.name,
@@ -40419,19 +40626,25 @@
       }
   }
 
+  /**
+   * Gets the text between two positions in a Prosemirror node
+   * and serializes it using the given text serializers and block separator (see getText)
+   * @param startNode The Prosemirror node to start from
+   * @param range The range of the text to get
+   * @param options Options for the text serializer & block separator
+   * @returns The text between the two positions
+   */
   function getTextBetween(startNode, range, options) {
       const { from, to } = range;
       const { blockSeparator = '\n\n', textSerializers = {} } = options || {};
       let text = '';
-      let separated = true;
       startNode.nodesBetween(from, to, (node, pos, parent, index) => {
           var _a;
+          if (node.isBlock && pos > from) {
+              text += blockSeparator;
+          }
           const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
           if (textSerializer) {
-              if (node.isBlock && !separated) {
-                  text += blockSeparator;
-                  separated = true;
-              }
               if (parent) {
                   text += textSerializer({
                       node,
@@ -40446,16 +40659,16 @@
           }
           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;
-          }
-          else if (node.isBlock && !separated) {
-              text += blockSeparator;
-              separated = true;
           }
       });
       return text;
   }
 
+  /**
+   * Find text serializers `toText` in a Prosemirror schema
+   * @param schema The Prosemirror schema to search in
+   * @returns A record of text serializers by node name
+   */
   function getTextSerializersFromSchema(schema) {
       return Object.fromEntries(Object.entries(schema.nodes)
           .filter(([, node]) => node.spec.toText)
@@ -40838,15 +41051,26 @@
       return removeWhitespaces(html);
   }
 
+  /**
+   * Takes a JSON or HTML content and creates a Prosemirror node or fragment from it.
+   * @param content The JSON or HTML content to create the node from
+   * @param schema The Prosemirror schema to use for the node
+   * @param options Options for the parser
+   * @returns The created Prosemirror node or fragment
+   */
   function createNodeFromContent(content, schema, options) {
       options = {
           slice: true,
           parseOptions: {},
           ...options,
       };
-      if (typeof content === 'object' && content !== null) {
+      const isJSONContent = typeof content === 'object' && content !== null;
+      const isTextContent = typeof content === 'string';
+      if (isJSONContent) {
           try {
-              if (Array.isArray(content) && content.length > 0) {
+              const isArrayContent = Array.isArray(content) && content.length > 0;
+              // if the JSON Content is an array of nodes, create a fragment for each node
+              if (isArrayContent) {
                   return Fragment.fromArray(content.map(item => schema.nodeFromJSON(item)));
               }
               return schema.nodeFromJSON(content);
@@ -40856,7 +41080,7 @@
               return createNodeFromContent('', schema, options);
           }
       }
-      if (typeof content === 'string') {
+      if (isTextContent) {
           const parser = DOMParser.fromSchema(schema);
           return options.slice
               ? parser.parseSlice(elementFromString(content), options.parseOptions).content
@@ -41156,6 +41380,12 @@
       return newlineInCode$1(state, dispatch);
   };
 
+  /**
+   * Get the type of a schema item by its name.
+   * @param name The name of the schema item
+   * @param schema The Prosemiror schema to search in
+   * @returns The type of the schema item (`node` or `mark`), or null if it doesn't exist
+   */
   function getSchemaTypeNameByName(name, schema) {
       if (schema.nodes[name]) {
           return 'node';
@@ -41253,6 +41483,13 @@
       return selectTextblockStart$1(state, dispatch);
   };
 
+  /**
+   * Create a new Prosemirror document node from content.
+   * @param content The JSON or HTML content to create the document from
+   * @param schema The Prosemirror schema to use for the document
+   * @param parseOptions Options for the parser
+   * @returns The created Prosemirror document node
+   */
   function createDocument(content, schema, parseOptions = {}) {
       return createNodeFromContent(content, schema, { slice: false, parseOptions });
   }
@@ -41290,6 +41527,9 @@
 
   /**
    * Returns a new `Transform` based on all steps of the passed transactions.
+   * @param oldDoc The Prosemirror node to start from
+   * @param transactions The transactions to combine
+   * @returns A new `Transform` with all steps of the passed transactions
    */
   function combineTransactionSteps(oldDoc, transactions) {
       const transform = new Transform$1(oldDoc);
@@ -41301,6 +41541,11 @@
       return transform;
   }
 
+  /**
+   * Gets the default block type at a given match
+   * @param match The content match to get the default block type from
+   * @returns The default block type or null
+   */
   function defaultBlockAt(match) {
       for (let i = 0; i < match.edgeCount; i += 1) {
           const { type } = match.edge(i);
@@ -41313,6 +41558,10 @@
 
   /**
    * Same as `findChildren` but searches only within a `range`.
+   * @param node The Prosemirror node to search in
+   * @param range The range to search in
+   * @param predicate The predicate to match
+   * @returns An array of nodes with their positions
    */
   function findChildrenInRange(node, range, predicate) {
       const nodesWithPos = [];
@@ -41336,6 +41585,15 @@
       return nodesWithPos;
   }
 
+  /**
+   * Finds the closest parent node to a resolved position that matches a predicate.
+   * @param $pos The resolved position to search from
+   * @param predicate The predicate to match
+   * @returns The closest parent node to the resolved position that matches the predicate
+   * @example ```js
+   * findParentNodeClosestToPos($from, node => node.type.name === 'paragraph')
+   * ```
+   */
   function findParentNodeClosestToPos($pos, predicate) {
       for (let i = $pos.depth; i > 0; i -= 1) {
           const node = $pos.node(i);
@@ -41350,6 +41608,14 @@
       }
   }
 
+  /**
+   * Finds the closest parent node to the current selection that matches a predicate.
+   * @param predicate The predicate to match
+   * @returns A command that finds the closest parent node to the current selection that matches the predicate
+   * @example ```js
+   * findParentNode(node => node.type.name === 'paragraph')
+   * ```
+   */
   function findParentNode(predicate) {
       return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
   }
@@ -41362,6 +41628,15 @@
       return container.innerHTML;
   }
 
+  /**
+   * Gets the text of a Prosemirror node
+   * @param node The Prosemirror node
+   * @param options Options for the text serializer & block separator
+   * @returns The text of the node
+   * @example ```js
+   * const text = getText(node, { blockSeparator: '\n' })
+   * ```
+   */
   function getText(node, options) {
       const range = {
           from: 0,
@@ -41384,6 +41659,12 @@
       return { ...node.attrs };
   }
 
+  /**
+   * Get node or mark attributes by type or name on the current editor state
+   * @param state The current editor state
+   * @param typeOrName The node or mark type or name
+   * @returns The attributes of the node or mark or an empty object
+   */
   function getAttributes(state, typeOrName) {
       const schemaType = getSchemaTypeNameByName(typeof typeOrName === 'string' ? typeOrName : typeOrName.name, state.schema);
       if (schemaType === 'node') {
@@ -41505,6 +41786,13 @@
       return marks;
   }
 
+  /**
+   * Return attributes of an extension that should be splitted by keepOnSplit flag
+   * @param extensionAttributes Array of extension attributes
+   * @param typeName The type of the extension
+   * @param attributes The attributes of the extension
+   * @returns The splitted attributes
+   */
   function getSplittedAttributes(extensionAttributes, typeName, attributes) {
       return Object.fromEntries(Object
           .entries(attributes)
@@ -42293,7 +42581,12 @@
                   const isAtStart = (parentIsIsolating && $parentPos.parent.childCount === 1)
                       ? parentPos === $anchor.pos
                       : Selection$2.atStart(doc).from === pos;
-                  if (!empty || !isAtStart || !parent.type.isTextblock || parent.textContent.length) {
+                  if (!empty
+                      || !parent.type.isTextblock
+                      || parent.textContent.length
+                      || !isAtStart
+                      || (isAtStart && $anchor.parent.type.name === 'paragraph') // prevent clearNodes when no nodes to clear, otherwise history stack is appended
+                  ) {
                       return false;
                   }
                   return commands.clearNodes();
@@ -42545,28 +42838,30 @@
       }
       querySelectorAll(selector, attributes = {}, firstItemOnly = false) {
           let nodes = [];
-          // iterate through children recursively finding all nodes which match the selector with the node name
           if (!this.children || this.children.length === 0) {
               return nodes;
           }
+          const attrKeys = Object.keys(attributes);
+          /**
+           * Finds all children recursively that match the selector and attributes
+           * If firstItemOnly is true, it will return the first item found
+           */
           this.children.forEach(childPos => {
+              // If we already found a node and we only want the first item, we dont need to keep going
+              if (firstItemOnly && nodes.length > 0) {
+                  return;
+              }
               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;
+                  const doesAllAttributesMatch = attrKeys.every(key => attributes[key] === childPos.node.attrs[key]);
+                  if (doesAllAttributesMatch) {
+                      nodes.push(childPos);
                   }
               }
-              nodes = nodes.concat(childPos.querySelectorAll(selector));
+              // If we already found a node and we only want the first item, we can stop here and skip the recursion
+              if (firstItemOnly && nodes.length > 0) {
+                  return;
+              }
+              nodes = nodes.concat(childPos.querySelectorAll(selector, attributes, firstItemOnly));
           });
           return nodes;
       }
@@ -43053,6 +43348,7 @@ img.ProseMirror-separator {
   /**
    * Build an input rule that adds a mark when the
    * matched text is typed into it.
+   * @see https://tiptap.dev/guide/custom-extensions/#input-rules
    */
   function markInputRule(config) {
       return new InputRule({
@@ -43106,6 +43402,7 @@ img.ProseMirror-separator {
    * two nodes. You can pass a join predicate, which takes a regular
    * expression match and the node before the wrapped node, and can
    * return a boolean to indicate whether a join should happen.
+   * @see https://tiptap.dev/guide/custom-extensions/#input-rules
    */
   function wrappingInputRule(config) {
       return new InputRule({
@@ -43145,6 +43442,10 @@ img.ProseMirror-separator {
       });
   }
 
+  /**
+   * The Mark class is used to create custom mark extensions.
+   * @see https://tiptap.dev/api/extensions#create-a-new-extension
+   */
   class Mark {
       constructor(config = {}) {
           this.type = 'mark';
@@ -43228,6 +43529,10 @@ img.ProseMirror-separator {
       }
   }
 
+  /**
+   * The Node class is used to create custom node extensions.
+   * @see https://tiptap.dev/api/extensions#create-a-new-extension
+   */
   let Node$1 = class Node {
       constructor(config = {}) {
           this.type = 'node';
@@ -43294,6 +43599,7 @@ img.ProseMirror-separator {
   /**
    * Build an paste rule that adds a mark when the
    * matched text is pasted into it.
+   * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
    */
   function markPasteRule(config) {
       return new PasteRule({
@@ -43340,6 +43646,10 @@ img.ProseMirror-separator {
       return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
   }
 
+  /**
+   * This extension allows you to insert hard breaks.
+   * @see https://www.tiptap.dev/api/nodes/hard-break
+   */
   const HardBreak = Node$1.create({
       name: 'hardBreak',
       addOptions() {
@@ -54023,10 +54333,26 @@ img.ProseMirror-separator {
       observable
   ], RichText.prototype, "configuration", void 0);
 
+  /**
+   * Matches bold text via `**` as input.
+   */
   const starInputRegex$1 = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
+  /**
+   * Matches bold text via `**` while pasting.
+   */
   const starPasteRegex$1 = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
+  /**
+   * Matches bold text via `__` as input.
+   */
   const underscoreInputRegex$1 = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
+  /**
+   * Matches bold text via `__` while pasting.
+   */
   const underscorePasteRegex$1 = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
+  /**
+   * This extension allows you to mark text as bold.
+   * @see https://tiptap.dev/api/marks/bold
+   */
   const Bold = Mark.create({
       name: 'bold',
       addOptions() {
@@ -54097,6 +54423,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create list items.
+   * @see https://www.tiptap.dev/api/nodes/list-item
+   */
   const ListItem$2 = Node$1.create({
       name: 'listItem',
       addOptions() {
@@ -54127,6 +54457,11 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create text styles. It is required by default
+   * for the `textColor` and `backgroundColor` extensions.
+   * @see https://www.tiptap.dev/api/marks/text-style
+   */
   const TextStyle$1 = Mark.create({
       name: 'textStyle',
       addOptions() {
@@ -54165,7 +54500,16 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * Matches a bullet list to a dash or asterisk.
+   */
   const inputRegex$1 = /^\s*([-+*])\s$/;
+  /**
+   * This extension allows you to create bullet lists.
+   * This requires the ListItem extension
+   * @see https://tiptap.dev/api/nodes/bullet-list
+   * @see https://tiptap.dev/api/nodes/list-item.
+   */
   const BulletList = Node$1.create({
       name: 'bulletList',
       addOptions() {
@@ -54224,6 +54568,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * The default document node which represents the top level node of the editor.
+   * @see https://tiptap.dev/api/nodes/document
+   */
   const Document$1 = Node$1.create({
       name: 'doc',
       topNode: true,
@@ -54844,6 +55192,15 @@ img.ProseMirror-separator {
   */
   const redo = buildCommand(true, true);
 
+  /**
+   * This extension allows you to undo and redo recent changes.
+   * @see https://www.tiptap.dev/api/extensions/history
+   *
+   * **Important**: If the `@tiptap/extension-collaboration` package is used, make sure to remove
+   * the `history` extension, as it is not compatible with the `collaboration` extension.
+   *
+   * `@tiptap/extension-collaboration` uses its own history implementation.
+   */
   const History = Extension.create({
       name: 'history',
       addOptions() {
@@ -54879,10 +55236,26 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * Matches an italic to a *italic* on input.
+   */
   const starInputRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/;
+  /**
+   * Matches an italic to a *italic* on paste.
+   */
   const starPasteRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g;
+  /**
+   * Matches an italic to a _italic_ on input.
+   */
   const underscoreInputRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/;
+  /**
+   * Matches an italic to a _italic_ on paste.
+   */
   const underscorePasteRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g;
+  /**
+   * This extension allows you to create italic text.
+   * @see https://www.tiptap.dev/api/marks/italic
+   */
   const Italic = Mark.create({
       name: 'italic',
       addOptions() {
@@ -56717,12 +57090,27 @@ img.ProseMirror-separator {
       }
       return false;
   }
+  /**
+   * This plugin allows you to automatically add links to your editor.
+   * @param options The plugin options
+   * @returns The plugin instance
+   */
   function autolink(options) {
       return new Plugin({
           key: new PluginKey('autolink'),
           appendTransaction: (transactions, oldState, newState) => {
+              /**
+               * Does the transaction change the document?
+               */
               const docChanges = transactions.some(transaction => transaction.docChanged) && !oldState.doc.eq(newState.doc);
+              /**
+               * Prevent autolink if the transaction is not a document change or if the transaction has the meta `preventAutolink`.
+               */
               const preventAutolink = transactions.some(transaction => transaction.getMeta('preventAutolink'));
+              /**
+               * Prevent autolink if the transaction is not a document change
+               * or if the transaction has the meta `preventAutolink`.
+               */
               if (!docChanges || preventAutolink) {
                   return;
               }
@@ -56862,6 +57250,10 @@ img.ProseMirror-separator {
           },
       });
   }
+  /**
+   * This extension allows you to create links.
+   * @see https://www.tiptap.dev/api/marks/link
+   */
   const Link = Mark.create({
       name: 'link',
       priority: 1000,
@@ -56996,6 +57388,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create list items.
+   * @see https://www.tiptap.dev/api/nodes/list-item
+   */
   const ListItem$1 = Node$1.create({
       name: 'listItem',
       addOptions() {
@@ -57026,6 +57422,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create list items.
+   * @see https://www.tiptap.dev/api/nodes/list-item
+   */
   const ListItem = Node$1.create({
       name: 'listItem',
       addOptions() {
@@ -57056,6 +57456,11 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create text styles. It is required by default
+   * for the `textColor` and `backgroundColor` extensions.
+   * @see https://www.tiptap.dev/api/marks/text-style
+   */
   const TextStyle = Mark.create({
       name: 'textStyle',
       addOptions() {
@@ -57094,7 +57499,16 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * Matches an ordered list to a 1. on input (or any number followed by a dot).
+   */
   const inputRegex = /^(\d+)\.\s$/;
+  /**
+   * This extension allows you to create ordered lists.
+   * This requires the ListItem extension
+   * @see https://www.tiptap.dev/api/nodes/ordered-list
+   * @see https://www.tiptap.dev/api/nodes/list-item
+   */
   const OrderedList = Node$1.create({
       name: 'orderedList',
       addOptions() {
@@ -57173,6 +57587,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create paragraphs.
+   * @see https://www.tiptap.dev/api/nodes/paragraph
+   */
   const Paragraph = Node$1.create({
       name: 'paragraph',
       priority: 1000,
@@ -57205,6 +57623,11 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to add a placeholder to your editor.
+   * A placeholder is a text that appears when the editor or a node is empty.
+   * @see https://www.tiptap.dev/api/extensions/placeholder
+   */
   const Placeholder = Extension.create({
       name: 'placeholder',
       addOptions() {
@@ -57273,6 +57696,10 @@ img.ProseMirror-separator {
       },
   });
 
+  /**
+   * This extension allows you to create text nodes.
+   * @see https://www.tiptap.dev/api/nodes/text
+   */
   const Text = Node$1.create({
       name: 'text',
       group: 'inline',
@@ -57327,6 +57754,10 @@ img.ProseMirror-separator {
   }
 
   const SuggestionPluginKey = new PluginKey('suggestion');
+  /**
+   * This utility allows you to create suggestions.
+   * @see https://tiptap.dev/api/utilities/suggestion
+   */
   function Suggestion({ pluginKey = SuggestionPluginKey, editor, char = '@', allowSpaces = false, allowedPrefixes = [' '], startOfLine = false, decorationTag = 'span', decorationClass = 'suggestion', command = () => null, items = () => [], render = () => ({}), allow = () => true, findSuggestionMatch: findSuggestionMatch$1 = findSuggestionMatch, }) {
       let props;
       const renderer = render === null || render === void 0 ? void 0 : render();
@@ -57503,7 +57934,15 @@ img.ProseMirror-separator {
       return plugin;
   }
 
+  /**
+   * The plugin key for the mention plugin.
+   * @default 'mention'
+   */
   const MentionPluginKey = new PluginKey('mention');
+  /**
+   * This extension allows you to insert mentions into the editor.
+   * @see https://www.tiptap.dev/api/extensions/mention
+   */
   const Mention = Node$1.create({
       name: 'mention',
       addOptions() {