@prosekit/extensions 0.1.6 → 0.2.1

package/dist/_tsup-dts-rollup.d.ts

@@ -1,16 +1,22 @@
+import { Attrs } from '@prosekit/pm/model';
+import type { BundledTheme } from 'shikiji';
 import { CommandArgs } from '@prosekit/core';
+import type { ContentMatch } from '@prosekit/pm/model';
 import { DedentListOptions } from 'prosemirror-flat-list';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
-import type { HLJSApi } from 'highlight.js';
 import { IndentListOptions } from 'prosemirror-flat-list';
+import { InputRule } from '@prosekit/pm/inputrules';
 import { ListAttributes } from 'prosemirror-flat-list';
 import { NodeRange } from 'prosemirror-model';
+import { NodeType } from '@prosekit/pm/model';
+import { NodeType as NodeType_2 } from 'prosemirror-model';
 import { Options } from 'tsup';
 import { Parser } from 'prosemirror-highlight';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
+import { ProseMirrorNode } from '@prosekit/pm/model';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
@@ -49,8 +55,6 @@ export declare function createAutocompletePlugin({ getRules, }: {
     getRules: () => AutocompleteRule[];
 }): Plugin_2;
 
-export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
-
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -59,11 +63,9 @@ export declare const default_alias_1: {
     };
 };
 
-export declare function defaultCanMatch({ state }: {
-    state: EditorState;
-}): boolean;
+export declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
 
