@portabletext/editor 2.13.2 → 2.13.4

package/src/editor/plugins/createWithEditableAPI.ts

@@ -26,18 +26,12 @@ import {
 } from '../../internal-utils/slate-utils'
 import {toSlateRange} from '../../internal-utils/to-slate-range'
 import {fromSlateValue, toSlateValue} from '../../internal-utils/values'
-import {
-  KEY_TO_VALUE_ELEMENT,
-  SLATE_TO_PORTABLE_TEXT_RANGE,
-} from '../../internal-utils/weakMaps'
-import {
-  getFocusBlock,
-  getFocusSpan,
-  getSelectedValue,
-  isActiveAnnotation,
-} from '../../selectors'
 import {getActiveAnnotationsMarks} from '../../selectors/selector.get-active-annotation-marks'
 import {getActiveDecorators} from '../../selectors/selector.get-active-decorators'
+import {getFocusBlock} from '../../selectors/selector.get-focus-block'
+import {getFocusSpan} from '../../selectors/selector.get-focus-span'
+import {getSelectedValue} from '../../selectors/selector.get-selected-value'
+import {isActiveAnnotation} from '../../selectors/selector.is-active-annotation'
 import type {
   EditableAPI,
   EditableAPIDeleteOptions,
@@ -46,6 +40,7 @@ import type {
 } from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import {getEditorSnapshot} from '../editor-selector'
+import {KEY_TO_VALUE_ELEMENT, SLATE_TO_PORTABLE_TEXT_RANGE} from '../weakMaps'
 
 const debug = debugWithName('API:editable')
 

package/src/editor/plugins/createWithMaxBlocks.ts

@@ -1,7 +1,7 @@
-import {isChangingRemotely} from '../../internal-utils/withChanges'
-import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {isChangingRemotely} from '../withChanges'
+import {isRedoing, isUndoing} from '../withUndoRedo'
 
 /**
  * This plugin makes sure that the PTE maxBlocks prop is respected

package/src/editor/plugins/createWithObjectKeys.ts

@@ -1,10 +1,10 @@
 import {isSpan, isTextBlock} from '@portabletext/schema'
 import {isEqual} from 'lodash'
 import {Editor, Element, Node, Path, Transforms} from 'slate'
-import {isChangingRemotely} from '../../internal-utils/withChanges'
-import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {isChangingRemotely} from '../withChanges'
+import {isRedoing, isUndoing} from '../withUndoRedo'
 
 /**
  * This plugin makes sure that every new node in the editor get a new _key prop when created

package/src/editor/plugins/createWithPatches.ts

@@ -13,20 +13,13 @@ import {
   splitNodePatch,
 } from '../../internal-utils/operation-to-patches'
 import {fromSlateValue, isEqualToEmptyEditor} from '../../internal-utils/values'
-import {
-  IS_PROCESSING_REMOTE_CHANGES,
-  KEY_TO_VALUE_ELEMENT,
-} from '../../internal-utils/weakMaps'
-import {withRemoteChanges} from '../../internal-utils/withChanges'
-import {
-  isPatching,
-  PATCHING,
-  withoutPatching,
-} from '../../internal-utils/withoutPatching'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import type {RelayActor} from '../relay-machine'
+import {IS_PROCESSING_REMOTE_CHANGES, KEY_TO_VALUE_ELEMENT} from '../weakMaps'
 import {getCurrentUndoStepId} from '../with-undo-step'
+import {withRemoteChanges} from '../withChanges'
+import {isPatching, PATCHING, withoutPatching} from '../withoutPatching'
 import {withoutSaving} from './createWithUndoRedo'
 
 const debug = debugWithName('plugin:withPatches')

package/src/editor/plugins/createWithPlaceholderBlock.ts

@@ -1,9 +1,9 @@
 import {Editor} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
-import {isChangingRemotely} from '../../internal-utils/withChanges'
-import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {isChangingRemotely} from '../withChanges'
+import {isRedoing, isUndoing} from '../withUndoRedo'
 
 const debug = debugWithName('plugin:withPlaceholderBlock')
 

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -10,14 +10,14 @@ import {isEqual, uniq} from 'lodash'
 import {Editor, Element, Node, Path, Range, Text, Transforms} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
-import {isChangingRemotely} from '../../internal-utils/withChanges'
-import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
 import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
 import {getActiveDecorators} from '../../selectors/selector.get-active-decorators'
 import {getMarkState} from '../../selectors/selector.get-mark-state'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import {getEditorSnapshot} from '../editor-selector'
+import {isChangingRemotely} from '../withChanges'
+import {isRedoing, isUndoing} from '../withUndoRedo'
 
 const debug = debugWithName('plugin:withPortableTextMarkModel')
 

package/src/editor/plugins/createWithSchemaTypes.ts

@@ -6,8 +6,8 @@ import type {
 } from '@sanity/types'
 import {Editor, Transforms, type Element} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
-import {isListBlock} from '../../internal-utils/parse-blocks'
 import type {PortableTextSlateEditor} from '../../types/editor'
+import {isListBlock} from '../../utils/parse-blocks'
 import type {EditorActor} from '../editor-machine'
 
 const debug = debugWithName('plugin:withSchemaTypes')

package/src/editor/plugins/createWithUndoRedo.ts

@@ -22,7 +22,11 @@ import {
 } from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
 import {fromSlateValue} from '../../internal-utils/values'
-import {isChangingRemotely} from '../../internal-utils/withChanges'
+import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
+import type {PortableTextSlateEditor} from '../../types/editor'
+import type {EditorActor} from '../editor-machine'
+import {getCurrentUndoStepId} from '../with-undo-step'
+import {isChangingRemotely} from '../withChanges'
 import {
   isRedoing,
   isUndoing,
@@ -30,11 +34,7 @@ import {
   setIsUndoing,
   withRedoing,
   withUndoing,
-} from '../../internal-utils/withUndoRedo'
-import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
-import type {PortableTextSlateEditor} from '../../types/editor'
-import type {EditorActor} from '../editor-machine'
-import {getCurrentUndoStepId} from '../with-undo-step'
+} from '../withUndoRedo'
 
 const debug = debugWithName('plugin:withUndoRedo')
 const debugVerbose = debug.enabled && false

package/src/editor/plugins/slate-plugin.update-selection.ts

@@ -1,7 +1,7 @@
 import {slateRangeToSelection} from '../../internal-utils/slate-utils'
-import {SLATE_TO_PORTABLE_TEXT_RANGE} from '../../internal-utils/weakMaps'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {SLATE_TO_PORTABLE_TEXT_RANGE} from '../weakMaps'
 
 export function pluginUpdateSelection({
   editor,

package/src/editor/sync-machine.ts

@@ -25,11 +25,6 @@ import type {ActorRefFrom} from 'xstate'
 import {debugWithName} from '../internal-utils/debug'
 import {validateValue} from '../internal-utils/validateValue'
 import {toSlateValue, VOID_CHILD_KEY} from '../internal-utils/values'
-import {
-  isChangingRemotely,
-  withRemoteChanges,
-} from '../internal-utils/withChanges'
-import {withoutPatching} from '../internal-utils/withoutPatching'
 import type {PickFromUnion} from '../type-utils'
 import type {
   InvalidValueResolution,
@@ -37,6 +32,8 @@ import type {
 } from '../types/editor'
 import type {EditorSchema} from './editor-schema'
 import {withoutSaving} from './plugins/createWithUndoRedo'
+import {isChangingRemotely, withRemoteChanges} from './withChanges'
+import {withoutPatching} from './withoutPatching'
 
 const debug = debugWithName('sync machine')
 

package/src/editor/validate-selection-machine.test.ts

@@ -0,0 +1,47 @@
+import {getTersePt} from '@portabletext/test'
+import {userEvent} from '@vitest/browser/context'
+import {describe, expect, test, vi} from 'vitest'
+import {getSelectionAfterText} from '../internal-utils/text-selection'
+import {createTestEditor} from '../test/vitest'
+import {validateSelectionMachine} from './validate-selection-machine'
+
+describe(validateSelectionMachine.id, () => {
+  test('Scenario: Does not validate selection while Slate has pending operations', async () => {
+    const {editor, locator} = await createTestEditor()
+
+    await userEvent.click(locator)
+
+    editor.send({type: 'insert.text', text: 'foo'})
+
+    await vi.waitFor(() => {
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['foo'])
+      expect(editor.getSnapshot().context.selection).toEqual(
+        getSelectionAfterText(editor.getSnapshot().context, 'foo'),
+      )
+    })
+
+    // This event is being sent in before "foo" has been inserted in the DOM
+    // This means that when the MutationObserver is finally triggered for the
+    // "foo" insertion, "bar" will be in the Slate state but not in the DOM.
+    // This causes the selection to be out of sync and this is why we need to
+    // make sure the selection is not validated before Slate has committed all
+    // pending operations.
+    editor.send({type: 'insert.text', text: 'bar'})
+
+    await vi.waitFor(() => {
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['foobar'])
+      expect(editor.getSnapshot().context.selection).toEqual(
+        getSelectionAfterText(editor.getSnapshot().context, 'foobar'),
+      )
+    })
+
+    editor.send({type: 'delete.backward', unit: 'character'})
+
+    await vi.waitFor(() => {
+      expect(getTersePt(editor.getSnapshot().context)).toEqual(['fooba'])
+      expect(editor.getSnapshot().context.selection).toEqual(
+        getSelectionAfterText(editor.getSnapshot().context, 'fooba'),
+      )
+    })
+  })
+})

package/src/editor/validate-selection-machine.ts

@@ -0,0 +1,149 @@
+import {Editor, Transforms} from 'slate'
+import {ReactEditor} from 'slate-react'
+import {setup} from 'xstate'
+import {debugWithName} from '../internal-utils/debug'
+import type {PortableTextSlateEditor} from '../types/editor'
+
+const debug = debugWithName('validate selection machine')
+
+const validateSelectionSetup = setup({
+  types: {
+    context: {} as {
+      slateEditor: PortableTextSlateEditor
+    },
+    input: {} as {
+      slateEditor: PortableTextSlateEditor
+    },
+    events: {} as {
+      type: 'validate selection'
+      editorElement: HTMLDivElement
+    },
+  },
+  guards: {
+    'pending operations': ({context}) =>
+      context.slateEditor.operations.length > 0,
+  },
+})
+
+const validateSelectionAction = validateSelectionSetup.createAction(
+  ({context, event}) => {
+    validateSelection(context.slateEditor, event.editorElement)
+  },
+)
+
+export const validateSelectionMachine = validateSelectionSetup.createMachine({
+  id: 'validate selection',
+  context: ({input}) => ({
+    slateEditor: input.slateEditor,
+  }),
+  initial: 'idle',
+  states: {
+    idle: {
+      on: {
+        'validate selection': [
+          {
+            guard: 'pending operations',
+            target: 'waiting',
+          },
+          {
+            actions: [validateSelectionAction],
+            target: 'idle',
+          },
+        ],
+      },
+    },
+    waiting: {
+      after: {
+        0: [
+          {
+            guard: 'pending operations',
+            target: '.',
+            reenter: true,
+          },
+          {
+            target: 'idle',
+            actions: [validateSelectionAction],
+          },
+        ],
+      },
+      on: {
+        'validate selection': {
+          target: '.',
+          reenter: true,
+        },
+      },
+    },
+  },
+})
+
+// This function will handle unexpected DOM changes inside the Editable rendering,
+// and make sure that we can maintain a stable slateEditor.selection when that happens.
+//
+// For example, if this Editable is rendered inside something that might re-render
+// this component (hidden contexts) while the user is still actively changing the
+// contentEditable, this could interfere with the intermediate DOM selection,
+// which again could be picked up by ReactEditor's event listeners.
+// If that range is invalid at that point, the slate.editorSelection could be
+// set either wrong, or invalid, to which slateEditor will throw exceptions
+// that are impossible to recover properly from or result in a wrong selection.
+//
+// Also the other way around, when the ReactEditor will try to create a DOM Range
+// from the current slateEditor.selection, it may throw unrecoverable errors
+// if the current editor.selection is invalid according to the DOM.
+// If this is the case, default to selecting the top of the document, if the
+// user already had a selection.
+function validateSelection(
+  slateEditor: PortableTextSlateEditor,
+  editorElement: HTMLDivElement,
+) {
+  if (!slateEditor.selection) {
+    return
+  }
+
+  let root: Document | ShadowRoot | undefined
+
+  try {
+    root = ReactEditor.findDocumentOrShadowRoot(slateEditor)
+  } catch {}
+
+  if (!root) {
+    // The editor has most likely been unmounted
+    return
+  }
+
+  // Return if the editor isn't the active element
+  if (editorElement !== root.activeElement) {
+    return
+  }
+  const window = ReactEditor.getWindow(slateEditor)
+  const domSelection = window.getSelection()
+  if (!domSelection || domSelection.rangeCount === 0) {
+    return
+  }
+  const existingDOMRange = domSelection.getRangeAt(0)
+  try {
+    const newDOMRange = ReactEditor.toDOMRange(
+      slateEditor,
+      slateEditor.selection,
+    )
+    if (
+      newDOMRange.startOffset !== existingDOMRange.startOffset ||
+      newDOMRange.endOffset !== existingDOMRange.endOffset
+    ) {
+      debug('DOM range out of sync, validating selection')
+      // Remove all ranges temporary
+      domSelection?.removeAllRanges()
+      // Set the correct range
+      domSelection.addRange(newDOMRange)
+    }
+  } catch {
+    debug(`Could not resolve selection, selecting top document`)
+    // Deselect the editor
+    Transforms.deselect(slateEditor)
+    // Select top document if there is a top block to select
+    if (slateEditor.children.length > 0) {
+      Transforms.select(slateEditor, Editor.start(slateEditor, []))
+    }
+    slateEditor.onChange()
+  }
+}

package/src/{internal-utils → editor}/weakMaps.ts

@@ -1,5 +1,5 @@
 import type {Editor, Range} from 'slate'
-import type {EditorSelection} from '..'
+import type {EditorSelection} from '../types/editor'
 
 // Is the editor currently receiving remote changes that are being applied to the content?
 export const IS_PROCESSING_REMOTE_CHANGES: WeakMap<Editor, boolean> =

package/src/editor/with-undo-step.ts

@@ -1,5 +1,5 @@
 import type {Editor} from 'slate'
-import {defaultKeyGenerator} from './key-generator'
+import {defaultKeyGenerator} from '../utils/key-generator'
 
 const CURRENT_UNDO_STEP: WeakMap<Editor, {undoStepId: string} | undefined> =
   new WeakMap()

package/src/index.ts

@@ -40,7 +40,7 @@ export {useEditorSelector, type EditorSelector} from './editor/editor-selector'
 export type {EditorContext, EditorSnapshot} from './editor/editor-snapshot'
 export {usePortableTextEditor} from './editor/hooks/usePortableTextEditor'
 export {usePortableTextEditorSelection} from './editor/hooks/usePortableTextEditorSelection'
-export {defaultKeyGenerator as keyGenerator} from './editor/key-generator'
+export {defaultKeyGenerator as keyGenerator} from './utils/key-generator'
 export {PortableTextEditor} from './editor/PortableTextEditor'
 export type {PortableTextEditorProps} from './editor/PortableTextEditor'
 export type {EditorEmittedEvent, MutationEvent} from './editor/relay-machine'

package/src/internal-utils/applyPatch.ts

@@ -18,10 +18,10 @@ import {
 import type {Path, PortableTextBlock, PortableTextChild} from '@sanity/types'
 import {Element, Node, Text, Transforms, type Descendant} from 'slate'
 import type {EditorSchema} from '../editor/editor-schema'
+import {KEY_TO_SLATE_ELEMENT} from '../editor/weakMaps'
 import type {PortableTextSlateEditor} from '../types/editor'
-import {isKeyedSegment} from '../utils'
+import {isKeyedSegment} from '../utils/util.is-keyed-segment'
 import {isEqualToEmptyEditor, toSlateValue} from './values'
-import {KEY_TO_SLATE_ELEMENT} from './weakMaps'
 
 /**
  * Creates a function that can apply a patch onto a PortableTextSlateEditor.

package/src/internal-utils/build-index-maps.test.ts

@@ -1,7 +1,7 @@
 import {compileSchema, defineSchema} from '@portabletext/schema'
 import type {PortableTextBlock} from '@sanity/types'
 import {describe, expect, test} from 'vitest'
-import {defaultKeyGenerator} from '../editor/key-generator'
+import {defaultKeyGenerator} from '../utils/key-generator'
 import {buildIndexMaps} from './build-index-maps'
 
 function blockObject(_key: string, name: string) {

package/src/internal-utils/create-test-snapshot.ts

@@ -1,6 +1,6 @@
 import {compileSchema, defineSchema} from '@portabletext/schema'
 import {createTestKeyGenerator} from '@portabletext/test'
-import type {EditorSnapshot} from '..'
+import type {EditorSnapshot} from '../editor/editor-snapshot'
 
 export function createTestSnapshot(snapshot: {
   context?: Partial<EditorSnapshot['context']>

package/src/internal-utils/event-position.ts

@@ -1,10 +1,12 @@
 import {Editor, type BaseRange, type Node} from 'slate'
 import {DOMEditor, isDOMNode} from 'slate-dom'
-import type {EditorSchema, EditorSelection} from '..'
 import type {EditorActor} from '../editor/editor-machine'
-import {getBlockKeyFromSelectionPoint} from '../selection/selection-point'
-import type {PortableTextSlateEditor} from '../types/editor'
-import * as utils from '../utils'
+import type {EditorSchema} from '../editor/editor-schema'
+import type {EditorSelection, PortableTextSlateEditor} from '../types/editor'
+import {getBlockEndPoint} from '../utils/util.get-block-end-point'
+import {getBlockStartPoint} from '../utils/util.get-block-start-point'
+import {isSelectionCollapsed} from '../utils/util.is-selection-collapsed'
+import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
 import {
   getFirstBlock,
   getLastBlock,
@@ -69,14 +71,14 @@ export function getEventPosition({
       block: eventPositionBlock,
       isEditor: false,
       selection: {
-        anchor: utils.getBlockStartPoint({
+        anchor: getBlockStartPoint({
           context: editorActor.getSnapshot().context,
           block: {
             node: eventBlock,
             path: [{_key: eventBlock._key}],
           },
         }),
-        focus: utils.getBlockEndPoint({
+        focus: getBlockEndPoint({
           context: editorActor.getSnapshot().context,
           block: {
             node: eventBlock,
@@ -100,7 +102,7 @@ export function getEventPosition({
   }
 
   if (
-    utils.isSelectionCollapsed(eventSelection) &&
+    isSelectionCollapsed(eventSelection) &&
     eventBlock &&
     eventSelectionFocusBlockKey !== eventBlock._key
   ) {
@@ -110,14 +112,14 @@ export function getEventPosition({
       block: eventPositionBlock,
       isEditor: false,
       selection: {
-        anchor: utils.getBlockStartPoint({
+        anchor: getBlockStartPoint({
           context: editorActor.getSnapshot().context,
           block: {
             node: eventBlock,
             path: [{_key: eventBlock._key}],
           },
         }),
-        focus: utils.getBlockEndPoint({
+        focus: getBlockEndPoint({
           context: editorActor.getSnapshot().context,
           block: {
             node: eventBlock,

package/src/internal-utils/operation-to-patches.test.ts

@@ -5,9 +5,9 @@ import {createEditor, type Descendant} from 'slate'
 import {beforeEach, describe, expect, it} from 'vitest'
 import {createActor} from 'xstate'
 import {editorMachine} from '../editor/editor-machine'
-import {defaultKeyGenerator} from '../editor/key-generator'
 import {withPlugins} from '../editor/plugins/with-plugins'
 import {relayMachine} from '../editor/relay-machine'
+import {defaultKeyGenerator} from '../utils/key-generator'
 import {
   insertNodePatch,
   insertTextPatch,

package/src/internal-utils/portable-text-node.ts

@@ -1,5 +1,5 @@
 import type {EditorSchema} from '../editor/editor-schema'
-import {isTypedObject} from './asserters'
+import {isTypedObject} from '../utils/asserters'
 
 type Path = Array<number>
 

package/src/internal-utils/selection-block-keys.ts

@@ -1,5 +1,5 @@
-import {getBlockKeyFromSelectionPoint} from '../selection/selection-point'
 import type {EditorSelection} from '../types/editor'
+import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
 
 export function getSelectionBlockKeys(selection: EditorSelection) {
   if (!selection) {

package/src/internal-utils/selection-focus-text.ts

@@ -3,7 +3,7 @@ import type {EditorContext} from '../editor/editor-snapshot'
 import {
   getBlockKeyFromSelectionPoint,
   getChildKeyFromSelectionPoint,
-} from '../selection/selection-point'
+} from '../utils/util.selection-point'
 
 export function getSelectionFocusText(
   context: Pick<EditorContext, 'schema' | 'value' | 'selection'>,

package/src/internal-utils/to-slate-range.ts

@@ -2,13 +2,13 @@ import {isSpan, isTextBlock} from '@portabletext/schema'
 import type {PortableTextObject, PortableTextSpan} from '@sanity/types'
 import type {Path, Range} from 'slate'
 import type {EditorContext, EditorSnapshot} from '../editor/editor-snapshot'
+import type {EditorSelectionPoint} from '../types/editor'
+import {blockOffsetToSpanSelectionPoint} from '../utils/util.block-offset'
+import {isEqualSelectionPoints} from '../utils/util.is-equal-selection-points'
 import {
   getBlockKeyFromSelectionPoint,
   getChildKeyFromSelectionPoint,
-} from '../selection/selection-point'
-import type {EditorSelectionPoint} from '../types/editor'
-import {isEqualSelectionPoints} from '../utils'
-import {blockOffsetToSpanSelectionPoint} from '../utils/util.block-offset'
+} from '../utils/util.selection-point'
 
 export function toSlateRange(
   snapshot: {

package/src/operations/behavior.operation.annotation.add.ts

@@ -1,5 +1,5 @@
 import {Editor, Node, Range, Text, Transforms} from 'slate'
-import {parseAnnotation} from '../internal-utils/parse-blocks'
+import {parseAnnotation} from '../utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const addAnnotationOperationImplementation: BehaviorOperationImplementation<

package/src/operations/behavior.operation.block.set.ts

@@ -1,6 +1,6 @@
 import {Transforms, type Element as SlateElement} from 'slate'
-import {parseBlock} from '../internal-utils/parse-blocks'
 import {toSlateValue} from '../internal-utils/values'
+import {parseBlock} from '../utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const blockSetOperationImplementation: BehaviorOperationImplementation<

package/src/operations/behavior.operation.block.unset.ts

@@ -1,10 +1,10 @@
 import {isTextBlock} from '@portabletext/schema'
 import {omit} from 'lodash'
 import {Editor, Transforms} from 'slate'
-import {parseBlock} from '../internal-utils/parse-blocks'
+import {KEY_TO_VALUE_ELEMENT} from '../editor/weakMaps'
 import {toSlateRange} from '../internal-utils/to-slate-range'
 import {fromSlateValue} from '../internal-utils/values'
-import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
+import {parseBlock} from '../utils/parse-blocks'
 import type {BehaviorOperationImplementation} from './behavior.operations'
 
 export const blockUnsetOperationImplementation: BehaviorOperationImplementation<