@milkdown/crepe 7.20.0 → 7.21.1

package/lib/esm/index.js

@@ -1,16 +1,23 @@
 import { defaultsDeep } from 'lodash-es';
 import { languages } from '@codemirror/language-data';
 import { oneDark } from '@codemirror/theme-one-dark';
-import { blockConfig, block, BlockProvider } from '@milkdown/kit/plugin/block';
+import { diffComponentConfig, diffComponent } from '@milkdown/kit/component/diff';
+import { diffPluginKey, clearDiffReviewCmd, acceptAllDiffsCmd, diffConfig, diff } from '@milkdown/kit/plugin/diff';
+import { streamingPluginKey, startStreamingCmd, abortStreamingCmd, pushChunkCmd, endStreamingCmd, streamingConfig, streaming } from '@milkdown/kit/plugin/streaming';
 import { createSlice } from '@milkdown/kit/ctx';
-import { commandsCtx, editorViewCtx, editorCtx, EditorStatus, Editor, rootCtx, defaultValueCtx, editorViewOptionsCtx } from '@milkdown/kit/core';
+import { editorViewCtx, serializerCtx, commandsCtx, editorCtx, EditorStatus, Editor, rootCtx, defaultValueCtx, editorViewOptionsCtx } from '@milkdown/kit/core';
+import { aiBuildContextError, aiProviderError } from '@milkdown/kit/exception';
+import { $ctx, $command, $prose, $nodeSchema, $inputRule, $remark, getMarkdown } from '@milkdown/kit/utils';
+import { TextSelection, PluginKey, Plugin, NodeSelection, EditorState } from '@milkdown/kit/prose/state';
+import DOMPurify from 'dompurify';
+import { TooltipProvider, tooltipFactory } from '@milkdown/kit/plugin/tooltip';
+import { posToDOMRect, findParent, findNodeInSelection, nodeRule } from '@milkdown/kit/prose';
+import { defineComponent, ref, watch, computed, h, nextTick, createApp, watchEffect, onUnmounted, Fragment, shallowRef, onMounted } from 'vue';
+import { Icon } from '@milkdown/kit/component';
+import { DecorationSet, Decoration, EditorView } from '@milkdown/kit/prose/view';
+import { blockConfig, block, BlockProvider } from '@milkdown/kit/plugin/block';
 import { paragraphSchema, clearTextInCurrentBlockCommand, setBlockTypeCommand, headingSchema, blockquoteSchema, wrapInBlockTypeCommand, hrSchema, addBlockTypeCommand, bulletListSchema, orderedListSchema, listItemSchema, codeBlockSchema, selectTextNearPosCommand, toggleStrongCommand, isMarkSelectedCommand, strongSchema, toggleEmphasisCommand, emphasisSchema, toggleInlineCodeCommand, inlineCodeSchema, isNodeSelectedCommand, linkSchema, commonmark } from '@milkdown/kit/preset/commonmark';
-import { findParent, findNodeInSelection, nodeRule } from '@milkdown/kit/prose';
-import { TextSelection, NodeSelection, EditorState, Plugin, PluginKey } from '@milkdown/kit/prose/state';
-import { defineComponent, ref, computed, watch, watchEffect, onUnmounted, h, createApp, Fragment, shallowRef, onMounted } from 'vue';
 import { slashFactory, SlashProvider } from '@milkdown/kit/plugin/slash';
-import { $ctx, $prose, $nodeSchema, $command, $inputRule, $remark, getMarkdown } from '@milkdown/kit/utils';
-import { Icon } from '@milkdown/kit/component';
 import { imageBlockSchema, imageBlockConfig, imageBlockComponent } from '@milkdown/kit/component/image-block';
 import { createTable, toggleStrikethroughCommand, strikethroughSchema, gfm } from '@milkdown/kit/preset/gfm';
 import { defaultKeymap, indentWithTab } from '@codemirror/commands';
@@ -21,11 +28,9 @@ import { dropIndicatorConfig, cursor as cursor$1 } from '@milkdown/kit/plugin/cu
 import { createVirtualCursor } from 'prosemirror-virtual-cursor';
 import { inlineImageConfig, imageInlineComponent } from '@milkdown/kit/component/image-inline';
 import katex from 'katex';
-import { tooltipFactory, TooltipProvider } from '@milkdown/kit/plugin/tooltip';
 import { redo, undo } from '@milkdown/kit/prose/history';
 import { keymap as keymap$1 } from '@milkdown/kit/prose/keymap';
 import { Schema } from '@milkdown/kit/prose/model';
-import { EditorView, DecorationSet, Decoration } from '@milkdown/kit/prose/view';
 import { textblockTypeInputRule } from '@milkdown/kit/prose/inputrules';
 import remarkMath from 'remark-math';
 import { visit } from 'unist-util-visit';
