@prosekit/extensions 0.0.0-next-20231120040948 → 0.0.0-next-20240421132240

package/dist/chunk-ASTUC4KT.js

@@ -0,0 +1,111 @@
+// src/enter-rule/index.ts
+import {
+  Facet,
+  OBJECT_REPLACEMENT_CHARACTER,
+  getNodeType,
+  isTextSelection,
+  pluginFacet
+} from "@prosekit/core";
+import { keydownHandler } from "@prosekit/pm/keymap";
+import {
+  ProseMirrorPlugin
+} from "@prosekit/pm/state";
+function defineEnterRule({
+  regex,
+  handler,
+  stop = false
+}) {
+  const rule = new EnterRule(regex, handler, stop);
+  return enterRule.extension([rule]);
+}
+function defineTextBlockEnterRule({
+  regex,
+  type,
+  attrs,
+  stop = true
+}) {
+  return defineEnterRule({
+    regex,
+    handler: ({ state, from, to, match }) => {
+      const nodeType = getNodeType(state.schema, type);
+      const $start = state.doc.resolve(from);
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
+        return null;
+      }
+      const nodeAttrs = attrs && typeof attrs === "function" ? attrs(match) : attrs;
+      return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
+    },
+    stop
+  });
+}
+var EnterRule = class {
+  constructor(regex, handler, stop) {
+    this.regex = regex;
+    this.handler = handler;
+    this.stop = stop;
+  }
+};
+var enterRule = Facet.define({
+  converter: () => {
+    let rules = [];
+    const command = (state, dispatch, view) => {
+      if (!view)
+        return false;
+      return execRules(view, rules, dispatch);
+    };
+    const handler = keydownHandler({ Enter: command });
+    const plugin = new ProseMirrorPlugin({ props: { handleKeyDown: handler } });
+    const pluginFunc = () => [plugin];
+    return {
+      create: (inputs) => {
+        rules = inputs;
+        return pluginFunc;
+      },
+      update: (inputs) => {
+        rules = inputs;
+        return null;
+      }
+    };
+  },
+  next: pluginFacet
+});
+function execRules(view, rules, dispatch) {
+  if (view.composing)
+    return false;
+  const state = view.state;
+  const selection = state.selection;
+  if (!isTextSelection(selection))
+    return false;
+  const $cursor = selection.$cursor;
+  if (!$cursor || $cursor.parent.type.spec.code)
+    return false;
+  const textBefore = $cursor.parent.textBetween(
+    Math.max(0, $cursor.parentOffset - MAX_MATCH),
+    $cursor.parentOffset,
+    null,
+    OBJECT_REPLACEMENT_CHARACTER
+  );
+  for (const rule of rules) {
+    rule.regex.lastIndex = 0;
+    const match = rule.regex.exec(textBefore);
+    const tr = match && rule.handler({
+      state,
+      from: $cursor.pos - match[0].length,
+      to: $cursor.pos,
+      match
+    });
+    if (!tr)
+      continue;
+    dispatch == null ? void 0 : dispatch(tr);
+    if (rule.stop) {
+      return true;
+    }
+  }
+  return false;
+}
+var MAX_MATCH = 200;
+
+export {
+  defineEnterRule,
+  defineTextBlockEnterRule
+};

package/dist/chunk-DYFRBXUX.js

