@portabletext/editor 1.12.2 → 1.13.0

package/lib/index.js

@@ -1,15 +1,127 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var types = require("@sanity/types"), schema = require("@sanity/schema"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), throttle = require("lodash/throttle.js"), debounce = require("lodash/debounce.js"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), getRandomValues = require("get-random-values-esm"), xstate = require("xstate"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools");
+var types = require("@sanity/types"), schema = require("@sanity/schema"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), throttle = require("lodash/throttle.js"), debounce = require("lodash/debounce.js"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), getRandomValues = require("get-random-values-esm"), xstate = require("xstate"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), blockTools = require("@sanity/block-tools");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
 var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$m), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy);
+const IS_MAC = typeof window < "u" && /Mac|iPod|iPhone|iPad/.test(window.navigator.userAgent), modifiers = {
+  alt: "altKey",
+  control: "ctrlKey",
+  meta: "metaKey",
+  shift: "shiftKey"
+}, aliases = {
+  add: "+",
+  break: "pause",
+  cmd: "meta",
+  command: "meta",
+  ctl: "control",
+  ctrl: "control",
+  del: "delete",
+  down: "arrowdown",
+  esc: "escape",
+  ins: "insert",
+  left: "arrowleft",
+  mod: IS_MAC ? "meta" : "control",
+  opt: "alt",
+  option: "alt",
+  return: "enter",
+  right: "arrowright",
+  space: " ",
+  spacebar: " ",
+  up: "arrowup",
+  win: "meta",
+  windows: "meta"
+}, keyCodes = {
+  backspace: 8,
+  tab: 9,
+  enter: 13,
+  shift: 16,
+  control: 17,
+  alt: 18,
+  pause: 19,
+  capslock: 20,
+  escape: 27,
+  " ": 32,
+  pageup: 33,
+  pagedown: 34,
+  end: 35,
+  home: 36,
+  arrowleft: 37,
+  arrowup: 38,
+  arrowright: 39,
+  arrowdown: 40,
+  insert: 45,
+  delete: 46,
+  meta: 91,
+  numlock: 144,
+  scrolllock: 145,
+  ";": 186,
+  "=": 187,
+  ",": 188,
+  "-": 189,
+  ".": 190,
+  "/": 191,
+  "`": 192,
+  "[": 219,
+  "\\": 220,
+  "]": 221,
+  "'": 222,
+  f1: 112,
+  f2: 113,
+  f3: 114,
+  f4: 115,
+  f5: 116,
+  f6: 117,
+  f7: 118,
+  f8: 119,
+  f9: 120,
+  f10: 121,
+  f11: 122,
+  f12: 123,
+  f13: 124,
+  f14: 125,
+  f15: 126,
+  f16: 127,
+  f17: 128,
+  f18: 129,
+  f19: 130,
+  f20: 131
+};
+function isHotkey(hotkey, event) {
+  return compareHotkey(parseHotkey(hotkey), event);
+}
+function parseHotkey(hotkey) {
+  const parsedHotkey = {
+    altKey: !1,
+    ctrlKey: !1,
+    metaKey: !1,
+    shiftKey: !1
+  }, hotkeySegments = hotkey.replace("++", "+add").split("+");
+  for (const rawHotkeySegment of hotkeySegments) {
+    const optional = rawHotkeySegment.endsWith("?") && rawHotkeySegment.length > 1, hotkeySegment = optional ? rawHotkeySegment.slice(0, -1) : rawHotkeySegment, keyName = toKeyName(hotkeySegment), modifier = modifiers[keyName], alias = aliases[hotkeySegment], code = keyCodes[keyName];
+    if (hotkeySegment.length > 1 && modifier === void 0 && alias === void 0 && code === void 0)
+      throw new TypeError(`Unknown modifier: "${hotkeySegment}"`);
+    (hotkeySegments.length === 1 || modifier === void 0) && (parsedHotkey.key = keyName, parsedHotkey.keyCode = toKeyCode(hotkeySegment)), modifier !== void 0 && (parsedHotkey[modifier] = optional ? null : !0);
+  }
+  return parsedHotkey;
+}
+function compareHotkey(parsedHotkey, event) {
+  return (parsedHotkey.altKey == null || parsedHotkey.altKey === event.altKey) && (parsedHotkey.ctrlKey == null || parsedHotkey.ctrlKey === event.ctrlKey) && (parsedHotkey.metaKey == null || parsedHotkey.metaKey === event.metaKey) && (parsedHotkey.shiftKey == null || parsedHotkey.shiftKey === event.shiftKey) ? parsedHotkey.keyCode !== void 0 && event.keyCode !== void 0 ? parsedHotkey.keyCode === 91 && event.keyCode === 93 ? !0 : parsedHotkey.keyCode === event.keyCode : parsedHotkey.keyCode === event.keyCode || parsedHotkey.key === event.key.toLowerCase() : !1;
+}
+function toKeyCode(name) {
+  const keyName = toKeyName(name);
+  return keyCodes[keyName] ?? keyName.toUpperCase().charCodeAt(0);
+}
+function toKeyName(name) {
+  const keyName = name.toLowerCase();
+  return aliases[keyName] ?? keyName;
+}
 function defineBehavior(behavior) {
   return behavior;
 }
 function selectionIsCollapsed(context) {
-  return context.selection?.anchor.path.join() === context.selection?.focus.path.join() && context.selection?.anchor.offset === context.selection?.focus.offset;
+  return JSON.stringify(context.selection?.anchor.path) === JSON.stringify(context.selection?.focus.path) && context.selection?.anchor.offset === context.selection?.focus.offset;
 }
 function getFocusBlock(context) {
   const key = context.selection && types.isKeySegment(context.selection.focus.path[0]) ? context.selection.focus.path[0]._key : void 0, node = key ? context.value.find((block) => block._key === key) : void 0;
@@ -125,11 +237,42 @@ function isEmptyTextBlock(block) {
 function getTextBlockText(block) {
   return block.children.map((child) => child.text ?? "").join("");
 }
-const breakingBlockObject = {
+const arrowDownOnLonelyBlockObject = {
+  on: "key.down",
+  guard: ({
+    context,
+    event
+  }) => {
+    const isArrowDown = isHotkey("ArrowDown", event.keyboardEvent), focusBlockObject = getFocusBlockObject(context), nextBlock = getNextBlock(context);
+    return isArrowDown && focusBlockObject && !nextBlock;
+  },
+  actions: [() => [{
+    type: "insert text block",
+    placement: "after"
+  }]]
+}, arrowUpOnLonelyBlockObject = {
+  on: "key.down",
+  guard: ({
+    context,
+    event
+  }) => {
+    const isArrowUp = isHotkey("ArrowUp", event.keyboardEvent), focusBlockObject = getFocusBlockObject(context), previousBlock = getPreviousBlock(context);
+    return isArrowUp && focusBlockObject && !previousBlock;
+  },
+  actions: [() => [{
+    type: "insert text block",
+    placement: "before"
+  }, {
+    type: "select previous block"
+  }]]
+}, breakingBlockObject = {
   on: "insert break",
   guard: ({
     context
-  }) => !!getFocusBlockObject(context),
+  }) => {
+    const focusBlockObject = getFocusBlockObject(context);
+    return selectionIsCollapsed(context) && focusBlockObject !== void 0;
+  },
   actions: [() => [{
     type: "insert text block",
     placement: "after"
@@ -195,6 +338,8 @@ const breakingBlockObject = {
     }
   }]]
 }, coreBlockObjectBehaviors = {
+  arrowDownOnLonelyBlockObject,
+  arrowUpOnLonelyBlockObject,
   breakingBlockObject,
   deletingEmptyTextBlockAfterBlockObject,
   deletingEmptyTextBlockBeforeBlockObject
@@ -278,7 +423,7 @@ const breakingBlockObject = {
     text: `
 `
   }]]
