@tiptap/core 2.0.0-beta.209 → 2.0.0-beta.210

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -1,4 +1,4 @@
-import { MarkSpec, NodeSpec, Schema } from 'prosemirror-model'
+import { MarkSpec, NodeSpec, Schema } from '@tiptap/pm/model'
 
 import { MarkConfig, NodeConfig } from '..'
 import { AnyConfig, Extensions } from '../types'
@@ -11,13 +11,15 @@ import { injectExtensionAttributesToParseRule } from './injectExtensionAttribute
 import { splitExtensions } from './splitExtensions'
 
 function cleanUpSchemaItem<T>(data: T) {
-  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-    if (key === 'attrs' && isEmptyObject(value)) {
-      return false
-    }
+  return Object.fromEntries(
+    Object.entries(data).filter(([key, value]) => {
+      if (key === 'attrs' && isEmptyObject(value)) {
+        return false
+      }
 
-    return value !== null && value !== undefined
-  })) as T
+      return value !== null && value !== undefined
+    }),
+  ) as T
 }
 
 export function getSchemaByResolvedExtensions(extensions: Extensions): Schema {
@@ -25,120 +27,162 @@ export function getSchemaByResolvedExtensions(extensions: Extensions): Schema {
   const { nodeExtensions, markExtensions } = splitExtensions(extensions)
   const topNode = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))?.name
 
-  const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-    }
-
-    const extraNodeFields = extensions.reduce((fields, e) => {
-      const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
-        e,
-        'extendNodeSchema',
-        context,
+  const nodes = Object.fromEntries(
+    nodeExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(
+        attribute => attribute.type === extension.name,
       )
-
-      return {
-        ...fields,
-        ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
       }
-    }, {})
-
-    const schema: NodeSpec = cleanUpSchemaItem({
-      ...extraNodeFields,
-      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)),
-      code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', 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 }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = node => renderHTML({
-        node,
-        HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+
+      const extraNodeFields = extensions.reduce((fields, e) => {
+        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
+          e,
+          'extendNodeSchema',
+          context,
+        )
+
+        return {
+          ...fields,
+          ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+        }
+      }, {})
+
+      const schema: NodeSpec = cleanUpSchemaItem({
+        ...extraNodeFields,
+        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),
+        ),
+        code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', 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 }]
+          }),
+        ),
       })
-    }
 
-    const renderText = getExtensionField<NodeConfig['renderText']>(extension, 'renderText', context)
+      const parseHTML = callOrReturn(
+        getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context),
+      )
 
-    if (renderText) {
-      schema.toText = renderText
-    }
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+      }
 
-    return [extension.name, schema]
-  }))
+      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(
+        extension,
+        'renderHTML',
+        context,
+      )
 
-  const marks = Object.fromEntries(markExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-    }
+      if (renderHTML) {
+        schema.toDOM = node => renderHTML({
+          node,
+          HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+        })
+      }
 
-    const extraMarkFields = extensions.reduce((fields, e) => {
-      const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
-        e,
-        'extendMarkSchema',
+      const renderText = getExtensionField<NodeConfig['renderText']>(
+        extension,
+        'renderText',
         context,
       )
 
-      return {
-        ...fields,
-        ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+      if (renderText) {
+        schema.toText = renderText
       }
-    }, {})
-
-    const schema: MarkSpec = cleanUpSchemaItem({
-      ...extraMarkFields,
-      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)),
-      code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = mark => renderHTML({
-        mark,
-        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+
+      return [extension.name, schema]
+    }),
+  )
+
+  const marks = Object.fromEntries(
+    markExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(
+        attribute => attribute.type === extension.name,
+      )
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+      }
+
+      const extraMarkFields = extensions.reduce((fields, e) => {
+        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
+          e,
+          'extendMarkSchema',
+          context,
+        )
+
+        return {
+          ...fields,
+          ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+        }
+      }, {})
+
+      const schema: MarkSpec = cleanUpSchemaItem({
+        ...extraMarkFields,
+        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),
+        ),
+        code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
+        attrs: Object.fromEntries(
+          extensionAttributes.map(extensionAttribute => {
+            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+          }),
+        ),
       })