@@ -0,0 +1,56 @@
+// src/input-rule/index.ts
+import {
+  Facet,
+  getNodeType,
+  pluginFacet
+} from "@prosekit/core";
+import {
+  inputRules,
+  textblockTypeInputRule,
+  wrappingInputRule
+} from "@prosekit/pm/inputrules";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function defineInputRule(rule) {
+  return inputRuleFacet.extension([() => rule]);
+}
+function defineTextBlockInputRule({
+  regex,
+  type,
+  attrs
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return textblockTypeInputRule(regex, nodeType, attrs);
+    }
+  ]);
+}
+function defineWrappingInputRule({
+  regex,
+  type,
+  attrs,
+  join
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return wrappingInputRule(regex, nodeType, attrs, join);
+    }
+  ]);
+}
+var inputRuleFacet = Facet.define({
+  convert: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
+
+export {
+  defineInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+};

package/dist/list/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-flat-list@0.4.3/node_modules/prosemirror-flat-list/dist/style.css */
+/* ../../node_modules/.pnpm/prosemirror-flat-list@0.5.0/node_modules/prosemirror-flat-list/dist/style.css */
 .prosemirror-flat-list {
   padding: 0;
   margin-top: 0;
@@ -25,25 +25,30 @@
 .prosemirror-flat-list[data-list-kind=bullet] {
   list-style: disc;
 }
+.prosemirror-flat-list[data-list-kind=ordered] {
+  counter-increment: prosemirror-flat-list-counter;
+}
+.prosemirror-flat-list[data-list-kind=ordered] > * {
+  contain: style;
+}
 .prosemirror-flat-list[data-list-kind=ordered]::before {
   position: absolute;
   right: 100%;
   font-variant-numeric: tabular-nums;
   content: counter(prosemirror-flat-list-counter, decimal) ". ";
 }
-@supports (-moz-appearance: none) {
-  .prosemirror-flat-list[data-list-kind=ordered] {
-    contain: style;
-    counter-increment: prosemirror-flat-list-counter;
-  }
+.prosemirror-flat-list[data-list-kind=ordered]:first-child,
+:not(.prosemirror-flat-list[data-list-kind=ordered]) + .prosemirror-flat-list[data-list-kind=ordered] {
+  counter-reset: prosemirror-flat-list-counter;
 }
-@supports not (-moz-appearance: none) {
-  .prosemirror-flat-list[data-list-kind=ordered] {
-    counter-reset: prosemirror-flat-list-counter;
-    counter-increment: prosemirror-flat-list-counter;
+@supports (counter-set: prosemirror-flat-list-counter 1) {
+  [data-list-order]:is(.prosemirror-flat-list[data-list-kind=ordered]:first-child, :not(.prosemirror-flat-list[data-list-kind=ordered]) + .prosemirror-flat-list[data-list-kind=ordered]) {
+    counter-set: prosemirror-flat-list-counter var(--prosemirror-flat-list-order);
   }
-  .prosemirror-flat-list[data-list-kind=ordered] + .prosemirror-flat-list[data-list-kind=ordered] {
-    counter-reset: none;
+}
+@supports not (counter-set: prosemirror-flat-list-counter 1) {
+  [data-list-order]:is(.prosemirror-flat-list[data-list-kind=ordered]:first-child, :not(.prosemirror-flat-list[data-list-kind=ordered]) + .prosemirror-flat-list[data-list-kind=ordered]) {
+    counter-increment: prosemirror-flat-list-counter var(--prosemirror-flat-list-order);
   }
 }
 .prosemirror-flat-list[data-list-kind=task] > .list-marker {

package/dist/prosekit-extensions-autocomplete.js

@@ -5,6 +5,7 @@ import {
 } from "@prosekit/core";
 
 // src/autocomplete/plugin.ts
+import { OBJECT_REPLACEMENT_CHARACTER } from "@prosekit/core";
 import { Plugin } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";
 
@@ -22,7 +23,6 @@ function isInsideCode($pos) {
   }
   return $pos.marks().some((mark) => mark.type.name === "code");
 }
-var OBJECT_REPLACEMENT = "\uFFFC";
 function getPluginState(state) {
   return pluginKey.getState(state);
 }
@@ -75,10 +75,14 @@ function createAutocompletePlugin({
           const textContent = view.state.doc.textBetween(
             from,
             to,
-            OBJECT_REPLACEMENT
+            OBJECT_REPLACEMENT_CHARACTER
           );
           const deleteMatch = () => {
-            if (view.state.doc.textBetween(from, to, OBJECT_REPLACEMENT) === textContent) {
+            if (view.state.doc.textBetween(
+              from,
+              to,
+              OBJECT_REPLACEMENT_CHARACTER
+            ) === textContent) {
               view.dispatch(view.state.tr.delete(from, to));
             }
           };
@@ -125,7 +129,7 @@ function calcPluginState(state, rules) {
     Math.max(0, parentOffset - MAX_MATCH),
     parentOffset,
     null,
-    OBJECT_REPLACEMENT
+    OBJECT_REPLACEMENT_CHARACTER
   );
   for (const rule of rules) {
     if (!rule.canMatch({ state })) {

package/dist/prosekit-extensions-blockquote.d.ts

@@ -1,2 +1,3 @@
 export { defineBlockquoteSpec } from './_tsup-dts-rollup';
+export { defineBlockquoteInputRule } from './_tsup-dts-rollup';
 export { defineBlockquote } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-blockquote.js

@@ -1,3 +1,7 @@
+import {
+  defineWrappingInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/blockquote/index.ts
 import { defineNodeSpec, union } from "@prosekit/core";
 function defineBlockquoteSpec() {
@@ -12,10 +16,17 @@ function defineBlockquoteSpec() {
     }
   });
 }
+function defineBlockquoteInputRule() {
+  return defineWrappingInputRule({
+    regex: /^>\s/,
+    type: "blockquote"
+  });
+}
 function defineBlockquote() {
-  return union([defineBlockquoteSpec()]);
+  return union([defineBlockquoteSpec(), defineBlockquoteInputRule()]);
 }
 export {
   defineBlockquote,
+  defineBlockquoteInputRule,
   defineBlockquoteSpec
 };

package/dist/prosekit-extensions-code-block.d.ts

@@ -1,5 +1,15 @@
-export { defineCodeBlockSpec } from './_tsup-dts-rollup';
-export { defineCodeBlockInputRule } from './_tsup-dts-rollup';
-export { defineCodeBlockCommands } from './_tsup-dts-rollup';
-export { defineCodeBlock } from './_tsup-dts-rollup';
+export { defineCodeBlock_alias_1 as defineCodeBlock } from './_tsup-dts-rollup';
+export { defineCodeBlockCommands_alias_1 as defineCodeBlockCommands } from './_tsup-dts-rollup';
+export { defineCodeBlockHighlight_alias_1 as defineCodeBlockHighlight } from './_tsup-dts-rollup';
+export { HighlightParser_alias_1 as HighlightParser } from './_tsup-dts-rollup';
+export { defineCodeBlockEnterRule_alias_1 as defineCodeBlockEnterRule } from './_tsup-dts-rollup';
+export { defineCodeBlockInputRule_alias_1 as defineCodeBlockInputRule } from './_tsup-dts-rollup';
+export { defineCodeBlockShiki_alias_1 as defineCodeBlockShiki } from './_tsup-dts-rollup';
+export { defineCodeBlockSpec_alias_1 as defineCodeBlockSpec } from './_tsup-dts-rollup';
 export { CodeBlockAttrs_alias_1 as CodeBlockAttrs } from './_tsup-dts-rollup';
+export { shikiBundledLanguagesInfo } from './_tsup-dts-rollup';
+export { shikiBundledThemesInfo } from './_tsup-dts-rollup';
+export { ShikiBundledLanguage } from './_tsup-dts-rollup';
+export { ShikiBundledLanguageInfo } from './_tsup-dts-rollup';
+export { ShikiBundledTheme } from './_tsup-dts-rollup';
+export { ShikiBundledThemeInfo } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code-block.js

@@ -1,55 +1,96 @@
-// src/code-block/index.ts
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+import {
+  defineTextBlockEnterRule
+} from "./chunk-ASTUC4KT.js";
+
+// src/code-block/code-block.ts
+import { union } from "@prosekit/core";
+
+// src/code-block/code-block-commands.ts
 import {
   defineCommands,
-  defineInputRule,
-  defineNodeSpec,
-  union,
-  getNodeType
+  insertNode,
+  setBlockType,
+  setNodeAttrs,
+  toggleNode
 } from "@prosekit/core";
-import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
-
-// src/code-block/code-block-highlight.ts
-import { definePlugin } from "@prosekit/core";
-import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
-import { DecorationSet } from "@prosekit/pm/view";
-import { getHighlightDecorations } from "prosemirror-highlightjs";
-function defineCodeBlockHighlight(options) {
-  const hljs = options.hljs;
-  const plugin = new ProseMirrorPlugin({
-    key,
-    state: {
-      init(_config, state) {
-        const decorations = hljs ? getHighlightDecorations(
-          state.doc,
-          hljs,
-          blockTypes,
-          languageExtractor
-        ) : [];
-        return DecorationSet.create(state.doc, decorations);
-      },
-      apply(tr, set) {
-        if (!tr.docChanged) {
-          return set.map(tr.mapping, tr.doc);
-        }
-        const decorations = hljs ? getHighlightDecorations(tr.doc, hljs, blockTypes, languageExtractor) : [];
-        return DecorationSet.create(tr.doc, decorations);
-      }
+function defineCodeBlockCommands() {
+  return defineCommands({
+    setCodeBlock: (attrs) => {
+      return setBlockType({ type: "codeBlock", attrs });
     },
-    props: {
-      decorations(state) {
-        return key.getState(state);
-      }
+    insertCodeBlock: (attrs) => {
+      return insertNode({ type: "codeBlock", attrs });
+    },
+    toggleCodeBlock: (attrs) => {
+      return toggleNode({ type: "codeBlock", attrs });
+    },
+    setCodeBlockAttrs: (attrs) => {
+      return setNodeAttrs({ type: "codeBlock", attrs });
     }
   });
-  return definePlugin(plugin);
 }
-var key = new PluginKey("prosekit-code-block-highlight");
-var blockTypes = ["codeBlock"];
-function languageExtractor(node) {
-  return node.attrs.language || "javascript";
+
+// src/code-block/code-block-input-rule.ts
+function defineCodeBlockInputRule() {
+  return defineTextBlockInputRule({
+    regex: /^```(\S*)\s$/,
+    type: "codeBlock",
+    attrs: getAttrs
+  });
+}
+function defineCodeBlockEnterRule() {
+  return defineTextBlockEnterRule({
+    regex: /^```(\S*)$/,
+    type: "codeBlock",
+    attrs: getAttrs
+  });
 }
+function getAttrs(match) {
+  return { language: match[1] || "" };
+}
+
+// src/code-block/code-block-keymap.ts
+import { defaultBlockAt, defineKeymap } from "@prosekit/core";
+import { TextSelection } from "@prosekit/pm/state";
+function defineCodeBlockKeymap() {
+  return defineKeymap({
+    Enter: existCodeBlock
+  });
+}
+var existCodeBlock = (state, dispatch) => {
+  if (!state.selection.empty) {
+    return false;
+  }
+  const { $head } = state.selection;
+  const parent = $head.parent;
+  if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith("\n\n")) {
+    const grandParent = $head.node(-1);
+    const insertIndex = $head.indexAfter(-1);
+    const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
+    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) {
+      return false;
+    }
+    if (dispatch) {
+      const { tr } = state;
+      tr.delete($head.pos - 2, $head.pos);
+      const pos = tr.selection.$head.after();
+      const node = type.createAndFill();
+      if (node) {
+        tr.replaceWith(pos, pos, node);
+        tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  }
+  return false;
+};
 
-// src/code-block/index.ts
+// src/code-block/code-block-spec.ts
+import { defineNodeSpec } from "@prosekit/core";
 function defineCodeBlockSpec() {
   return defineNodeSpec({
     name: "codeBlock",
@@ -70,49 +111,104 @@ function defineCodeBlockSpec() {
     ],
     toDOM(node) {
       const attrs = node.attrs;
-      return [
-        "pre",
-        { "data-language": attrs.language, class: "hljs" },
-        ["code", 0]
-      ];
+      return ["pre", { "data-language": attrs.language }, ["code", 0]];
     }
   });
 }
-function defineCodeBlockInputRule() {
-  return defineInputRule(({ schema }) => {
-    const nodeType = getNodeType(schema, "codeBlock");
-    const getAttrs = (match) => {
-      return { language: match[1] || "" };
-    };
-    return textblockTypeInputRule(/^```(\S*)\s$/, nodeType, getAttrs);
-  });
-}
-function defineCodeBlockCommands() {
-  return defineCommands({
-    setCodeBlockLanguage: (language) => (state, dispatch) => {
-      const pos = state.selection.$from.before();
-      const codeBlock = state.doc.nodeAt(pos);
-      if (!codeBlock || codeBlock.type.name !== "codeBlock") {
-        return false;
-      }
-      const { tr } = state;
-      tr.setNodeMarkup(pos, void 0, { language });
-      dispatch == null ? void 0 : dispatch(tr);
-      return true;
-    }
-  });
-}
-function defineCodeBlock(options) {
+
+// src/code-block/code-block.ts
+function defineCodeBlock() {
   return union([
     defineCodeBlockSpec(),
     defineCodeBlockInputRule(),
-    defineCodeBlockHighlight({ hljs: options == null ? void 0 : options.hljs }),
+    defineCodeBlockEnterRule(),
+    defineCodeBlockKeymap(),
     defineCodeBlockCommands()
   ]);
 }
+
+// src/code-block/code-block-highlight.ts
+import { definePlugin } from "@prosekit/core";
+import { createHighlightPlugin } from "prosemirror-highlight";
+function defineCodeBlockHighlight({
+  parser
+}) {
+  return definePlugin(
+    createHighlightPlugin({ parser, nodeTypes: ["codeBlock"] })
+  );
+}
+
+// src/code-block/shiki-parser.ts
+import { createParser } from "prosemirror-highlight/shiki";
+function createHighlighterLoader() {
+  let highlighterPromise;
+  let highlighter;
+  const loadLangs = /* @__PURE__ */ new Set();
+  return function highlighterLoader(lang, options) {
+    if (!highlighterPromise) {
+      highlighterPromise = import("./shiki-import-25BJYIO2.js").then(({ getHighlighter }) => {
+        return getHighlighter(options);
+      }).then((h) => {
+        highlighter = h;
+      });
+      return { promise: highlighterPromise };
+    }
+    if (!highlighter) {
+      return { promise: highlighterPromise };
+    }
+    if (!loadLangs.has(lang)) {
+      const promise = highlighter.loadLanguage(lang).then(() => {
+        loadLangs.add(lang);
+      }).catch((error) => {
+        console.warn(`Failed to load language '${lang}'`, error);
+      });
+      return { promise };
+    }
+    return { highlighter };
+  };
+}
+function createLazyParser(highlighterOptions) {
+  let parser;
+  const highlighterLoader = createHighlighterLoader();
+  return function lazyParser(options) {
+    const language = options.language || "";
+    const { highlighter, promise } = highlighterLoader(
+      language,
+      highlighterOptions
+    );
+    if (!highlighter) {
+      return promise || [];
+    }
+    if (!parser) {
+      parser = createParser(highlighter);
+    }
+    return parser(options);
+  };
+}
+
+// src/code-block/code-block-shiki.ts
+function defineCodeBlockShiki({
+  themes = ["one-dark-pro"],
+  langs = ["text"],
+  langAlias = {}
+} = {}) {
+  const parser = createLazyParser({ themes, langs, langAlias });
+  return defineCodeBlockHighlight({ parser });
+}
+
+// src/code-block/shiki-bundle.ts
+import {
+  bundledLanguagesInfo,
+  bundledThemesInfo
+} from "shiki";
 export {
   defineCodeBlock,
   defineCodeBlockCommands,
+  defineCodeBlockEnterRule,
+  defineCodeBlockHighlight,
   defineCodeBlockInputRule,
-  defineCodeBlockSpec
+  defineCodeBlockShiki,
+  defineCodeBlockSpec,
+  bundledLanguagesInfo as shikiBundledLanguagesInfo,
+  bundledThemesInfo as shikiBundledThemesInfo
 };

package/dist/prosekit-extensions-drop-cursor.d.ts

@@ -0,0 +1,2 @@
+export { defineDropCursor } from './_tsup-dts-rollup';
+export { DropCursorOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-drop-cursor.js

@@ -0,0 +1,9 @@
+// src/drop-cursor/index.ts
+import { definePlugin } from "@prosekit/core";
+import { dropCursor } from "prosemirror-dropcursor";
+function defineDropCursor(options) {
+  return definePlugin(() => dropCursor(options));
+}
+export {
+  defineDropCursor
+};

package/dist/prosekit-extensions-enter-rule.d.ts

@@ -0,0 +1,5 @@
+export { defineEnterRule } from './_tsup-dts-rollup';
+export { defineTextBlockEnterRule } from './_tsup-dts-rollup';
+export { EnterRuleHandler } from './_tsup-dts-rollup';
+export { EnterRuleOptions } from './_tsup-dts-rollup';
+export { TextBlockEnterRuleOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-enter-rule.js

@@ -0,0 +1,8 @@
+import {
+  defineEnterRule,
+  defineTextBlockEnterRule
+} from "./chunk-ASTUC4KT.js";
+export {
+  defineEnterRule,
+  defineTextBlockEnterRule
+};

package/dist/prosekit-extensions-heading.js

@@ -1,16 +1,18 @@
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/heading/index.ts
 import {
   defineCommands,
-  defineInputRule,
   defineKeymap,
   defineNodeSpec,
-  getNodeType,
   insertNode,
   setBlockType,
   toggleNode,
-  union
+  union,
+  withSkipCodeBlock
 } from "@prosekit/core";
-import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
 function defineHeadingSpec() {
   return defineNodeSpec({
     name: "heading",
@@ -33,22 +35,26 @@ function defineHeadingSpec() {
 }
 function defineHeadingKeymap() {
   return defineKeymap({
-    "mod-1": toggleNode({ type: "heading", attrs: { level: 1 } }),
-    "mod-2": toggleNode({ type: "heading", attrs: { level: 2 } }),
-    "mod-3": toggleNode({ type: "heading", attrs: { level: 3 } }),
-    "mod-4": toggleNode({ type: "heading", attrs: { level: 4 } }),
-    "mod-5": toggleNode({ type: "heading", attrs: { level: 5 } }),
-    "mod-6": toggleNode({ type: "heading", attrs: { level: 6 } })
+    "mod-1": toggleHeadingKeybinding(1),
+    "mod-2": toggleHeadingKeybinding(2),
+    "mod-3": toggleHeadingKeybinding(3),
+    "mod-4": toggleHeadingKeybinding(4),
+    "mod-5": toggleHeadingKeybinding(5),
+    "mod-6": toggleHeadingKeybinding(6)
   });
 }
+function toggleHeadingKeybinding(level) {
+  return withSkipCodeBlock(toggleNode({ type: "heading", attrs: { level } }));
+}
 function defineHeadingInputRule() {
-  return defineInputRule(({ schema }) => {
-    const nodeSpec = getNodeType(schema, "heading");
-    return textblockTypeInputRule(/^(#{1,6})\s/, nodeSpec, (match) => {
+  return defineTextBlockInputRule({
+    regex: /^(#{1,6})\s$/,
+    type: "heading",
+    attrs: (match) => {
       var _a, _b;
       const level = (_b = (_a = match[1]) == null ? void 0 : _a.length) != null ? _b : 1;
       return { level };
-    });
+    }
   });
 }
 function defineHeadingCommands() {

package/dist/prosekit-extensions-image.js

@@ -13,6 +13,7 @@ function defineImageSpec() {
     },
     group: "block",
     defining: true,
+    draggable: true,
     parseDOM: [
       {
         tag: "img[src]",