{"version":3,"sources":["webpack:///./node_modules/@tiptap/extension-task-list/dist/tiptap-extension-task-list.esm.js","webpack:///./node_modules/@tiptap/extension-character-count/dist/tiptap-extension-character-count.esm.js","webpack:///./node_modules/@tiptap/extension-placeholder/dist/tiptap-extension-placeholder.esm.js","webpack:///./node_modules/@tiptap/extension-task-item/dist/tiptap-extension-task-item.esm.js","webpack:///./node_modules/@tiptap/extension-collaboration/node_modules/y-prosemirror/src/plugins/keys.js","webpack:///./node_modules/@tiptap/extension-collaboration/node_modules/y-prosemirror/src/lib.js","webpack:///./node_modules/@tiptap/extension-collaboration/node_modules/y-prosemirror/src/plugins/sync-plugin.js","webpack:///./node_modules/@tiptap/extension-collaboration/node_modules/y-prosemirror/src/plugins/undo-plugin.js","webpack:///./node_modules/@tiptap/extension-collaboration/dist/tiptap-extension-collaboration.esm.js","webpack:///./node_modules/@tiptap/extension-heading/dist/tiptap-extension-heading.esm.js"],"names":["TaskList","create","name","itemTypeName","HTMLAttributes","group","this","options","tag","priority","toggleTaskList","commands","toggleList","editor","CharacterCount","limit","mode","characters","words","storage","node","state","doc","text","textBetween","content","size","undefined","length","nodeSize","split","filter","word","key","filterTransaction","transaction","docChanged","oldSize","newSize","isPaste","getMeta","pos","selection","$head","over","from","to","deleteRange","updatedSize","Placeholder","emptyEditorClass","emptyNodeClass","placeholder","showOnlyWhenEditable","showOnlyCurrent","includeChildren","props","decorations","active","isEditable","anchor","descendants","hasAnchor","isEmpty","isLeaf","childCount","classes","push","decoration","class","join","inputRegex","TaskItem","nested","defining","checked","default","keepOnSplit","parseHTML","element","getAttribute","renderHTML","attributes","type","attrs","shortcuts","Enter","splitListItem","liftListItem","Tab","sinkListItem","getPos","listItem","document","createElement","checkboxWrapper","checkboxStyler","checkbox","contentEditable","addEventListener","event","onReadOnlyChecked","target","chain","focus","scrollIntoView","command","tr","position","currentNode","nodeAt","setNodeMarkup","run","Object","entries","forEach","value","setAttribute","dataset","append","dom","contentDOM","update","updatedNode","removeAttribute","find","getAttributes","match","ySyncPluginKey","yUndoPluginKey","absolutePositionToRelativePosition","mapping","n","_first","_length","_item","next","parent","pNodeSize","get","id","error","constructor","createRelativePosition","item","typeid","tname","client","clock","relativePositionToAbsolutePosition","y","documentType","relPos","decodedPos","index","deleted","i","t","contentType","right","isVisible","snapshot","sv","has","ds","defaultColors","light","dark","getUserColor","colorMapping","colors","user","usedColors","set","color","add","random","ySyncPlugin","yXmlFragment","Map","permanentUserData","onFirstRender","rerenderTimeoutId","changedInitialContent","plugin","editable","syncState","getState","prevSnapshot","init","initargs","binding","isChangeOrigin","apply","pluginState","change","assign","eventloop","isDestroyed","restore","_renderSnapshot","_prosemirrorChanged","prosemirrorView","view","clearTimeout","_forceRerender","dispatch","setMeta","findDiffStart","createAndFill","destroy","restoreRelativeSelection","relSel","head","setSelection","getRelativeSelection","pmbinding","mux","_observeFunction","_typeChanged","bind","beforeTransactionSelection","beforeAllTransactions","afterAllTransactions","on","observeDeep","_domSelectionInView","hasFocus","environment","_isDomSelectionInView","_root","getSelection","range","createRange","setStart","anchorNode","anchorOffset","setEnd","focusNode","focusOffset","rects","getClientRects","startContainer","collapsed","selectNodeContents","bounding","getBoundingClientRect","documentElement","bottom","left","window","innerWidth","clientWidth","top","innerHeight","clientHeight","_tr","fragmentContent","toArray","map","createNodeFromYElement","schema","replace","transact","pud","dss","computeYChange","getUserByClientId","getUserByDeletedId","events","delType","_","delete","deleteSet","struct","changed","changedParentTypes","createNodeIfNotExists","_isLocalCursorInView","renderSnapshot","updateYFragment","unobserveDeep","off","el","children","createChildren","ns","createTextNodesFromYText","textchild","ychange","nodeName","e","nodes","deltas","toDelta","delta","marks","markName","mark","insert","createTypeFromTextNodes","marksToAttributes","applyDelta","createTypeFromElementNode","val","normalizePNodeContent","createTypeFromTextOrElementNode","Array","isObject","equalAttrs","pattrs","yattrs","keys","eq","l","r","pnode","c","res","isText","textNodes","tnode","equalYTextPText","ytext","ptexts","every","d","object","equalYTypePNode","ytype","matchNodeName","normalizedContent","ychild","mappedIdentity","mapped","pcontent","a","computeChildEqualityFactor","yChildren","pChildren","pChildCnt","yChildCnt","minCnt","math","foundMappedChild","leftY","leftP","rightY","rightP","equalityFactor","ytextTrans","str","_start","nAttrs","countable","updateYText","p","remove","retain","yDomFragment","pNode","Error","yDomAttrs","pAttrs","updateLeft","updateRight","equalityLeft","equalityRight","yDelLen","ins","yElement","undo","undoManager","redo","defaultProtectedNodes","Set","defaultDeleteFilter","protectedNodes","yUndoPlugin","trackedOrigins","ystate","_undoManager","concat","deleteFilter","prevSel","hasUndoOps","undoStack","hasRedoOps","redoStack","oldState","stackItem","meta","Collaboration","field","fragment","extensionManager","extensions","extension","console","warn","getXmlFragment","Heading","levels","level","rendered","hasLevel","includes","setHeading","setNode","toggleHeading","toggleNode","reduce","items","RegExp"],"mappings":"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","file":"js/group-account~5bfb3d22.0c14d5b1.js","sourcesContent":["import { Node, mergeAttributes } from '@tiptap/core';\n\nconst TaskList = Node.create({\r\n    name: 'taskList',\r\n    addOptions() {\r\n        return {\r\n            itemTypeName: 'taskItem',\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    group: 'block list',\r\n    content() {\r\n        return `${this.options.itemTypeName}+`;\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: `ul[data-type=\"${this.name}\"]`,\r\n                priority: 51,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { 'data-type': this.name }), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            toggleTaskList: () => ({ commands }) => {\r\n                return commands.toggleList(this.name, this.options.itemTypeName);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-9': () => this.editor.commands.toggleTaskList(),\r\n        };\r\n    },\r\n});\n\nexport { TaskList, TaskList as default };\n//# sourceMappingURL=tiptap-extension-task-list.esm.js.map\n","import { Extension } from '@tiptap/core';\nimport { Plugin, PluginKey } from 'prosemirror-state';\n\nconst CharacterCount = Extension.create({\r\n    name: 'characterCount',\r\n    addOptions() {\r\n        return {\r\n            limit: null,\r\n            mode: 'textSize',\r\n        };\r\n    },\r\n    addStorage() {\r\n        return {\r\n            characters: () => 0,\r\n            words: () => 0,\r\n        };\r\n    },\r\n    onBeforeCreate() {\r\n        this.storage.characters = options => {\r\n            const node = (options === null || options === void 0 ? void 0 : options.node) || this.editor.state.doc;\r\n            const mode = (options === null || options === void 0 ? void 0 : options.mode) || this.options.mode;\r\n            if (mode === 'textSize') {\r\n                const text = node.textBetween(0, node.content.size, undefined, ' ');\r\n                return text.length;\r\n            }\r\n            return node.nodeSize;\r\n        };\r\n        this.storage.words = options => {\r\n            const node = (options === null || options === void 0 ? void 0 : options.node) || this.editor.state.doc;\r\n            const text = node.textBetween(0, node.content.size, ' ', ' ');\r\n            const words = text\r\n                .split(' ')\r\n                .filter(word => word !== '');\r\n            return words.length;\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            new Plugin({\r\n                key: new PluginKey('characterCount'),\r\n                filterTransaction: (transaction, state) => {\r\n                    const limit = this.options.limit;\r\n                    // Nothing has changed or no limit is defined. Ignore it.\r\n                    if (!transaction.docChanged || limit === 0 || limit === null || limit === undefined) {\r\n                        return true;\r\n                    }\r\n                    const oldSize = this.storage.characters({ node: state.doc });\r\n                    const newSize = this.storage.characters({ node: transaction.doc });\r\n                    // Everything is in the limit. Good.\r\n                    if (newSize <= limit) {\r\n                        return true;\r\n                    }\r\n                    // The limit has already been exceeded but will be reduced.\r\n                    if (oldSize > limit && newSize > limit && newSize <= oldSize) {\r\n                        return true;\r\n                    }\r\n                    // The limit has already been exceeded and will be increased further.\r\n                    if (oldSize > limit && newSize > limit && newSize > oldSize) {\r\n                        return false;\r\n                    }\r\n                    const isPaste = transaction.getMeta('paste');\r\n                    // Block all exceeding transactions that were not pasted.\r\n                    if (!isPaste) {\r\n                        return false;\r\n                    }\r\n                    // For pasted content, we try to remove the exceeding content.\r\n                    const pos = transaction.selection.$head.pos;\r\n                    const over = newSize - limit;\r\n                    const from = pos - over;\r\n                    const to = pos;\r\n                    // It’s probably a bad idea to mutate transactions within `filterTransaction`\r\n                    // but for now this is working fine.\r\n                    transaction.deleteRange(from, to);\r\n                    // In some situations, the limit will continue to be exceeded after trimming.\r\n                    // This happens e.g. when truncating within a complex node (e.g. table)\r\n                    // and ProseMirror has to close this node again.\r\n                    // If this is the case, we prevent the transaction completely.\r\n                    const updatedSize = this.storage.characters({ node: transaction.doc });\r\n                    if (updatedSize > limit) {\r\n                        return false;\r\n                    }\r\n                    return true;\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { CharacterCount, CharacterCount as default };\n//# sourceMappingURL=tiptap-extension-character-count.esm.js.map\n","import { Extension } from '@tiptap/core';\nimport { Plugin } from 'prosemirror-state';\nimport { Decoration, DecorationSet } from 'prosemirror-view';\n\nconst Placeholder = Extension.create({\r\n    name: 'placeholder',\r\n    addOptions() {\r\n        return {\r\n            emptyEditorClass: 'is-editor-empty',\r\n            emptyNodeClass: 'is-empty',\r\n            placeholder: 'Write something …',\r\n            showOnlyWhenEditable: true,\r\n            showOnlyCurrent: true,\r\n            includeChildren: false,\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            new Plugin({\r\n                props: {\r\n                    decorations: ({ doc, selection }) => {\r\n                        const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;\r\n                        const { anchor } = selection;\r\n                        const decorations = [];\r\n                        if (!active) {\r\n                            return null;\r\n                        }\r\n                        doc.descendants((node, pos) => {\r\n                            const hasAnchor = anchor >= pos && anchor <= (pos + node.nodeSize);\r\n                            const isEmpty = !node.isLeaf && !node.childCount;\r\n                            if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {\r\n                                const classes = [this.options.emptyNodeClass];\r\n                                if (this.editor.isEmpty) {\r\n                                    classes.push(this.options.emptyEditorClass);\r\n                                }\r\n                                const decoration = Decoration.node(pos, pos + node.nodeSize, {\r\n                                    class: classes.join(' '),\r\n                                    'data-placeholder': typeof this.options.placeholder === 'function'\r\n                                        ? this.options.placeholder({\r\n                                            editor: this.editor,\r\n                                            node,\r\n                                            pos,\r\n                                            hasAnchor,\r\n                                        })\r\n                                        : this.options.placeholder,\r\n                                });\r\n                                decorations.push(decoration);\r\n                            }\r\n                            return this.options.includeChildren;\r\n                        });\r\n                        return DecorationSet.create(doc, decorations);\r\n                    },\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Placeholder, Placeholder as default };\n//# sourceMappingURL=tiptap-extension-placeholder.esm.js.map\n","import { Node, mergeAttributes, wrappingInputRule } from '@tiptap/core';\n\nconst inputRegex = /^\\s*(\\[([( |x])?\\])\\s$/;\r\nconst TaskItem = Node.create({\r\n    name: 'taskItem',\r\n    addOptions() {\r\n        return {\r\n            nested: false,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content() {\r\n        return this.options.nested ? 'paragraph block*' : 'paragraph+';\r\n    },\r\n    defining: true,\r\n    addAttributes() {\r\n        return {\r\n            checked: {\r\n                default: false,\r\n                keepOnSplit: false,\r\n                parseHTML: element => element.getAttribute('data-checked') === 'true',\r\n                renderHTML: attributes => ({\r\n                    'data-checked': attributes.checked,\r\n                }),\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: `li[data-type=\"${this.name}\"]`,\r\n                priority: 51,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        return [\r\n            'li',\r\n            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {\r\n                'data-type': this.name,\r\n            }),\r\n            [\r\n                'label',\r\n                [\r\n                    'input',\r\n                    {\r\n                        type: 'checkbox',\r\n                        checked: node.attrs.checked ? 'checked' : null,\r\n                    },\r\n                ],\r\n                ['span'],\r\n            ],\r\n            ['div', 0],\r\n        ];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        const shortcuts = {\r\n            Enter: () => this.editor.commands.splitListItem(this.name),\r\n            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),\r\n        };\r\n        if (!this.options.nested) {\r\n            return shortcuts;\r\n        }\r\n        return {\r\n            ...shortcuts,\r\n            Tab: () => this.editor.commands.sinkListItem(this.name),\r\n        };\r\n    },\r\n    addNodeView() {\r\n        return ({ node, HTMLAttributes, getPos, editor, }) => {\r\n            const listItem = document.createElement('li');\r\n            const checkboxWrapper = document.createElement('label');\r\n            const checkboxStyler = document.createElement('span');\r\n            const checkbox = document.createElement('input');\r\n            const content = document.createElement('div');\r\n            checkboxWrapper.contentEditable = 'false';\r\n            checkbox.type = 'checkbox';\r\n            checkbox.addEventListener('change', event => {\r\n                // if the editor isn’t editable and we don't have a handler for\r\n                // readonly checks we have to undo the latest change\r\n                if (!editor.isEditable && !this.options.onReadOnlyChecked) {\r\n                    checkbox.checked = !checkbox.checked;\r\n                    return;\r\n                }\r\n                const { checked } = event.target;\r\n                if (editor.isEditable && typeof getPos === 'function') {\r\n                    editor\r\n                        .chain()\r\n                        .focus(undefined, { scrollIntoView: false })\r\n                        .command(({ tr }) => {\r\n                        const position = getPos();\r\n                        const currentNode = tr.doc.nodeAt(position);\r\n                        tr.setNodeMarkup(position, undefined, {\r\n                            ...currentNode === null || currentNode === void 0 ? void 0 : currentNode.attrs,\r\n                            checked,\r\n                        });\r\n                        return true;\r\n                    })\r\n                        .run();\r\n                }\r\n                if (!editor.isEditable && this.options.onReadOnlyChecked) {\r\n                    // Reset state if onReadOnlyChecked returns false\r\n                    if (!this.options.onReadOnlyChecked(node, checked)) {\r\n                        checkbox.checked = !checkbox.checked;\r\n                    }\r\n                }\r\n            });\r\n            Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {\r\n                listItem.setAttribute(key, value);\r\n            });\r\n            listItem.dataset.checked = node.attrs.checked;\r\n            if (node.attrs.checked) {\r\n                checkbox.setAttribute('checked', 'checked');\r\n            }\r\n            checkboxWrapper.append(checkbox, checkboxStyler);\r\n            listItem.append(checkboxWrapper, content);\r\n            Object.entries(HTMLAttributes).forEach(([key, value]) => {\r\n                listItem.setAttribute(key, value);\r\n            });\r\n            return {\r\n                dom: listItem,\r\n                contentDOM: content,\r\n                update: updatedNode => {\r\n                    if (updatedNode.type !== this.type) {\r\n                        return false;\r\n                    }\r\n                    listItem.dataset.checked = updatedNode.attrs.checked;\r\n                    if (updatedNode.attrs.checked) {\r\n                        checkbox.setAttribute('checked', 'checked');\r\n                    }\r\n                    else {\r\n                        checkbox.removeAttribute('checked');\r\n                    }\r\n                    return true;\r\n                },\r\n            };\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            wrappingInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n                getAttributes: match => ({\r\n                    checked: match[match.length - 1] === 'x',\r\n                }),\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { TaskItem, TaskItem as default, inputRegex };\n//# sourceMappingURL=tiptap-extension-task-item.esm.js.map\n","\nimport { PluginKey } from 'prosemirror-state' // eslint-disable-line\n\n/**\n * The unique prosemirror plugin key for syncPlugin\n *\n * @public\n */\nexport const ySyncPluginKey = new PluginKey('y-sync')\n\n/**\n * The unique prosemirror plugin key for undoPlugin\n *\n * @public\n */\nexport const yUndoPluginKey = new PluginKey('y-undo')\n\n/**\n * The unique prosemirror plugin key for cursorPlugin\n *\n * @public\n */\nexport const yCursorPluginKey = new PluginKey('yjs-cursor')\n","import { updateYFragment } from './plugins/sync-plugin.js' // eslint-disable-line\nimport { ySyncPluginKey } from './plugins/keys.js'\nimport * as Y from 'yjs'\nimport { EditorView } from 'prosemirror-view' // eslint-disable-line\nimport { Node, Schema } from 'prosemirror-model' // eslint-disable-line\nimport * as error from 'lib0/error'\nimport * as map from 'lib0/map'\nimport * as eventloop from 'lib0/eventloop'\n\n/**\n * Either a node if type is YXmlElement or an Array of text nodes if YXmlText\n * @typedef {Map<Y.AbstractType, Node | Array<Node>>} ProsemirrorMapping\n */\n\n/**\n * Is null if no timeout is in progress.\n * Is defined if a timeout is in progress.\n * Maps from view\n * @type {Map<EditorView, Map<any, any>>|null}\n */\nlet viewsToUpdate = null\n\nconst updateMetas = () => {\n  const ups = /** @type {Map<EditorView, Map<any, any>>} */ (viewsToUpdate)\n  viewsToUpdate = null\n  ups.forEach((metas, view) => {\n    const tr = view.state.tr\n    const syncState = ySyncPluginKey.getState(view.state)\n    if (syncState && syncState.binding && !syncState.binding.isDestroyed) {\n      metas.forEach((val, key) => {\n        tr.setMeta(key, val)\n      })\n      view.dispatch(tr)\n    }\n  })\n}\n\nexport const setMeta = (view, key, value) => {\n  if (!viewsToUpdate) {\n    viewsToUpdate = new Map()\n    eventloop.timeout(0, updateMetas)\n  }\n  map.setIfUndefined(viewsToUpdate, view, map.create).set(key, value)\n}\n\n/**\n * Transforms a Prosemirror based absolute position to a Yjs Cursor (relative position in the Yjs model).\n *\n * @param {number} pos\n * @param {Y.XmlFragment} type\n * @param {ProsemirrorMapping} mapping\n * @return {any} relative position\n */\nexport const absolutePositionToRelativePosition = (pos, type, mapping) => {\n  if (pos === 0) {\n    return Y.createRelativePositionFromTypeIndex(type, 0)\n  }\n  /**\n   * @type {any}\n   */\n  let n = type._first === null ? null : /** @type {Y.ContentType} */ (type._first.content).type\n  while (n !== null && type !== n) {\n    if (n instanceof Y.XmlText) {\n      if (n._length >= pos) {\n        return Y.createRelativePositionFromTypeIndex(n, pos)\n      } else {\n        pos -= n._length\n      }\n      if (n._item !== null && n._item.next !== null) {\n        n = /** @type {Y.ContentType} */ (n._item.next.content).type\n      } else {\n        do {\n          n = n._item === null ? null : n._item.parent\n          pos--\n        } while (n !== type && n !== null && n._item !== null && n._item.next === null)\n        if (n !== null && n !== type) {\n          // @ts-gnore we know that n.next !== null because of above loop conditition\n          n = n._item === null ? null : /** @type {Y.ContentType} */ (/** @type Y.Item */ (n._item.next).content).type\n        }\n      }\n    } else {\n      const pNodeSize = /** @type {any} */ (mapping.get(n) || { nodeSize: 0 }).nodeSize\n      if (n._first !== null && pos < pNodeSize) {\n        n = /** @type {Y.ContentType} */ (n._first.content).type\n        pos--\n      } else {\n        if (pos === 1 && n._length === 0 && pNodeSize > 1) {\n          // edge case, should end in this paragraph\n          return new Y.RelativePosition(n._item === null ? null : n._item.id, n._item === null ? Y.findRootTypeKey(n) : null, null)\n        }\n        pos -= pNodeSize\n        if (n._item !== null && n._item.next !== null) {\n          n = /** @type {Y.ContentType} */ (n._item.next.content).type\n        } else {\n          if (pos === 0) {\n            // set to end of n.parent\n            n = n._item === null ? n : n._item.parent\n            return new Y.RelativePosition(n._item === null ? null : n._item.id, n._item === null ? Y.findRootTypeKey(n) : null, null)\n          }\n          do {\n            n = /** @type {Y.Item} */ (n._item).parent\n            pos--\n          } while (n !== type && /** @type {Y.Item} */ (n._item).next === null)\n          // if n is null at this point, we have an unexpected case\n          if (n !== type) {\n            // We know that n._item.next is defined because of above loop condition\n            n = /** @type {Y.ContentType} */ (/** @type {Y.Item} */ (/** @type {Y.Item} */ (n._item).next).content).type\n          }\n        }\n      }\n    }\n    if (n === null) {\n      throw error.unexpectedCase()\n    }\n    if (pos === 0 && n.constructor !== Y.XmlText && n !== type) { // TODO: set to <= 0\n      return createRelativePosition(n._item.parent, n._item)\n    }\n  }\n  return Y.createRelativePositionFromTypeIndex(type, type._length)\n}\n\nconst createRelativePosition = (type, item) => {\n  let typeid = null\n  let tname = null\n  if (type._item === null) {\n    tname = Y.findRootTypeKey(type)\n  } else {\n    typeid = Y.createID(type._item.id.client, type._item.id.clock)\n  }\n  return new Y.RelativePosition(typeid, tname, item.id)\n}\n\n/**\n * @param {Y.Doc} y\n * @param {Y.XmlFragment} documentType Top level type that is bound to pView\n * @param {any} relPos Encoded Yjs based relative position\n * @param {ProsemirrorMapping} mapping\n * @return {null|number}\n */\nexport const relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) => {\n  const decodedPos = Y.createAbsolutePositionFromRelativePosition(relPos, y)\n  if (decodedPos === null || (decodedPos.type !== documentType && !Y.isParentOf(documentType, decodedPos.type._item))) {\n    return null\n  }\n  let type = decodedPos.type\n  let pos = 0\n  if (type.constructor === Y.XmlText) {\n    pos = decodedPos.index\n  } else if (type._item === null || !type._item.deleted) {\n    let n = type._first\n    let i = 0\n    while (i < type._length && i < decodedPos.index && n !== null) {\n      if (!n.deleted) {\n        const t = /** @type {Y.ContentType} */ (n.content).type\n        i++\n        if (t instanceof Y.XmlText) {\n          pos += t._length\n        } else {\n          pos += /** @type {any} */ (mapping.get(t)).nodeSize\n        }\n      }\n      n = /** @type {Y.Item} */ (n.right)\n    }\n    pos += 1 // increase because we go out of n\n  }\n  while (type !== documentType && type._item !== null) {\n    // @ts-ignore\n    const parent = type._item.parent\n    // @ts-ignore\n    if (parent._item === null || !parent._item.deleted) {\n      pos += 1 // the start tag\n      let n = /** @type {Y.AbstractType} */ (parent)._first\n      // now iterate until we found type\n      while (n !== null) {\n        const contentType = /** @type {Y.ContentType} */ (n.content).type\n        if (contentType === type) {\n          break\n        }\n        if (!n.deleted) {\n          if (contentType instanceof Y.XmlText) {\n            pos += contentType._length\n          } else {\n            pos += /** @type {any} */ (mapping.get(contentType)).nodeSize\n          }\n        }\n        n = n.right\n      }\n    }\n    type = /** @type {Y.AbstractType} */ (parent)\n  }\n  return pos - 1 // we don't count the most outer tag, because it is a fragment\n}\n\n/**\n * Utility method to convert a Prosemirror Doc Node into a Y.Doc.\n *\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * @param {Node} doc\n * @param {string} xmlFragment\n * @return {Y.Doc}\n */\nexport function prosemirrorToYDoc (doc, xmlFragment = 'prosemirror') {\n  const ydoc = new Y.Doc()\n  const type = /** @type {Y.XmlFragment} */ (ydoc.get(xmlFragment, Y.XmlFragment))\n  if (!type.doc) {\n    return ydoc\n  }\n\n  prosemirrorToYXmlFragment(doc, type)\n  return type.doc\n}\n\n/**\n * Utility method to update an empty Y.XmlFragment with content from a Prosemirror Doc Node.\n *\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * Note: The Y.XmlFragment does not need to be part of a Y.Doc document at the time that this\n * method is called, but it must be added before any other operations are performed on it.\n *\n * @param {Node} doc prosemirror document.\n * @param {Y.XmlFragment} [xmlFragment] If supplied, an xml fragment to be\n *   populated from the prosemirror state; otherwise a new XmlFragment will be created.\n * @return {Y.XmlFragment}\n */\nexport function prosemirrorToYXmlFragment (doc, xmlFragment) {\n  const type = xmlFragment || new Y.XmlFragment()\n  const ydoc = type.doc ? type.doc : { transact: (transaction) => transaction(undefined) }\n  updateYFragment(ydoc, type, doc, new Map())\n  return type\n}\n\n/**\n * Utility method to convert Prosemirror compatible JSON into a Y.Doc.\n *\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * @param {Schema} schema\n * @param {any} state\n * @param {string} xmlFragment\n * @return {Y.Doc}\n */\nexport function prosemirrorJSONToYDoc (schema, state, xmlFragment = 'prosemirror') {\n  const doc = Node.fromJSON(schema, state)\n  return prosemirrorToYDoc(doc, xmlFragment)\n}\n\n/**\n * Utility method to convert Prosemirror compatible JSON to a Y.XmlFragment\n *\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * @param {Schema} schema\n * @param {any} state\n * @param {Y.XmlFragment} [xmlFragment] If supplied, an xml fragment to be\n *   populated from the prosemirror state; otherwise a new XmlFragment will be created.\n * @return {Y.XmlFragment}\n */\nexport function prosemirrorJSONToYXmlFragment (schema, state, xmlFragment) {\n  const doc = Node.fromJSON(schema, state)\n  return prosemirrorToYXmlFragment(doc, xmlFragment)\n}\n\n/**\n * Utility method to convert a Y.Doc to a Prosemirror Doc node.\n *\n * @param {Schema} schema\n * @param {Y.Doc} ydoc\n * @return {Node}\n */\nexport function yDocToProsemirror (schema, ydoc) {\n  const state = yDocToProsemirrorJSON(ydoc)\n  return Node.fromJSON(schema, state)\n}\n\n/**\n * Utility method to convert a Y.XmlFragment to a Prosemirror Doc node.\n *\n * @param {Schema} schema\n * @param {Y.XmlFragment} xmlFragment\n * @return {Node}\n */\nexport function yXmlFragmentToProsemirror (schema, xmlFragment) {\n  const state = yXmlFragmentToProsemirrorJSON(xmlFragment)\n  return Node.fromJSON(schema, state)\n}\n\n/**\n * Utility method to convert a Y.Doc to Prosemirror compatible JSON.\n *\n * @param {Y.Doc} ydoc\n * @param {string} xmlFragment\n * @return {Record<string, any>}\n */\nexport function yDocToProsemirrorJSON (\n  ydoc,\n  xmlFragment = 'prosemirror'\n) {\n  return yXmlFragmentToProsemirrorJSON(ydoc.getXmlFragment(xmlFragment))\n}\n\n/**\n * Utility method to convert a Y.Doc to Prosemirror compatible JSON.\n *\n * @param {Y.XmlFragment} xmlFragment The fragment, which must be part of a Y.Doc.\n * @return {Record<string, any>}\n */\nexport function yXmlFragmentToProsemirrorJSON (xmlFragment) {\n  const items = xmlFragment.toArray()\n\n  function serialize (item) {\n    /**\n     * @type {Object} NodeObject\n     * @property {string} NodeObject.type\n     * @property {Record<string, string>=} NodeObject.attrs\n     * @property {Array<NodeObject>=} NodeObject.content\n     */\n    let response\n\n    // TODO: Must be a better way to detect text nodes than this\n    if (!item.nodeName) {\n      const delta = item.toDelta()\n      response = delta.map((d) => {\n        const text = {\n          type: 'text',\n          text: d.insert\n        }\n\n        if (d.attributes) {\n          text.marks = Object.keys(d.attributes).map((type) => {\n            const attrs = d.attributes[type]\n            const mark = {\n              type\n            }\n\n            if (Object.keys(attrs)) {\n              mark.attrs = attrs\n            }\n\n            return mark\n          })\n        }\n        return text\n      })\n    } else {\n      response = {\n        type: item.nodeName\n      }\n\n      const attrs = item.getAttributes()\n      if (Object.keys(attrs).length) {\n        response.attrs = attrs\n      }\n\n      const children = item.toArray()\n      if (children.length) {\n        response.content = children.map(serialize).flat()\n      }\n    }\n\n    return response\n  }\n\n  return {\n    type: 'doc',\n    content: items.map(serialize)\n  }\n}\n","/**\n * @module bindings/prosemirror\n */\n\nimport { createMutex } from 'lib0/mutex'\nimport * as PModel from 'prosemirror-model'\nimport { Plugin, TextSelection } from 'prosemirror-state' // eslint-disable-line\nimport * as math from 'lib0/math'\nimport * as object from 'lib0/object'\nimport * as set from 'lib0/set'\nimport { simpleDiff } from 'lib0/diff'\nimport * as error from 'lib0/error'\nimport { ySyncPluginKey } from './keys.js'\nimport * as Y from 'yjs'\nimport { absolutePositionToRelativePosition, relativePositionToAbsolutePosition } from '../lib.js'\nimport * as random from 'lib0/random'\nimport * as environment from 'lib0/environment'\nimport * as dom from 'lib0/dom'\nimport * as eventloop from 'lib0/eventloop'\n\n/**\n * @param {Y.Item} item\n * @param {Y.Snapshot} [snapshot]\n */\nexport const isVisible = (item, snapshot) => snapshot === undefined ? !item.deleted : (snapshot.sv.has(item.id.client) && /** @type {number} */ (snapshot.sv.get(item.id.client)) > item.id.clock && !Y.isDeleted(snapshot.ds, item.id))\n\n/**\n * Either a node if type is YXmlElement or an Array of text nodes if YXmlText\n * @typedef {Map<Y.AbstractType<any>, PModel.Node | Array<PModel.Node>>} ProsemirrorMapping\n */\n\n/**\n * @typedef {Object} ColorDef\n * @property {string} ColorDef.light\n * @property {string} ColorDef.dark\n */\n\n/**\n * @typedef {Object} YSyncOpts\n * @property {Array<ColorDef>} [YSyncOpts.colors]\n * @property {Map<string,ColorDef>} [YSyncOpts.colorMapping]\n * @property {Y.PermanentUserData|null} [YSyncOpts.permanentUserData]\n * @property {function} [YSyncOpts.onFirstRender] Fired when the content from Yjs is initially rendered to ProseMirror\n */\n\n/**\n * @type {Array<ColorDef>}\n */\nconst defaultColors = [{ light: '#ecd44433', dark: '#ecd444' }]\n\n/**\n * @param {Map<string,ColorDef>} colorMapping\n * @param {Array<ColorDef>} colors\n * @param {string} user\n * @return {ColorDef}\n */\nconst getUserColor = (colorMapping, colors, user) => {\n  // @todo do not hit the same color twice if possible\n  if (!colorMapping.has(user)) {\n    if (colorMapping.size < colors.length) {\n      const usedColors = set.create()\n      colorMapping.forEach(color => usedColors.add(color))\n      colors = colors.filter(color => !usedColors.has(color))\n    }\n    colorMapping.set(user, random.oneOf(colors))\n  }\n  return /** @type {ColorDef} */ (colorMapping.get(user))\n}\n\n/**\n * This plugin listens to changes in prosemirror view and keeps yXmlState and view in sync.\n *\n * This plugin also keeps references to the type and the shared document so other plugins can access it.\n * @param {Y.XmlFragment} yXmlFragment\n * @param {YSyncOpts} opts\n * @return {any} Returns a prosemirror plugin that binds to this type\n */\nexport const ySyncPlugin = (yXmlFragment, {\n  colors = defaultColors,\n  colorMapping = new Map(),\n  permanentUserData = null,\n  onFirstRender = () => {}\n} = {}) => {\n  let changedInitialContent = false\n  let rerenderTimeoutId\n  const plugin = new Plugin({\n    props: {\n      editable: (state) => {\n        const syncState = ySyncPluginKey.getState(state)\n        return syncState.snapshot == null && syncState.prevSnapshot == null\n      }\n    },\n    key: ySyncPluginKey,\n    state: {\n      init: (initargs, state) => {\n        return {\n          type: yXmlFragment,\n          doc: yXmlFragment.doc,\n          binding: null,\n          snapshot: null,\n          prevSnapshot: null,\n          isChangeOrigin: false,\n          colors,\n          colorMapping,\n          permanentUserData\n        }\n      },\n      apply: (tr, pluginState) => {\n        const change = tr.getMeta(ySyncPluginKey)\n        if (change !== undefined) {\n          pluginState = Object.assign({}, pluginState)\n          for (const key in change) {\n            pluginState[key] = change[key]\n          }\n        }\n        // always set isChangeOrigin. If undefined, this is not change origin.\n        pluginState.isChangeOrigin = change !== undefined && !!change.isChangeOrigin\n        if (pluginState.binding !== null) {\n          if (change !== undefined && (change.snapshot != null || change.prevSnapshot != null)) {\n            // snapshot changed, rerender next\n            eventloop.timeout(0, () => {\n              if (pluginState.binding == null || pluginState.binding.isDestroyed) {\n                return\n              }\n              if (change.restore == null) {\n                pluginState.binding._renderSnapshot(change.snapshot, change.prevSnapshot, pluginState)\n              } else {\n                pluginState.binding._renderSnapshot(change.snapshot, change.snapshot, pluginState)\n                // reset to current prosemirror state\n                delete pluginState.restore\n                delete pluginState.snapshot\n                delete pluginState.prevSnapshot\n                pluginState.binding._prosemirrorChanged(pluginState.binding.prosemirrorView.state.doc)\n              }\n            })\n          }\n        }\n        return pluginState\n      }\n    },\n    view: view => {\n      const binding = new ProsemirrorBinding(yXmlFragment, view)\n      if (rerenderTimeoutId != null) {\n        clearTimeout(rerenderTimeoutId)\n      }\n      // Make sure this is called in a separate context\n      rerenderTimeoutId = eventloop.timeout(0, () => {\n        binding._forceRerender()\n        view.dispatch(view.state.tr.setMeta(ySyncPluginKey, { binding }))\n        onFirstRender()\n      })\n      return {\n        update: () => {\n          const pluginState = plugin.getState(view.state)\n          if (pluginState.snapshot == null && pluginState.prevSnapshot == null) {\n            if (changedInitialContent || view.state.doc.content.findDiffStart(view.state.doc.type.createAndFill().content) !== null) {\n              changedInitialContent = true\n              binding._prosemirrorChanged(view.state.doc)\n            }\n          }\n        },\n        destroy: () => {\n          clearTimeout(rerenderTimeoutId)\n          binding.destroy()\n        }\n      }\n    }\n  })\n  return plugin\n}\n\n/**\n * @param {any} tr\n * @param {any} relSel\n * @param {ProsemirrorBinding} binding\n */\nconst restoreRelativeSelection = (tr, relSel, binding) => {\n  if (relSel !== null && relSel.anchor !== null && relSel.head !== null) {\n    const anchor = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.anchor, binding.mapping)\n    const head = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.head, binding.mapping)\n    if (anchor !== null && head !== null) {\n      tr = tr.setSelection(TextSelection.create(tr.doc, anchor, head))\n    }\n  }\n}\n\nexport const getRelativeSelection = (pmbinding, state) => ({\n  anchor: absolutePositionToRelativePosition(state.selection.anchor, pmbinding.type, pmbinding.mapping),\n  head: absolutePositionToRelativePosition(state.selection.head, pmbinding.type, pmbinding.mapping)\n})\n\n/**\n * Binding for prosemirror.\n *\n * @protected\n */\nexport class ProsemirrorBinding {\n  /**\n   * @param {Y.XmlFragment} yXmlFragment The bind source\n   * @param {any} prosemirrorView The target binding\n   */\n  constructor (yXmlFragment, prosemirrorView) {\n    this.type = yXmlFragment\n    this.prosemirrorView = prosemirrorView\n    this.mux = createMutex()\n    this.isDestroyed = false\n    /**\n     * @type {ProsemirrorMapping}\n     */\n    this.mapping = new Map()\n    this._observeFunction = this._typeChanged.bind(this)\n    /**\n     * @type {Y.Doc}\n     */\n    // @ts-ignore\n    this.doc = yXmlFragment.doc\n    /**\n     * current selection as relative positions in the Yjs model\n     */\n    this.beforeTransactionSelection = null\n    this.beforeAllTransactions = () => {\n      if (this.beforeTransactionSelection === null) {\n        this.beforeTransactionSelection = getRelativeSelection(this, prosemirrorView.state)\n      }\n    }\n    this.afterAllTransactions = () => {\n      this.beforeTransactionSelection = null\n    }\n\n    this.doc.on('beforeAllTransactions', this.beforeAllTransactions)\n    this.doc.on('afterAllTransactions', this.afterAllTransactions)\n    yXmlFragment.observeDeep(this._observeFunction)\n\n    this._domSelectionInView = null\n  }\n\n  /**\n   * Create a transaction for changing the prosemirror state.\n   *\n   * @returns\n   */\n  get _tr () {\n    return this.prosemirrorView.state.tr.setMeta('addToHistory', false)\n  }\n\n  _isLocalCursorInView () {\n    if (!this.prosemirrorView.hasFocus()) return false\n    if (environment.isBrowser && this._domSelectionInView === null) {\n      // Calculate the domSelectionInView and clear by next tick after all events are finished\n      eventloop.timeout(0, () => {\n        this._domSelectionInView = null\n      })\n      this._domSelectionInView = this._isDomSelectionInView()\n    }\n    return this._domSelectionInView\n  }\n\n  _isDomSelectionInView () {\n    const selection = this.prosemirrorView._root.getSelection()\n\n    const range = this.prosemirrorView._root.createRange()\n    range.setStart(selection.anchorNode, selection.anchorOffset)\n    range.setEnd(selection.focusNode, selection.focusOffset)\n\n    // This is a workaround for an edgecase where getBoundingClientRect will\n    // return zero values if the selection is collapsed at the start of a newline\n    // see reference here: https://stackoverflow.com/a/59780954\n    const rects = range.getClientRects()\n    if (rects.length === 0) {\n      // probably buggy newline behavior, explicitly select the node contents\n      if (range.startContainer && range.collapsed) {\n        range.selectNodeContents(range.startContainer)\n      }\n    }\n\n    const bounding = range.getBoundingClientRect()\n    const documentElement = dom.doc.documentElement\n\n    return bounding.bottom >= 0 && bounding.right >= 0 &&\n      bounding.left <= (window.innerWidth || documentElement.clientWidth || 0) &&\n      bounding.top <= (window.innerHeight || documentElement.clientHeight || 0)\n  }\n\n  renderSnapshot (snapshot, prevSnapshot) {\n    if (!prevSnapshot) {\n      prevSnapshot = Y.createSnapshot(Y.createDeleteSet(), new Map())\n    }\n    this.prosemirrorView.dispatch(this._tr.setMeta(ySyncPluginKey, { snapshot, prevSnapshot }))\n  }\n\n  unrenderSnapshot () {\n    this.mapping = new Map()\n    this.mux(() => {\n      const fragmentContent = this.type.toArray().map(t => createNodeFromYElement(/** @type {Y.XmlElement} */ (t), this.prosemirrorView.state.schema, this.mapping)).filter(n => n !== null)\n      // @ts-ignore\n      const tr = this._tr.replace(0, this.prosemirrorView.state.doc.content.size, new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0))\n      tr.setMeta(ySyncPluginKey, { snapshot: null, prevSnapshot: null })\n      this.prosemirrorView.dispatch(tr)\n    })\n  }\n\n  _forceRerender () {\n    this.mapping = new Map()\n    this.mux(() => {\n      const fragmentContent = this.type.toArray().map(t => createNodeFromYElement(/** @type {Y.XmlElement} */ (t), this.prosemirrorView.state.schema, this.mapping)).filter(n => n !== null)\n      // @ts-ignore\n      const tr = this._tr.replace(0, this.prosemirrorView.state.doc.content.size, new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0))\n      this.prosemirrorView.dispatch(tr.setMeta(ySyncPluginKey, { isChangeOrigin: true }))\n    })\n  }\n\n  /**\n   * @param {Y.Snapshot} snapshot\n   * @param {Y.Snapshot} prevSnapshot\n   * @param {Object} pluginState\n   */\n  _renderSnapshot (snapshot, prevSnapshot, pluginState) {\n    if (!snapshot) {\n      snapshot = Y.snapshot(this.doc)\n    }\n    // clear mapping because we are going to rerender\n    this.mapping = new Map()\n    this.mux(() => {\n      this.doc.transact(transaction => {\n        // before rendering, we are going to sanitize ops and split deleted ops\n        // if they were deleted by seperate users.\n        const pud = pluginState.permanentUserData\n        if (pud) {\n          pud.dss.forEach(ds => {\n            Y.iterateDeletedStructs(transaction, ds, item => {})\n          })\n        }\n        const computeYChange = (type, id) => {\n          const user = type === 'added' ? pud.getUserByClientId(id.client) : pud.getUserByDeletedId(id)\n          return {\n            user,\n            type,\n            color: getUserColor(pluginState.colorMapping, pluginState.colors, user)\n          }\n        }\n        // Create document fragment and render\n        const fragmentContent = Y.typeListToArraySnapshot(this.type, new Y.Snapshot(prevSnapshot.ds, snapshot.sv)).map(t => {\n          if (!t._item.deleted || isVisible(t._item, snapshot) || isVisible(t._item, prevSnapshot)) {\n            return createNodeFromYElement(t, this.prosemirrorView.state.schema, new Map(), snapshot, prevSnapshot, computeYChange)\n          } else {\n            // No need to render elements that are not visible by either snapshot.\n            // If a client adds and deletes content in the same snapshot the element is not visible by either snapshot.\n            return null\n          }\n        }).filter(n => n !== null)\n        // @ts-ignore\n        const tr = this._tr.replace(0, this.prosemirrorView.state.doc.content.size, new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0))\n        this.prosemirrorView.dispatch(tr.setMeta(ySyncPluginKey, { isChangeOrigin: true }))\n      }, ySyncPluginKey)\n    })\n  }\n\n  /**\n   * @param {Array<Y.YEvent<any>>} events\n   * @param {Y.Transaction} transaction\n   */\n  _typeChanged (events, transaction) {\n    const syncState = ySyncPluginKey.getState(this.prosemirrorView.state)\n    if (events.length === 0 || syncState.snapshot != null || syncState.prevSnapshot != null) {\n      // drop out if snapshot is active\n      this.renderSnapshot(syncState.snapshot, syncState.prevSnapshot)\n      return\n    }\n    this.mux(() => {\n      /**\n       * @param {any} _\n       * @param {Y.AbstractType<any>} type\n       */\n      const delType = (_, type) => this.mapping.delete(type)\n      Y.iterateDeletedStructs(transaction, transaction.deleteSet, struct => struct.constructor === Y.Item && this.mapping.delete(/** @type {Y.ContentType} */ (/** @type {Y.Item} */ (struct).content).type))\n      transaction.changed.forEach(delType)\n      transaction.changedParentTypes.forEach(delType)\n      const fragmentContent = this.type.toArray().map(t => createNodeIfNotExists(/** @type {Y.XmlElement | Y.XmlHook} */ (t), this.prosemirrorView.state.schema, this.mapping)).filter(n => n !== null)\n      // @ts-ignore\n      let tr = this._tr.replace(0, this.prosemirrorView.state.doc.content.size, new PModel.Slice(new PModel.Fragment(fragmentContent), 0, 0))\n      restoreRelativeSelection(tr, this.beforeTransactionSelection, this)\n      tr = tr.setMeta(ySyncPluginKey, { isChangeOrigin: true })\n      if (this.beforeTransactionSelection !== null && this._isLocalCursorInView()) {\n        tr.scrollIntoView()\n      }\n      this.prosemirrorView.dispatch(tr)\n    })\n  }\n\n  _prosemirrorChanged (doc) {\n    this.mux(() => {\n      this.doc.transact(() => {\n        updateYFragment(this.doc, this.type, doc, this.mapping)\n        this.beforeTransactionSelection = getRelativeSelection(this, this.prosemirrorView.state)\n      }, ySyncPluginKey)\n    })\n  }\n\n  destroy () {\n    this.isDestroyed = true\n    this.type.unobserveDeep(this._observeFunction)\n    this.doc.off('beforeAllTransactions', this.beforeAllTransactions)\n    this.doc.off('afterAllTransactions', this.afterAllTransactions)\n  }\n}\n\n/**\n * @private\n * @param {Y.XmlElement | Y.XmlHook} el\n * @param {PModel.Schema} schema\n * @param {ProsemirrorMapping} mapping\n * @param {Y.Snapshot} [snapshot]\n * @param {Y.Snapshot} [prevSnapshot]\n * @param {function('removed' | 'added', Y.ID):any} [computeYChange]\n * @return {PModel.Node | null}\n */\nconst createNodeIfNotExists = (el, schema, mapping, snapshot, prevSnapshot, computeYChange) => {\n  const node = /** @type {PModel.Node} */ (mapping.get(el))\n  if (node === undefined) {\n    if (el instanceof Y.XmlElement) {\n      return createNodeFromYElement(el, schema, mapping, snapshot, prevSnapshot, computeYChange)\n    } else {\n      throw error.methodUnimplemented() // we are currently not handling hooks\n    }\n  }\n  return node\n}\n\n/**\n * @private\n * @param {Y.XmlElement} el\n * @param {any} schema\n * @param {ProsemirrorMapping} mapping\n * @param {Y.Snapshot} [snapshot]\n * @param {Y.Snapshot} [prevSnapshot]\n * @param {function('removed' | 'added', Y.ID):any} [computeYChange]\n * @return {PModel.Node | null} Returns node if node could be created. Otherwise it deletes the yjs type and returns null\n */\nconst createNodeFromYElement = (el, schema, mapping, snapshot, prevSnapshot, computeYChange) => {\n  const children = []\n  const createChildren = type => {\n    if (type.constructor === Y.XmlElement) {\n      const n = createNodeIfNotExists(type, schema, mapping, snapshot, prevSnapshot, computeYChange)\n      if (n !== null) {\n        children.push(n)\n      }\n    } else {\n      const ns = createTextNodesFromYText(type, schema, mapping, snapshot, prevSnapshot, computeYChange)\n      if (ns !== null) {\n        ns.forEach(textchild => {\n          if (textchild !== null) {\n            children.push(textchild)\n          }\n        })\n      }\n    }\n  }\n  if (snapshot === undefined || prevSnapshot === undefined) {\n    el.toArray().forEach(createChildren)\n  } else {\n    Y.typeListToArraySnapshot(el, new Y.Snapshot(prevSnapshot.ds, snapshot.sv)).forEach(createChildren)\n  }\n  try {\n    const attrs = el.getAttributes(snapshot)\n    if (snapshot !== undefined) {\n      if (!isVisible(/** @type {Y.Item} */ (el._item), snapshot)) {\n        attrs.ychange = computeYChange ? computeYChange('removed', /** @type {Y.Item} */ (el._item).id) : { type: 'removed' }\n      } else if (!isVisible(/** @type {Y.Item} */ (el._item), prevSnapshot)) {\n        attrs.ychange = computeYChange ? computeYChange('added', /** @type {Y.Item} */ (el._item).id) : { type: 'added' }\n      }\n    }\n    const node = schema.node(el.nodeName, attrs, children)\n    mapping.set(el, node)\n    return node\n  } catch (e) {\n    // an error occured while creating the node. This is probably a result of a concurrent action.\n    /** @type {Y.Doc} */ (el.doc).transact(transaction => {\n      /** @type {Y.Item} */ (el._item).delete(transaction)\n    }, ySyncPluginKey)\n    mapping.delete(el)\n    return null\n  }\n}\n\n/**\n * @private\n * @param {Y.XmlText} text\n * @param {any} schema\n * @param {ProsemirrorMapping} mapping\n * @param {Y.Snapshot} [snapshot]\n * @param {Y.Snapshot} [prevSnapshot]\n * @param {function('removed' | 'added', Y.ID):any} [computeYChange]\n * @return {Array<PModel.Node>|null}\n */\nconst createTextNodesFromYText = (text, schema, mapping, snapshot, prevSnapshot, computeYChange) => {\n  const nodes = []\n  const deltas = text.toDelta(snapshot, prevSnapshot, computeYChange)\n  try {\n    for (let i = 0; i < deltas.length; i++) {\n      const delta = deltas[i]\n      const marks = []\n      for (const markName in delta.attributes) {\n        marks.push(schema.mark(markName, delta.attributes[markName]))\n      }\n      nodes.push(schema.text(delta.insert, marks))\n    }\n  } catch (e) {\n    // an error occured while creating the node. This is probably a result of a concurrent action.\n    /** @type {Y.Doc} */ (text.doc).transact(transaction => {\n      /** @type {Y.Item} */ (text._item).delete(transaction)\n    }, ySyncPluginKey)\n    return null\n  }\n  // @ts-ignore\n  return nodes\n}\n\n/**\n * @private\n * @param {Array<any>} nodes prosemirror node\n * @param {ProsemirrorMapping} mapping\n * @return {Y.XmlText}\n */\nconst createTypeFromTextNodes = (nodes, mapping) => {\n  const type = new Y.XmlText()\n  const delta = nodes.map(node => ({\n    // @ts-ignore\n    insert: node.text,\n    attributes: marksToAttributes(node.marks)\n  }))\n  type.applyDelta(delta)\n  mapping.set(type, nodes)\n  return type\n}\n\n/**\n * @private\n * @param {any} node prosemirror node\n * @param {ProsemirrorMapping} mapping\n * @return {Y.XmlElement}\n */\nconst createTypeFromElementNode = (node, mapping) => {\n  const type = new Y.XmlElement(node.type.name)\n  for (const key in node.attrs) {\n    const val = node.attrs[key]\n    if (val !== null && key !== 'ychange') {\n      type.setAttribute(key, val)\n    }\n  }\n  type.insert(0, normalizePNodeContent(node).map(n => createTypeFromTextOrElementNode(n, mapping)))\n  mapping.set(type, node)\n  return type\n}\n\n/**\n * @private\n * @param {PModel.Node|Array<PModel.Node>} node prosemirror text node\n * @param {ProsemirrorMapping} mapping\n * @return {Y.XmlElement|Y.XmlText}\n */\nconst createTypeFromTextOrElementNode = (node, mapping) => node instanceof Array ? createTypeFromTextNodes(node, mapping) : createTypeFromElementNode(node, mapping)\n\nconst isObject = (val) => typeof val === 'object' && val !== null\n\nconst equalAttrs = (pattrs, yattrs) => {\n  const keys = Object.keys(pattrs).filter(key => pattrs[key] !== null)\n  let eq = keys.length === Object.keys(yattrs).filter(key => yattrs[key] !== null).length\n  for (let i = 0; i < keys.length && eq; i++) {\n    const key = keys[i]\n    const l = pattrs[key]\n    const r = yattrs[key]\n    eq = key === 'ychange' || l === r || (isObject(l) && isObject(r) && equalAttrs(l, r))\n  }\n  return eq\n}\n\n/**\n * @typedef {Array<Array<PModel.Node>|PModel.Node>} NormalizedPNodeContent\n */\n\n/**\n * @param {any} pnode\n * @return {NormalizedPNodeContent}\n */\nconst normalizePNodeContent = pnode => {\n  const c = pnode.content.content\n  const res = []\n  for (let i = 0; i < c.length; i++) {\n    const n = c[i]\n    if (n.isText) {\n      const textNodes = []\n      for (let tnode = c[i]; i < c.length && tnode.isText; tnode = c[++i]) {\n        textNodes.push(tnode)\n      }\n      i--\n      res.push(textNodes)\n    } else {\n      res.push(n)\n    }\n  }\n  return res\n}\n\n/**\n * @param {Y.XmlText} ytext\n * @param {Array<any>} ptexts\n */\nconst equalYTextPText = (ytext, ptexts) => {\n  const delta = ytext.toDelta()\n  return delta.length === ptexts.length && delta.every((d, i) => d.insert === /** @type {any} */ (ptexts[i]).text && object.keys(d.attributes || {}).length === ptexts[i].marks.length && ptexts[i].marks.every(mark => equalAttrs(d.attributes[mark.type.name] || {}, mark.attrs)))\n}\n\n/**\n * @param {Y.XmlElement|Y.XmlText|Y.XmlHook} ytype\n * @param {any|Array<any>} pnode\n */\nconst equalYTypePNode = (ytype, pnode) => {\n  if (ytype instanceof Y.XmlElement && !(pnode instanceof Array) && matchNodeName(ytype, pnode)) {\n    const normalizedContent = normalizePNodeContent(pnode)\n    return ytype._length === normalizedContent.length && equalAttrs(ytype.getAttributes(), pnode.attrs) && ytype.toArray().every((ychild, i) => equalYTypePNode(ychild, normalizedContent[i]))\n  }\n  return ytype instanceof Y.XmlText && pnode instanceof Array && equalYTextPText(ytype, pnode)\n}\n\n/**\n * @param {PModel.Node | Array<PModel.Node> | undefined} mapped\n * @param {PModel.Node | Array<PModel.Node>} pcontent\n */\nconst mappedIdentity = (mapped, pcontent) => mapped === pcontent || (mapped instanceof Array && pcontent instanceof Array && mapped.length === pcontent.length && mapped.every((a, i) => pcontent[i] === a))\n\n/**\n * @param {Y.XmlElement} ytype\n * @param {PModel.Node} pnode\n * @param {ProsemirrorMapping} mapping\n * @return {{ foundMappedChild: boolean, equalityFactor: number }}\n */\nconst computeChildEqualityFactor = (ytype, pnode, mapping) => {\n  const yChildren = ytype.toArray()\n  const pChildren = normalizePNodeContent(pnode)\n  const pChildCnt = pChildren.length\n  const yChildCnt = yChildren.length\n  const minCnt = math.min(yChildCnt, pChildCnt)\n  let left = 0\n  let right = 0\n  let foundMappedChild = false\n  for (; left < minCnt; left++) {\n    const leftY = yChildren[left]\n    const leftP = pChildren[left]\n    if (mappedIdentity(mapping.get(leftY), leftP)) {\n      foundMappedChild = true// definite (good) match!\n    } else if (!equalYTypePNode(leftY, leftP)) {\n      break\n    }\n  }\n  for (; left + right < minCnt; right++) {\n    const rightY = yChildren[yChildCnt - right - 1]\n    const rightP = pChildren[pChildCnt - right - 1]\n    if (mappedIdentity(mapping.get(rightY), rightP)) {\n      foundMappedChild = true\n    } else if (!equalYTypePNode(rightY, rightP)) {\n      break\n    }\n  }\n  return {\n    equalityFactor: left + right,\n    foundMappedChild\n  }\n}\n\nconst ytextTrans = ytext => {\n  let str = ''\n  /**\n   * @type {Y.Item|null}\n   */\n  let n = ytext._start\n  const nAttrs = {}\n  while (n !== null) {\n    if (!n.deleted) {\n      if (n.countable && n.content instanceof Y.ContentString) {\n        str += n.content.str\n      } else if (n.content instanceof Y.ContentFormat) {\n        nAttrs[n.content.key] = null\n      }\n    }\n    n = n.right\n  }\n  return {\n    str,\n    nAttrs\n  }\n}\n\n/**\n * @todo test this more\n *\n * @param {Y.Text} ytext\n * @param {Array<any>} ptexts\n * @param {ProsemirrorMapping} mapping\n */\nconst updateYText = (ytext, ptexts, mapping) => {\n  mapping.set(ytext, ptexts)\n  const { nAttrs, str } = ytextTrans(ytext)\n  const content = ptexts.map(p => ({ insert: /** @type {any} */ (p).text, attributes: Object.assign({}, nAttrs, marksToAttributes(p.marks)) }))\n  const { insert, remove, index } = simpleDiff(str, content.map(c => c.insert).join(''))\n  ytext.delete(index, remove)\n  ytext.insert(index, insert)\n  ytext.applyDelta(content.map(c => ({ retain: c.insert.length, attributes: c.attributes })))\n}\n\nconst marksToAttributes = marks => {\n  const pattrs = {}\n  marks.forEach(mark => {\n    if (mark.type.name !== 'ychange') {\n      pattrs[mark.type.name] = mark.attrs\n    }\n  })\n  return pattrs\n}\n\n/**\n * @private\n * @param {{transact: Function}} y\n * @param {Y.XmlFragment} yDomFragment\n * @param {any} pNode\n * @param {ProsemirrorMapping} mapping\n */\nexport const updateYFragment = (y, yDomFragment, pNode, mapping) => {\n  if (yDomFragment instanceof Y.XmlElement && yDomFragment.nodeName !== pNode.type.name) {\n    throw new Error('node name mismatch!')\n  }\n  mapping.set(yDomFragment, pNode)\n  // update attributes\n  if (yDomFragment instanceof Y.XmlElement) {\n    const yDomAttrs = yDomFragment.getAttributes()\n    const pAttrs = pNode.attrs\n    for (const key in pAttrs) {\n      if (pAttrs[key] !== null) {\n        if (yDomAttrs[key] !== pAttrs[key] && key !== 'ychange') {\n          yDomFragment.setAttribute(key, pAttrs[key])\n        }\n      } else {\n        yDomFragment.removeAttribute(key)\n      }\n    }\n    // remove all keys that are no longer in pAttrs\n    for (const key in yDomAttrs) {\n      if (pAttrs[key] === undefined) {\n        yDomFragment.removeAttribute(key)\n      }\n    }\n  }\n  // update children\n  const pChildren = normalizePNodeContent(pNode)\n  const pChildCnt = pChildren.length\n  const yChildren = yDomFragment.toArray()\n  const yChildCnt = yChildren.length\n  const minCnt = math.min(pChildCnt, yChildCnt)\n  let left = 0\n  let right = 0\n  // find number of matching elements from left\n  for (;left < minCnt; left++) {\n    const leftY = yChildren[left]\n    const leftP = pChildren[left]\n    if (!mappedIdentity(mapping.get(leftY), leftP)) {\n      if (equalYTypePNode(leftY, leftP)) {\n        // update mapping\n        mapping.set(leftY, leftP)\n      } else {\n        break\n      }\n    }\n  }\n  // find number of matching elements from right\n  for (;right + left + 1 < minCnt; right++) {\n    const rightY = yChildren[yChildCnt - right - 1]\n    const rightP = pChildren[pChildCnt - right - 1]\n    if (!mappedIdentity(mapping.get(rightY), rightP)) {\n      if (equalYTypePNode(rightY, rightP)) {\n        // update mapping\n        mapping.set(rightY, rightP)\n      } else {\n        break\n      }\n    }\n  }\n  y.transact(() => {\n    // try to compare and update\n    while (yChildCnt - left - right > 0 && pChildCnt - left - right > 0) {\n      const leftY = yChildren[left]\n      const leftP = pChildren[left]\n      const rightY = yChildren[yChildCnt - right - 1]\n      const rightP = pChildren[pChildCnt - right - 1]\n      if (leftY instanceof Y.XmlText && leftP instanceof Array) {\n        if (!equalYTextPText(leftY, leftP)) {\n          updateYText(leftY, leftP, mapping)\n        }\n        left += 1\n      } else {\n        let updateLeft = leftY instanceof Y.XmlElement && matchNodeName(leftY, leftP)\n        let updateRight = rightY instanceof Y.XmlElement && matchNodeName(rightY, rightP)\n        if (updateLeft && updateRight) {\n          // decide which which element to update\n          const equalityLeft = computeChildEqualityFactor(/** @type {Y.XmlElement} */ (leftY), /** @type {PModel.Node} */ (leftP), mapping)\n          const equalityRight = computeChildEqualityFactor(/** @type {Y.XmlElement} */ (rightY), /** @type {PModel.Node} */ (rightP), mapping)\n          if (equalityLeft.foundMappedChild && !equalityRight.foundMappedChild) {\n            updateRight = false\n          } else if (!equalityLeft.foundMappedChild && equalityRight.foundMappedChild) {\n            updateLeft = false\n          } else if (equalityLeft.equalityFactor < equalityRight.equalityFactor) {\n            updateLeft = false\n          } else {\n            updateRight = false\n          }\n        }\n        if (updateLeft) {\n          updateYFragment(y, /** @type {Y.XmlFragment} */ (leftY), /** @type {PModel.Node} */ (leftP), mapping)\n          left += 1\n        } else if (updateRight) {\n          updateYFragment(y, /** @type {Y.XmlFragment} */ (rightY), /** @type {PModel.Node} */ (rightP), mapping)\n          right += 1\n        } else {\n          yDomFragment.delete(left, 1)\n          yDomFragment.insert(left, [createTypeFromTextOrElementNode(leftP, mapping)])\n          left += 1\n        }\n      }\n    }\n    const yDelLen = yChildCnt - left - right\n    if (yChildCnt === 1 && pChildCnt === 0 && yChildren[0] instanceof Y.XmlText) {\n      // Edge case handling https://github.com/yjs/y-prosemirror/issues/108\n      // Only delete the content of the Y.Text to retain remote changes on the same Y.Text object\n      yChildren[0].delete(0, yChildren[0].length)\n    } else if (yDelLen > 0) {\n      yDomFragment.delete(left, yDelLen)\n    }\n    if (left + right < pChildCnt) {\n      const ins = []\n      for (let i = left; i < pChildCnt - right; i++) {\n        ins.push(createTypeFromTextOrElementNode(pChildren[i], mapping))\n      }\n      yDomFragment.insert(left, ins)\n    }\n  }, ySyncPluginKey)\n}\n\n/**\n * @function\n * @param {Y.XmlElement} yElement\n * @param {any} pNode Prosemirror Node\n */\nconst matchNodeName = (yElement, pNode) => !(pNode instanceof Array) && yElement.nodeName === pNode.type.name\n","\nimport { Plugin } from 'prosemirror-state' // eslint-disable-line\n\nimport { getRelativeSelection } from './sync-plugin.js'\nimport { UndoManager, Item, ContentType, XmlElement, Text } from 'yjs'\nimport { yUndoPluginKey, ySyncPluginKey } from './keys.js'\n\nexport const undo = state => {\n  const undoManager = yUndoPluginKey.getState(state).undoManager\n  if (undoManager != null) {\n    undoManager.undo()\n    return true\n  }\n}\n\nexport const redo = state => {\n  const undoManager = yUndoPluginKey.getState(state).undoManager\n  if (undoManager != null) {\n    undoManager.redo()\n    return true\n  }\n}\n\nexport const defaultProtectedNodes = new Set(['paragraph'])\n\nexport const defaultDeleteFilter = (item, protectedNodes) => !(item instanceof Item) ||\n!(item.content instanceof ContentType) ||\n!(item.content.type instanceof Text ||\n  (item.content.type instanceof XmlElement && protectedNodes.has(item.content.type.nodeName))) ||\nitem.content.type._length === 0\n\nexport const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins = [], undoManager = null } = {}) => new Plugin({\n  key: yUndoPluginKey,\n  state: {\n    init: (initargs, state) => {\n      // TODO: check if plugin order matches and fix\n      const ystate = ySyncPluginKey.getState(state)\n      const _undoManager = undoManager || new UndoManager(ystate.type, {\n        trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)),\n        deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes)\n      })\n      return {\n        undoManager: _undoManager,\n        prevSel: null,\n        hasUndoOps: _undoManager.undoStack.length > 0,\n        hasRedoOps: _undoManager.redoStack.length > 0\n      }\n    },\n    apply: (tr, val, oldState, state) => {\n      const binding = ySyncPluginKey.getState(state).binding\n      const undoManager = val.undoManager\n      const hasUndoOps = undoManager.undoStack.length > 0\n      const hasRedoOps = undoManager.redoStack.length > 0\n      if (binding) {\n        return {\n          undoManager,\n          prevSel: getRelativeSelection(binding, oldState),\n          hasUndoOps,\n          hasRedoOps\n        }\n      } else {\n        if (hasUndoOps !== val.hasUndoOps || hasRedoOps !== val.hasRedoOps) {\n          return Object.assign({}, val, {\n            hasUndoOps: undoManager.undoStack.length > 0,\n            hasRedoOps: undoManager.redoStack.length > 0\n          })\n        } else { // nothing changed\n          return val\n        }\n      }\n    }\n  },\n  view: view => {\n    const ystate = ySyncPluginKey.getState(view.state)\n    const undoManager = yUndoPluginKey.getState(view.state).undoManager\n    undoManager.on('stack-item-added', ({ stackItem }) => {\n      const binding = ystate.binding\n      if (binding) {\n        stackItem.meta.set(binding, yUndoPluginKey.getState(view.state).prevSel)\n      }\n    })\n    undoManager.on('stack-item-popped', ({ stackItem }) => {\n      const binding = ystate.binding\n      if (binding) {\n        binding.beforeTransactionSelection = stackItem.meta.get(binding) || binding.beforeTransactionSelection\n      }\n    })\n    return {\n      destroy: () => {\n        undoManager.destroy()\n      }\n    }\n  }\n})\n","import { Extension } from '@tiptap/core';\nimport { yUndoPluginKey, undo, redo, ySyncPlugin, yUndoPlugin, ySyncPluginKey } from 'y-prosemirror';\n\nconst Collaboration = Extension.create({\r\n    name: 'collaboration',\r\n    priority: 1000,\r\n    addOptions() {\r\n        return {\r\n            document: null,\r\n            field: 'default',\r\n            fragment: null,\r\n        };\r\n    },\r\n    onCreate() {\r\n        if (this.editor.extensionManager.extensions.find(extension => extension.name === 'history')) {\r\n            console.warn('[tiptap warn]: \"@tiptap/extension-collaboration\" comes with its own history support and is not compatible with \"@tiptap/extension-history\".');\r\n        }\r\n    },\r\n    addCommands() {\r\n        return {\r\n            undo: () => ({ tr, state, dispatch }) => {\r\n                tr.setMeta('preventDispatch', true);\r\n                const undoManager = yUndoPluginKey.getState(state).undoManager;\r\n                if (undoManager.undoStack.length === 0) {\r\n                    return false;\r\n                }\r\n                if (!dispatch) {\r\n                    return true;\r\n                }\r\n                return undo(state);\r\n            },\r\n            redo: () => ({ tr, state, dispatch }) => {\r\n                tr.setMeta('preventDispatch', true);\r\n                const undoManager = yUndoPluginKey.getState(state).undoManager;\r\n                if (undoManager.redoStack.length === 0) {\r\n                    return false;\r\n                }\r\n                if (!dispatch) {\r\n                    return true;\r\n                }\r\n                return redo(state);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-z': () => this.editor.commands.undo(),\r\n            'Mod-y': () => this.editor.commands.redo(),\r\n            'Shift-Mod-z': () => this.editor.commands.redo(),\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        const fragment = this.options.fragment\r\n            ? this.options.fragment\r\n            : this.options.document.getXmlFragment(this.options.field);\r\n        return [\r\n            ySyncPlugin(fragment),\r\n            yUndoPlugin(),\r\n        ];\r\n    },\r\n});\n\nfunction isChangeOrigin(transaction) {\r\n    return !!transaction.getMeta(ySyncPluginKey);\r\n}\n\nexport { Collaboration, Collaboration as default, isChangeOrigin };\n//# sourceMappingURL=tiptap-extension-collaboration.esm.js.map\n","import { Node, mergeAttributes, textblockTypeInputRule } from '@tiptap/core';\n\nconst Heading = Node.create({\r\n    name: 'heading',\r\n    addOptions() {\r\n        return {\r\n            levels: [1, 2, 3, 4, 5, 6],\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'inline*',\r\n    group: 'block',\r\n    defining: true,\r\n    addAttributes() {\r\n        return {\r\n            level: {\r\n                default: 1,\r\n                rendered: false,\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return this.options.levels\r\n            .map((level) => ({\r\n            tag: `h${level}`,\r\n            attrs: { level },\r\n        }));\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        const hasLevel = this.options.levels.includes(node.attrs.level);\r\n        const level = hasLevel\r\n            ? node.attrs.level\r\n            : this.options.levels[0];\r\n        return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setHeading: attributes => ({ commands }) => {\r\n                if (!this.options.levels.includes(attributes.level)) {\r\n                    return false;\r\n                }\r\n                return commands.setNode(this.name, attributes);\r\n            },\r\n            toggleHeading: attributes => ({ commands }) => {\r\n                if (!this.options.levels.includes(attributes.level)) {\r\n                    return false;\r\n                }\r\n                return commands.toggleNode(this.name, 'paragraph', attributes);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return this.options.levels.reduce((items, level) => ({\r\n            ...items,\r\n            ...{\r\n                [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level }),\r\n            },\r\n        }), {});\r\n    },\r\n    addInputRules() {\r\n        return this.options.levels.map(level => {\r\n            return textblockTypeInputRule({\r\n                find: new RegExp(`^(#{1,${level}})\\\\s$`),\r\n                type: this.type,\r\n                getAttributes: {\r\n                    level,\r\n                },\r\n            });\r\n        });\r\n    },\r\n});\n\nexport { Heading, Heading as default };\n//# sourceMappingURL=tiptap-extension-heading.esm.js.map\n"],"sourceRoot":""}