-}, coreBehaviors = [softReturn, coreDecoratorBehaviors.decoratorAdd, coreDecoratorBehaviors.decoratorRemove, coreDecoratorBehaviors.decoratorToggle, coreBlockObjectBehaviors.breakingBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject, coreListBehaviors.clearListOnBackspace, coreListBehaviors.unindentListOnBackspace], coreBehavior = {
+}, coreBehaviors = [softReturn, coreDecoratorBehaviors.decoratorAdd, coreDecoratorBehaviors.decoratorRemove, coreDecoratorBehaviors.decoratorToggle, coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject, coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject, coreBlockObjectBehaviors.breakingBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject, coreListBehaviors.clearListOnBackspace, coreListBehaviors.unindentListOnBackspace], coreBehavior = {
   softReturn,
   decorators: coreDecoratorBehaviors,
   blockObjects: coreBlockObjectBehaviors,
@@ -291,7 +436,7 @@ function createLinkBehaviors(config) {
       context,
       event
     }) => {
-      const selectionCollapsed = selectionIsCollapsed(context), text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
+      const selectionCollapsed = selectionIsCollapsed(context), text = event.data.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
         url,
         schema: context.schema
       }) : void 0;
@@ -314,7 +459,7 @@ function createLinkBehaviors(config) {
       const focusSpan = getFocusSpan(context), selectionCollapsed = selectionIsCollapsed(context);
       if (!focusSpan || !selectionCollapsed)
         return !1;
-      const text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
+      const text = event.data.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
         url,
         schema: context.schema
       }) : void 0;
