@tiptap/core 2.11.7 → 3.0.0-beta.0

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -1,9 +1,8 @@
-import {
-  MarkSpec, NodeSpec, Schema, TagParseRule,
-} from '@tiptap/pm/model'
+import type { MarkSpec, NodeSpec, TagParseRule } from '@tiptap/pm/model'
+import { Schema } from '@tiptap/pm/model'
 
-import { Editor, MarkConfig, NodeConfig } from '../index.js'
-import { AnyConfig, Extensions } from '../types.js'
+import type { Editor, MarkConfig, NodeConfig } from '../index.js'
+import type { AnyConfig, Extensions } from '../types.js'
 import { callOrReturn } from '../utilities/callOrReturn.js'
 import { isEmptyObject } from '../utilities/isEmptyObject.js'
 import { getAttributesFromExtensions } from './getAttributesFromExtensions.js'
@@ -38,9 +37,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
   const nodes = Object.fromEntries(
     nodeExtensions.map(extension => {
-      const extensionAttributes = allAttributes.filter(
-        attribute => attribute.type === extension.name,
-      )
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
       const context = {
         name: extension.name,
         options: extension.options,
@@ -49,11 +46,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
       }
 
       const extraNodeFields = extensions.reduce((fields, e) => {
-        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
-          e,
-          'extendNodeSchema',
-          context,
-        )
+        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(e, 'extendNodeSchema', context)
 
         return {
           ...fields,
@@ -63,61 +56,49 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
       const schema: NodeSpec = cleanUpSchemaItem({
         ...extraNodeFields,
-        content: callOrReturn(
-          getExtensionField<NodeConfig['content']>(extension, 'content', context),
-        ),
+        content: callOrReturn(getExtensionField<NodeConfig['content']>(extension, 'content', context)),
         marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
         group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
         inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
         atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
-        selectable: callOrReturn(
-          getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context),
-        ),
-        draggable: callOrReturn(
-          getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context),
-        ),
+        selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
+        draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
         code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
         whitespace: callOrReturn(getExtensionField<NodeConfig['whitespace']>(extension, 'whitespace', context)),
-        linebreakReplacement: callOrReturn(getExtensionField<NodeConfig['linebreakReplacement']>(extension, 'linebreakReplacement', context)),
-        defining: callOrReturn(
-          getExtensionField<NodeConfig['defining']>(extension, 'defining', context),
-        ),
-        isolating: callOrReturn(
-          getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context),
+        linebreakReplacement: callOrReturn(
+          getExtensionField<NodeConfig['linebreakReplacement']>(extension, 'linebreakReplacement', context),
         ),
+        defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
+        isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
         attrs: Object.fromEntries(
           extensionAttributes.map(extensionAttribute => {
-            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+            return [
+              extensionAttribute.name,
+              { default: extensionAttribute?.attribute?.default, validate: extensionAttribute?.attribute?.validate },
+            ]
           }),
         ),
       })
 
-      const parseHTML = callOrReturn(
-        getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context),
-      )
+      const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
 
       if (parseHTML) {
-        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes)) as TagParseRule[]
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        ) as TagParseRule[]
       }
 
-      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(
-        extension,
-        'renderHTML',
-        context,
-      )
+      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
 
       if (renderHTML) {
-        schema.toDOM = node => renderHTML({
-          node,
-          HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-        })
+        schema.toDOM = node =>
+          renderHTML({
+            node,
+            HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+          })
       }
 
