{"version":3,"file":"static/js/vendors-d4b33a19.3461f7e0.js","mappings":"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","sources":["../node_modules/node_modules/use-sync-external-store/shim/index.js","../node_modules/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js","../node_modules/@tiptap/react/src/EditorContent.tsx","../node_modules/node_modules/fast-deep-equal/es6/react.js","../node_modules/node_modules/use-sync-external-store/shim/with-selector.js","../node_modules/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.min.js","../node_modules/@tiptap/react/src/useEditorState.ts","../node_modules/@tiptap/react/src/useEditor.ts","../node_modules/@tiptap/react/src/Context.tsx","../node_modules/@tiptap/react/src/BubbleMenu.tsx","../node_modules/@tiptap/react/src/useReactNodeView.ts","../node_modules/@tiptap/react/src/NodeViewWrapper.tsx","../node_modules/@tiptap/react/src/ReactRenderer.tsx","../node_modules/@tiptap/starter-kit/src/starter-kit.ts","../node_modules/@tiptap/suggestion/src/findSuggestionMatch.ts","../node_modules/@tiptap/suggestion/src/suggestion.ts","../node_modules/tslib/tslib.es6.mjs"],"sourcesContent":["'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim.production.min.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim.development.js');\n}\n","/**\n * @license React\n * use-sync-external-store-shim.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var e=require(\"react\");function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k=\"function\"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}\nfunction r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u=\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;\n","import { Editor } from '@tiptap/core'\nimport React, {\n  ForwardedRef, forwardRef, HTMLProps, LegacyRef, MutableRefObject,\n} from 'react'\nimport ReactDOM from 'react-dom'\nimport { useSyncExternalStore } from 'use-sync-external-store/shim'\n\nimport { ContentComponent, EditorWithContentComponent } from './Editor.js'\nimport { ReactRenderer } from './ReactRenderer.js'\n\nconst mergeRefs = <T extends HTMLDivElement>(\n  ...refs: Array<MutableRefObject<T> | LegacyRef<T> | undefined>\n) => {\n  return (node: T) => {\n    refs.forEach(ref => {\n      if (typeof ref === 'function') {\n        ref(node)\n      } else if (ref) {\n        (ref as MutableRefObject<T | null>).current = node\n      }\n    })\n  }\n}\n\n/**\n * This component renders all of the editor's node views.\n */\nconst Portals: React.FC<{ contentComponent: ContentComponent }> = ({\n  contentComponent,\n}) => {\n  // For performance reasons, we render the node view portals on state changes only\n  const renderers = useSyncExternalStore(\n    contentComponent.subscribe,\n    contentComponent.getSnapshot,\n    contentComponent.getServerSnapshot,\n  )\n\n  // This allows us to directly render the portals without any additional wrapper\n  return (\n    <>\n      {Object.values(renderers)}\n    </>\n  )\n}\n\nexport interface EditorContentProps extends HTMLProps<HTMLDivElement> {\n  editor: Editor | null;\n  innerRef?: ForwardedRef<HTMLDivElement | null>;\n}\n\nfunction getInstance(): ContentComponent {\n  const subscribers = new Set<() => void>()\n  let renderers: Record<string, React.ReactPortal> = {}\n\n  return {\n    /**\n     * Subscribe to the editor instance's changes.\n     */\n    subscribe(callback: () => void) {\n      subscribers.add(callback)\n      return () => {\n        subscribers.delete(callback)\n      }\n    },\n    getSnapshot() {\n      return renderers\n    },\n    getServerSnapshot() {\n      return renderers\n    },\n    /**\n     * Adds a new NodeView Renderer to the editor.\n     */\n    setRenderer(id: string, renderer: ReactRenderer) {\n      renderers = {\n        ...renderers,\n        [id]: ReactDOM.createPortal(renderer.reactElement, renderer.element, id),\n      }\n\n      subscribers.forEach(subscriber => subscriber())\n    },\n    /**\n     * Removes a NodeView Renderer from the editor.\n     */\n    removeRenderer(id: string) {\n      const nextRenderers = { ...renderers }\n\n      delete nextRenderers[id]\n      renderers = nextRenderers\n      subscribers.forEach(subscriber => subscriber())\n    },\n  }\n}\n\nexport class PureEditorContent extends React.Component<\n  EditorContentProps,\n  { hasContentComponentInitialized: boolean }\n> {\n  editorContentRef: React.RefObject<any>\n\n  initialized: boolean\n\n  unsubscribeToContentComponent?: () => void\n\n  constructor(props: EditorContentProps) {\n    super(props)\n    this.editorContentRef = React.createRef()\n    this.initialized = false\n\n    this.state = {\n      hasContentComponentInitialized: Boolean((props.editor as EditorWithContentComponent | null)?.contentComponent),\n    }\n  }\n\n  componentDidMount() {\n    this.init()\n  }\n\n  componentDidUpdate() {\n    this.init()\n  }\n\n  init() {\n    const editor = this.props.editor as EditorWithContentComponent | null\n\n    if (editor && !editor.isDestroyed && editor.options.element) {\n      if (editor.contentComponent) {\n        return\n      }\n\n      const element = this.editorContentRef.current\n\n      element.append(...editor.options.element.childNodes)\n\n      editor.setOptions({\n        element,\n      })\n\n      editor.contentComponent = getInstance()\n\n      // Has the content component been initialized?\n      if (!this.state.hasContentComponentInitialized) {\n        // Subscribe to the content component\n        this.unsubscribeToContentComponent = editor.contentComponent.subscribe(() => {\n          this.setState(prevState => {\n            if (!prevState.hasContentComponentInitialized) {\n              return {\n                hasContentComponentInitialized: true,\n              }\n            }\n            return prevState\n          })\n\n          // Unsubscribe to previous content component\n          if (this.unsubscribeToContentComponent) {\n            this.unsubscribeToContentComponent()\n          }\n        })\n      }\n\n      editor.createNodeViews()\n\n      this.initialized = true\n    }\n  }\n\n  componentWillUnmount() {\n    const editor = this.props.editor as EditorWithContentComponent | null\n\n    if (!editor) {\n      return\n    }\n\n    this.initialized = false\n\n    if (!editor.isDestroyed) {\n      editor.view.setProps({\n        nodeViews: {},\n      })\n    }\n\n    if (this.unsubscribeToContentComponent) {\n      this.unsubscribeToContentComponent()\n    }\n\n    editor.contentComponent = null\n\n    if (!editor.options.element.firstChild) {\n      return\n    }\n\n    const newElement = document.createElement('div')\n\n    newElement.append(...editor.options.element.childNodes)\n\n    editor.setOptions({\n      element: newElement,\n    })\n  }\n\n  render() {\n    const { editor, innerRef, ...rest } = this.props\n\n    return (\n      <>\n        <div ref={mergeRefs(innerRef, this.editorContentRef)} {...rest} />\n        {/* @ts-ignore */}\n        {editor?.contentComponent && <Portals contentComponent={editor.contentComponent} />}\n      </>\n    )\n  }\n}\n\n// EditorContent should be re-created whenever the Editor instance changes\nconst EditorContentWithKey = forwardRef<HTMLDivElement, EditorContentProps>(\n  (props: Omit<EditorContentProps, 'innerRef'>, ref) => {\n    const key = React.useMemo(() => {\n      return Math.floor(Math.random() * 0xffffffff).toString()\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [props.editor])\n\n    // Can't use JSX here because it conflicts with the type definition of Vue's JSX, so use createElement\n    return React.createElement(PureEditorContent, {\n      key,\n      innerRef: ref,\n      ...props,\n    })\n  },\n)\n\nexport const EditorContent = React.memo(EditorContentWithKey)\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n    if ((a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      for (i of a.entries())\n        if (!equal(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if ((a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (key === '_owner' && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner.\n        //  _owner contains circular references\n        // and is not needed when comparing the actual elements (and not their owners)\n        continue;\n      }\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim/with-selector.production.min.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim/with-selector.development.js');\n}\n","/**\n * @license React\n * use-sync-external-store-shim/with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var h=require(\"react\"),n=require(\"use-sync-external-store/shim\");function p(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q=\"function\"===typeof Object.is?Object.is:p,r=n.useSyncExternalStore,t=h.useRef,u=h.useEffect,v=h.useMemo,w=h.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,g){var c=t(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=v(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q(d,a))return b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,g]);var d=r(a,c[0],c[1]);\nu(function(){f.hasValue=!0;f.value=d},[d]);w(d);return d};\n","import type { Editor } from '@tiptap/core'\nimport deepEqual from 'fast-deep-equal/es6/react'\nimport {\n  useDebugValue, useEffect, useLayoutEffect, useState,\n} from 'react'\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'\n\nconst useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect\n\nexport type EditorStateSnapshot<TEditor extends Editor | null = Editor | null> = {\n  editor: TEditor;\n  transactionNumber: number;\n};\n\nexport type UseEditorStateOptions<\n  TSelectorResult,\n  TEditor extends Editor | null = Editor | null,\n> = {\n  /**\n   * The editor instance.\n   */\n  editor: TEditor;\n  /**\n   * A selector function to determine the value to compare for re-rendering.\n   */\n  selector: (context: EditorStateSnapshot<TEditor>) => TSelectorResult;\n  /**\n   * A custom equality function to determine if the editor should re-render.\n   * @default `deepEqual` from `fast-deep-equal`\n   */\n  equalityFn?: (a: TSelectorResult, b: TSelectorResult | null) => boolean;\n};\n\n/**\n * To synchronize the editor instance with the component state,\n * we need to create a separate instance that is not affected by the component re-renders.\n */\nclass EditorStateManager<TEditor extends Editor | null = Editor | null> {\n  private transactionNumber = 0\n\n  private lastTransactionNumber = 0\n\n  private lastSnapshot: EditorStateSnapshot<TEditor>\n\n  private editor: TEditor\n\n  private subscribers = new Set<() => void>()\n\n  constructor(initialEditor: TEditor) {\n    this.editor = initialEditor\n    this.lastSnapshot = { editor: initialEditor, transactionNumber: 0 }\n\n    this.getSnapshot = this.getSnapshot.bind(this)\n    this.getServerSnapshot = this.getServerSnapshot.bind(this)\n    this.watch = this.watch.bind(this)\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  /**\n   * Get the current editor instance.\n   */\n  getSnapshot(): EditorStateSnapshot<TEditor> {\n    if (this.transactionNumber === this.lastTransactionNumber) {\n      return this.lastSnapshot\n    }\n    this.lastTransactionNumber = this.transactionNumber\n    this.lastSnapshot = { editor: this.editor, transactionNumber: this.transactionNumber }\n    return this.lastSnapshot\n  }\n\n  /**\n   * Always disable the editor on the server-side.\n   */\n  getServerSnapshot(): EditorStateSnapshot<null> {\n    return { editor: null, transactionNumber: 0 }\n  }\n\n  /**\n   * Subscribe to the editor instance's changes.\n   */\n  subscribe(callback: () => void): () => void {\n    this.subscribers.add(callback)\n    return () => {\n      this.subscribers.delete(callback)\n    }\n  }\n\n  /**\n   * Watch the editor instance for changes.\n   */\n  watch(nextEditor: Editor | null): undefined | (() => void) {\n    this.editor = nextEditor as TEditor\n\n    if (this.editor) {\n      /**\n       * This will force a re-render when the editor state changes.\n       * This is to support things like `editor.can().toggleBold()` in components that `useEditor`.\n       * This could be more efficient, but it's a good trade-off for now.\n       */\n      const fn = () => {\n        this.transactionNumber += 1\n        this.subscribers.forEach(callback => callback())\n      }\n\n      const currentEditor = this.editor\n\n      currentEditor.on('transaction', fn)\n      return () => {\n        currentEditor.off('transaction', fn)\n      }\n    }\n\n    return undefined\n  }\n}\n\n/**\n * This hook allows you to watch for changes on the editor instance.\n * It will allow you to select a part of the editor state and re-render the component when it changes.\n * @example\n * ```tsx\n * const editor = useEditor({...options})\n * const { currentSelection } = useEditorState({\n *  editor,\n *  selector: snapshot => ({ currentSelection: snapshot.editor.state.selection }),\n * })\n */\nexport function useEditorState<TSelectorResult>(\n  options: UseEditorStateOptions<TSelectorResult, Editor>\n): TSelectorResult;\n/**\n * This hook allows you to watch for changes on the editor instance.\n * It will allow you to select a part of the editor state and re-render the component when it changes.\n * @example\n * ```tsx\n * const editor = useEditor({...options})\n * const { currentSelection } = useEditorState({\n *  editor,\n *  selector: snapshot => ({ currentSelection: snapshot.editor.state.selection }),\n * })\n */\nexport function useEditorState<TSelectorResult>(\n  options: UseEditorStateOptions<TSelectorResult, Editor | null>\n): TSelectorResult | null;\n\n/**\n * This hook allows you to watch for changes on the editor instance.\n * It will allow you to select a part of the editor state and re-render the component when it changes.\n * @example\n * ```tsx\n * const editor = useEditor({...options})\n * const { currentSelection } = useEditorState({\n *  editor,\n *  selector: snapshot => ({ currentSelection: snapshot.editor.state.selection }),\n * })\n */\nexport function useEditorState<TSelectorResult>(\n  options: UseEditorStateOptions<TSelectorResult, Editor> | UseEditorStateOptions<TSelectorResult, Editor | null>,\n): TSelectorResult | null {\n  const [editorStateManager] = useState(() => new EditorStateManager(options.editor))\n\n  // Using the `useSyncExternalStore` hook to sync the editor instance with the component state\n  const selectedState = useSyncExternalStoreWithSelector(\n    editorStateManager.subscribe,\n    editorStateManager.getSnapshot,\n    editorStateManager.getServerSnapshot,\n    options.selector as UseEditorStateOptions<TSelectorResult, Editor | null>['selector'],\n    options.equalityFn ?? deepEqual,\n  )\n\n  useIsomorphicLayoutEffect(() => {\n    return editorStateManager.watch(options.editor)\n  }, [options.editor, editorStateManager])\n\n  useDebugValue(selectedState)\n\n  return selectedState\n}\n","import { type EditorOptions, Editor } from '@tiptap/core'\nimport {\n  DependencyList,\n  MutableRefObject,\n  useDebugValue,\n  useEffect,\n  useRef,\n  useState,\n} from 'react'\nimport { useSyncExternalStore } from 'use-sync-external-store/shim'\n\nimport { useEditorState } from './useEditorState.js'\n\nconst isDev = process.env.NODE_ENV !== 'production'\nconst isSSR = typeof window === 'undefined'\nconst isNext = isSSR || Boolean(typeof window !== 'undefined' && (window as any).next)\n\n/**\n * The options for the `useEditor` hook.\n */\nexport type UseEditorOptions = Partial<EditorOptions> & {\n  /**\n   * Whether to render the editor on the first render.\n   * If client-side rendering, set this to `true`.\n   * If server-side rendering, set this to `false`.\n   * @default true\n   */\n  immediatelyRender?: boolean;\n  /**\n   * Whether to re-render the editor on each transaction.\n   * This is legacy behavior that will be removed in future versions.\n   * @default true\n   */\n  shouldRerenderOnTransaction?: boolean;\n};\n\n/**\n * This class handles the creation, destruction, and re-creation of the editor instance.\n */\nclass EditorInstanceManager {\n  /**\n   * The current editor instance.\n   */\n  private editor: Editor | null = null\n\n  /**\n   * The most recent options to apply to the editor.\n   */\n  private options: MutableRefObject<UseEditorOptions>\n\n  /**\n   * The subscriptions to notify when the editor instance\n   * has been created or destroyed.\n   */\n  private subscriptions = new Set<() => void>()\n\n  /**\n   * A timeout to destroy the editor if it was not mounted within a time frame.\n   */\n  private scheduledDestructionTimeout: ReturnType<typeof setTimeout> | undefined\n\n  /**\n   * Whether the editor has been mounted.\n   */\n  private isComponentMounted = false\n\n  /**\n   * The most recent dependencies array.\n   */\n  private previousDeps: DependencyList | null = null\n\n  /**\n   * The unique instance ID. This is used to identify the editor instance. And will be re-generated for each new instance.\n   */\n  public instanceId = ''\n\n  constructor(options: MutableRefObject<UseEditorOptions>) {\n    this.options = options\n    this.subscriptions = new Set<() => void>()\n    this.setEditor(this.getInitialEditor())\n    this.scheduleDestroy()\n\n    this.getEditor = this.getEditor.bind(this)\n    this.getServerSnapshot = this.getServerSnapshot.bind(this)\n    this.subscribe = this.subscribe.bind(this)\n    this.refreshEditorInstance = this.refreshEditorInstance.bind(this)\n    this.scheduleDestroy = this.scheduleDestroy.bind(this)\n    this.onRender = this.onRender.bind(this)\n    this.createEditor = this.createEditor.bind(this)\n  }\n\n  private setEditor(editor: Editor | null) {\n    this.editor = editor\n    this.instanceId = Math.random().toString(36).slice(2, 9)\n\n    // Notify all subscribers that the editor instance has been created\n    this.subscriptions.forEach(cb => cb())\n  }\n\n  private getInitialEditor() {\n    if (this.options.current.immediatelyRender === undefined) {\n      if (isSSR || isNext) {\n        // TODO in the next major release, we should throw an error here\n        if (isDev) {\n          /**\n           * Throw an error in development, to make sure the developer is aware that tiptap cannot be SSR'd\n           * and that they need to set `immediatelyRender` to `false` to avoid hydration mismatches.\n           */\n          console.warn(\n            'Tiptap Error: SSR has been detected, please set `immediatelyRender` explicitly to `false` to avoid hydration mismatches.',\n          )\n        }\n\n        // Best faith effort in production, run the code in the legacy mode to avoid hydration mismatches and errors in production\n        return null\n      }\n\n      // Default to immediately rendering when client-side rendering\n      return this.createEditor()\n    }\n\n    if (this.options.current.immediatelyRender && isSSR && isDev) {\n      // Warn in development, to make sure the developer is aware that tiptap cannot be SSR'd, set `immediatelyRender` to `false` to avoid hydration mismatches.\n      throw new Error(\n        'Tiptap Error: SSR has been detected, and `immediatelyRender` has been set to `true` this is an unsupported configuration that may result in errors, explicitly set `immediatelyRender` to `false` to avoid hydration mismatches.',\n      )\n    }\n\n    if (this.options.current.immediatelyRender) {\n      return this.createEditor()\n    }\n\n    return null\n  }\n\n  /**\n   * Create a new editor instance. And attach event listeners.\n   */\n  private createEditor(): Editor {\n    const optionsToApply: Partial<EditorOptions> = {\n      ...this.options.current,\n      // Always call the most recent version of the callback function by default\n      onBeforeCreate: (...args) => this.options.current.onBeforeCreate?.(...args),\n      onBlur: (...args) => this.options.current.onBlur?.(...args),\n      onCreate: (...args) => this.options.current.onCreate?.(...args),\n      onDestroy: (...args) => this.options.current.onDestroy?.(...args),\n      onFocus: (...args) => this.options.current.onFocus?.(...args),\n      onSelectionUpdate: (...args) => this.options.current.onSelectionUpdate?.(...args),\n      onTransaction: (...args) => this.options.current.onTransaction?.(...args),\n      onUpdate: (...args) => this.options.current.onUpdate?.(...args),\n      onContentError: (...args) => this.options.current.onContentError?.(...args),\n      onDrop: (...args) => this.options.current.onDrop?.(...args),\n      onPaste: (...args) => this.options.current.onPaste?.(...args),\n    }\n    const editor = new Editor(optionsToApply)\n\n    // no need to keep track of the event listeners, they will be removed when the editor is destroyed\n\n    return editor\n  }\n\n  /**\n   * Get the current editor instance.\n   */\n  getEditor(): Editor | null {\n    return this.editor\n  }\n\n  /**\n   * Always disable the editor on the server-side.\n   */\n  getServerSnapshot(): null {\n    return null\n  }\n\n  /**\n   * Subscribe to the editor instance's changes.\n   */\n  subscribe(onStoreChange: () => void) {\n    this.subscriptions.add(onStoreChange)\n\n    return () => {\n      this.subscriptions.delete(onStoreChange)\n    }\n  }\n\n  static compareOptions(a: UseEditorOptions, b: UseEditorOptions) {\n    return (Object.keys(a) as (keyof UseEditorOptions)[]).every(key => {\n      if (['onCreate', 'onBeforeCreate', 'onDestroy', 'onUpdate', 'onTransaction', 'onFocus', 'onBlur', 'onSelectionUpdate', 'onContentError', 'onDrop', 'onPaste'].includes(key)) {\n        // we don't want to compare callbacks, they are always different and only registered once\n        return true\n      }\n\n      // We often encourage putting extensions inlined in the options object, so we will do a slightly deeper comparison here\n      if (key === 'extensions' && a.extensions && b.extensions) {\n        if (a.extensions.length !== b.extensions.length) {\n          return false\n        }\n        return a.extensions.every((extension, index) => {\n          if (extension !== b.extensions?.[index]) {\n            return false\n          }\n          return true\n        })\n      }\n      if (a[key] !== b[key]) {\n        // if any of the options have changed, we should update the editor options\n        return false\n      }\n      return true\n    })\n  }\n\n  /**\n   * On each render, we will create, update, or destroy the editor instance.\n   * @param deps The dependencies to watch for changes\n   * @returns A cleanup function\n   */\n  onRender(deps: DependencyList) {\n    // The returned callback will run on each render\n    return () => {\n      this.isComponentMounted = true\n      // Cleanup any scheduled destructions, since we are currently rendering\n      clearTimeout(this.scheduledDestructionTimeout)\n\n      if (this.editor && !this.editor.isDestroyed && deps.length === 0) {\n        // if the editor does exist & deps are empty, we don't need to re-initialize the editor generally\n        if (!EditorInstanceManager.compareOptions(this.options.current, this.editor.options)) {\n          // But, the options are different, so we need to update the editor options\n          // Still, this is faster than re-creating the editor\n          this.editor.setOptions({\n            ...this.options.current,\n            editable: this.editor.isEditable,\n          })\n        }\n      } else {\n        // When the editor:\n        // - does not yet exist\n        // - is destroyed\n        // - the deps array changes\n        // We need to destroy the editor instance and re-initialize it\n        this.refreshEditorInstance(deps)\n      }\n\n      return () => {\n        this.isComponentMounted = false\n        this.scheduleDestroy()\n      }\n    }\n  }\n\n  /**\n   * Recreate the editor instance if the dependencies have changed.\n   */\n  private refreshEditorInstance(deps: DependencyList) {\n    if (this.editor && !this.editor.isDestroyed) {\n      // Editor instance already exists\n      if (this.previousDeps === null) {\n        // If lastDeps has not yet been initialized, reuse the current editor instance\n        this.previousDeps = deps\n        return\n      }\n      const depsAreEqual = this.previousDeps.length === deps.length\n        && this.previousDeps.every((dep, index) => dep === deps[index])\n\n      if (depsAreEqual) {\n        // deps exist and are equal, no need to recreate\n        return\n      }\n    }\n\n    if (this.editor && !this.editor.isDestroyed) {\n      // Destroy the editor instance if it exists\n      this.editor.destroy()\n    }\n\n    this.setEditor(this.createEditor())\n\n    // Update the lastDeps to the current deps\n    this.previousDeps = deps\n  }\n\n  /**\n   * Schedule the destruction of the editor instance.\n   * This will only destroy the editor if it was not mounted on the next tick.\n   * This is to avoid destroying the editor instance when it's actually still mounted.\n   */\n  private scheduleDestroy() {\n    const currentInstanceId = this.instanceId\n    const currentEditor = this.editor\n\n    // Wait two ticks to see if the component is still mounted\n    this.scheduledDestructionTimeout = setTimeout(() => {\n      if (this.isComponentMounted && this.instanceId === currentInstanceId) {\n        // If still mounted on the following tick, with the same instanceId, do not destroy the editor\n        if (currentEditor) {\n          // just re-apply options as they might have changed\n          currentEditor.setOptions(this.options.current)\n        }\n        return\n      }\n      if (currentEditor && !currentEditor.isDestroyed) {\n        currentEditor.destroy()\n        if (this.instanceId === currentInstanceId) {\n          this.setEditor(null)\n        }\n      }\n      // This allows the effect to run again between ticks\n      // which may save us from having to re-create the editor\n    }, 1)\n  }\n}\n\n/**\n * This hook allows you to create an editor instance.\n * @param options The editor options\n * @param deps The dependencies to watch for changes\n * @returns The editor instance\n * @example const editor = useEditor({ extensions: [...] })\n */\nexport function useEditor(\n  options: UseEditorOptions & { immediatelyRender: true },\n  deps?: DependencyList\n): Editor;\n\n/**\n * This hook allows you to create an editor instance.\n * @param options The editor options\n * @param deps The dependencies to watch for changes\n * @returns The editor instance\n * @example const editor = useEditor({ extensions: [...] })\n */\nexport function useEditor(options?: UseEditorOptions, deps?: DependencyList): Editor | null;\n\nexport function useEditor(\n  options: UseEditorOptions = {},\n  deps: DependencyList = [],\n): Editor | null {\n  const mostRecentOptions = useRef(options)\n\n  mostRecentOptions.current = options\n\n  const [instanceManager] = useState(() => new EditorInstanceManager(mostRecentOptions))\n\n  const editor = useSyncExternalStore(\n    instanceManager.subscribe,\n    instanceManager.getEditor,\n    instanceManager.getServerSnapshot,\n  )\n\n  useDebugValue(editor)\n\n  // This effect will handle creating/updating the editor instance\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  useEffect(instanceManager.onRender(deps))\n\n  // The default behavior is to re-render on each transaction\n  // This is legacy behavior that will be removed in future versions\n  useEditorState({\n    editor,\n    selector: ({ transactionNumber }) => {\n      if (options.shouldRerenderOnTransaction === false) {\n        // This will prevent the editor from re-rendering on each transaction\n        return null\n      }\n\n      // This will avoid re-rendering on the first transaction when `immediatelyRender` is set to `true`\n      if (options.immediatelyRender && transactionNumber === 0) {\n        return 0\n      }\n      return transactionNumber + 1\n    },\n  })\n\n  return editor\n}\n","import { Editor } from '@tiptap/core'\nimport React, {\n  createContext, HTMLAttributes, ReactNode, useContext,\n} from 'react'\n\nimport { EditorContent } from './EditorContent.js'\nimport { useEditor, UseEditorOptions } from './useEditor.js'\n\nexport type EditorContextValue = {\n  editor: Editor | null;\n}\n\nexport const EditorContext = createContext<EditorContextValue>({\n  editor: null,\n})\n\nexport const EditorConsumer = EditorContext.Consumer\n\n/**\n * A hook to get the current editor instance.\n */\nexport const useCurrentEditor = () => useContext(EditorContext)\n\nexport type EditorProviderProps = {\n  children?: ReactNode;\n  slotBefore?: ReactNode;\n  slotAfter?: ReactNode;\n  editorContainerProps?: HTMLAttributes<HTMLDivElement>;\n} & UseEditorOptions\n\n/**\n * This is the provider component for the editor.\n * It allows the editor to be accessible across the entire component tree\n * with `useCurrentEditor`.\n */\nexport function EditorProvider({\n  children, slotAfter, slotBefore, editorContainerProps = {}, ...editorOptions\n}: EditorProviderProps) {\n  const editor = useEditor(editorOptions)\n\n  if (!editor) {\n    return null\n  }\n\n  return (\n    <EditorContext.Provider value={{ editor }}>\n      {slotBefore}\n      <EditorConsumer>\n        {({ editor: currentEditor }) => (\n          <EditorContent editor={currentEditor} {...editorContainerProps} />\n        )}\n      </EditorConsumer>\n      {children}\n      {slotAfter}\n    </EditorContext.Provider>\n  )\n}\n","import { BubbleMenuPlugin, BubbleMenuPluginProps } from '@tiptap/extension-bubble-menu'\nimport React, { useEffect, useState } from 'react'\n\nimport { useCurrentEditor } from './Context.js'\n\ntype Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;\n\nexport type BubbleMenuProps = Omit<Optional<BubbleMenuPluginProps, 'pluginKey'>, 'element' | 'editor'> & {\n  editor: BubbleMenuPluginProps['editor'] | null;\n  className?: string;\n  children: React.ReactNode;\n  updateDelay?: number;\n};\n\nexport const BubbleMenu = (props: BubbleMenuProps) => {\n  const [element, setElement] = useState<HTMLDivElement | null>(null)\n  const { editor: currentEditor } = useCurrentEditor()\n\n  useEffect(() => {\n    if (!element) {\n      return\n    }\n\n    if (props.editor?.isDestroyed || currentEditor?.isDestroyed) {\n      return\n    }\n\n    const {\n      pluginKey = 'bubbleMenu', editor, tippyOptions = {}, updateDelay, shouldShow = null,\n    } = props\n\n    const menuEditor = editor || currentEditor\n\n    if (!menuEditor) {\n      console.warn('BubbleMenu component is not rendered inside of an editor component or does not have editor prop.')\n      return\n    }\n\n    const plugin = BubbleMenuPlugin({\n      updateDelay,\n      editor: menuEditor,\n      element,\n      pluginKey,\n      shouldShow,\n      tippyOptions,\n    })\n\n    menuEditor.registerPlugin(plugin)\n    return () => { menuEditor.unregisterPlugin(pluginKey) }\n  }, [props.editor, currentEditor, element])\n\n  return (\n    <div ref={setElement} className={props.className} style={{ visibility: 'hidden' }}>\n      {props.children}\n    </div>\n  )\n}\n","import { createContext, useContext } from 'react'\n\nexport interface ReactNodeViewContextProps {\n  onDragStart: (event: DragEvent) => void,\n  nodeViewContentRef: (element: HTMLElement | null) => void,\n}\n\nexport const ReactNodeViewContext = createContext<Partial<ReactNodeViewContextProps>>({\n  onDragStart: undefined,\n})\n\nexport const useReactNodeView = () => useContext(ReactNodeViewContext)\n","import React from 'react'\n\nimport { useReactNodeView } from './useReactNodeView.js'\n\nexport interface NodeViewWrapperProps {\n  [key: string]: any,\n  as?: React.ElementType,\n}\n\nexport const NodeViewWrapper: React.FC<NodeViewWrapperProps> = React.forwardRef((props, ref) => {\n  const { onDragStart } = useReactNodeView()\n  const Tag = props.as || 'div'\n\n  return (\n    // @ts-ignore\n    <Tag\n      {...props}\n      ref={ref}\n      data-node-view-wrapper=\"\"\n      onDragStart={onDragStart}\n      style={{\n        whiteSpace: 'normal',\n        ...props.style,\n      }}\n    />\n  )\n})\n","import { Editor } from '@tiptap/core'\nimport React from 'react'\nimport { flushSync } from 'react-dom'\n\nimport { EditorWithContentComponent } from './Editor.js'\n\n/**\n * Check if a component is a class component.\n * @param Component\n * @returns {boolean}\n */\nfunction isClassComponent(Component: any) {\n  return !!(\n    typeof Component === 'function'\n    && Component.prototype\n    && Component.prototype.isReactComponent\n  )\n}\n\n/**\n * Check if a component is a forward ref component.\n * @param Component\n * @returns {boolean}\n */\nfunction isForwardRefComponent(Component: any) {\n  return !!(\n    typeof Component === 'object'\n    && Component.$$typeof?.toString() === 'Symbol(react.forward_ref)'\n  )\n}\n\nexport interface ReactRendererOptions {\n  /**\n   * The editor instance.\n   * @type {Editor}\n   */\n  editor: Editor,\n\n  /**\n   * The props for the component.\n   * @type {Record<string, any>}\n   * @default {}\n   */\n  props?: Record<string, any>,\n\n  /**\n   * The tag name of the element.\n   * @type {string}\n   * @default 'div'\n   */\n  as?: string,\n\n  /**\n   * The class name of the element.\n   * @type {string}\n   * @default ''\n   * @example 'foo bar'\n   */\n  className?: string,\n}\n\ntype ComponentType<R, P> =\n  React.ComponentClass<P> |\n  React.FunctionComponent<P> |\n  React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<R>>;\n\n/**\n * The ReactRenderer class. It's responsible for rendering React components inside the editor.\n * @example\n * new ReactRenderer(MyComponent, {\n *   editor,\n *   props: {\n *     foo: 'bar',\n *   },\n *   as: 'span',\n * })\n*/\nexport class ReactRenderer<R = unknown, P extends Record<string, any> = object> {\n  id: string\n\n  editor: Editor\n\n  component: any\n\n  element: Element\n\n  props: P\n\n  reactElement: React.ReactNode\n\n  ref: R | null = null\n\n  /**\n   * Immediately creates element and renders the provided React component.\n   */\n  constructor(component: ComponentType<R, P>, {\n    editor,\n    props = {},\n    as = 'div',\n    className = '',\n  }: ReactRendererOptions) {\n    this.id = Math.floor(Math.random() * 0xFFFFFFFF).toString()\n    this.component = component\n    this.editor = editor as EditorWithContentComponent\n    this.props = props as P\n    this.element = document.createElement(as)\n    this.element.classList.add('react-renderer')\n\n    if (className) {\n      this.element.classList.add(...className.split(' '))\n    }\n\n    if (this.editor.isInitialized) {\n      // On first render, we need to flush the render synchronously\n      // Renders afterwards can be async, but this fixes a cursor positioning issue\n      flushSync(() => {\n        this.render()\n      })\n    } else {\n      this.render()\n    }\n  }\n\n  /**\n   * Render the React component.\n   */\n  render(): void {\n    const Component = this.component\n    const props = this.props\n    const editor = this.editor as EditorWithContentComponent\n\n    if (isClassComponent(Component) || isForwardRefComponent(Component)) {\n      // @ts-ignore This is a hack to make the ref work\n      props.ref = (ref: R) => {\n        this.ref = ref\n      }\n    }\n\n    this.reactElement = <Component {...props} />\n\n    editor?.contentComponent?.setRenderer(this.id, this)\n  }\n\n  /**\n   * Re-renders the React component with new props.\n   */\n  updateProps(props: Record<string, any> = {}): void {\n    this.props = {\n      ...this.props,\n      ...props,\n    }\n\n    this.render()\n  }\n\n  /**\n   * Destroy the React component.\n   */\n  destroy(): void {\n    const editor = this.editor as EditorWithContentComponent\n\n    editor?.contentComponent?.removeRenderer(this.id)\n  }\n\n  /**\n   * Update the attributes of the element that holds the React component.\n   */\n  updateAttributes(attributes: Record<string, string>): void {\n    Object.keys(attributes).forEach(key => {\n      this.element.setAttribute(key, attributes[key])\n    })\n  }\n}\n","import { Extension } from '@tiptap/core'\nimport { Blockquote, BlockquoteOptions } from '@tiptap/extension-blockquote'\nimport { Bold, BoldOptions } from '@tiptap/extension-bold'\nimport { BulletList, BulletListOptions } from '@tiptap/extension-bullet-list'\nimport { Code, CodeOptions } from '@tiptap/extension-code'\nimport { CodeBlock, CodeBlockOptions } from '@tiptap/extension-code-block'\nimport { Document } from '@tiptap/extension-document'\nimport { Dropcursor, DropcursorOptions } from '@tiptap/extension-dropcursor'\nimport { Gapcursor } from '@tiptap/extension-gapcursor'\nimport { HardBreak, HardBreakOptions } from '@tiptap/extension-hard-break'\nimport { Heading, HeadingOptions } from '@tiptap/extension-heading'\nimport { History, HistoryOptions } from '@tiptap/extension-history'\nimport { HorizontalRule, HorizontalRuleOptions } from '@tiptap/extension-horizontal-rule'\nimport { Italic, ItalicOptions } from '@tiptap/extension-italic'\nimport { ListItem, ListItemOptions } from '@tiptap/extension-list-item'\nimport { OrderedList, OrderedListOptions } from '@tiptap/extension-ordered-list'\nimport { Paragraph, ParagraphOptions } from '@tiptap/extension-paragraph'\nimport { Strike, StrikeOptions } from '@tiptap/extension-strike'\nimport { Text } from '@tiptap/extension-text'\n\nexport interface StarterKitOptions {\n  /**\n   * If set to false, the blockquote extension will not be registered\n   * @example blockquote: false\n   */\n  blockquote: Partial<BlockquoteOptions> | false,\n\n  /**\n   * If set to false, the bold extension will not be registered\n   * @example bold: false\n   */\n  bold: Partial<BoldOptions> | false,\n\n  /**\n   * If set to false, the bulletList extension will not be registered\n   * @example bulletList: false\n   */\n  bulletList: Partial<BulletListOptions> | false,\n\n  /**\n   * If set to false, the code extension will not be registered\n   * @example code: false\n   */\n  code: Partial<CodeOptions> | false,\n\n  /**\n   * If set to false, the codeBlock extension will not be registered\n   * @example codeBlock: false\n   */\n  codeBlock: Partial<CodeBlockOptions> | false,\n\n  /**\n   * If set to false, the document extension will not be registered\n   * @example document: false\n   */\n  document: false,\n\n  /**\n   * If set to false, the dropcursor extension will not be registered\n   * @example dropcursor: false\n   */\n  dropcursor: Partial<DropcursorOptions> | false,\n\n  /**\n   * If set to false, the gapcursor extension will not be registered\n   * @example gapcursor: false\n   */\n  gapcursor: false,\n\n  /**\n   * If set to false, the hardBreak extension will not be registered\n   * @example hardBreak: false\n   */\n  hardBreak: Partial<HardBreakOptions> | false,\n\n  /**\n   * If set to false, the heading extension will not be registered\n   * @example heading: false\n   */\n  heading: Partial<HeadingOptions> | false,\n\n  /**\n   * If set to false, the history extension will not be registered\n   * @example history: false\n   */\n  history: Partial<HistoryOptions> | false,\n\n  /**\n   * If set to false, the horizontalRule extension will not be registered\n   * @example horizontalRule: false\n   */\n  horizontalRule: Partial<HorizontalRuleOptions> | false,\n\n  /**\n   * If set to false, the italic extension will not be registered\n   * @example italic: false\n   */\n  italic: Partial<ItalicOptions> | false,\n\n  /**\n   * If set to false, the listItem extension will not be registered\n   * @example listItem: false\n   */\n  listItem: Partial<ListItemOptions> | false,\n\n  /**\n   * If set to false, the orderedList extension will not be registered\n   * @example orderedList: false\n   */\n  orderedList: Partial<OrderedListOptions> | false,\n\n  /**\n   * If set to false, the paragraph extension will not be registered\n   * @example paragraph: false\n   */\n  paragraph: Partial<ParagraphOptions> | false,\n\n  /**\n   * If set to false, the strike extension will not be registered\n   * @example strike: false\n   */\n  strike: Partial<StrikeOptions> | false,\n\n  /**\n   * If set to false, the text extension will not be registered\n   * @example text: false\n   */\n  text: false,\n}\n\n/**\n * The starter kit is a collection of essential editor extensions.\n *\n * It’s a good starting point for building your own editor.\n */\nexport const StarterKit = Extension.create<StarterKitOptions>({\n  name: 'starterKit',\n\n  addExtensions() {\n    const extensions = []\n\n    if (this.options.bold !== false) {\n      extensions.push(Bold.configure(this.options?.bold))\n    }\n\n    if (this.options.blockquote !== false) {\n      extensions.push(Blockquote.configure(this.options?.blockquote))\n    }\n\n    if (this.options.bulletList !== false) {\n      extensions.push(BulletList.configure(this.options?.bulletList))\n    }\n\n    if (this.options.code !== false) {\n      extensions.push(Code.configure(this.options?.code))\n    }\n\n    if (this.options.codeBlock !== false) {\n      extensions.push(CodeBlock.configure(this.options?.codeBlock))\n    }\n\n    if (this.options.document !== false) {\n      extensions.push(Document.configure(this.options?.document))\n    }\n\n    if (this.options.dropcursor !== false) {\n      extensions.push(Dropcursor.configure(this.options?.dropcursor))\n    }\n\n    if (this.options.gapcursor !== false) {\n      extensions.push(Gapcursor.configure(this.options?.gapcursor))\n    }\n\n    if (this.options.hardBreak !== false) {\n      extensions.push(HardBreak.configure(this.options?.hardBreak))\n    }\n\n    if (this.options.heading !== false) {\n      extensions.push(Heading.configure(this.options?.heading))\n    }\n\n    if (this.options.history !== false) {\n      extensions.push(History.configure(this.options?.history))\n    }\n\n    if (this.options.horizontalRule !== false) {\n      extensions.push(HorizontalRule.configure(this.options?.horizontalRule))\n    }\n\n    if (this.options.italic !== false) {\n      extensions.push(Italic.configure(this.options?.italic))\n    }\n\n    if (this.options.listItem !== false) {\n      extensions.push(ListItem.configure(this.options?.listItem))\n    }\n\n    if (this.options.orderedList !== false) {\n      extensions.push(OrderedList.configure(this.options?.orderedList))\n    }\n\n    if (this.options.paragraph !== false) {\n      extensions.push(Paragraph.configure(this.options?.paragraph))\n    }\n\n    if (this.options.strike !== false) {\n      extensions.push(Strike.configure(this.options?.strike))\n    }\n\n    if (this.options.text !== false) {\n      extensions.push(Text.configure(this.options?.text))\n    }\n\n    return extensions\n  },\n})\n","import { escapeForRegEx, Range } from '@tiptap/core'\nimport { ResolvedPos } from '@tiptap/pm/model'\n\nexport interface Trigger {\n  char: string\n  allowSpaces: boolean\n  allowToIncludeChar: boolean\n  allowedPrefixes: string[] | null\n  startOfLine: boolean\n  $position: ResolvedPos\n}\n\nexport type SuggestionMatch = {\n  range: Range\n  query: string\n  text: string\n} | null\n\nexport function findSuggestionMatch(config: Trigger): SuggestionMatch {\n  const {\n    char, allowSpaces: allowSpacesOption, allowToIncludeChar, allowedPrefixes, startOfLine, $position,\n  } = config\n\n  const allowSpaces = allowSpacesOption && !allowToIncludeChar\n\n  const escapedChar = escapeForRegEx(char)\n  const suffix = new RegExp(`\\\\s${escapedChar}$`)\n  const prefix = startOfLine ? '^' : ''\n  const finalEscapedChar = allowToIncludeChar ? '' : escapedChar\n  const regexp = allowSpaces\n    ? new RegExp(`${prefix}${escapedChar}.*?(?=\\\\s${finalEscapedChar}|$)`, 'gm')\n    : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\\\s${finalEscapedChar}]*`, 'gm')\n\n  const text = $position.nodeBefore?.isText && $position.nodeBefore.text\n\n  if (!text) {\n    return null\n  }\n\n  const textFrom = $position.pos - text.length\n  const match = Array.from(text.matchAll(regexp)).pop()\n\n  if (!match || match.input === undefined || match.index === undefined) {\n    return null\n  }\n\n  // JavaScript doesn't have lookbehinds. This hacks a check that first character\n  // is a space or the start of the line\n  const matchPrefix = match.input.slice(Math.max(0, match.index - 1), match.index)\n  const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes?.join('')}\\0]?$`).test(matchPrefix)\n\n  if (allowedPrefixes !== null && !matchPrefixIsAllowed) {\n    return null\n  }\n\n  // The absolute position of the match in the document\n  const from = textFrom + match.index\n  let to = from + match[0].length\n\n  // Edge case handling; if spaces are allowed and we're directly in between\n  // two triggers\n  if (allowSpaces && suffix.test(text.slice(to - 1, to + 1))) {\n    match[0] += ' '\n    to += 1\n  }\n\n  // If the $position is located within the matched substring, return that range\n  if (from < $position.pos && to >= $position.pos) {\n    return {\n      range: {\n        from,\n        to,\n      },\n      query: match[0].slice(char.length),\n      text: match[0],\n    }\n  }\n\n  return null\n}\n","import { Editor, Range } from '@tiptap/core'\nimport { EditorState, Plugin, PluginKey } from '@tiptap/pm/state'\nimport { Decoration, DecorationSet, EditorView } from '@tiptap/pm/view'\n\nimport { findSuggestionMatch as defaultFindSuggestionMatch } from './findSuggestionMatch.js'\n\nexport interface SuggestionOptions<I = any, TSelected = any> {\n  /**\n   * The plugin key for the suggestion plugin.\n   * @default 'suggestion'\n   * @example 'mention'\n   */\n  pluginKey?: PluginKey\n\n  /**\n   * The editor instance.\n   * @default null\n   */\n  editor: Editor\n\n  /**\n   * The character that triggers the suggestion.\n   * @default '@'\n   * @example '#'\n   */\n  char?: string\n\n  /**\n   * Allow spaces in the suggestion query. Not compatible with `allowToIncludeChar`. Will be disabled if `allowToIncludeChar` is set to `true`.\n   * @default false\n   * @example true\n  */\n  allowSpaces?: boolean\n\n  /**\n   * Allow the character to be included in the suggestion query. Not compatible with `allowSpaces`.\n   * @default false\n   */\n  allowToIncludeChar?: boolean\n\n  /**\n   * Allow prefixes in the suggestion query.\n   * @default [' ']\n   * @example [' ', '@']\n   */\n  allowedPrefixes?: string[] | null\n\n  /**\n   * Only match suggestions at the start of the line.\n   * @default false\n   * @example true\n   */\n  startOfLine?: boolean\n\n  /**\n   * The tag name of the decoration node.\n   * @default 'span'\n   * @example 'div'\n   */\n  decorationTag?: string\n\n  /**\n   * The class name of the decoration node.\n   * @default 'suggestion'\n   * @example 'mention'\n   */\n  decorationClass?: string\n\n  /**\n   * A function that is called when a suggestion is selected.\n   * @param props The props object.\n   * @param props.editor The editor instance.\n   * @param props.range The range of the suggestion.\n   * @param props.props The props of the selected suggestion.\n   * @returns void\n   * @example ({ editor, range, props }) => { props.command(props.props) }\n   */\n  command?: (props: { editor: Editor; range: Range; props: TSelected }) => void\n\n  /**\n   * A function that returns the suggestion items in form of an array.\n   * @param props The props object.\n   * @param props.editor The editor instance.\n   * @param props.query The current suggestion query.\n   * @returns An array of suggestion items.\n   * @example ({ editor, query }) => [{ id: 1, label: 'John Doe' }]\n   */\n  items?: (props: { query: string; editor: Editor }) => I[] | Promise<I[]>\n\n  /**\n   * The render function for the suggestion.\n   * @returns An object with render functions.\n   */\n  render?: () => {\n    onBeforeStart?: (props: SuggestionProps<I, TSelected>) => void;\n    onStart?: (props: SuggestionProps<I, TSelected>) => void;\n    onBeforeUpdate?: (props: SuggestionProps<I, TSelected>) => void;\n    onUpdate?: (props: SuggestionProps<I, TSelected>) => void;\n    onExit?: (props: SuggestionProps<I, TSelected>) => void;\n    onKeyDown?: (props: SuggestionKeyDownProps) => boolean;\n  }\n\n  /**\n   * A function that returns a boolean to indicate if the suggestion should be active.\n   * @param props The props object.\n   * @returns {boolean}\n   */\n  allow?: (props: { editor: Editor; state: EditorState; range: Range, isActive?: boolean }) => boolean\n  findSuggestionMatch?: typeof defaultFindSuggestionMatch\n}\n\nexport interface SuggestionProps<I = any, TSelected = any> {\n  /**\n   * The editor instance.\n   */\n  editor: Editor\n\n  /**\n   * The range of the suggestion.\n   */\n  range: Range\n\n  /**\n   * The current suggestion query.\n   */\n  query: string\n\n  /**\n   * The current suggestion text.\n   */\n  text: string\n\n  /**\n   * The suggestion items array.\n   */\n  items: I[]\n\n  /**\n   * A function that is called when a suggestion is selected.\n   * @param props The props object.\n   * @returns void\n   */\n  command: (props: TSelected) => void\n\n  /**\n   * The decoration node HTML element\n   * @default null\n   */\n  decorationNode: Element | null\n\n  /**\n   * The function that returns the client rect\n   * @default null\n   * @example () => new DOMRect(0, 0, 0, 0)\n   */\n  clientRect?: (() => DOMRect | null) | null\n}\n\nexport interface SuggestionKeyDownProps {\n  view: EditorView\n  event: KeyboardEvent\n  range: Range\n}\n\nexport const SuggestionPluginKey = new PluginKey('suggestion')\n\n/**\n * This utility allows you to create suggestions.\n * @see https://tiptap.dev/api/utilities/suggestion\n */\nexport function Suggestion<I = any, TSelected = any>({\n  pluginKey = SuggestionPluginKey,\n  editor,\n  char = '@',\n  allowSpaces = false,\n  allowToIncludeChar = false,\n  allowedPrefixes = [' '],\n  startOfLine = false,\n  decorationTag = 'span',\n  decorationClass = 'suggestion',\n  command = () => null,\n  items = () => [],\n  render = () => ({}),\n  allow = () => true,\n  findSuggestionMatch = defaultFindSuggestionMatch,\n}: SuggestionOptions<I, TSelected>) {\n  let props: SuggestionProps<I, TSelected> | undefined\n  const renderer = render?.()\n\n  const plugin: Plugin<any> = new Plugin({\n    key: pluginKey,\n\n    view() {\n      return {\n        update: async (view, prevState) => {\n          const prev = this.key?.getState(prevState)\n          const next = this.key?.getState(view.state)\n\n          // See how the state changed\n          const moved = prev.active && next.active && prev.range.from !== next.range.from\n          const started = !prev.active && next.active\n          const stopped = prev.active && !next.active\n          const changed = !started && !stopped && prev.query !== next.query\n\n          const handleStart = started || (moved && changed)\n          const handleChange = changed || moved\n          const handleExit = stopped || (moved && changed)\n\n          // Cancel when suggestion isn't active\n          if (!handleStart && !handleChange && !handleExit) {\n            return\n          }\n\n          const state = handleExit && !handleStart ? prev : next\n          const decorationNode = view.dom.querySelector(\n            `[data-decoration-id=\"${state.decorationId}\"]`,\n          )\n\n          props = {\n            editor,\n            range: state.range,\n            query: state.query,\n            text: state.text,\n            items: [],\n            command: commandProps => {\n              return command({\n                editor,\n                range: state.range,\n                props: commandProps,\n              })\n            },\n            decorationNode,\n            // virtual node for popper.js or tippy.js\n            // this can be used for building popups without a DOM node\n            clientRect: decorationNode\n              ? () => {\n                // because of `items` can be asynchrounous we’ll search for the current decoration node\n                  const { decorationId } = this.key?.getState(editor.state) // eslint-disable-line\n                const currentDecorationNode = view.dom.querySelector(\n                  `[data-decoration-id=\"${decorationId}\"]`,\n                )\n\n                return currentDecorationNode?.getBoundingClientRect() || null\n              }\n              : null,\n          }\n\n          if (handleStart) {\n            renderer?.onBeforeStart?.(props)\n          }\n\n          if (handleChange) {\n            renderer?.onBeforeUpdate?.(props)\n          }\n\n          if (handleChange || handleStart) {\n            props.items = await items({\n              editor,\n              query: state.query,\n            })\n          }\n\n          if (handleExit) {\n            renderer?.onExit?.(props)\n          }\n\n          if (handleChange) {\n            renderer?.onUpdate?.(props)\n          }\n\n          if (handleStart) {\n            renderer?.onStart?.(props)\n          }\n        },\n\n        destroy: () => {\n          if (!props) {\n            return\n          }\n\n          renderer?.onExit?.(props)\n        },\n      }\n    },\n\n    state: {\n      // Initialize the plugin's internal state.\n      init() {\n        const state: {\n          active: boolean\n          range: Range\n          query: null | string\n          text: null | string\n          composing: boolean\n          decorationId?: string | null\n        } = {\n          active: false,\n          range: {\n            from: 0,\n            to: 0,\n          },\n          query: null,\n          text: null,\n          composing: false,\n        }\n\n        return state\n      },\n\n      // Apply changes to the plugin state from a view transaction.\n      apply(transaction, prev, _oldState, state) {\n        const { isEditable } = editor\n        const { composing } = editor.view\n        const { selection } = transaction\n        const { empty, from } = selection\n        const next = { ...prev }\n\n        next.composing = composing\n\n        // We can only be suggesting if the view is editable, and:\n        //   * there is no selection, or\n        //   * a composition is active (see: https://github.com/ueberdosis/tiptap/issues/1449)\n        if (isEditable && (empty || editor.view.composing)) {\n          // Reset active state if we just left the previous suggestion range\n          if ((from < prev.range.from || from > prev.range.to) && !composing && !prev.composing) {\n            next.active = false\n          }\n\n          // Try to match against where our cursor currently is\n          const match = findSuggestionMatch({\n            char,\n            allowSpaces,\n            allowToIncludeChar,\n            allowedPrefixes,\n            startOfLine,\n            $position: selection.$from,\n          })\n          const decorationId = `id_${Math.floor(Math.random() * 0xffffffff)}`\n\n          // If we found a match, update the current state to show it\n          if (match && allow({\n            editor, state, range: match.range, isActive: prev.active,\n          })) {\n            next.active = true\n            next.decorationId = prev.decorationId ? prev.decorationId : decorationId\n            next.range = match.range\n            next.query = match.query\n            next.text = match.text\n          } else {\n            next.active = false\n          }\n        } else {\n          next.active = false\n        }\n\n        // Make sure to empty the range if suggestion is inactive\n        if (!next.active) {\n          next.decorationId = null\n          next.range = { from: 0, to: 0 }\n          next.query = null\n          next.text = null\n        }\n\n        return next\n      },\n    },\n\n    props: {\n      // Call the keydown hook if suggestion is active.\n      handleKeyDown(view, event) {\n        const { active, range } = plugin.getState(view.state)\n\n        if (!active) {\n          return false\n        }\n\n        return renderer?.onKeyDown?.({ view, event, range }) || false\n      },\n\n      // Setup decorator on the currently active suggestion.\n      decorations(state) {\n        const { active, range, decorationId } = plugin.getState(state)\n\n        if (!active) {\n          return null\n        }\n\n        return DecorationSet.create(state.doc, [\n          Decoration.inline(range.from, range.to, {\n            nodeName: decorationTag,\n            class: decorationClass,\n            'data-decoration-id': decorationId,\n          }),\n        ])\n      },\n    },\n  })\n\n  return plugin\n}\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n  ownKeys = Object.getOwnPropertyNames || function (o) {\n    var ar = [];\n    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n    return ar;\n  };\n  return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n"],"names":["shim","exports","e","React","k","Object","is","a","b","l","useState","m","useEffect","n","useLayoutEffect","p","useDebugValue","r","getSnapshot","value","d","f","u","window","document","createElement","inst","c","g","useSyncExternalStoreShim_production_min","useSyncExternalStore","requireUseSyncExternalStoreShim_production_min","mergeRefs","_len","arguments","length","refs","Array","_key","node","forEach","ref","current","Portals","_ref","contentComponent","renderers","shimExports","subscribe","getServerSnapshot","values","PureEditorContent","constructor","props","super","this","editorContentRef","initialized","state","hasContentComponentInitialized","Boolean","_a","editor","componentDidMount","init","componentDidUpdate","isDestroyed","options","element","append","childNodes","setOptions","subscribers","Set","callback","add","delete","setRenderer","id","renderer","_objectSpread","ReactDOM","reactElement","subscriber","removeRenderer","nextRenderers","getInstance","unsubscribeToContentComponent","setState","prevState","createNodeViews","componentWillUnmount","view","setProps","nodeViews","firstChild","newElement","render","_this$props","innerRef","rest","_objectWithoutProperties","_excluded","EditorContentWithKey","forwardRef","key","Math","floor","random","toString","EditorContent","equal","i","keys","isArray","Map","size","entries","has","get","ArrayBuffer","isView","RegExp","source","flags","valueOf","prototype","hasOwnProperty","call","$$typeof","withSelector","h","q","t","useRef","v","useMemo","w","withSelector_production_min","useSyncExternalStoreWithSelector","hasValue","requireWithSelector_production_min","useIsomorphicLayoutEffect","EditorStateManager","initialEditor","transactionNumber","lastTransactionNumber","lastSnapshot","bind","watch","nextEditor","fn","currentEditor","on","off","isDev","process","isSSR","isNext","next","EditorInstanceManager","subscriptions","isComponentMounted","previousDeps","instanceId","setEditor","getInitialEditor","scheduleDestroy","getEditor","refreshEditorInstance","onRender","createEditor","slice","cb","undefined","immediatelyRender","Error","_this","optionsToApply","onBeforeCreate","_b","_len3","args","_key3","onBlur","_len4","_key4","onCreate","_len5","_key5","onDestroy","_len6","_key6","onFocus","_len7","_key7","onSelectionUpdate","_len8","_key8","onTransaction","_len9","_key9","onUpdate","_len10","_key10","onContentError","_len11","_key11","onDrop","_len12","_key12","onPaste","_len13","_key13","Editor","onStoreChange","compareOptions","every","includes","extensions","extension","index","deps","clearTimeout","scheduledDestructionTimeout","editable","isEditable","dep","destroy","currentInstanceId","setTimeout","useEditor","mostRecentOptions","instanceManager","editorStateManager","selectedState","withSelectorExports","selector","equalityFn","deepEqual","useEditorState","_ref2","shouldRerenderOnTransaction","EditorContext","createContext","Consumer","ReactNodeViewContext","onDragStart","useReactNodeView","useContext","Tag","as","style","whiteSpace","ReactRenderer","component","_ref5","className","classList","split","isInitialized","flushSync","Component","isReactComponent","isClassComponent","isForwardRefComponent","updateProps","updateAttributes","attributes","setAttribute","StarterKit","Extension","create","name","addExtensions","bold","push","Bold","configure","blockquote","Blockquote","bulletList","BulletList","_c","code","Code","_d","codeBlock","CodeBlock","_e","Document","_f","dropcursor","Dropcursor","_g","gapcursor","Gapcursor","_h","hardBreak","HardBreak","_j","heading","Heading","_k","history","History","_l","horizontalRule","HorizontalRule","_m","italic","Italic","_o","listItem","ListItem","_p","orderedList","OrderedList","_q","paragraph","Paragraph","_r","strike","Strike","_s","text","Text","_t","findSuggestionMatch","config","char","allowSpaces","allowSpacesOption","allowToIncludeChar","allowedPrefixes","startOfLine","$position","escapedChar","escapeForRegEx","suffix","concat","prefix","finalEscapedChar","regexp","nodeBefore","isText","textFrom","pos","match","from","matchAll","pop","input","matchPrefix","max","matchPrefixIsAllowed","join","test","to","range","query","SuggestionPluginKey","PluginKey","Suggestion","pluginKey","decorationTag","decorationClass","command","items","allow","findSuggestionMatch$1","plugin","Plugin","update","async","prev","getState","moved","active","started","stopped","changed","handleStart","handleChange","handleExit","decorationNode","dom","querySelector","decorationId","commandProps","clientRect","currentDecorationNode","getBoundingClientRect","onBeforeStart","onBeforeUpdate","onExit","onStart","composing","apply","transaction","_oldState","selection","empty","$from","isActive","handleKeyDown","event","onKeyDown","decorations","DecorationSet","doc","Decoration","inline","nodeName","class","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","rejected","result","done","then","__generator","body","y","_","label","sent","trys","ops","Iterator","verb","Symbol","iterator","op","TypeError","__values","o","s","SuppressedError"],"sourceRoot":""}