@@ -590,7 +735,7 @@ function createMarkdownBehaviors(config) {
       context,
       event
     }) => {
-      const text = event.clipboardData.getData("text/plain"), hrRegExp = /^(---)$|(___)$|(\*\*\*)$/gm, hrCharacters = text.match(hrRegExp)?.[0], hrObject = config.horizontalRuleObject?.({
+      const text = event.data.getData("text/plain"), hrRegExp = /^(---)$|(___)$|(\*\*\*)$/gm, hrCharacters = text.match(hrRegExp)?.[0], hrObject = config.horizontalRuleObject?.({
         schema: context.schema
       }), focusBlock = getFocusBlock(context);
       return !hrCharacters || !hrObject || !focusBlock ? !1 : {
@@ -786,6 +931,53 @@ function createMarkdownBehaviors(config) {
   };
   return [automaticBlockquoteOnSpace, automaticHeadingOnSpace, automaticHr, automaticHrOnPaste, clearStyleOnBackspace, automaticListOnSpace];
 }
+function createCodeEditorBehaviors(config) {
+  return [{
+    on: "key.down",
+    guard: ({
+      context,
+      event
+    }) => {
+      if (!isHotkey(config.moveBlockUpShortcut, event.keyboardEvent) || !selectionIsCollapsed(context))
+        return !1;
+      const focusBlock = getFocusBlock(context), previousBlock = getPreviousBlock(context);
+      return focusBlock && previousBlock ? {
+        focusBlock,
+        previousBlock
+      } : !1;
+    },
+    actions: [(_, {
+      focusBlock,
+      previousBlock
+    }) => [{
+      type: "move block",
+      blockPath: focusBlock.path,
+      to: previousBlock.path
+    }]]
+  }, {
+    on: "key.down",
+    guard: ({
+      context,
+      event
+    }) => {
+      if (!isHotkey(config.moveBlockDownShortcut, event.keyboardEvent) || !selectionIsCollapsed(context))
+        return !1;
+      const focusBlock = getFocusBlock(context), nextBlock = getNextBlock(context);
+      return focusBlock && nextBlock ? {
+        focusBlock,
+        nextBlock
+      } : !1;
+    },
+    actions: [(_, {
+      focusBlock,
+      nextBlock
+    }) => [{
+      type: "move block",
+      blockPath: focusBlock.path,
+      to: nextBlock.path
+    }]]
+  }];
+}
 function getPortableTextMemberSchemaTypes(portableTextType) {
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
@@ -5417,43 +5609,31 @@ const addAnnotationActionImplementation = ({
     at: editor.selection.focus,
     match: (n) => editor.isTextSpan(n),
     voids: !1
-  }))[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter((mark) => schema2.decorators.some((decorator) => decorator.value === mark)) ?? [], focusAnnotations = focusSpan.marks?.filter((mark) => !schema2.decorators.some((decorator) => decorator.value === mark)) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+  }))[0] ?? [void 0], focusDecorators = focusSpan?.marks?.filter((mark) => schema2.decorators.some((decorator) => decorator.value === mark)) ?? [], focusAnnotations = focusSpan?.marks?.filter((mark) => !schema2.decorators.some((decorator) => decorator.value === mark)) ?? [], anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock)) {
-    const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
+    const [start, end] = slate.Range.edges(editor.selection), lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual__default.default(start, {
+      path: [...focusBlockPath, focusBlock.children.length - 1],
+      offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
+    }), atTheStartOfBlock = isEqual__default.default(end, {
       path: [...focusBlockPath, 0],
       offset: 0
     });
-    if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
+    if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
       slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
-        decorators: focusAnnotations.length === 0 ? focusDecorators : [],
+        decorators: [],
         listItem: focusBlock.listItem,
         level: focusBlock.level
       }));