-      const renderText = getExtensionField<NodeConfig['renderText']>(
-        extension,
-        'renderText',
-        context,
-      )
+      const renderText = getExtensionField<NodeConfig['renderText']>(extension, 'renderText', context)
 
       if (renderText) {
         schema.toText = renderText
@@ -129,9 +110,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
   const marks = Object.fromEntries(
     markExtensions.map(extension => {
-      const extensionAttributes = allAttributes.filter(
-        attribute => attribute.type === extension.name,
-      )
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
       const context = {
         name: extension.name,
         options: extension.options,
@@ -140,11 +119,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
       }
 
       const extraMarkFields = extensions.reduce((fields, e) => {
-        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
-          e,
-          'extendMarkSchema',
-          context,
-        )
+        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(e, 'extendMarkSchema', context)
 
         return {
           ...fields,
@@ -154,43 +129,37 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
       const schema: MarkSpec = cleanUpSchemaItem({
         ...extraMarkFields,
-        inclusive: callOrReturn(
-          getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context),
-        ),
-        excludes: callOrReturn(
-          getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context),
-        ),
+        inclusive: callOrReturn(getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context)),
+        excludes: callOrReturn(getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context)),
         group: callOrReturn(getExtensionField<MarkConfig['group']>(extension, 'group', context)),
-        spanning: callOrReturn(
-          getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context),
-        ),
+        spanning: callOrReturn(getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context)),
         code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
         attrs: Object.fromEntries(
           extensionAttributes.map(extensionAttribute => {
-            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+            return [
+              extensionAttribute.name,
+              { default: extensionAttribute?.attribute?.default, validate: extensionAttribute?.attribute?.validate },
+            ]
           }),
         ),
       })
 
-      const parseHTML = callOrReturn(
-        getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context),
-      )
+      const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
 
       if (parseHTML) {
-        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        )
       }
 
-      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(
-        extension,
-        'renderHTML',
-        context,
-      )
+      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
 
       if (renderHTML) {
-        schema.toDOM = mark => renderHTML({
-          mark,
-          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-        })
+        schema.toDOM = mark =>
+          renderHTML({
+            mark,
+            HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+          })
       }
 
       return [extension.name, schema]

package/src/helpers/getSchemaTypeByName.ts