-    }
 
-    return [extension.name, schema]
-  }))
+      const parseHTML = callOrReturn(
+        getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context),
+      )
+
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+      }
+
+      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(
+        extension,
+        'renderHTML',
+        context,
+      )
+
+      if (renderHTML) {
+        schema.toDOM = mark => renderHTML({
+          mark,
+          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+        })
+      }
+
+      return [extension.name, schema]
+    }),
+  )
 
   return new Schema({
     topNode,

package/src/helpers/getSchemaTypeByName.ts

@@ -1,4 +1,4 @@
-import { MarkType, NodeType, Schema } from 'prosemirror-model'
+import { MarkType, NodeType, Schema } from '@tiptap/pm/model'
 
 export function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
   return schema.nodes[name] || schema.marks[name] || null

package/src/helpers/getSchemaTypeNameByName.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'prosemirror-model'
+import { Schema } from '@tiptap/pm/model'
 
 export function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
   if (schema.nodes[name]) {

package/src/helpers/getText.ts

@@ -1,4 +1,4 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
 import { TextSerializer } from '../types'
 import { getTextBetween } from './getTextBetween'
@@ -6,8 +6,8 @@ import { getTextBetween } from './getTextBetween'
 export function getText(
   node: ProseMirrorNode,
   options?: {
-    blockSeparator?: string,
-    textSerializers?: Record<string, TextSerializer>,
+    blockSeparator?: string
+    textSerializers?: Record<string, TextSerializer>
   },
 ) {
   const range = {

package/src/helpers/getTextBetween.ts

@@ -1,4 +1,4 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
 import { Range, TextSerializer } from '../types'
 
@@ -6,15 +6,12 @@ export function getTextBetween(
   startNode: ProseMirrorNode,
   range: Range,
   options?: {
-    blockSeparator?: string,
-    textSerializers?: Record<string, TextSerializer>,
+    blockSeparator?: string
+    textSerializers?: Record<string, TextSerializer>
   },
 ): string {
   const { from, to } = range
-  const {
-    blockSeparator = '\n\n',
-    textSerializers = {},
-  } = options || {}
+  const { blockSeparator = '\n\n', textSerializers = {} } = options || {}
   let text = ''
   let separated = true
 

package/src/helpers/getTextContentFromNodes.ts

@@ -1,4 +1,4 @@
-import { ResolvedPos } from 'prosemirror-model'
+import { ResolvedPos } from '@tiptap/pm/model'
 
 export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
   let textBefore = ''
@@ -10,8 +10,13 @@ export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
     sliceEndPos,
     (node, pos, parent, index) => {
       const chunk = node.type.spec.toText?.({
-        node, pos, parent, index,
-      }) || node.textContent || '%leaf%'
+        node,
+        pos,
+        parent,
+        index,
+      })
+        || node.textContent
+        || '%leaf%'
 
       textBefore += chunk.slice(0, Math.max(0, sliceEndPos - pos))
     },

package/src/helpers/getTextSerializersFromSchema.ts

@@ -1,10 +1,11 @@
-import { Schema } from 'prosemirror-model'
+import { Schema } from '@tiptap/pm/model'
 
 import { TextSerializer } from '../types'
 
 export function getTextSerializersFromSchema(schema: Schema): Record<string, TextSerializer> {
-  return Object.fromEntries(Object
-    .entries(schema.nodes)
-    .filter(([, node]) => node.spec.toText)
-    .map(([name, node]) => [name, node.spec.toText]))
+  return Object.fromEntries(
+    Object.entries(schema.nodes)
+      .filter(([, node]) => node.spec.toText)
+      .map(([name, node]) => [name, node.spec.toText]),
+  )
 }

package/src/helpers/injectExtensionAttributesToParseRule.ts

@@ -1,4 +1,4 @@
-import { ParseRule } from 'prosemirror-model'
+import { ParseRule } from '@tiptap/pm/model'
 
 import { ExtensionAttribute } from '../types'
 import { fromString } from '../utilities/fromString'
@@ -9,7 +9,10 @@ import { fromString } from '../utilities/fromString'
  * @param parseRule ProseMirror ParseRule
  * @param extensionAttributes List of attributes to inject
  */
-export function injectExtensionAttributesToParseRule(parseRule: ParseRule, extensionAttributes: ExtensionAttribute[]): ParseRule {
+export function injectExtensionAttributesToParseRule(
+  parseRule: ParseRule,
+  extensionAttributes: ExtensionAttribute[],
+): ParseRule {
   if (parseRule.style) {
     return parseRule
   }
@@ -17,9 +20,7 @@ export function injectExtensionAttributesToParseRule(parseRule: ParseRule, exten
   return {
     ...parseRule,
     getAttrs: node => {
-      const oldAttributes = parseRule.getAttrs
-        ? parseRule.getAttrs(node)
-        : parseRule.attrs
+      const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs
 
       if (oldAttributes === false) {
         return false

package/src/helpers/isActive.ts

@@ -1,10 +1,14 @@
-import { EditorState } from 'prosemirror-state'
+import { EditorState } from '@tiptap/pm/state'
 
 import { getSchemaTypeNameByName } from './getSchemaTypeNameByName'
 import { isMarkActive } from './isMarkActive'
 import { isNodeActive } from './isNodeActive'
 
-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/isMarkActive.ts

@@ -1,5 +1,5 @@
-import { MarkType } from 'prosemirror-model'
-import { EditorState } from 'prosemirror-state'
+import { MarkType } from '@tiptap/pm/model'
+import { EditorState } from '@tiptap/pm/state'
 
 import { MarkRange } from '../types'
 import { objectIncludes } from '../utilities/objectIncludes'
@@ -11,9 +11,7 @@ export function isMarkActive(
   attributes: Record<string, any> = {},
 ): boolean {
   const { empty, ranges } = state.selection
-  const type = typeOrName
-    ? getMarkType(typeOrName, state.schema)
-    : null
+  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null
 
   if (empty) {
     return !!(state.storedMarks || state.selection.$from.marks())
@@ -45,11 +43,13 @@ export function isMarkActive(
 
       selectionRange += range
 
-      markRanges.push(...node.marks.map(mark => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo,
-      })))
+      markRanges.push(
+        ...node.marks.map(mark => ({
+          mark,
+          from: relativeFrom,
+          to: relativeTo,
+        })),
+      )
     })
   })
 
@@ -77,16 +77,13 @@ export function isMarkActive(
         return true
       }
 
-      return markRange.mark.type !== type
-        && markRange.mark.type.excludes(type)
+      return markRange.mark.type !== type && markRange.mark.type.excludes(type)
     })
     .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0)
 
   // we only include the result of `excludedRange`
   // if there is a match at all
-  const range = matchedRange > 0
-    ? matchedRange + excludedRange
-    : matchedRange
+  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange
 
   return range >= selectionRange
 }

package/src/helpers/isNodeActive.ts

@@ -1,5 +1,5 @@
-import { NodeType } from 'prosemirror-model'
-import { EditorState } from 'prosemirror-state'
+import { NodeType } from '@tiptap/pm/model'
+import { EditorState } from '@tiptap/pm/state'
 
 import { NodeRange } from '../types'
 import { objectIncludes } from '../utilities/objectIncludes'
@@ -11,9 +11,7 @@ export function isNodeActive(
   attributes: Record<string, any> = {},
 ): boolean {
   const { from, to, empty } = state.selection
-  const type = typeOrName
-    ? getNodeType(typeOrName, state.schema)
-    : null
+  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null
 
   const nodeRanges: NodeRange[] = []
 
@@ -47,8 +45,7 @@ export function isNodeActive(
     return !!matchedNodeRanges.length
   }
 
-  const range = matchedNodeRanges
-    .reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0)
+  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0)
 
   return range >= selectionRange
 }

package/src/helpers/isNodeEmpty.ts

@@ -1,4 +1,4 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
 export function isNodeEmpty(node: ProseMirrorNode): boolean {
   const defaultContent = node.type.createAndFill()?.toJSON()

package/src/helpers/isNodeSelection.ts

@@ -1,4 +1,4 @@
-import { NodeSelection } from 'prosemirror-state'
+import { NodeSelection } from '@tiptap/pm/state'
 
 export function isNodeSelection(value: unknown): value is NodeSelection {
   return value instanceof NodeSelection

package/src/helpers/isTextSelection.ts

@@ -1,4 +1,4 @@
-import { TextSelection } from 'prosemirror-state'
+import { TextSelection } from '@tiptap/pm/state'
 
 export function isTextSelection(value: unknown): value is TextSelection {
   return value instanceof TextSelection

package/src/helpers/posToDOMRect.ts

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

package/src/helpers/resolveFocusPosition.ts

@@ -1,5 +1,5 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
-import { Selection, TextSelection } from 'prosemirror-state'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { Selection, TextSelection } from '@tiptap/pm/state'
 
 import { FocusPosition } from '../types'
 import { minMax } from '../utilities/minMax'
@@ -8,7 +8,6 @@ export function resolveFocusPosition(
   doc: ProseMirrorNode,
   position: FocusPosition = null,
 ): Selection | null {
-
   if (!position) {
     return null
   }

package/src/helpers/selectionToInsertionEnd.ts

@@ -1,5 +1,5 @@
-import { Selection, Transaction } from 'prosemirror-state'
-import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform'
+import { Selection, Transaction } from '@tiptap/pm/state'
+import { ReplaceAroundStep, ReplaceStep } from '@tiptap/pm/transform'
 
 // source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
 export function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number) {

package/src/inputRules/markInputRule.ts

@@ -1,4 +1,4 @@
-import { MarkType } from 'prosemirror-model'
+import { MarkType } from '@tiptap/pm/model'
 
 import { getMarksBetween } from '../helpers/getMarksBetween'
 import { InputRule, InputRuleFinder } from '../InputRule'
@@ -10,14 +10,13 @@ import { callOrReturn } from '../utilities/callOrReturn'
  * matched text is typed into it.
  */
 export function markInputRule(config: {
-  find: InputRuleFinder,
-  type: MarkType,
+  find: InputRuleFinder
+  type: MarkType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
     | null
-  ,
 }) {
   return new InputRule({
     find: config.find,

package/src/inputRules/nodeInputRule.ts

@@ -1,4 +1,4 @@
-import { NodeType } from 'prosemirror-model'
+import { NodeType } from '@tiptap/pm/model'
 
 import { InputRule, InputRuleFinder } from '../InputRule'
 import { ExtendedRegExpMatchArray } from '../types'
@@ -9,14 +9,13 @@ import { callOrReturn } from '../utilities/callOrReturn'
  * matched text is typed into it.
  */
 export function nodeInputRule(config: {
-  find: InputRuleFinder,
-  type: NodeType,
+  find: InputRuleFinder
+  type: NodeType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
     | null
-  ,
 }) {
   return new InputRule({
     find: config.find,

package/src/inputRules/textblockTypeInputRule.ts

@@ -1,4 +1,4 @@
-import { NodeType } from 'prosemirror-model'
+import { NodeType } from '@tiptap/pm/model'
 
 import { InputRule, InputRuleFinder } from '../InputRule'
 import { ExtendedRegExpMatchArray } from '../types'
@@ -11,14 +11,13 @@ import { callOrReturn } from '../utilities/callOrReturn'
  * only occur at the start of a textblock.
  */
 export function textblockTypeInputRule(config: {
-  find: InputRuleFinder,
-  type: NodeType,
+  find: InputRuleFinder
+  type: NodeType
   getAttributes?:
     | Record<string, any>
     | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
     | false
     | null
-  ,
 }) {
   return new InputRule({
     find: config.find,