@@ -52,6 +57,7 @@ var CrepeFeature = /* @__PURE__ */ ((CrepeFeature2) => {
   CrepeFeature2["Table"] = "table";
   CrepeFeature2["Latex"] = "latex";
   CrepeFeature2["TopBar"] = "top-bar";
+  CrepeFeature2["AI"] = "ai";
   return CrepeFeature2;
 })(CrepeFeature || {});
 const defaultFeatures = {
@@ -65,9 +71,25 @@ const defaultFeatures = {
   ["code-mirror" /* CodeMirror */]: true,
   ["table" /* Table */]: true,
   ["latex" /* Latex */]: true,
-  ["top-bar" /* TopBar */]: false
+  ["top-bar" /* TopBar */]: false,
+  ["ai" /* AI */]: false
 };
 
+const aiIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M19 9l1.25-2.75L23 5l-2.75-1.25L19 1l-1.25 2.75L15 5l2.75 1.25zm0 14l1.25-2.75L23 19l-2.75-1.25L19 15l-1.25 2.75L15 19l2.75 1.25zM9 20l3-6.5L18 10l-6-3.5L9 0L6 6.5L0 10l6 3.5z"
+      transform="translate(3 3) scale(0.75)"
+    />
+  </svg>
+`;
+
 const alignCenterIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -229,6 +251,38 @@ const chevronDownIcon = `
   </svg>
 `;
 
+const chevronLeftIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    fill="none"
+    viewBox="0 0 24 24"
+    stroke-width="1.5"
+    stroke="currentColor"
+  >
+    <path
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      d="M15.75 19.5L8.25 12l7.5-7.5"
+    />
+  </svg>
+`;
+
+const chevronRightIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    fill="none"
+    viewBox="0 0 24 24"
+    stroke-width="1.5"
+    stroke="currentColor"
+  >
+    <path
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      d="M8.25 4.5l7.5 7.5-7.5 7.5"
+    />
+  </svg>
+`;
+
 const clearIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -373,6 +427,34 @@ const editIcon = `
   </svg>
 `;
 
+const enterKeyIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M9 16l-5-5l5-5l1.4 1.4L7.825 10H18V6h2v6H7.825l2.575 2.6z"
+    />
+  </svg>
+`;
+
+const grammarCheckIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M9.55 17.575L4.225 12.25l1.4-1.425L9.55 14.75l8.825-8.825l1.4 1.425z"
+    />
+  </svg>
+`;
+
 const h1Icon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -539,6 +621,20 @@ const linkIcon = `
   </svg>
 `;
 
+const longerIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M3 18v-2h13v2zm0-5v-2h18v2zm0-5V6h18v2zm15 13v-3h-3v-2h3v-3h2v3h3v2h-3v3z"
+    />
+  </svg>
+`;
+
 const menuIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -632,6 +728,20 @@ const removeIcon = `
   </svg>
 `;
 
+const retryIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M12 20q-3.35 0-5.675-2.325T4 12q0-3.35 2.325-5.675T12 4q1.725 0 3.3.713T18 6.75V4h2v7h-7V9h4.2q-.8-1.4-2.187-2.2T12 6Q9.5 6 7.75 7.75T6 12q0 2.5 1.75 4.25T12 18q1.925 0 3.475-1.1T17.65 14h2.1q-.7 2.65-2.85 4.325T12 20"
+    />
+  </svg>
+`;
+
 const searchIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -649,6 +759,48 @@ const searchIcon = `
   </svg>
 `;
 
+const sendIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M11 20V7.825l-5.6 5.6L4 12l8-8l8 8l-1.4 1.425l-5.6-5.6V20z"
+    />
+  </svg>
+`;
+
+const sendPromptIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M3 20v-6l8-2l-8-2V4l19 8z"
+    />
+  </svg>
+`;
+
+const shorterIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="M5 13v-2h14v2z"
+    />
+  </svg>
+`;
+
 const strikethroughIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -715,6 +867,20 @@ const todoListIcon = `
   </svg>
 `;
 
+const translateIcon = `
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="24"
+    height="24"
+    viewBox="0 0 24 24"
+  >
+    <path
+      fill="currentColor"
+      d="m12.9 16l-2.55-2.5l.05-.05q1.45-1.6 2.262-3.117T13.95 7H16V5h-6V3H8v2H2v2h9.1q-.5 1.2-1.225 2.387T8 11.7q-.6-.6-1.187-1.412T5.85 8.6H3.85q.5 1.4 1.3 2.7T6.95 13.7L2.85 17.75L4.25 19.15L8 15.4L10.55 17.95zM18.5 22h-2L21 10h2l4.5 12h-2l-1.05-3h-4.9zm1.6-5h3.6l-1.8-5.1z"
+    />
+  </svg>
+`;
+
 const functionsIcon = `
   <svg
     xmlns="http://www.w3.org/2000/svg"
@@ -774,6 +940,1223 @@ function crepeFeatureConfig(feature) {
   };
 }
 
+function defaultBuildContext(ctx, instruction) {
+  var _a;
+  const view = ctx.get(editorViewCtx);
+  const serializer = ctx.get(serializerCtx);
+  const { state } = view;
+  const document = serializer(state.doc);
+  let selection = "";
+  if (!state.selection.empty) {
+    const { from, to } = state.selection;
+    const slice = state.doc.slice(from, to);
+    const { schema } = state.doc.type;
+    let wrapper = schema.topNodeType.createAndFill(null, slice.content);
+    if (!wrapper) {
+      const paragraph = (_a = schema.nodes.paragraph) == null ? void 0 : _a.createAndFill(
+        null,
+        slice.content
+      );
+      if (paragraph) wrapper = schema.topNodeType.createAndFill(null, paragraph);
+    }
+    selection = wrapper ? serializer(wrapper) : state.doc.textBetween(from, to);
+  }
+  return { document, selection, instruction };
+}
+
+const aiProviderConfig = $ctx(
+  {
+    provider: void 0,
+    buildContext: void 0,
+    diffReviewOnEnd: true,
+    onError: (error) => {
+      console.error(`[milkdown/ai] [${error.code}]`, error);
+    },
+    aiIcon: void 0
+  },
+  "aiProviderConfig"
+);
+const aiSessionCtx = $ctx(
+  {
+    abortController: null,
+    label: "",
+    lastInstruction: "",
+    lastLabel: void 0,
+    lastFrom: -1,
+    lastTo: -1,
+    diffOwnedByAI: false
+  },
+  "aiSession"
+);
+function emitAIError(ctx, error) {
+  const config = ctx.get(aiProviderConfig.key);
+  try {
+    config.onError(error);
+  } catch (handlerError) {
+    console.error("[milkdown/ai] onError handler failed:", handlerError);
+  }
+}
+function clearActiveSession(ctx) {
+  const current = ctx.get(aiSessionCtx.key);
+  ctx.set(aiSessionCtx.key, {
+    ...current,
+    abortController: null,
+    label: ""
+  });
+}
+async function runProvider(ctx, provider, promptContext, abortController) {
+  try {
+    const iterable = provider(promptContext, abortController.signal);
+    const commands = ctx.get(commandsCtx);
+    for await (const chunk of iterable) {
+      if (abortController.signal.aborted) break;
+      commands.call(pushChunkCmd.key, chunk);
+    }
+    if (abortController.signal.aborted) return;
+    const config = ctx.get(aiProviderConfig.key);
+    if (config.diffReviewOnEnd) {
+      const cur = ctx.get(aiSessionCtx.key);
+      ctx.set(aiSessionCtx.key, { ...cur, diffOwnedByAI: true });
+    }
+    const dispatched = commands.call(endStreamingCmd.key, {
+      diffReview: config.diffReviewOnEnd
+    });
+    if (config.diffReviewOnEnd && !dispatched) {
+      const cur = ctx.get(aiSessionCtx.key);
+      ctx.set(aiSessionCtx.key, { ...cur, diffOwnedByAI: false });
+    }
+  } catch (error) {
+    if (abortController.signal.aborted) return;
+    const milkdownError = aiProviderError(error);
+    emitAIError(ctx, milkdownError);
+    const commands = ctx.get(commandsCtx);
+    commands.call(abortStreamingCmd.key, { keep: false });
+  } finally {
+    const current = ctx.get(aiSessionCtx.key);
+    if (current.abortController === abortController) {
+      clearActiveSession(ctx);
+    }
+  }
+}
+const runAICmd = $command("RunAI", (ctx) => {
+  return (options) => (state, dispatch) => {
+    var _a, _b, _c, _d;
+    if (!(options == null ? void 0 : options.instruction)) return false;
+    const config = ctx.get(aiProviderConfig.key);
+    if (!config.provider) return false;
+    const session = ctx.get(aiSessionCtx.key);
+    if (session.abortController) return false;
+    if ((_a = streamingPluginKey.getState(state)) == null ? void 0 : _a.active) return false;
+    if ((_b = diffPluginKey.getState(state)) == null ? void 0 : _b.active) return false;
+    if (!dispatch) return true;
+    const abortController = new AbortController();
+    const { from, to } = state.selection;
+    ctx.set(aiSessionCtx.key, {
+      abortController,
+      label: (_c = options.label) != null ? _c : "",
+      lastInstruction: options.instruction,
+      lastLabel: options.label,
+      lastFrom: from,
+      lastTo: to,
+      // Reset every run; only the success path that hands off to diff
+      // review flips it back on.
+      diffOwnedByAI: false
+    });
+    const commands = ctx.get(commandsCtx);
+    const insertAt = state.selection.empty ? "cursor" : "selection";
+    if (!commands.call(startStreamingCmd.key, { insertAt })) {
+      clearActiveSession(ctx);
+      return false;
+    }
+    let promptContext;
+    try {
+      const buildContext = (_d = config.buildContext) != null ? _d : defaultBuildContext;
+      promptContext = buildContext(ctx, options.instruction);
+    } catch (error) {
+      const milkdownError = aiBuildContextError(error);
+      emitAIError(ctx, milkdownError);
+      commands.call(abortStreamingCmd.key, { keep: false });
+      clearActiveSession(ctx);
+      return false;
+    }
+    void runProvider(ctx, config.provider, promptContext, abortController);
+    return true;
+  };
+});
+const abortAICmd = $command("AbortAI", (ctx) => {
+  return (options) => (state, dispatch) => {
+    var _a;
+    const session = ctx.get(aiSessionCtx.key);
+    if (!dispatch) return !!session.abortController;
+    if (!session.abortController) return false;
+    session.abortController.abort();
+    clearActiveSession(ctx);
+    if ((_a = streamingPluginKey.getState(state)) == null ? void 0 : _a.active) {
+      const commands = ctx.get(commandsCtx);
+      commands.call(abortStreamingCmd.key, options);
+    }
+    return true;
+  };
+});
+
+var __typeError$a = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$a = (obj, member, msg) => member.has(obj) || __typeError$a("Cannot " + msg);
+var __privateGet$a = (obj, member, getter) => (__accessCheck$a(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$a = (obj, member, value) => member.has(obj) ? __typeError$a("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$a = (obj, member, value, setter) => (__accessCheck$a(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck$a(obj, member, "access private method"), method);
+var _panel, _host, _retryBtn, _config, _visible, _diffActive, _diffStartDoc, _ownedByAI, _DiffActionsPanelView_instances, findHost_fn, makeButton_fn, makeShortcutChip_fn, _retry, canRetry_fn, _rejectAll, _acceptAll;
+const PANEL_CLASS = "milkdown-ai-diff-actions";
+function setSanitizedIcon(host, svg) {
+  host.innerHTML = DOMPurify.sanitize(svg.trim());
+}
+function createIcon(svg) {
+  const span = document.createElement("span");
+  span.className = `${PANEL_CLASS}-icon`;
+  setSanitizedIcon(span, svg);
+  return span;
+}
+class DiffActionsPanelView {
+  constructor(ctx, view, config) {
+    this.ctx = ctx;
+    __privateAdd$a(this, _DiffActionsPanelView_instances);
+    __privateAdd$a(this, _panel);
+    __privateAdd$a(this, _host);
+    __privateAdd$a(this, _retryBtn);
+    __privateAdd$a(this, _config);
+    __privateAdd$a(this, _visible, false);
+    /// Tracks the diff plugin's `active` flag across transactions so we
+    /// can detect false→true / true→false edges independently of whether
+    /// the panel is actually being shown.
+    __privateAdd$a(this, _diffActive, false);
+    /// Doc snapshot at the moment diff review activated. If the live doc
+    /// drifts from this snapshot the user has accepted some per-change
+    /// diffs and the stored `lastFrom`/`lastTo` no longer point at the
+    /// original range — Retry is unsafe at that point.
+    __privateAdd$a(this, _diffStartDoc, null);
+    /// Whether the active diff review came from this AI session's
+    /// streaming hand-off (vs being started manually via
+    /// `startDiffReviewCmd`). Captured at the false→true transition.
+    /// The panel only renders when this is true so it doesn't take over
+    /// non-AI diff flows that exist independently of the AI feature.
+    __privateAdd$a(this, _ownedByAI, false);
+    __privateAdd$a(this, _retry, () => {
+      const session = this.ctx.get(aiSessionCtx.key);
+      if (!session.lastInstruction) return;
+      if (!__privateGet$a(this, _ownedByAI) || !__privateMethod(this, _DiffActionsPanelView_instances, canRetry_fn).call(this)) return;
+      const commands = this.ctx.get(commandsCtx);
+      commands.call(clearDiffReviewCmd.key);
+      const editorView = this.ctx.get(editorViewCtx);
+      const { doc } = editorView.state;
+      const from = Math.min(Math.max(session.lastFrom, 0), doc.content.size);
+      const to = Math.min(Math.max(session.lastTo, 0), doc.content.size);
+      editorView.dispatch(
+        editorView.state.tr.setSelection(
+          TextSelection.create(editorView.state.doc, from, to)
+        )
+      );
+      commands.call(runAICmd.key, {
+        instruction: session.lastInstruction,
+        label: session.lastLabel
+      });
+    });
+    __privateAdd$a(this, _rejectAll, () => {
+      this.ctx.get(commandsCtx).call(clearDiffReviewCmd.key);
+    });
+    __privateAdd$a(this, _acceptAll, () => {
+      this.ctx.get(commandsCtx).call(acceptAllDiffsCmd.key);
+    });
+    __privateSet$a(this, _config, config);
+    __privateSet$a(this, _host, __privateMethod(this, _DiffActionsPanelView_instances, findHost_fn).call(this, view));
+    const panel = document.createElement("div");
+    panel.className = PANEL_CLASS;
+    panel.dataset.show = "false";
+    __privateSet$a(this, _retryBtn, __privateMethod(this, _DiffActionsPanelView_instances, makeButton_fn).call(this, "retry", config.retryIcon, config.retryLabel, __privateGet$a(this, _retry)));
+    panel.appendChild(__privateGet$a(this, _retryBtn));
+    panel.appendChild(
+      __privateMethod(this, _DiffActionsPanelView_instances, makeButton_fn).call(this, "reject", config.rejectIcon, config.rejectAllLabel, __privateGet$a(this, _rejectAll))
+    );
+    const acceptBtn = __privateMethod(this, _DiffActionsPanelView_instances, makeButton_fn).call(this, "accept", config.acceptIcon, config.acceptAllLabel, __privateGet$a(this, _acceptAll));
+    acceptBtn.appendChild(__privateMethod(this, _DiffActionsPanelView_instances, makeShortcutChip_fn).call(this));
+    panel.appendChild(acceptBtn);
+    __privateSet$a(this, _panel, panel);
+    __privateGet$a(this, _host).appendChild(panel);
+    this.update(view);
+  }
+  update(view) {
+    var _a;
+    const diffActive = !!((_a = diffPluginKey.getState(view.state)) == null ? void 0 : _a.active);
+    if (diffActive !== __privateGet$a(this, _diffActive)) {
+      __privateSet$a(this, _diffActive, diffActive);
+      if (diffActive) {
+        const session = this.ctx.get(aiSessionCtx.key);
+        __privateSet$a(this, _ownedByAI, session.diffOwnedByAI);
+        __privateSet$a(this, _diffStartDoc, view.state.doc);
+      } else {
+        __privateSet$a(this, _ownedByAI, false);
+        __privateSet$a(this, _diffStartDoc, null);
+        const session = this.ctx.get(aiSessionCtx.key);
+        if (session.diffOwnedByAI) {
+          this.ctx.set(aiSessionCtx.key, {
+            ...session,
+            diffOwnedByAI: false
+          });
+        }
+      }
+    }
+    const shouldShow = diffActive && __privateGet$a(this, _ownedByAI);
+    if (shouldShow !== __privateGet$a(this, _visible)) {
+      __privateSet$a(this, _visible, shouldShow);
+      __privateGet$a(this, _panel).dataset.show = shouldShow ? "true" : "false";
+    }
+    if (shouldShow) {
+      const session = this.ctx.get(aiSessionCtx.key);
+      const docUntouched = !!__privateGet$a(this, _diffStartDoc) && view.state.doc.eq(__privateGet$a(this, _diffStartDoc));
+      __privateGet$a(this, _retryBtn).disabled = !session.lastInstruction || !docUntouched;
+    }
+  }
+  destroy() {
+    __privateGet$a(this, _panel).remove();
+  }
+}
+_panel = new WeakMap();
+_host = new WeakMap();
+_retryBtn = new WeakMap();
+_config = new WeakMap();
+_visible = new WeakMap();
+_diffActive = new WeakMap();
+_diffStartDoc = new WeakMap();
+_ownedByAI = new WeakMap();
+_DiffActionsPanelView_instances = new WeakSet();
+findHost_fn = function(view) {
+  var _a;
+  return (_a = view.dom.closest(".milkdown")) != null ? _a : document.body;
+};
+makeButton_fn = function(variant, icon, label, onClick) {
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = `${PANEL_CLASS}-btn ${PANEL_CLASS}-btn-${variant}`;
+  btn.appendChild(createIcon(icon));
+  const text = document.createElement("span");
+  text.textContent = label;
+  btn.appendChild(text);
+  btn.addEventListener("mousedown", (e) => e.preventDefault());
+  btn.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    onClick();
+  });
+  return btn;
+};
+makeShortcutChip_fn = function() {
+  const shortcut = document.createElement("span");
+  shortcut.className = `${PANEL_CLASS}-shortcut`;
+  const cmd = document.createElement("span");
+  cmd.textContent = __privateGet$a(this, _config).modSymbol;
+  const enter = document.createElement("span");
+  enter.className = `${PANEL_CLASS}-shortcut-icon`;
+  setSanitizedIcon(enter, __privateGet$a(this, _config).enterKeyIcon);
+  shortcut.append(cmd, enter);
+  return shortcut;
+};
+_retry = new WeakMap();
+canRetry_fn = function() {
+  if (!__privateGet$a(this, _diffStartDoc)) return false;
+  const editorView = this.ctx.get(editorViewCtx);
+  return editorView.state.doc.eq(__privateGet$a(this, _diffStartDoc));
+};
+_rejectAll = new WeakMap();
+_acceptAll = new WeakMap();
+
+const diffActionsPanelKey = new PluginKey("CREPE_AI_DIFF_ACTIONS_PANEL");
+const DEFAULT_DIFF_ACTIONS_RETRY_LABEL = "Retry";
+const DEFAULT_DIFF_ACTIONS_REJECT_ALL_LABEL = "Reject all";
+const DEFAULT_DIFF_ACTIONS_ACCEPT_ALL_LABEL = "Accept all";
+function detectModSymbol() {
+  var _a, _b, _c, _d;
+  if (typeof navigator === "undefined") return "\u2318";
+  const ua = navigator;
+  const platform = (_d = (_c = (_b = (_a = ua.userAgentData) == null ? void 0 : _a.platform) != null ? _b : ua.platform) != null ? _c : ua.userAgent) != null ? _d : "";
+  return /mac|iphone|ipad|ipod/i.test(platform) ? "\u2318" : "Ctrl";
+}
+const DEFAULT_DIFF_ACTIONS_MOD_SYMBOL = detectModSymbol();
+function resolveDiffActionsConfig(options) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const { config, enterKeyIcon: enterKeyIcon$1 } = options;
+  return {
+    retryLabel: (_a = config == null ? void 0 : config.retryLabel) != null ? _a : DEFAULT_DIFF_ACTIONS_RETRY_LABEL,
+    rejectAllLabel: (_b = config == null ? void 0 : config.rejectAllLabel) != null ? _b : DEFAULT_DIFF_ACTIONS_REJECT_ALL_LABEL,
+    acceptAllLabel: (_c = config == null ? void 0 : config.acceptAllLabel) != null ? _c : DEFAULT_DIFF_ACTIONS_ACCEPT_ALL_LABEL,
+    retryIcon: (_d = config == null ? void 0 : config.retryIcon) != null ? _d : retryIcon,
+    rejectIcon: (_e = config == null ? void 0 : config.rejectIcon) != null ? _e : clearIcon,
+    acceptIcon: (_f = config == null ? void 0 : config.acceptIcon) != null ? _f : confirmIcon,
+    enterKeyIcon: enterKeyIcon$1 != null ? enterKeyIcon$1 : enterKeyIcon,
+    modSymbol: (_g = config == null ? void 0 : config.modSymbol) != null ? _g : DEFAULT_DIFF_ACTIONS_MOD_SYMBOL
+  };
+}
+function diffActionsPanelPlugin(options = {}) {
+  const resolved = resolveDiffActionsConfig(options);
+  return $prose((ctx) => {
+    return new Plugin({
+      key: diffActionsPanelKey,
+      view(view) {
+        return new DiffActionsPanelView(ctx, view, resolved);
+      },
+      props: {
+        handleKeyDown(view, event) {
+          var _a;
+          if (event.key !== "Enter") return false;
+          if (!(event.metaKey || event.ctrlKey)) return false;
+          if (!((_a = diffPluginKey.getState(view.state)) == null ? void 0 : _a.active)) return false;
+          if (!ctx.get(aiSessionCtx.key).diffOwnedByAI) return false;
+          event.preventDefault();
+          const commands = ctx.get(commandsCtx);
+          commands.call(acceptAllDiffsCmd.key);
+          return true;
+        }
+      }
+    });
+  });
+}
+
+var __typeError$9 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$9 = (obj, member, msg) => member.has(obj) || __typeError$9("Cannot " + msg);
+var __privateGet$9 = (obj, member, getter) => (__accessCheck$9(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$9 = (obj, member, value) => member.has(obj) ? __typeError$9("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$9 = (obj, member, value, setter) => (__accessCheck$9(obj, member, "write to private field"), member.set(obj, value), value);
+var _nodes, _removeById;
+function createSubmenuBuilder(node) {
+  const builder = {
+    addItem: (id, item) => {
+      node.items.set(id, item);
+      return builder;
+    },
+    removeItem: (id) => {
+      node.items.delete(id);
+      return builder;
+    },
+    getItem: (id) => node.items.get(id),
+    clear: () => {
+      node.items.clear();
+      return builder;
+    }
+  };
+  return builder;
+}
+class AISuggestionsBuilder {
+  constructor() {
+    __privateAdd$9(this, _nodes, []);
+    this.addItem = (id, item) => {
+      __privateGet$9(this, _removeById).call(this, id);
+      __privateGet$9(this, _nodes).push({ kind: "item", id, item });
+      return this;
+    };
+    /// Add a submenu. Populate items via the optional `build` callback,
+    /// or call `getSubmenu(id)` afterward. Returns `this` so calls can be
+    /// chained at the parent level alongside `addItem`.
+    this.addSubmenu = (id, def, build) => {
+      __privateGet$9(this, _removeById).call(this, id);
+      const node = { def, items: /* @__PURE__ */ new Map() };
+      if (build) build(createSubmenuBuilder(node));
+      __privateGet$9(this, _nodes).push({ kind: "submenu", id, node });
+      return this;
+    };
+    this.removeItem = (id) => {
+      __privateGet$9(this, _removeById).call(this, id);
+      return this;
+    };
+    this.getItem = (id) => {
+      const node = __privateGet$9(this, _nodes).find((n) => n.kind === "item" && n.id === id);
+      return (node == null ? void 0 : node.kind) === "item" ? node.item : void 0;
+    };
+    /// Return a builder that mutates the submenu's items in place.
+    /// Multiple calls return distinct builder objects backed by the same
+    /// underlying node, so changes are always visible.
+    this.getSubmenu = (id) => {
+      const node = __privateGet$9(this, _nodes).find((n) => n.kind === "submenu" && n.id === id);
+      return (node == null ? void 0 : node.kind) === "submenu" ? createSubmenuBuilder(node.node) : void 0;
+    };
+    this.clear = () => {
+      __privateSet$9(this, _nodes, []);
+      return this;
+    };
+    this.build = () => {
+      const main = [];
+      const submenus = {};
+      for (const node of __privateGet$9(this, _nodes)) {
+        if (node.kind === "item") {
+          main.push({ kind: "item", id: node.id, item: node.item });
+        } else {
+          main.push({ kind: "submenu", id: node.id, def: node.node.def });
+          submenus[node.id] = {
+            def: node.node.def,
+            items: Array.from(node.node.items.entries()).map(([id, item]) => ({
+              id,
+              item
+            }))
+          };
+        }
+      }
+      return { main, submenus };
+    };
+    __privateAdd$9(this, _removeById, (id) => {
+      __privateSet$9(this, _nodes, __privateGet$9(this, _nodes).filter((n) => n.id !== id));
+    });
+  }
+}
+_nodes = new WeakMap();
+_removeById = new WeakMap();
+function applyDefaultSuggestions(builder) {
+  builder.addItem("improve", {
+    icon: aiIcon,
+    label: "Improve writing",
+    streamingLabel: "Improving writing",
+    prompt: "Improve the writing while preserving the original meaning."
+  }).addItem("grammar", {
+    icon: grammarCheckIcon,
+    label: "Fix grammar & spelling",
+    streamingLabel: "Fixing grammar & spelling",
+    prompt: "Fix any grammar and spelling errors without changing the meaning."
+  }).addItem("shorter", {
+    icon: shorterIcon,
+    label: "Make shorter",
+    streamingLabel: "Making shorter",
+    prompt: "Make this shorter while preserving the key information."
+  }).addItem("longer", {
+    icon: longerIcon,
+    label: "Make longer",
+    streamingLabel: "Expanding",
+    prompt: "Expand this with more detail and examples."
+  });
+  builder.addSubmenu(
+    "tone",
+    {
+      icon: editIcon,
+      label: "Change tone\u2026",
+      title: "Change tone",
+      searchPlaceholder: "Search tones\u2026"
+    },
+    (sub) => {
+      const tones = [
+        ["professional", "Professional"],
+        ["casual", "Casual"],
+        ["confident", "Confident"],
+        ["friendly", "Friendly"],
+        ["direct", "Direct"],
+        ["formal", "Formal"]
+      ];
+      for (const [id, label] of tones) {
+        sub.addItem(id, {
+          icon: editIcon,
+          label,
+          streamingLabel: "Adjusting tone",
+          prompt: `Rewrite this in a ${label.toLowerCase()} tone.`
+        });
+      }
+    }
+  );
+  builder.addSubmenu(
+    "translate",
+    {
+      icon: translateIcon,
+      label: "Translate\u2026",
+      title: "Translate",
+      searchPlaceholder: "Search languages\u2026"
+    },
+    (sub) => {
+      const languages = [
+        ["english", "English", "English"],
+        ["chinese", "Chinese", "Chinese (Simplified)"],
+        ["japanese", "Japanese", "Japanese"],
+        ["korean", "Korean", "Korean"],
+        ["spanish", "Spanish", "Spanish"],
+        ["french", "French", "French"],
+        ["german", "German", "German"]
+      ];
+      for (const [id, label, promptName] of languages) {
+        sub.addItem(id, {
+          icon: translateIcon,
+          label,
+          streamingLabel: `Translating to ${label}`,
+          prompt: `Translate this to ${promptName}.`
+        });
+      }
+    }
+  );
+}
+
+function keepAlive(..._args) {
+}
+
+keepAlive(h);
+function renderHighlighted(label, query) {
+  const q = query.trim();
+  if (!q) return [label];
+  const lower = label.toLowerCase();
+  const lq = q.toLowerCase();
+  const idx = lower.indexOf(lq);
+  if (idx === -1) return [label];
+  return [
+    label.slice(0, idx),
+    h("mark", null, label.slice(idx, idx + q.length)),
+    label.slice(idx + q.length)
+  ];
+}
+const AIInstructionInput = defineComponent({
+  props: {
+    placeholder: { type: Object, required: true },
+    resetSignal: { type: Object, required: true },
+    suggestions: { type: Object, required: true },
+    chrome: { type: Object, required: true },
+    onConfirm: { type: Function, required: true },
+    onCancel: { type: Function, required: true }
+  },
+  setup({
+    placeholder,
+    resetSignal,
+    suggestions,
+    chrome,
+    onConfirm,
+    onCancel
+  }) {
+    const inputValue = ref("");
+    const view = ref({ kind: "main" });
+    const selectedIndex = ref(0);
+    const inputRef = ref(null);
+    const listRef = ref(null);
+    const listboxId = `ai-instruction-list-${Math.random().toString(36).slice(2, 9)}`;
+    const optionId = (idx) => `${listboxId}-opt-${idx}`;
+    watch(resetSignal, () => {
+      inputValue.value = "";
+      view.value = { kind: "main" };
+      selectedIndex.value = 0;
+    });
+    const allItems = computed(() => {
+      if (view.value.kind === "submenu") {
+        const submenu = suggestions.submenus[view.value.id];
+        if (!submenu) return [];
+        return submenu.items.map(({ id, item }) => ({
+          id,
+          icon: item.icon,
+          label: item.label,
+          hasSubmenu: false,
+          prompt: { text: item.prompt, streamingLabel: item.streamingLabel }
+        }));
+      }
+      return suggestions.main.map((entry) => {
+        if (entry.kind === "item") {
+          return {
+            id: entry.id,
+            icon: entry.item.icon,
+            label: entry.item.label,
+            hasSubmenu: false,
+            prompt: {
+              text: entry.item.prompt,
+              streamingLabel: entry.item.streamingLabel
+            }
+          };
+        }
+        return {
+          id: entry.id,
+          icon: entry.def.icon,
+          label: entry.def.label,
+          hasSubmenu: true
+        };
+      });
+    });
+    const currentSubmenuDef = computed(() => {
+      var _a, _b;
+      if (view.value.kind !== "submenu") return null;
+      return (_b = (_a = suggestions.submenus[view.value.id]) == null ? void 0 : _a.def) != null ? _b : null;
+    });
+    const filteredItems = computed(() => {
+      const q = inputValue.value.trim().toLowerCase();
+      if (!q) return allItems.value;
+      return allItems.value.filter(
+        (item) => item.label.toLowerCase().includes(q)
+      );
+    });
+    const showSendAsPrompt = computed(() => inputValue.value.trim().length > 0);
+    const totalItems = computed(
+      () => filteredItems.value.length + (showSendAsPrompt.value ? 1 : 0)
+    );
+    watch([filteredItems, view, showSendAsPrompt], () => {
+      selectedIndex.value = showSendAsPrompt.value ? filteredItems.value.length : 0;
+    });
+    const focusInput = () => {
+      void nextTick(() => {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.focus();
+      });
+    };
+    const enterSubmenu = (id) => {
+      view.value = { kind: "submenu", id };
+      inputValue.value = "";
+      selectedIndex.value = 0;
+      focusInput();
+    };
+    const exitSubmenu = () => {
+      view.value = { kind: "main" };
+      inputValue.value = "";
+      selectedIndex.value = 0;
+      focusInput();
+    };
+    const runItem = (item) => {
+      if (item.hasSubmenu) {
+        enterSubmenu(item.id);
+      } else if (item.prompt) {
+        onConfirm(item.prompt.text, item.prompt.streamingLabel);
+        inputValue.value = "";
+      }
+    };
+    const submitRaw = () => {
+      const v = inputValue.value.trim();
+      if (!v) return;
+      onConfirm(v);
+      inputValue.value = "";
+    };
+    const onSelectCurrent = () => {
+      const idx = selectedIndex.value;
+      const items = filteredItems.value;
+      if (idx < items.length) {
+        runItem(items[idx]);
+      } else if (showSendAsPrompt.value) {
+        submitRaw();
+      }
+    };
+    const scrollToSelected = () => {
+      void nextTick(() => {
+        const list = listRef.value;
+        if (!list) return;
+        const el = list.querySelector(
+          `[data-index="${selectedIndex.value}"]`
+        );
+        el == null ? void 0 : el.scrollIntoView({ block: "nearest" });
+      });
+    };
+    const onKeydown = (e) => {
+      e.stopPropagation();
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        if (totalItems.value === 0) return;
+        selectedIndex.value = (selectedIndex.value + 1) % totalItems.value;
+        scrollToSelected();
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        if (totalItems.value === 0) return;
+        selectedIndex.value = (selectedIndex.value - 1 + totalItems.value) % totalItems.value;
+        scrollToSelected();
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        onSelectCurrent();
+        return;
+      }
+      if (e.key === "Escape") {
+        e.preventDefault();
+        if (view.value.kind === "submenu") exitSubmenu();
+        else onCancel();
+        return;
+      }
+      if (e.key === "Backspace" && inputValue.value === "" && view.value.kind === "submenu") {
+        e.preventDefault();
+        exitSubmenu();
+      }
+    };
+    const onItemPointerDown = (e) => {
+      e.preventDefault();
+    };
+    return () => {
+      const items = filteredItems.value;
+      const showPrompt = showSendAsPrompt.value;
+      const submenuDef = currentSubmenuDef.value;
+      return /* @__PURE__ */ h("div", { class: "ai-instruction" }, /* @__PURE__ */ h("div", { class: "ai-instruction-input" }, /* @__PURE__ */ h("span", { class: "ai-instruction-input-prefix" }, /* @__PURE__ */ h(Icon, { icon: chrome.aiIcon })), /* @__PURE__ */ h(
+        "input",
+        {
+          ref: inputRef,
+          class: "ai-instruction-input-field",
+          role: "combobox",
+          "aria-expanded": "true",
+          "aria-autocomplete": "list",
+          "aria-controls": listboxId,
+          "aria-activedescendant": totalItems.value > 0 ? optionId(selectedIndex.value) : void 0,
+          placeholder: submenuDef ? submenuDef.searchPlaceholder : placeholder.value,
+          value: inputValue.value,
+          onInput: (e) => {
+            inputValue.value = e.target.value;
+          },
+          onKeydown
+        }
+      ), /* @__PURE__ */ h(
+        "button",
+        {
+          type: "button",
+          class: "ai-instruction-submit",
+          "aria-label": chrome.submitButtonLabel,
+          disabled: !showPrompt,
+          onMousedown: onItemPointerDown,
+          onClick: submitRaw
+        },
+        /* @__PURE__ */ h(Icon, { icon: chrome.sendIcon })
+      )), /* @__PURE__ */ h(
+        "div",
+        {
+          class: "ai-instruction-list",
+          ref: listRef,
+          id: listboxId,
+          role: "listbox",
+          "aria-label": chrome.listboxLabel
+        },
+        submenuDef && /* @__PURE__ */ h(
+          "button",
+          {
+            type: "button",
+            class: "ai-instruction-back",
+            onMousedown: onItemPointerDown,
+            onClick: exitSubmenu
+          },
+          /* @__PURE__ */ h("span", { class: "ai-instruction-back-icon", "aria-hidden": "true" }, /* @__PURE__ */ h(Icon, { icon: chrome.chevronLeftIcon })),
+          /* @__PURE__ */ h("span", null, submenuDef.title)
+        ),
+        items.length > 0 && /* @__PURE__ */ h("div", { class: "ai-instruction-section" }, /* @__PURE__ */ h("div", { class: "ai-instruction-section-header" }, chrome.suggestionsHeaderLabel), items.map((item, idx) => /* @__PURE__ */ h(
+          "div",
+          {
+            key: item.id,
+            id: optionId(idx),
+            "data-index": idx,
+            role: "option",
+            "aria-selected": idx === selectedIndex.value,
+            class: [
+              "ai-instruction-item",
+              idx === selectedIndex.value ? "active" : ""
+            ],
+            onMousedown: onItemPointerDown,
+            onClick: () => runItem(item),
+            onPointerenter: () => {
+              selectedIndex.value = idx;
+            }
+          },
+          /* @__PURE__ */ h("span", { class: "ai-instruction-item-icon" }, /* @__PURE__ */ h(Icon, { icon: item.icon })),
+          /* @__PURE__ */ h("span", { class: "ai-instruction-item-label" }, renderHighlighted(item.label, inputValue.value)),
+          item.hasSubmenu && /* @__PURE__ */ h("span", { class: "ai-instruction-item-arrow" }, /* @__PURE__ */ h(Icon, { icon: chrome.chevronRightIcon }))
+        ))),
+        showPrompt && /* @__PURE__ */ h("div", { class: "ai-instruction-section" }, /* @__PURE__ */ h("div", { class: "ai-instruction-section-header" }, chrome.sendAsPromptHeaderLabel), /* @__PURE__ */ h(
+          "div",
+          {
+            id: optionId(items.length),
+            "data-index": items.length,
+            role: "option",
+            "aria-selected": selectedIndex.value === items.length,
+            class: [
+              "ai-instruction-item",
+              "ai-instruction-item-prompt",
+              selectedIndex.value === items.length ? "active" : ""
+            ],
+            onMousedown: onItemPointerDown,
+            onClick: submitRaw,
+            onPointerenter: () => {
+              selectedIndex.value = items.length;
+            }
+          },
+          /* @__PURE__ */ h("span", { class: "ai-instruction-item-icon" }, /* @__PURE__ */ h(Icon, { icon: chrome.sendPromptIcon })),
+          /* @__PURE__ */ h("span", { class: "ai-instruction-item-label" }, chrome.sendAsPromptLabel, " ", /* @__PURE__ */ h("span", { class: "ai-instruction-item-quote" }, '"', inputValue.value, '"')),
+          /* @__PURE__ */ h("span", { class: "ai-instruction-item-shortcut" }, /* @__PURE__ */ h(Icon, { icon: chrome.enterKeyIcon }))
+        ))
+      ));
+    };
+  }
+});
+
+var __typeError$8 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$8 = (obj, member, msg) => member.has(obj) || __typeError$8("Cannot " + msg);
+var __privateGet$8 = (obj, member, getter) => (__accessCheck$8(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$8 = (obj, member, value) => member.has(obj) ? __typeError$8("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$8 = (obj, member, value, setter) => (__accessCheck$8(obj, member, "write to private field"), member.set(obj, value), value);
+var _content$4, _provider$2, _app$5, _placeholder, _resetSignal, _from, _to, _wantsShow, _onConfirm, _onCancel;
+class AIInstructionTooltipView {
+  constructor(ctx, view, config) {
+    this.ctx = ctx;
+    __privateAdd$8(this, _content$4);
+    __privateAdd$8(this, _provider$2);
+    __privateAdd$8(this, _app$5);
+    __privateAdd$8(this, _placeholder);
+    __privateAdd$8(this, _resetSignal);
+    __privateAdd$8(this, _from, -1);
+    __privateAdd$8(this, _to, -1);
+    /// Source of truth for "should the palette currently be showing".
+    /// `TooltipProvider.shouldShow` reads this so that forwarding `update()`
+    /// to the provider on every editor transition (needed to keep the
+    /// floating position in sync with layout changes) doesn't dismiss the
+    /// palette behind our back.
+    __privateAdd$8(this, _wantsShow, false);
+    __privateAdd$8(this, _onConfirm, (instruction, label) => {
+      if (!instruction.trim()) return;
+      const commands = this.ctx.get(commandsCtx);
+      const accepted = commands.call(runAICmd.key, { instruction, label });
+      if (!accepted) return;
+      __privateSet$8(this, _wantsShow, false);
+      __privateGet$8(this, _provider$2).hide();
+    });
+    __privateAdd$8(this, _onCancel, () => {
+      __privateSet$8(this, _wantsShow, false);
+      __privateGet$8(this, _provider$2).hide();
+    });
+    this.show = (from, to) => {
+      __privateSet$8(this, _from, from);
+      __privateSet$8(this, _to, to);
+      __privateGet$8(this, _resetSignal).value++;
+      __privateSet$8(this, _wantsShow, true);
+      const view = this.ctx.get(editorViewCtx);
+      __privateGet$8(this, _provider$2).show(
+        { getBoundingClientRect: () => posToDOMRect(view, from, to) },
+        view
+      );
+      requestAnimationFrame(() => {
+        var _a;
+        (_a = __privateGet$8(this, _content$4).querySelector("input")) == null ? void 0 : _a.focus();
+      });
+    };
+    this.update = (view, prevState) => {
+      const { selection } = view.state;
+      const isTextSelection = selection instanceof TextSelection;
+      const movedRange = selection.from !== __privateGet$8(this, _from) || selection.to !== __privateGet$8(this, _to);
+      if (!isTextSelection || movedRange) {
+        __privateSet$8(this, _wantsShow, false);
+        __privateGet$8(this, _provider$2).hide();
+        return;
+      }
+      __privateGet$8(this, _provider$2).update(view, prevState);
+    };
+    this.destroy = () => {
+      __privateGet$8(this, _app$5).unmount();
+      __privateGet$8(this, _provider$2).destroy();
+      __privateGet$8(this, _content$4).remove();
+    };
+    __privateSet$8(this, _placeholder, ref(config.placeholder));
+    __privateSet$8(this, _resetSignal, ref(0));
+    const content = document.createElement("div");
+    content.className = "milkdown-ai-instruction";
+    const app = createApp(AIInstructionInput, {
+      placeholder: __privateGet$8(this, _placeholder),
+      resetSignal: __privateGet$8(this, _resetSignal),
+      suggestions: config.suggestions,
+      chrome: config.chrome,
+      onConfirm: __privateGet$8(this, _onConfirm),
+      onCancel: __privateGet$8(this, _onCancel)
+    });
+    app.mount(content);
+    __privateSet$8(this, _app$5, app);
+    __privateSet$8(this, _content$4, content);
+    __privateSet$8(this, _provider$2, new TooltipProvider({
+      content,
+      debounce: 0,
+      offset: 10,
+      shouldShow: () => __privateGet$8(this, _wantsShow),
+      floatingUIOptions: {
+        placement: "bottom"
+      }
+    }));
+    __privateGet$8(this, _provider$2).onHide = () => {
+      __privateSet$8(this, _wantsShow, false);
+      requestAnimationFrame(() => {
+        try {
+          const root = __privateGet$8(this, _content$4).getRootNode();
+          const active = root.activeElement;
+          if (!active || !__privateGet$8(this, _content$4).contains(active)) return;
+          const v = this.ctx.get(editorViewCtx);
+          v.dom.focus({ preventScroll: true });
+        } catch (e) {
+        }
+      });
+    };
+    __privateGet$8(this, _provider$2).update(view);
+  }
+}
+_content$4 = new WeakMap();
+_provider$2 = new WeakMap();
+_app$5 = new WeakMap();
+_placeholder = new WeakMap();
+_resetSignal = new WeakMap();
+_from = new WeakMap();
+_to = new WeakMap();
+_wantsShow = new WeakMap();
+_onConfirm = new WeakMap();
+_onCancel = new WeakMap();
+
+const defaultAPI = {
+  show: () => {
+  }
+};
+const aiInstructionTooltipAPI = $ctx(
+  { ...defaultAPI },
+  "aiInstructionTooltipAPI"
+);
+const aiInstructionTooltip = tooltipFactory("CREPE_AI_INSTRUCTION");
+const DEFAULT_SUGGESTIONS_HEADER_LABEL = "SUGGESTIONS";
+const DEFAULT_SEND_AS_PROMPT_HEADER_LABEL = "SEND AS PROMPT";
+const DEFAULT_SEND_AS_PROMPT_LABEL = "Ask AI:";
+const DEFAULT_SUBMIT_BUTTON_LABEL = "Send prompt";
+const DEFAULT_LISTBOX_LABEL = "AI suggestions";
+const DEFAULT_INSTRUCTION_PLACEHOLDER = "Tell AI what to do with the selection\u2026";
+function resolveChrome(config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  return {
+    aiIcon: (_a = config == null ? void 0 : config.aiIcon) != null ? _a : aiIcon,
+    sendIcon: (_b = config == null ? void 0 : config.sendIcon) != null ? _b : sendIcon,
+    sendPromptIcon: (_c = config == null ? void 0 : config.sendPromptIcon) != null ? _c : sendPromptIcon,
+    enterKeyIcon: (_d = config == null ? void 0 : config.enterKeyIcon) != null ? _d : enterKeyIcon,
+    chevronLeftIcon: (_e = config == null ? void 0 : config.chevronLeftIcon) != null ? _e : chevronLeftIcon,
+    chevronRightIcon: (_f = config == null ? void 0 : config.chevronRightIcon) != null ? _f : chevronRightIcon,
+    suggestionsHeaderLabel: (_g = config == null ? void 0 : config.suggestionsHeaderLabel) != null ? _g : DEFAULT_SUGGESTIONS_HEADER_LABEL,
+    sendAsPromptHeaderLabel: (_h = config == null ? void 0 : config.sendAsPromptHeaderLabel) != null ? _h : DEFAULT_SEND_AS_PROMPT_HEADER_LABEL,
+    sendAsPromptLabel: (_i = config == null ? void 0 : config.sendAsPromptLabel) != null ? _i : DEFAULT_SEND_AS_PROMPT_LABEL,
+    submitButtonLabel: (_j = config == null ? void 0 : config.submitButtonLabel) != null ? _j : DEFAULT_SUBMIT_BUTTON_LABEL,
+    listboxLabel: (_k = config == null ? void 0 : config.listboxLabel) != null ? _k : DEFAULT_LISTBOX_LABEL
+  };
+}
+function resolveViewConfig(config) {
+  var _a, _b;
+  const builder = new AISuggestionsBuilder();
+  applyDefaultSuggestions(builder);
+  (_a = config == null ? void 0 : config.buildAISuggestions) == null ? void 0 : _a.call(config, builder);
+  return {
+    placeholder: (_b = config == null ? void 0 : config.instructionPlaceholder) != null ? _b : DEFAULT_INSTRUCTION_PLACEHOLDER,
+    chrome: resolveChrome(config),
+    suggestions: builder.build()
+  };
+}
+function configureAIInstructionTooltip(config) {
+  return (ctx) => {
+    const viewConfig = resolveViewConfig(config);
+    let tooltipView = null;
+    ctx.update(aiInstructionTooltipAPI.key, (api) => ({
+      ...api,
+      show: (from, to) => {
+        tooltipView == null ? void 0 : tooltipView.show(from, to);
+      }
+    }));
+    ctx.set(aiInstructionTooltip.key, {
+      view: (view) => {
+        tooltipView = new AIInstructionTooltipView(ctx, view, viewConfig);
+        return tooltipView;
+      }
+    });
+  };
+}
+
+var __typeError$7 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$7 = (obj, member, msg) => member.has(obj) || __typeError$7("Cannot " + msg);
+var __privateGet$7 = (obj, member, getter) => (__accessCheck$7(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$7 = (obj, member, value) => member.has(obj) ? __typeError$7("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$7 = (obj, member, value, setter) => (__accessCheck$7(obj, member, "write to private field"), member.set(obj, value), value);
+var _spinner, _label, _fallbackLabel, _start, _lastLabelText, _rafId, _tick;
+const CLASS_PREFIX = "milkdown-ai-streaming";
+const SPINNER_PERIOD_MS = 800;
+const DEFAULT_STREAMING_FALLBACK_LABEL = "Generating";
+const DEFAULT_STREAMING_CANCEL_HINT = "Esc to cancel";
+const indicatorKey = new PluginKey(
+  "CREPE_AI_STREAMING_INDICATOR"
+);
+class IndicatorWidget {
+  constructor(ctx, fallbackLabel, cancelHint) {
+    __privateAdd$7(this, _spinner);
+    __privateAdd$7(this, _label);
+    __privateAdd$7(this, _fallbackLabel);
+    __privateAdd$7(this, _start, performance.now());
+    __privateAdd$7(this, _lastLabelText, "");
+    __privateAdd$7(this, _rafId, 0);
+    __privateAdd$7(this, _tick, () => {
+      const elapsed = performance.now() - __privateGet$7(this, _start);
+      const angle = elapsed / SPINNER_PERIOD_MS * 360;
+      __privateGet$7(this, _spinner).style.transform = `rotate(${angle}deg)`;
+      __privateSet$7(this, _rafId, requestAnimationFrame(__privateGet$7(this, _tick)));
+    });
+    __privateSet$7(this, _fallbackLabel, fallbackLabel);
+    const dom = document.createElement("span");
+    dom.className = `${CLASS_PREFIX}-indicator`;
+    dom.contentEditable = "false";
+    dom.setAttribute("role", "status");
+    dom.setAttribute("aria-live", "polite");
+    const spinner = document.createElement("span");
+    spinner.className = `${CLASS_PREFIX}-spinner`;
+    spinner.setAttribute("aria-hidden", "true");
+    dom.appendChild(spinner);
+    const label = document.createElement("span");
+    label.className = `${CLASS_PREFIX}-label`;
+    dom.appendChild(label);
+    const escHint = document.createElement("span");
+    escHint.className = `${CLASS_PREFIX}-esc`;
+    escHint.textContent = cancelHint;
+    dom.appendChild(escHint);
+    this.dom = dom;
+    __privateSet$7(this, _spinner, spinner);
+    __privateSet$7(this, _label, label);
+    this.setLabel(ctx);
+    __privateGet$7(this, _tick).call(this);
+  }
+  setLabel(ctx) {
+    const session = ctx.get(aiSessionCtx.key);
+    const text = `${session.label || __privateGet$7(this, _fallbackLabel)}\u2026`;
+    if (text === __privateGet$7(this, _lastLabelText)) return;
+    __privateSet$7(this, _lastLabelText, text);
+    __privateGet$7(this, _label).textContent = text;
+  }
+  destroy() {
+    if (__privateGet$7(this, _rafId)) cancelAnimationFrame(__privateGet$7(this, _rafId));
+    __privateSet$7(this, _rafId, 0);
+  }
+}
+_spinner = new WeakMap();
+_label = new WeakMap();
+_fallbackLabel = new WeakMap();
+_start = new WeakMap();
+_lastLabelText = new WeakMap();
+_rafId = new WeakMap();
+_tick = new WeakMap();
+function streamingIndicatorPlugin(options = {}) {
+  var _a, _b;
+  const { config } = options;
+  const fallbackLabel = (_a = config == null ? void 0 : config.fallbackLabel) != null ? _a : DEFAULT_STREAMING_FALLBACK_LABEL;
+  const cancelHint = (_b = config == null ? void 0 : config.cancelHint) != null ? _b : DEFAULT_STREAMING_CANCEL_HINT;
+  return $prose((ctx) => {
+    let widget = null;
+    function ensureWidget() {
+      if (!widget) widget = new IndicatorWidget(ctx, fallbackLabel, cancelHint);
+      else widget.setLabel(ctx);
+      return widget;
+    }
+    function dropWidget() {
+      if (widget) {
+        widget.destroy();
+        widget = null;
+      }
+    }
+    function buildSet(doc, insertEndPos) {
+      const pos = Math.min(insertEndPos, doc.content.size);
+      const decoration = Decoration.widget(pos, ensureWidget().dom, {
+        side: 1,
+        key: "ai-streaming-indicator"
+      });
+      return DecorationSet.create(doc, [decoration]);
+    }
+    return new Plugin({
+      key: indicatorKey,
+      state: {
+        init: () => DecorationSet.empty,
+        apply(tr, decorations, _oldState, newState) {
+          const streaming = streamingPluginKey.getState(newState);
+          if (!(streaming == null ? void 0 : streaming.active) || streaming.insertEndPos == null) {
+            dropWidget();
+            return DecorationSet.empty;
+          }
+          if (tr.getMeta(streamingPluginKey) || tr.docChanged) {
+            return buildSet(newState.doc, streaming.insertEndPos);
+          }
+          return decorations.map(tr.mapping, tr.doc);
+        }
+      },
+      view() {
+        return {
+          destroy() {
+            dropWidget();
+          }
+        };
+      },
+      props: {
+        decorations(state) {
+          var _a2;
+          return (_a2 = indicatorKey.getState(state)) != null ? _a2 : DecorationSet.empty;
+        },
+        handleKeyDown(view, event) {
+          var _a2;
+          if (event.key !== "Escape") return false;
+          const commands = ctx.get(commandsCtx);
+          if (ctx.get(aiSessionCtx.key).abortController) {
+            event.preventDefault();
+            commands.call(abortAICmd.key, { keep: true });
+            return true;
+          }
+          if ((_a2 = streamingPluginKey.getState(view.state)) == null ? void 0 : _a2.active) {
+            event.preventDefault();
+            commands.call(abortStreamingCmd.key, { keep: true });
+            return true;
+          }
+          return false;
+        }
+      }
+    });
+  });
+}
+
+const CREPE_CUSTOM_BLOCK_TYPES = ["table", "image-block", "code_block"];
+const CREPE_IGNORE_ATTRS = { heading: ["id"] };
+const ai = (editor, config) => {
+  var _a, _b;
+  const diffCfg = (_a = config == null ? void 0 : config.diff) != null ? _a : {};
+  const streamingCfg = (_b = config == null ? void 0 : config.streaming) != null ? _b : {};
+  editor.config(crepeFeatureConfig(CrepeFeature.AI)).config((ctx) => {
+    ctx.update(diffConfig.key, (prev) => {
+      var _a2;
+      return {
+        ...prev,
+        ignoreAttrs: (_a2 = diffCfg.ignoreAttrs) != null ? _a2 : CREPE_IGNORE_ATTRS
+      };
+    });
+    const { ignoreAttrs: _, ...componentConfig } = diffCfg;
+    ctx.update(diffComponentConfig.key, (prev) => {
+      var _a2;
+      return {
+        ...prev,
+        customBlockTypes: (_a2 = componentConfig.customBlockTypes) != null ? _a2 : CREPE_CUSTOM_BLOCK_TYPES,
+        ...componentConfig
+      };
+    });
+  }).use(diff).use(diffComponent).config((ctx) => {
+    ctx.update(streamingConfig.key, (prev) => {
+      var _a2;
+      return {
+        ...prev,
+        ...streamingCfg,
+        ignoreAttrs: (_a2 = streamingCfg.ignoreAttrs) != null ? _a2 : CREPE_IGNORE_ATTRS,
+        // Wire diffReviewOnEnd into the streaming plugin so manual
+        // endStreamingCmd calls (outside runAICmd) also respect it.
+        // Only override if the user explicitly set it — otherwise
+        // keep the streaming plugin's own default so tests and
+        // manual-streaming use cases aren't surprised.
+        ...(config == null ? void 0 : config.diffReviewOnEnd) !== void 0 ? { diffReviewOnEnd: config.diffReviewOnEnd } : {}
+      };
+    });
+  }).use(streaming).config((ctx) => {
+    ctx.update(aiProviderConfig.key, (prev) => {
+      var _a2;
+      return {
+        ...prev,
+        ...(config == null ? void 0 : config.provider) !== void 0 ? { provider: config.provider } : {},
+        ...(config == null ? void 0 : config.buildContext) !== void 0 ? { buildContext: config.buildContext } : {},
+        diffReviewOnEnd: (_a2 = config == null ? void 0 : config.diffReviewOnEnd) != null ? _a2 : prev.diffReviewOnEnd,
+        ...(config == null ? void 0 : config.onError) !== void 0 ? { onError: config.onError } : {},
+        ...(config == null ? void 0 : config.aiIcon) !== void 0 ? { aiIcon: config.aiIcon } : {}
+      };
+    });
+  }).use(aiProviderConfig).use(aiSessionCtx).use(runAICmd).use(abortAICmd).config(configureAIInstructionTooltip(config)).use(aiInstructionTooltipAPI).use(aiInstructionTooltip).use(streamingIndicatorPlugin({ config: config == null ? void 0 : config.streamingIndicator })).use(
+    diffActionsPanelPlugin({
+      config: config == null ? void 0 : config.diffActions,
+      enterKeyIcon: config == null ? void 0 : config.enterKeyIcon
+    })
+  );
+};
+
 function isInCodeBlock(selection) {
   const type = selection.$from.parent.type;
   return type.name === "code_block";
@@ -837,9 +2220,6 @@ class GroupBuilder {
 _groups = new WeakMap();
 _getGroupInstance = new WeakMap();
 
-function keepAlive(..._args) {
-}
-
 function getGroups$2(filter, config, ctx) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa, _ta, _ua, _va, _wa, _xa, _ya, _za, _Aa, _Ba, _Ca, _Da, _Ea, _Fa, _Ga, _Ha, _Ia, _Ja, _Ka, _La, _Ma, _Na, _Oa, _Pa, _Qa, _Ra, _Sa, _Ta, _Ua, _Va, _Wa, _Xa, _Ya, _Za, __a, _$a, _ab, _bb, _cb, _db, _eb, _fb, _gb, _hb, _ib, _jb, _kb;
   const flags = ctx && useCrepeFeatures(ctx).get();
@@ -1830,6 +3210,7 @@ class LatexInlineTooltip {
     });
     __privateAdd$3(this, _shouldShow, (view) => {
       const shouldShow = () => {
+        if (!view.editable) return false;
         const { selection, schema } = view.state;
         if (selection.empty) return false;
         if (!(selection instanceof NodeSelection)) return false;
@@ -2130,7 +3511,7 @@ const table = (editor, config) => {
 };
 
 function getGroups$1(config, ctx) {
-  var _a, _b, _c, _d, _e, _f, _g;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const groupBuilder = new GroupBuilder();
   groupBuilder.addGroup("formatting", "Formatting").addItem("bold", {
     icon: (_a = config == null ? void 0 : config.boldIcon) != null ? _a : boldIcon,
@@ -2213,7 +3594,22 @@ function getGroups$1(config, ctx) {
       commands.call(toggleLinkCommand.key);
     }
   });
-  (_g = config == null ? void 0 : config.buildToolbar) == null ? void 0 : _g.call(config, groupBuilder);
+  if (ctx && (flags == null ? void 0 : flags.includes(CrepeFeature.AI))) {
+    const aiCfg = ctx.get(aiProviderConfig.key);
+    if (aiCfg.provider) {
+      functionGroup.addItem("ai", {
+        icon: (_h = (_g = config == null ? void 0 : config.aiIcon) != null ? _g : aiCfg.aiIcon) != null ? _h : aiIcon,
+        active: () => false,
+        onRun: (ctx2) => {
+          const api = ctx2.get(aiInstructionTooltipAPI.key);
+          const view = ctx2.get(editorViewCtx);
+          const { from, to } = view.state.selection;
+          api.show(from, to);
+        }
+      });
+    }
+  }
+  (_i = config == null ? void 0 : config.buildToolbar) == null ? void 0 : _i.call(config, groupBuilder);
   return groupBuilder.build();
 }
 
@@ -2836,6 +4232,9 @@ function loadFeature(feature, editor, config) {
     case CrepeFeature.TopBar: {
       return topBar(editor, config);
     }
+    case CrepeFeature.AI: {
+      return ai(editor, config);
+    }
   }
 }