-export declare function defaultIsValid({ state }: {
+export declare function defaultCanMatch({ state }: {
     state: EditorState;
 }): boolean;
 
@@ -117,22 +119,13 @@ toggleCode: [];
  *
  * - {@link defineCodeBlockSpec}
  * - {@link defineCodeBlockInputRule}
+ * - {@link defineCodeBlockEnterRule}
+ * - {@link defineCodeBlockKeymap}
  * - {@link defineCodeBlockCommands}.
  *
  * @public
  */
-export declare function defineCodeBlock(options?: {
-    /**
-     * @deprecated Use `defineCodeBlockHighlight` function instead.
-     */
-    hljs?: HLJSApi;
-    /**
-     * A parser for the `prosemirror-highlight` package to use for syntax highlighting.
-     *
-     * @deprecated Use the standalone `defineCodeBlockHighlight` function instead.
-     */
-    parser?: HighlightParser;
-}): Extension<    {
+export declare function defineCodeBlock(): Extension<    {
 NODES: "codeBlock";
 COMMAND_ARGS: {
 setCodeBlockLanguage: [language: string];
@@ -152,6 +145,15 @@ setCodeBlockLanguage: [language: string];
 export { defineCodeBlockCommands }
 export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
 
+/**
+ * Adds enter rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockEnterRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockEnterRule }
+export { defineCodeBlockEnterRule as defineCodeBlockEnterRule_alias_1 }
+
 /**
  * Adds syntax highlighting to code blocks. This function requires a `Parser`
  * instance from the `prosemirror-highlight` package. See the
@@ -166,13 +168,6 @@ declare function defineCodeBlockHighlight({ parser, }: {
 export { defineCodeBlockHighlight }
 export { defineCodeBlockHighlight as defineCodeBlockHighlight_alias_1 }
 
-/**
- * @deprecated
- */
-export declare function defineCodeBlockHighlightDeprecated(options: {
-    hljs?: HLJSApi;
-}): Extension<ExtensionTyping<string, string, CommandArgs>>;
-
 /**
  * Adds input rules for `codeBlock` nodes.
  *
@@ -182,6 +177,27 @@ declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, s
 export { defineCodeBlockInputRule }
 export { defineCodeBlockInputRule as defineCodeBlockInputRule_alias_1 }
 
+/**
+ * Defines the keymap for code blocks.
+ */
+export declare function defineCodeBlockKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Adds syntax highlighting to code blocks using the [shikiji](https://github.com/antfu/shikiji) package.
+ *
+ * @public
+ */
+declare function defineCodeBlockShikiji(options?: {
+    /**
+     * The shikiji theme to use.
+     *
+     * @default 'github-light'
+     */
+    theme?: BundledTheme;
+}): Extension;
+export { defineCodeBlockShikiji }
+export { defineCodeBlockShikiji as defineCodeBlockShikiji_alias_1 }
+
 /**
  * Defines the `codeBlock` node spec.
  *
@@ -206,6 +222,15 @@ export declare function defineCodeSpec(): Extension<    {
 MARKS: "code";
 }>;
 
+/**
+ * Defines an enter rule. An enter rule applies when the text directly in front of
+ * the cursor matches `regex` and user presses Enter. The `regex` should end
+ * with `$`.
+ *
+ * @public
+ */
+export declare function defineEnterRule({ regex, handler, }: EnterRuleOptions): Extension;
+
 /**
  * @public
  */
@@ -254,6 +279,15 @@ export declare function defineImageSpec(): Extension<    {
 NODES: "image";
 }>;
 
+/**
+ * Defines an input rule extension.
+ *
+ * @param rule - The ProseMirror input rule to add.
+ *
+ * @public
+ */
+export declare function defineInputRule(rule: InputRule): Extension;
+
 /**
  * @public
  */
@@ -303,36 +337,36 @@ MARKS: "link";
 /**
  * @public
  */
-export declare function defineList(): Extension<    {
-NODES: "list";
-COMMAND_ARGS: {
-dedentList: [options?: DedentListOptions | undefined];
-indentList: [options?: IndentListOptions | undefined];
-moveList: [direction: "up" | "down"];
-splitList: [];
-toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-toggleList: [attrs: ListAttributes];
-unwrapList: [options?: UnwrapListOptions | undefined];
-wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
-insertList: [attrs?: ListAttributes | undefined];
-};
+export declare function defineList(): Extension<{
+    NODES: "list";
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
 }>;
 
-export declare function defineListCommands(): Extension<    {
-COMMAND_ARGS: {
-dedentList: [options?: DedentListOptions | undefined];
-indentList: [options?: IndentListOptions | undefined];
-moveList: [direction: "up" | "down"];
-splitList: [];
-toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-toggleList: [attrs: ListAttributes];
-unwrapList: [options?: UnwrapListOptions | undefined];
-wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
-insertList: [attrs?: ListAttributes | undefined];
-};
+export declare function defineListCommands(): Extension<{
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
 }>;
 
-export declare function defineListInputRules(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineListInputRules(): Extension;
 
 /**
  * Returns a extension that adds key bindings for list.
@@ -343,8 +377,8 @@ export declare function defineListKeymap(): Extension<ExtensionTyping<string, st
 
 export declare function defineListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function defineListSpec(): Extension<    {
-NODES: "list";
+export declare function defineListSpec(): Extension<{
+    NODES: "list";
 }>;
 
 /**
@@ -404,9 +438,35 @@ MARKS: "strike";
 }>;
 
 /**
- * @deprecated Use `defineAutocomplete` instead.
+ * Defines an enter rule that replaces the matched text with a block node.
+ *
+ * See also {@link defineEnterRule}.
+ *
+ * @public
  */
-export declare function defineSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineTextBlockEnterRule({ regex, type, attrs, }: TextBlockEnterRuleOptions): Extension;
+
+/**
+ * Defines an input rule that changes the type of a textblock when the matched
+ * text is typed into it.
+ *
+ * See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)
+ */
+export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}): Extension;
 
 /**
  * @public
@@ -430,6 +490,63 @@ export declare function defineUnderlineSpec(): Extension<    {
 MARKS: "underline";
 }>;
 
+/**
+ * Defines an input rule for automatically wrapping a textblock when a given
+ * string is typed.
+ *
+ * See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)
+ */
+export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The type of node to wrap in.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * By default, if there's a node with the same type above the newly wrapped
+     * node, the rule will try to
+     * [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those
+     * two nodes. You can pass a join predicate, which takes a regular expression
+     * match and the node before the wrapped node, and can return a boolean to
+     * indicate whether a join should happen.
+     */
+    join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
+}): Extension;
+
+/**
+ * @public
+ */
+export declare type EnterRuleHandler = (options: {
+    state: EditorState;
+    from: number;
+    to: number;
+    match: RegExpExecArray;
+}) => Transaction | null;
+
+/**
+ * Options for {@link createEnterRule}.
+ *
+ * @public
+ */
+export declare type EnterRuleOptions = {
+    /**
+     * The regular expression to match against. It should end with `$`.
+     */
+    regex: RegExp;
+    /**
+     * A handler function to be called when an enter rule is triggered.
+     */
+    handler: EnterRuleHandler;
+};
+
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
 
 export declare function getTrMeta(tr: Transaction): PredictionPluginState;
@@ -469,25 +586,15 @@ declare type MatchHandler = (options: {
 export { MatchHandler }
 export { MatchHandler as MatchHandler_alias_1 }
 
-/**
- * @returns Return a Transaction object if you want to append a transaction to current state (using )
- */
-declare type MatchHandler_2 = (options: {
-    rule: PredictionRule;
-    match: RegExpMatchArray;
-    matchAfter: RegExpMatchArray | null;
-    state: EditorState;
-    dismiss: VoidFunction;
-    deleteMatch: VoidFunction;
-}) => void;
-
 export declare interface MentionAttrs {
     id: string;
     kind: string;
     value: string;
 }
 
-export declare const OBJECT_REPLACEMENT = "\uFFFC";
+export declare const NO_BREAK_SPACE = "\u00A0";
+
+export declare const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 
 export declare interface PlaceholderOptions {
     /**
@@ -517,31 +624,26 @@ export declare interface PredictionPluginState {
     } | null;
 }
 
-declare interface PredictionRule {
-    match: RegExp;
-    matchAfter?: RegExp;
-}
-export { PredictionRule }
-export { PredictionRule as PredictionRule_alias_1 }
-
 export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState): Transaction;
 
-declare interface SuggestionOptions {
-    rules: PredictionRule[];
-    onMatch: MatchHandler_2;
-    onDeactivate: VoidFunction;
+/**
+ * Options for {@link createTextBlockEnterRule}.
+ *
+ * @public
+ */
+export declare type TextBlockEnterRuleOptions = {
     /**
-     * You can pass this function if you want to skip the matching in some cases.
-     * By default, the plugin will only run the matching if the current selection
-     * is empty, and the selection is not inside a
-     * [code](https://prosemirror.net/docs/ref/#model.NodeSpec.code) node nor
-     * inside a mark with the name as `code`.
+     * The regular expression to match against. It should end with `$`.
      */
-    isValid?: (options: {
-        state: EditorState;
-    }) => boolean;
-}
-export { SuggestionOptions }
-export { SuggestionOptions as SuggestionOptions_alias_1 }
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+};
 
 export { }

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/chunk-HQZORKGY.js

@@ -0,0 +1,6 @@
+// src/utils/unicode.ts
+var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
+
+export {
+  OBJECT_REPLACEMENT_CHARACTER
+};

package/dist/prosekit-extensions-autocomplete.js

@@ -1,3 +1,7 @@
+import {
+  OBJECT_REPLACEMENT_CHARACTER
+} from "./chunk-HQZORKGY.js";
+
 // src/autocomplete/index.ts
 import {
   Facet,
@@ -22,7 +26,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 +78,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 +132,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-code-block.d.ts

@@ -1,7 +1,9 @@
 export { defineCodeBlock } from './_tsup-dts-rollup';
 export { defineCodeBlockCommands_alias_1 as defineCodeBlockCommands } from './_tsup-dts-rollup';
+export { defineCodeBlockEnterRule_alias_1 as defineCodeBlockEnterRule } from './_tsup-dts-rollup';
 export { defineCodeBlockHighlight_alias_1 as defineCodeBlockHighlight } from './_tsup-dts-rollup';
 export { defineCodeBlockInputRule_alias_1 as defineCodeBlockInputRule } from './_tsup-dts-rollup';
+export { defineCodeBlockShikiji_alias_1 as defineCodeBlockShikiji } 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 { HighlightParser_alias_1 as HighlightParser } from './_tsup-dts-rollup';

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

@@ -1,3 +1,10 @@
+import {
+  OBJECT_REPLACEMENT_CHARACTER
+} from "./chunk-HQZORKGY.js";
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/code-block/index.ts
 import { union } from "@prosekit/core";
 
@@ -30,59 +37,216 @@ function defineCodeBlockHighlight({
   );
 }
 
-// src/code-block/code-block-highlight-deprecated.ts
-import { definePlugin as definePlugin2 } from "@prosekit/core";
-import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
-import { DecorationSet } from "@prosekit/pm/view";
-import { getHighlightDecorations } from "prosemirror-highlightjs";
-function defineCodeBlockHighlightDeprecated(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);
-      }
-    },
-    props: {
-      decorations(state) {
-        return key.getState(state);
+// src/enter-rule/index.ts
+import {
+  Facet,
+  getNodeType,
+  isTextSelection,
+  keymapFacet
+} from "@prosekit/core";
+function defineEnterRule({
+  regex,
+  handler
+}) {
+  const rule = new EnterRule(regex, handler);
+  return inputRuleFacet.extension([rule]);
+}
+function defineTextBlockEnterRule({
+  regex,
+  type,
+  attrs
+}) {
+  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);
     }
   });
-  return definePlugin2(plugin);
 }
-var key = new PluginKey("prosekit-code-block-highlight");
-var blockTypes = ["codeBlock"];
-function languageExtractor(node) {
-  return node.attrs.language || "javascript";
+var EnterRule = class {
+  constructor(regex, handler) {
+    this.regex = regex;
+    this.handler = handler;
+  }
+};
+var inputRuleFacet = Facet.define({
+  convert: (inputs) => {
+    return {
+      Enter: (state, dispatch, view) => {
+        if (!view)
+          return false;
+        return execRules(view, inputs, dispatch);
+      }
+    };
+  },
+  next: keymapFacet
+});
+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);
+    return true;
+  }
+  return false;
 }
+var MAX_MATCH = 200;
 
 // src/code-block/code-block-input-rule.ts
-import { defineInputRule, getNodeType } from "@prosekit/core";
-import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
 function defineCodeBlockInputRule() {
-  return defineInputRule(({ schema }) => {
-    const nodeType = getNodeType(schema, "codeBlock");
-    const getAttrs = (match) => {
-      return { language: match[1] || "" };
-    };
-    return textblockTypeInputRule(/^```(\S*)\s$/, nodeType, getAttrs);
+  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 { defineKeymap } from "@prosekit/core";
+import { TextSelection } from "@prosekit/pm/state";
+
+// src/utils/default-block-at.ts
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i++) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs())
+      return type;
+  }
+  return null;
+}
+
+// src/code-block/code-block-keymap.ts
+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/code-block-shikiji.ts
+import { createParser } from "prosemirror-highlight/shikiji";
+function createHighlighterLoader() {
+  let shikijiImport;
+  let highlighter;
+  const languages = /* @__PURE__ */ new Set();
+  const themes = /* @__PURE__ */ new Set();
+  return function highlighterLoader(lang, theme) {
+    if (!shikijiImport) {
+      shikijiImport = import("shikiji").then(async ({ getHighlighter }) => {
+        const fallbackLang = "md";
+        highlighter = await getHighlighter({
+          langs: [fallbackLang],
+          themes: []
+        });
+      });
+      return { promise: shikijiImport };
+    }
+    if (!highlighter) {
+      return { promise: shikijiImport };
+    }
+    if (!languages.has(lang)) {
+      const promise = highlighter.loadLanguage(lang).then(() => {
+        languages.add(lang);
+      }).catch(() => {
+      });
+      return { promise };
+    }
+    if (!themes.has(theme)) {
+      const promise = highlighter.loadTheme(theme).then(() => {
+        themes.add(theme);
+      }).catch(() => {
+      });
+      return { promise };
+    }
+    return { highlighter };
+  };
+}
+function createLazyParser(theme) {
+  let parser;
+  const highlighterLoader = createHighlighterLoader();
+  return function lazyParser(options) {
+    const language = options.language || "";
+    const { highlighter, promise } = highlighterLoader(language, theme);
+    if (!highlighter) {
+      return promise || [];
+    }
+    if (!parser) {
+      parser = createParser(highlighter);
+    }
+    return parser(options);
+  };
+}
+function defineCodeBlockShikiji(options) {
+  const theme = (options == null ? void 0 : options.theme) || "github-light";
+  const parser = createLazyParser(theme);
+  return defineCodeBlockHighlight({ parser });
+}
 
 // src/code-block/code-block-spec.ts
 import { defineNodeSpec } from "@prosekit/core";
@@ -106,37 +270,27 @@ function defineCodeBlockSpec() {
     ],
     toDOM(node) {
       const attrs = node.attrs;
-      return [
-        "pre",
-        // TODO: remove class 'hljs'
-        { "data-language": attrs.language, class: "hljs" },
-        ["code", 0]
-      ];
+      return ["pre", { "data-language": attrs.language }, ["code", 0]];
     }
   });
 }
 
 // src/code-block/index.ts
-function defineCodeBlock(options) {
-  const extensions = [
+function defineCodeBlock() {
+  return union([
     defineCodeBlockSpec(),
     defineCodeBlockInputRule(),
+    defineCodeBlockEnterRule(),
+    defineCodeBlockKeymap(),
     defineCodeBlockCommands()
-  ];
-  const parser = options == null ? void 0 : options.parser;
-  if (parser) {
-    extensions.push(defineCodeBlockHighlight({ parser }));
-  }
-  const hljs = options == null ? void 0 : options.hljs;
-  if (hljs) {
-    extensions.push(defineCodeBlockHighlightDeprecated({ hljs }));
-  }
-  return union(extensions);
+  ]);
 }
 export {
   defineCodeBlock,
   defineCodeBlockCommands,
+  defineCodeBlockEnterRule,
   defineCodeBlockHighlight,
   defineCodeBlockInputRule,
+  defineCodeBlockShikiji,
   defineCodeBlockSpec
 };

package/dist/prosekit-extensions-heading.js

@@ -1,16 +1,17 @@
+import {
+  defineTextBlockInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/heading/index.ts
 import {
   defineCommands,
-  defineInputRule,
   defineKeymap,
   defineNodeSpec,
-  getNodeType,
   insertNode,
   setBlockType,
   toggleNode,
   union
 } from "@prosekit/core";
-import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
 function defineHeadingSpec() {
   return defineNodeSpec({
     name: "heading",
@@ -42,13 +43,14 @@ function defineHeadingKeymap() {
   });
 }
 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-input-rule.d.ts

@@ -0,0 +1,3 @@
+export { defineInputRule } from './_tsup-dts-rollup';
+export { defineTextBlockInputRule } from './_tsup-dts-rollup';
+export { defineWrappingInputRule } from './_tsup-dts-rollup';

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

@@ -0,0 +1,10 @@
+import {
+  defineInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+} from "./chunk-DYFRBXUX.js";
+export {
+  defineInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+};

package/dist/prosekit-extensions-list.js

@@ -1,8 +1,11 @@
+import {
+  defineInputRule
+} from "./chunk-DYFRBXUX.js";
+
 // src/list/index.ts
 import {
   Priority,
   defineCommands,
-  defineInputRule,
   defineKeymap,
   defineNodeSpec,
   definePlugin,
@@ -34,7 +37,7 @@ function defineListKeymap() {
   return defineKeymap(listKeymap);
 }
 function defineListInputRules() {
-  return defineInputRule(() => listInputRules);
+  return union(listInputRules.map(defineInputRule));
 }
 function defineListCommands() {
   return defineCommands({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -65,6 +65,11 @@
       "import": "./dist/prosekit-extensions-image.js",
       "default": "./dist/prosekit-extensions-image.js"
     },
+    "./input-rule": {
+      "types": "./dist/prosekit-extensions-input-rule.d.ts",
+      "import": "./dist/prosekit-extensions-input-rule.js",
+      "default": "./dist/prosekit-extensions-input-rule.js"
+    },
     "./italic": {
       "types": "./dist/prosekit-extensions-italic.d.ts",
       "import": "./dist/prosekit-extensions-italic.js",
@@ -106,11 +111,6 @@
       "import": "./dist/prosekit-extensions-strike.js",
       "default": "./dist/prosekit-extensions-strike.js"
     },
-    "./suggestion": {
-      "types": "./dist/prosekit-extensions-suggestion.d.ts",
-      "import": "./dist/prosekit-extensions-suggestion.js",
-      "default": "./dist/prosekit-extensions-suggestion.js"
-    },
     "./underline": {
       "types": "./dist/prosekit-extensions-underline.d.ts",
       "import": "./dist/prosekit-extensions-underline.js",
@@ -121,18 +121,25 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.1.8",
+    "@prosekit/core": "^0.2.0",
     "@prosekit/pm": "^0.1.1",
-    "highlight.js": "^11.9.0",
     "prosemirror-flat-list": "^0.4.5",
-    "prosemirror-highlight": "^0.3.2",
-    "prosemirror-highlightjs": "^0.9.1"
+    "prosemirror-highlight": "^0.4.0"
+  },
+  "peerDependencies": {
+    "shikiji": ">= 0.9.0"
+  },
+  "peerDependenciesMeta": {
+    "shikiji": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@prosekit/dev": "*",
+    "shikiji": "^0.9.16",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.0.4"
+    "vitest": "^1.1.1"
   },
   "scripts": {
     "build:tsup": "tsup",
@@ -165,6 +172,9 @@
       "image": [
         "./dist/prosekit-extensions-image.d.ts"
       ],
+      "input-rule": [
+        "./dist/prosekit-extensions-input-rule.d.ts"
+      ],
       "italic": [
         "./dist/prosekit-extensions-italic.d.ts"
       ],
@@ -186,9 +196,6 @@
       "strike": [
         "./dist/prosekit-extensions-strike.d.ts"
       ],
-      "suggestion": [
-        "./dist/prosekit-extensions-suggestion.d.ts"
-      ],
       "underline": [
         "./dist/prosekit-extensions-underline.d.ts"
       ]

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

@@ -1,3 +0,0 @@
-export { defineSuggestion } from './_tsup-dts-rollup';
-export { PredictionRule } from './_tsup-dts-rollup';
-export { SuggestionOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-suggestion.js

@@ -1,161 +0,0 @@
-// src/suggestion/index.ts
-import { definePlugin } from "@prosekit/core";
-
-// src/suggestion/plugin.ts
-import { ProseKitError } from "@prosekit/core";
-import { Plugin, PluginKey } from "@prosekit/pm/state";
-import { Decoration, DecorationSet } from "@prosekit/pm/view";
-
-// src/suggestion/is-valid.ts
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function defaultIsValid({ state }) {
-  return state.selection.empty && !isInsideCode(state.selection.$from);
-}
-function isInsideCode($pos) {
-  for (let d = $pos.depth; d > 0; d--) {
-    if ($pos.node(d).type.spec.code) {
-      return true;
-    }
-  }
-  return $pos.marks().some((mark) => mark.type.name === "code");
-}
-
-// src/suggestion/plugin.ts
-var pluginKey = new PluginKey("prosemirror-prediction");
-function getPluginState(state) {
-  return pluginKey.getState(state);
-}
-function getTrMeta(tr) {
-  return tr.getMeta(pluginKey);
-}
-function setTrMeta(tr, meta) {
-  return tr.setMeta(pluginKey, meta);
-}
-function createPredictionPlugin(options) {
-  if (options.rules.length === 0) {
-    throw new ProseKitError(
-      "You can't create a prediction plugin without rules"
-    );
-  }
-  const { onMatch, onDeactivate, isValid = defaultIsValid } = options;
-  return new Plugin({
-    key: pluginKey,
-    state: {
-      init: () => {
-        return { active: false, ignore: null, matching: null };
-      },
-      apply: (tr, prevValue, oldState, newState) => {
-        var _a;
-        const meta = getTrMeta(tr);
-        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
-          return prevValue;
-        }
-        if (meta) {
-          return meta;
-        }
-        if (!isValid({ state: newState })) {
-          return { active: false, ignore: null, matching: null };
-        }
-        const nextValue = calcPluginState(newState, options.rules);
-        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
-          return prevValue;
-        }
-        return nextValue;
-      }
-    },
-    view: () => ({
-      update: (view, prevState) => {
-        const prevPluginState = getPluginState(prevState);
-        const currPluginState = getPluginState(view.state);
-        if ((currPluginState == null ? void 0 : currPluginState.active) && currPluginState.matching && currPluginState.matching.from !== currPluginState.ignore) {
-          const { from, to } = currPluginState.matching;
-          const dismiss = () => {
-            view.dispatch(
-              setTrMeta(view.state.tr, {
-                active: false,
-                ignore: from,
-                matching: null
-              })
-            );
-          };
-          const textContent = view.state.doc.textBetween(from, to, "\uFFFC");
-          const deleteMatch = () => {
-            if (view.state.doc.textBetween(from, to, "\uFFFC") === textContent) {
-              view.dispatch(view.state.tr.delete(from, to));
-            }
-          };
-          onMatch({
-            rule: currPluginState.matching.rule,
-            match: currPluginState.matching.match,
-            matchAfter: currPluginState.matching.matchAfter,
-            state: view.state,
-            dismiss,
-            deleteMatch
-          });
-        } else if (prevPluginState == null ? void 0 : prevPluginState.active) {
-          onDeactivate();
-        }
-      }
-    }),
-    props: {
-      decorations: (state) => {
-        const pluginState = getPluginState(state);
-        if ((pluginState == null ? void 0 : pluginState.active) && pluginState.matching) {
-          const { from, to } = pluginState.matching;
-          const deco = Decoration.inline(from, to, {
-            class: "prosemirror-prediction-match"
-          });
-          return DecorationSet.create(state.doc, [deco]);
-        }
-        return null;
-      }
-    }
-  });
-}
-function calcPluginState(state, rules) {
-  const { $anchor } = state.selection;
-  const matchAfter = rules.some((rule) => rule.matchAfter);
-  const parentOffset = $anchor.parentOffset;
-  const textBefore = $anchor.parent.textBetween(
-    Math.max(0, parentOffset - MAX_MATCH),
-    parentOffset,
-    null,
-    "\uFFFC"
-  );
-  const textAfter = matchAfter ? $anchor.parent.textBetween(
-    parentOffset,
-    Math.min(parentOffset + MAX_MATCH, $anchor.parent.content.size),
-    null
-  ) : "";
-  for (const rule of rules) {
-    const match = textBefore.match(rule.match);
-    const matchAfter2 = rule.matchAfter ? textAfter.match(rule.matchAfter) : null;
-    if ((match == null ? void 0 : match.index) != null) {
-      const from = $anchor.pos - textBefore.length + match.index;
-      const to = $anchor.pos + (matchAfter2 ? matchAfter2[0].length : 0);
-      return {
-        active: true,
-        ignore: null,
-        matching: {
-          rule,
-          from,
-          to,
-          match,
-          matchAfter: matchAfter2
-        }
-      };
-    }
-  }
-  return { active: false };
-}
-var MAX_MATCH = 200;
-
-// src/suggestion/index.ts
-function defineSuggestion(options) {
-  const plugin = createPredictionPlugin(options);
-  return definePlugin(plugin);
-}
-export {
-  defineSuggestion
-};