@@ -1,4 +1,4 @@
-import { MarkType, NodeType, Schema } from '@tiptap/pm/model'
+import type { MarkType, NodeType, Schema } from '@tiptap/pm/model'
 
 /**
  * Tries to get a node or mark type by its name.

package/src/helpers/getSchemaTypeNameByName.ts

@@ -1,4 +1,4 @@
-import { Schema } from '@tiptap/pm/model'
+import type { Schema } from '@tiptap/pm/model'
 
 /**
  * Get the type of a schema item by its name.

package/src/helpers/getSplittedAttributes.ts

@@ -1,4 +1,4 @@
-import { ExtensionAttribute } from '../types.js'
+import type { ExtensionAttribute } from '../types.js'
 
 /**
  * Return attributes of an extension that should be splitted by keepOnSplit flag
@@ -12,9 +12,8 @@ export function getSplittedAttributes(
   typeName: string,
   attributes: Record<string, any>,
 ): Record<string, any> {
-  return Object.fromEntries(Object
-    .entries(attributes)
-    .filter(([name]) => {
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([name]) => {
       const extensionAttribute = extensionAttributes.find(item => {
         return item.type === typeName && item.name === name
       })
@@ -24,5 +23,6 @@ export function getSplittedAttributes(
       }
 
       return extensionAttribute.attribute.keepOnSplit
-    }))
+    }),
+  )
 }

package/src/helpers/getText.ts

@@ -1,6 +1,6 @@
-import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
-import { TextSerializer } from '../types.js'
+import type { TextSerializer } from '../types.js'
 import { getTextBetween } from './getTextBetween.js'
 
 /**

package/src/helpers/getTextBetween.ts

@@ -1,6 +1,6 @@
-import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
-import { Range, TextSerializer } from '../types.js'
+import type { Range, TextSerializer } from '../types.js'
 
 /**
  * Gets the text between two positions in a Prosemirror node

package/src/helpers/getTextContentFromNodes.ts

@@ -1,4 +1,4 @@
-import { ResolvedPos } from '@tiptap/pm/model'
+import type { ResolvedPos } from '@tiptap/pm/model'
 
 /**
  * Returns the text content of a resolved prosemirror position
@@ -11,22 +11,19 @@ export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
 
   const sliceEndPos = $from.parentOffset
 
-  $from.parent.nodesBetween(
-    Math.max(0, sliceEndPos - maxMatch),
-    sliceEndPos,
-    (node, pos, parent, index) => {
-      const chunk = node.type.spec.toText?.({
+  $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
+    const chunk =
+      node.type.spec.toText?.({
         node,
         pos,
         parent,
         index,
-      })
-        || node.textContent
-        || '%leaf%'
+      }) ||
+      node.textContent ||
+      '%leaf%'
 
-      textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos))
-    },
-  )
+    textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos))
+  })
 
   return textBefore
 }

package/src/helpers/getTextSerializersFromSchema.ts

@@ -1,6 +1,6 @@
-import { Schema } from '@tiptap/pm/model'
+import type { Schema } from '@tiptap/pm/model'
 
-import { TextSerializer } from '../types.js'
+import type { TextSerializer } from '../types.js'
 
 /**
  * Find text serializers `toText` in a Prosemirror schema

package/src/helpers/index.ts

@@ -7,6 +7,7 @@ export * from './findChildren.js'
 export * from './findChildrenInRange.js'
 export * from './findParentNode.js'
 export * from './findParentNodeClosestToPos.js'
+export * from './flattenExtensions.js'
 export * from './generateHTML.js'
 export * from './generateJSON.js'
 export * from './generateText.js'
@@ -45,7 +46,9 @@ export * from './isNodeEmpty.js'
 export * from './isNodeSelection.js'
 export * from './isTextSelection.js'
 export * from './posToDOMRect.js'
+export * from './resolveExtensions.js'
 export * from './resolveFocusPosition.js'
 export * from './rewriteUnknownContent.js'
 export * from './selectionToInsertionEnd.js'
+export * from './sortExtensions.js'
 export * from './splitExtensions.js'

package/src/helpers/injectExtensionAttributesToParseRule.ts

@@ -1,6 +1,6 @@
-import { ParseRule } from '@tiptap/pm/model'
+import type { ParseRule } from '@tiptap/pm/model'
 
-import { ExtensionAttribute } from '../types.js'
+import type { ExtensionAttribute } from '../types.js'
 import { fromString } from '../utilities/fromString.js'
 
 /**
@@ -29,7 +29,7 @@ export function injectExtensionAttributesToParseRule(
       const newAttributes = extensionAttributes.reduce((items, item) => {
         const value = item.attribute.parseHTML
           ? item.attribute.parseHTML(node)
-          : fromString((node).getAttribute(item.name))
+          : fromString(node.getAttribute(item.name))
 
         if (value === null || value === undefined) {
           return items

package/src/helpers/isActive.ts

@@ -1,14 +1,10 @@
-import { EditorState } from '@tiptap/pm/state'
+import type { EditorState } from '@tiptap/pm/state'
 
 import { getSchemaTypeNameByName } from './getSchemaTypeNameByName.js'
 import { isMarkActive } from './isMarkActive.js'
 import { isNodeActive } from './isNodeActive.js'
 
-export function isActive(
-  state: EditorState,
-  name: string | null,
-  attributes: Record<string, any> = {},
-): boolean {
+export function isActive(state: EditorState, name: string | null, attributes: Record<string, any> = {}): boolean {
   if (!name) {
     return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes)
   }

package/src/helpers/isAtEndOfNode.ts

@@ -1,4 +1,4 @@
-import { EditorState } from '@tiptap/pm/state'
+import type { EditorState } from '@tiptap/pm/state'
 
 import { findParentNode } from './findParentNode.js'
 

package/src/helpers/isAtStartOfNode.ts

@@ -1,4 +1,4 @@
-import { EditorState } from '@tiptap/pm/state'
+import type { EditorState } from '@tiptap/pm/state'
 
 export const isAtStartOfNode = (state: EditorState) => {
   const { $from, $to } = state.selection

package/src/helpers/isExtensionRulesEnabled.ts

@@ -1,11 +1,9 @@
-import { AnyExtension, EnableRules } from '../types.js'
+import type { AnyExtension, EnableRules } from '../types.js'
 
 export function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean {
   if (Array.isArray(enabled)) {
     return enabled.some(enabledExtension => {
-      const name = typeof enabledExtension === 'string'
-        ? enabledExtension
-        : enabledExtension.name
+      const name = typeof enabledExtension === 'string' ? enabledExtension : enabledExtension.name
 
       return name === extension.name
     })

package/src/helpers/isList.ts

@@ -1,6 +1,6 @@
 import { getExtensionField } from '../helpers/getExtensionField.js'
-import { NodeConfig } from '../index.js'
-import { Extensions } from '../types.js'
+import type { NodeConfig } from '../index.js'
+import type { Extensions } from '../types.js'
 import { callOrReturn } from '../utilities/callOrReturn.js'
 import { splitExtensions } from './splitExtensions.js'
 

package/src/helpers/isMarkActive.ts

@@ -1,7 +1,7 @@
-import { MarkType } from '@tiptap/pm/model'
-import { EditorState } from '@tiptap/pm/state'
+import type { MarkType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
 
-import { MarkRange } from '../types.js'
+import type { MarkRange } from '../types.js'
 import { objectIncludes } from '../utilities/objectIncludes.js'
 import { getMarkType } from './getMarkType.js'
 

package/src/helpers/isNodeActive.ts

@@ -1,7 +1,7 @@
-import { NodeType } from '@tiptap/pm/model'
-import { EditorState } from '@tiptap/pm/state'
+import type { NodeType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
 
-import { NodeRange } from '../types.js'
+import type { NodeRange } from '../types.js'
 import { objectIncludes } from '../utilities/objectIncludes.js'
 import { getNodeType } from './getNodeType.js'
 

package/src/helpers/isNodeEmpty.ts

@@ -1,4 +1,4 @@
-import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
 /**
  * Returns true if the given prosemirror node is empty.
@@ -12,11 +12,11 @@ export function isNodeEmpty(
     /**
      * When true (default), it will also check if all children are empty.
      */