-      const [nextBlockPath] = slate.Path.next(focusBlockPath);
-      slate.Transforms.select(editor, {
-        anchor: {
-          path: [nextBlockPath, 0],
-          offset: 0
-        },
-        focus: {
-          path: [nextBlockPath, 0],
-          offset: 0
-        }
-      });
       return;
     }
-    const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual__default.default(start, {
-      path: [...focusBlockPath, focusBlock.children.length - 1],
-      offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
-    });
-    if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
+    if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
       slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
-        decorators: [],
+        decorators: focusAnnotations.length === 0 ? focusDecorators : [],
         listItem: focusBlock.listItem,
         level: focusBlock.level
       }));
       const [nextBlockPath] = slate.Path.next(focusBlockPath);
-      slate.Transforms.setSelection(editor, {
+      slate.Transforms.select(editor, {
         anchor: {
           path: [nextBlockPath, 0],
           offset: 0
@@ -5465,7 +5645,8 @@ const addAnnotationActionImplementation = ({
       });
       return;
     }
-    if (!atTheStartOfBlock && !atTheEndOfBlock) {
+    const selectionAcrossBlocks = anchorBlockPath[0] !== focusBlockPath[0];
+    if (!atTheStartOfBlock && !atTheEndOfBlock && !selectionAcrossBlocks) {
       slate.Editor.withoutNormalizing(editor, () => {
         if (!editor.selection)
           return;
@@ -5514,6 +5695,9 @@ const addAnnotationActionImplementation = ({
       return;
     }
   }
+  slate.Transforms.splitNodes(editor, {
+    always: !0
+  });
 }, insertSoftBreakActionImplementation = ({
   context,
   action
@@ -5614,6 +5798,8 @@ const addAnnotationActionImplementation = ({
       });
     }
   },
+  copy: () => {
+  },
   "delete backward": ({
     action
   }) => {
@@ -5713,10 +5899,48 @@ const addAnnotationActionImplementation = ({
   }) => {
     action.effect();
   },
-  paste: ({
+  "key.down": () => {
+  },
+  "key.up": () => {
+  },
+  "move block": ({
     action
   }) => {
-    action.editor.insertData(action.clipboardData);
+    const location = toSlateRange({
+      anchor: {
+        path: action.blockPath,
+        offset: 0
+      },
+      focus: {
+        path: action.blockPath,
+        offset: 0
+      }
+    }, action.editor);
+    if (!location) {
+      console.error("Unable to find Slate range from selection points");
+      return;
+    }
+    const newLocation = toSlateRange({
+      anchor: {
+        path: action.to,
+        offset: 0
+      },
+      focus: {
+        path: action.to,
+        offset: 0
+      }
+    }, action.editor);
+    if (!newLocation) {
+      console.error("Unable to find Slate range from selection points");
+      return;
+    }
+    slate.Transforms.moveNodes(action.editor, {
+      at: location,
+      to: newLocation.anchor.path.slice(0, 1),
+      mode: "highest"
+    });
+  },
+  paste: () => {
   },
   select: ({
     action
@@ -5724,6 +5948,31 @@ const addAnnotationActionImplementation = ({
     const newSelection = toSlateRange(action.selection, action.editor);
     newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
   },
+  "select previous block": ({
+    action
+  }) => {
+    if (!action.editor.selection) {
+      console.error("Unable to select previous block without a selection");
+      return;
+    }
+    const blockPath = action.editor.selection.focus.path.slice(0, 1);
+    if (!slate.Path.hasPrevious(blockPath)) {
+      console.error("There's no previous block to select");
+      return;
+    }
+    const previousBlockPath = slate.Path.previous(blockPath);
+    slate.Transforms.select(action.editor, previousBlockPath);
+  },
+  "select next block": ({
+    action
+  }) => {
+    if (!action.editor.selection) {
+      console.error("Unable to select next block without a selection");
+      return;
+    }
+    const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1];
+    slate.Transforms.select(action.editor, nextBlockPath);
+  },
   reselect: ({
     action
   }) => {
@@ -5775,6 +6024,13 @@ function performAction({
       });
       break;
     }
+    case "move block": {
+      behaviorActionImplementations["move block"]({
+        context,
+        action
+      });
+      break;
+    }
     case "set block": {
       behaviorActionImplementations["set block"]({
         context,
@@ -5803,6 +6059,20 @@ function performAction({
       });
       break;
     }
+    case "select previous block": {
+      behaviorActionImplementations["select previous block"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "select next block": {
+      behaviorActionImplementations["select next block"]({
+        context,
+        action
+      });
+      break;
+    }
     case "reselect": {
       behaviorActionImplementations.reselect({
         context,
@@ -5843,6 +6113,8 @@ function performDefaultAction({
       });
       break;
     }
+    case "copy":
+      break;
     case "decorator.add": {
       behaviorActionImplementations["decorator.add"]({
         context,
@@ -5906,11 +6178,6 @@ function performDefaultAction({
       });
       break;
     }
-    default:
-      behaviorActionImplementations.paste({
-        context,
-        action
-      });
   }
 }
 const editorMachine = xstate.setup({
@@ -5987,10 +6254,10 @@ const editorMachine = xstate.setup({
       };
       let behaviorOverwritten = !1;
       for (const eventBehavior of eventBehaviors) {
-        const shouldRun = eventBehavior.guard?.({
+        const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
           context: behaviorContext,
           event: event.behaviorEvent
-        }) ?? !0;
+        });
         if (!shouldRun)
           continue;
         const actionIntendSets = eventBehavior.actions.map((actionSet) => actionSet({
@@ -6003,8 +6270,10 @@ const editorMachine = xstate.setup({
             editor: event.editor,
             actionIntends
           });
-        if (behaviorOverwritten)
+        if (behaviorOverwritten) {
+          event.nativeEvent?.preventDefault();
           break;
+        }
       }
       behaviorOverwritten || enqueue.raise({
         type: "behavior action intends",
@@ -6621,7 +6890,7 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
           for (const hotkey in activeHotkeys[cat]) {
             if (reservedHotkeys.includes(hotkey))
               throw new Error(`The hotkey ${hotkey} is reserved!`);
-            if (isHotkeyEsm.isHotkey(hotkey, event.nativeEvent)) {
+            if (isHotkey(hotkey, event.nativeEvent)) {
               event.preventDefault();
               const possibleMark = activeHotkeys[cat];
               if (possibleMark) {
@@ -6641,7 +6910,7 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
           for (const hotkey in activeHotkeys[cat]) {
             if (reservedHotkeys.includes(hotkey))
               throw new Error(`The hotkey ${hotkey} is reserved!`);
-            if (isHotkeyEsm.isHotkey(hotkey, event.nativeEvent)) {
+            if (isHotkey(hotkey, event.nativeEvent)) {
               const possibleCommand = activeHotkeys[cat];
               if (possibleCommand) {
                 const command = possibleCommand[hotkey];
@@ -6650,38 +6919,7 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
             }
           }
       });
-      const isEnter = isHotkeyEsm.isHotkey("enter", event.nativeEvent), isTab = isHotkeyEsm.isHotkey("tab", event.nativeEvent), isShiftEnter = isHotkeyEsm.isHotkey("shift+enter", event.nativeEvent), isShiftTab = isHotkeyEsm.isHotkey("shift+tab", event.nativeEvent), isArrowDown = isHotkeyEsm.isHotkey("down", event.nativeEvent), isArrowUp = isHotkeyEsm.isHotkey("up", event.nativeEvent);
-      if (isArrowDown && editor.selection) {
-        const focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
-          const nextPath = slate.Path.next(editor.selection.focus.path.slice(0, 1));
-          if (!slate.Node.has(editor, nextPath)) {
-            slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({
-              decorators: []
-            }), {
-              at: nextPath
-            }), slate.Transforms.select(editor, {
-              path: [...nextPath, 0],
-              offset: 0
-            }), editor.onChange();
-            return;
-          }
-        }
-      }
-      if (isArrowUp && editor.selection) {
-        const isFirstBlock = editor.selection.focus.path[0] === 0, focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (isFirstBlock && focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
-          slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({
-            decorators: []
-          }), {
-            at: [0]
-          }), slate.Transforms.select(editor, {
-            path: [0, 0],
-            offset: 0
-          }), editor.onChange();
-          return;
-        }
-      }
+      const isEnter = isHotkey("enter", event.nativeEvent), isTab = isHotkey("tab", event.nativeEvent), isShiftEnter = isHotkey("shift+enter", event.nativeEvent), isShiftTab = isHotkey("shift+tab", event.nativeEvent);
       if ((isTab || isShiftTab) && editor.selection) {
         const [focusChild] = slate.Editor.node(editor, editor.selection.focus, {
           depth: 2
@@ -7028,8 +7266,16 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     return () => teardown();
   }, [slateEditor, syncRangeDecorations]);
   const handleCopy = React.useCallback((event) => {
-    onCopy && onCopy(event) !== void 0 && event.preventDefault();
-  }, [onCopy]), handlePaste = React.useCallback((event_0) => {
+    onCopy ? onCopy(event) !== void 0 && event.preventDefault() : event.nativeEvent.clipboardData && editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "copy",
+        data: event.nativeEvent.clipboardData
+      },
+      editor: slateEditor,
+      nativeEvent: event
+    });
+  }, [onCopy, editorActor, slateEditor]), handlePaste = React.useCallback((event_0) => {
     const value_0 = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(value_0, slateEditor.selection, schemaTypes)?.focus.path || [], onPasteResult = onPaste?.({
       event: event_0,
       value: value_0,
@@ -7046,14 +7292,15 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       editorActor.send({
         type: "done loading"
       });
-    })) : event_0.nativeEvent.clipboardData && (event_0.preventDefault(), editorActor.send({
+    })) : event_0.nativeEvent.clipboardData && editorActor.send({
       type: "behavior event",
       behaviorEvent: {
         type: "paste",
-        clipboardData: event_0.nativeEvent.clipboardData
+        data: event_0.nativeEvent.clipboardData
       },
-      editor: slateEditor
-    })), debug("No result from custom paste handler, pasting normally");
+      editor: slateEditor,
+      nativeEvent: event_0
+    }), debug("No result from custom paste handler, pasting normally");
   }, [editorActor, onPaste, portableTextEditor, schemaTypes, slateEditor]), handleOnFocus = React.useCallback((event_1) => {
     if (onFocus && onFocus(event_1), !event_1.isDefaultPrevented()) {
       const selection = PortableTextEditor.getSelection(portableTextEditor);
@@ -7114,8 +7361,40 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     }
   }, [validateSelection, editableElement]);
   const handleKeyDown = React.useCallback((event_5) => {
-    props.onKeyDown && props.onKeyDown(event_5), event_5.isDefaultPrevented() || slateEditor.pteWithHotKeys(event_5);
-  }, [props, slateEditor]), scrollSelectionIntoViewToSlate = React.useMemo(() => {
+    props.onKeyDown && props.onKeyDown(event_5), event_5.isDefaultPrevented() || slateEditor.pteWithHotKeys(event_5), event_5.isDefaultPrevented() || editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "key.down",
+        keyboardEvent: {
+          key: event_5.key,
+          code: event_5.code,
+          altKey: event_5.altKey,
+          ctrlKey: event_5.ctrlKey,
+          metaKey: event_5.metaKey,
+          shiftKey: event_5.shiftKey
+        }
+      },
+      editor: slateEditor,
+      nativeEvent: event_5
+    });
+  }, [props, editorActor, slateEditor]), handleKeyUp = React.useCallback((event_6) => {
+    props.onKeyUp && props.onKeyUp(event_6), event_6.isDefaultPrevented() || editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "key.up",
+        keyboardEvent: {
+          key: event_6.key,
+          code: event_6.code,
+          altKey: event_6.altKey,
+          ctrlKey: event_6.ctrlKey,
+          metaKey: event_6.metaKey,
+          shiftKey: event_6.shiftKey
+        }
+      },
+      editor: slateEditor,
+      nativeEvent: event_6
+    });
+  }, [props, editorActor, slateEditor]), scrollSelectionIntoViewToSlate = React.useMemo(() => {
     if (scrollSelectionIntoView !== void 0)
       return scrollSelectionIntoView === null ? noop__default.default : (_editor, domRange) => {
         scrollSelectionIntoView(portableTextEditor, domRange);
@@ -7162,6 +7441,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       onDOMBeforeInput: handleOnBeforeInput,
       onFocus: handleOnFocus,
       onKeyDown: handleKeyDown,
+      onKeyUp: handleKeyUp,
       onPaste: handlePaste,
       readOnly,
       renderPlaceholder: void 0,
@@ -7225,6 +7505,7 @@ exports.PortableTextEditable = PortableTextEditable;
 exports.PortableTextEditor = PortableTextEditor;
 exports.coreBehavior = coreBehavior;
 exports.coreBehaviors = coreBehaviors;
+exports.createCodeEditorBehaviors = createCodeEditorBehaviors;
 exports.createLinkBehaviors = createLinkBehaviors;
 exports.createMarkdownBehaviors = createMarkdownBehaviors;
 exports.defineBehavior = defineBehavior;