-    checkChildren?: boolean;
+    checkChildren?: boolean
     /**
      * When true, it will ignore whitespace when checking for emptiness.
      */
-    ignoreWhitespace?: boolean;
+    ignoreWhitespace?: boolean
   } = {},
 ): boolean {
   if (ignoreWhitespace) {

package/src/helpers/posToDOMRect.ts

@@ -1,4 +1,4 @@
-import { EditorView } from '@tiptap/pm/view'
+import type { EditorView } from '@tiptap/pm/view'
 
 import { minMax } from '../utilities/minMax.js'
 

package/src/helpers/resolveExtensions.ts

@@ -0,0 +1,25 @@
+import type { Extensions } from '../types.js'
+import { findDuplicates } from '../utilities/findDuplicates.js'
+import { flattenExtensions } from './flattenExtensions.js'
+import { sortExtensions } from './sortExtensions.js'
+
+/**
+ * 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
+ */
+export function resolveExtensions(extensions: Extensions): Extensions {
+  const resolvedExtensions = sortExtensions(flattenExtensions(extensions))
+  const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name))
+
+  if (duplicatedNames.length) {
+    console.warn(
+      `[tiptap warn]: Duplicate extension names found: [${duplicatedNames
+        .map(item => `'${item}'`)
+        .join(', ')}]. This can lead to issues.`,
+    )
+  }
+
+  return resolvedExtensions
+}

package/src/helpers/resolveFocusPosition.ts

@@ -1,13 +1,10 @@
-import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 import { Selection, TextSelection } from '@tiptap/pm/state'
 
-import { FocusPosition } from '../types.js'
+import type { FocusPosition } from '../types.js'
 import { minMax } from '../utilities/minMax.js'
 
-export function resolveFocusPosition(
-  doc: ProseMirrorNode,
-  position: FocusPosition = null,
-): Selection | null {
+export function resolveFocusPosition(doc: ProseMirrorNode, position: FocusPosition = null): Selection | null {
   if (!position) {
     return null
   }
@@ -27,16 +24,8 @@ export function resolveFocusPosition(
   const maxPos = selectionAtEnd.to
 
   if (position === 'all') {
-    return TextSelection.create(
-      doc,
-      minMax(0, minPos, maxPos),
-      minMax(doc.content.size, minPos, maxPos),
-    )
+    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos))
   }
 
-  return TextSelection.create(
-    doc,
-    minMax(position, minPos, maxPos),
-    minMax(position, minPos, maxPos),
-  )
+  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos))
 }

package/src/helpers/rewriteUnknownContent.ts

@@ -7,19 +7,19 @@ type RewriteUnknownContentOptions = {
    * If true, unknown nodes will be treated as paragraphs
    * @default true
    */
-  fallbackToParagraph?: boolean;
-};
+  fallbackToParagraph?: boolean
+}
 
 type RewrittenContent = {
   /**
    * The original JSON content that was rewritten
    */
-  original: JSONContent;
+  original: JSONContent
   /**
    * The name of the node or mark that was unsupported
    */
-  unsupported: string;
-}[];
+  unsupported: string
+}[]
 
 /**
  * The actual implementation of the rewriteUnknownContent function
@@ -31,20 +31,20 @@ function rewriteUnknownContentInner({
   options,
   rewrittenContent = [],
 }: {
-  json: JSONContent;
-  validMarks: Set<string>;
-  validNodes: Set<string>;
-  options?: RewriteUnknownContentOptions;
-  rewrittenContent?: RewrittenContent;
+  json: JSONContent
+  validMarks: Set<string>
+  validNodes: Set<string>
+  options?: RewriteUnknownContentOptions
+  rewrittenContent?: RewrittenContent
 }): {
   /**
    * The cleaned JSON content
    */
-  json: JSONContent | null;
+  json: JSONContent | null
   /**
    * The array of nodes and marks that were rewritten
    */
-  rewrittenContent: RewrittenContent;
+  rewrittenContent: RewrittenContent
 } {
   if (json.marks && Array.isArray(json.marks)) {
     json.marks = json.marks.filter(mark => {
@@ -66,13 +66,14 @@ function rewriteUnknownContentInner({
   if (json.content && Array.isArray(json.content)) {
     json.content = json.content
       .map(
-        value => rewriteUnknownContentInner({
-          json: value,
-          validMarks,
-          validNodes,
-          options,
-          rewrittenContent,
-        }).json,
+        value =>
+          rewriteUnknownContentInner({
+            json: value,
+            validMarks,
+            validNodes,
+            options,
+            rewrittenContent,
+          }).json,
       )
       .filter(a => a !== null && a !== undefined)
   }
@@ -83,7 +84,7 @@ function rewriteUnknownContentInner({
       unsupported: json.type,
     })
 
-    if (json.content && Array.isArray(json.content) && (options?.fallbackToParagraph !== false)) {
+    if (json.content && Array.isArray(json.content) && options?.fallbackToParagraph !== false) {
       // Just treat it like a paragraph and hope for the best
       json.type = 'paragraph'
 
@@ -124,7 +125,7 @@ export function rewriteUnknownContent(
   /**
    * The cleaned JSON content
    */
-  json: JSONContent | null;
+  json: JSONContent | null
   /**
    * The array of nodes and marks that were rewritten
    */
@@ -132,12 +133,12 @@ export function rewriteUnknownContent(
     /**
      * The original JSON content that was rewritten
      */
-    original: JSONContent;
+    original: JSONContent
     /**
      * The name of the node or mark that was unsupported
      */
-    unsupported: string;
-  }[];
+    unsupported: string
+  }[]
 } {
   return rewriteUnknownContentInner({
     json,

package/src/helpers/selectionToInsertionEnd.ts

@@ -1,4 +1,5 @@
-import { Selection, Transaction } from '@tiptap/pm/state'
+import type { Transaction } from '@tiptap/pm/state'
+import { Selection } from '@tiptap/pm/state'
 import { ReplaceAroundStep, ReplaceStep } from '@tiptap/pm/transform'
 
 // source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466