quoin-editor 0.4.2 → 1.0.0

package/dist/ai.cjs

@@ -0,0 +1,1107 @@
+'use client';"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+var _chunkQAW5NH6Scjs = require('./chunk-QAW5NH6S.cjs');
+
+
+var _chunkWXMYDXPNcjs = require('./chunk-WXMYDXPN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2VDK27IFcjs = require('./chunk-2VDK27IF.cjs');
+
+
+
+
+
+var _chunkGTTPVJSDcjs = require('./chunk-GTTPVJSD.cjs');
+require('./chunk-OMOBMXD5.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPZ4GT5JOcjs = require('./chunk-PZ4GT5JO.cjs');
+require('./chunk-2QCRZ7OL.cjs');
+
+
+
+
+
+var _chunkND5XJVK2cjs = require('./chunk-ND5XJVK2.cjs');
+
+// src/extensions/ai/streaming-markdown.ts
+var FENCE = /^ {0,3}(`{3,}|~{3,})/;
+var MARKER_ONLY = /^\s*(?:[-*+]|\d+[.)]|#{1,6}|>)\s*$/;
+var LINE_PREFIX = /^\s*(?:>\s?)*(?:(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?|#{1,6}\s+)?/;
+var BLOCK_START = /^\s*(?:[-*+]\s|\d+[.)]\s|#{1,6}\s|>)/;
+var OPEN_ADDRESS = /\[([^\]]*)\]\(([^)\s]*)$/;
+var OPEN_TEXT = /\[([^\]]*)$/;
+var DOUBLE = ["**", "__", "~~"];
+var WORD = /[\p{L}\p{N}]/u;
+var isSpace = (char) => char === void 0 || /\s/.test(char);
+function openFence(lines) {
+  let open = null;
+  for (const line of lines) {
+    const fence = _optionalChain([FENCE, 'access', _2 => _2.exec, 'call', _3 => _3(line), 'optionalAccess', _4 => _4[1]]);
+    if (open === null) open = _nullishCoalesce(fence, () => ( null));
+    else if (fence !== void 0 && fence[0] === open[0] && fence.length >= open.length && line.trim() === fence) {
+      open = null;
+    }
+  }
+  return open;
+}
+function closeLink(body) {
+  const address = OPEN_ADDRESS.exec(body);
+  if (address !== null) {
+    return address[2] === "" ? body.slice(0, address.index) + address[1] : `${body})`;
+  }
+  const text = OPEN_TEXT.exec(body);
+  return text === null ? body : body.slice(0, text.index) + text[1];
+}
+function tokenAt(body, at) {
+  const two = body.slice(at, at + 2);
+  if (DOUBLE.includes(two)) return two;
+  const one = body[at];
+  if (one === "*") return one;
+  if (one === "_" && !(WORD.test(_nullishCoalesce(body[at - 1], () => ( ""))) && WORD.test(_nullishCoalesce(body[at + 1], () => ( ""))))) return one;
+  return null;
+}
+function codeEnd(body, at) {
+  let end = at;
+  while (body[end] === "`") end++;
+  const run = body.slice(at, end);
+  const close = body.indexOf(run, end);
+  return { end: close === -1 ? -1 : close + run.length, run };
+}
+function closeInline(source) {
+  const body = closeLink(source);
+  const opened = [];
+  let code = null;
+  for (let at = 0; at < body.length && code === null; ) {
+    if (body[at] === "`") {
+      const { end, run } = codeEnd(body, at);
+      if (end === -1) code = { token: run, at };
+      at = end === -1 ? body.length : end;
+      continue;
+    }
+    if (body.startsWith("](", at)) {
+      const close = body.indexOf(")", at);
+      at = close === -1 ? body.length : close + 1;
+      continue;
+    }
+    const token = tokenAt(body, at);
+    if (token === null) {
+      at++;
+      continue;
+    }
+    const before = body[at - 1];
+    const after = body[at + token.length];
+    if (_optionalChain([opened, 'access', _5 => _5.at, 'call', _6 => _6(-1), 'optionalAccess', _7 => _7.token]) === token && !isSpace(before)) opened.pop();
+    else if (after === void 0 || !isSpace(after)) opened.push({ token, at });
+    at += token.length;
+  }
+  if (code !== null) opened.push(code);
+  let text = body;
+  while (opened.length > 0 && opened[opened.length - 1].at + opened[opened.length - 1].token.length === text.length) {
+    text = text.slice(0, opened.pop().at);
+  }
+  return text + opened.reverse().map(({ token }) => token).join("");
+}
+function closeStreaming(markdown) {
+  const lines = markdown.split("\n");
+  const fence = openFence(lines);
+  if (fence !== null) return `${markdown}${markdown.endsWith("\n") ? "" : "\n"}${fence[0].repeat(fence.length)}`;
+  const last = lines[lines.length - 1];
+  if (last.trim() !== "" && MARKER_ONLY.test(last)) return markdown.slice(0, markdown.length - last.length);
+  let first = lines.length - 1;
+  while (first > 0 && lines[first - 1].trim() !== "" && !FENCE.test(lines[first - 1]) && !BLOCK_START.test(lines[first])) {
+    first--;
+  }
+  const block = lines.slice(first).join("\n");
+  const head = markdown.slice(0, markdown.length - block.length);
+  const prefix = _nullishCoalesce(_optionalChain([LINE_PREFIX, 'access', _8 => _8.exec, 'call', _9 => _9(block), 'optionalAccess', _10 => _10[0]]), () => ( ""));
+  return head + prefix + closeInline(block.slice(prefix.length));
+}
+
+// src/extensions/ai/ai-target.ts
+function targetOfBlocks(state, ids) {
+  const { doc, schema } = state;
+  const first = doc.blocks[_nullishCoalesce(doc.index.get(ids[0]), () => ( -1))];
+  const last = doc.blocks[_nullishCoalesce(doc.index.get(ids[ids.length - 1]), () => ( -1))];
+  if (first === void 0 || last === void 0) return null;
+  const start = _chunkPZ4GT5JOcjs.primaryRegion.call(void 0, schema, first);
+  const end = _chunkPZ4GT5JOcjs.primaryRegion.call(void 0, schema, last);
+  if (start === null || end === null) return null;
+  const from = { block: first.id, region: start, offset: 0 };
+  return { from, to: { block: last.id, region: end, offset: _chunkPZ4GT5JOcjs.regionLength.call(void 0, last, end) }, selected: ids.length > 1 };
+}
+function targetOfSelection(state) {
+  const { doc, selection } = state;
+  if (selection === null) return null;
+  if (selection.kind !== "text") return targetOfBlocks(state, _chunkPZ4GT5JOcjs.selectedBlockIds.call(void 0, doc, selection));
+  const { from, to } = _chunkPZ4GT5JOcjs.orderedRange.call(void 0, doc, selection.anchor, selection.head);
+  if (_chunkPZ4GT5JOcjs.comparePos.call(void 0, doc, from, to) !== 0) return { from, to, selected: true };
+  const block = doc.blocks[doc.index.get(from.block)];
+  const whole = { block: from.block, region: from.region };
+  return { from: { ...whole, offset: 0 }, to: { ...whole, offset: _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, from.region) }, selected: false };
+}
+function nearestKept(tr, target) {
+  const { doc } = tr.before;
+  const first = _nullishCoalesce(doc.index.get(target.from.block), () => ( 0));
+  const last = _nullishCoalesce(doc.index.get(target.to.block), () => ( first));
+  const kept = (block) => block && tr.doc.blocks[_nullishCoalesce(tr.doc.index.get(block.id), () => ( -1))];
+  for (let step = 1; first - step >= 0 || last + step < doc.blocks.length; step++) {
+    const found = _nullishCoalesce(kept(doc.blocks[first - step]), () => ( kept(doc.blocks[last + step])));
+    if (found) return found;
+  }
+  return tr.doc.blocks[0];
+}
+function edgeOf(tr, target) {
+  const point = tr.mapPos(target.from, -1);
+  const block = _nullishCoalesce(tr.doc.blocks[_nullishCoalesce(tr.doc.index.get(point.block), () => ( -1))], () => ( nearestKept(tr, target)));
+  if (block === void 0) return null;
+  const region = _nullishCoalesce(_chunkPZ4GT5JOcjs.primaryRegion.call(void 0, tr.before.schema, block), () => ( ""));
+  const length = region === "" ? 0 : _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, region);
+  const offset = block.id === point.block ? Math.min(point.offset, length) : length;
+  const after = offset > 0 || length === 0;
+  const at = { block: block.id, region, offset: after ? length : 0 };
+  return { from: at, to: at, selected: true, lost: { after } };
+}
+function mapTarget(tr, target) {
+  if (!tr.doc.index.has(target.from.block) || !tr.doc.index.has(target.to.block)) return edgeOf(tr, target);
+  const inside = target.selected ? 1 : -1;
+  const from = tr.mapPos(target.from, inside);
+  const mapped2 = tr.mapPos(target.to, -inside);
+  if (!tr.doc.index.has(from.block) || !tr.doc.index.has(mapped2.block)) return edgeOf(tr, target);
+  const to = _chunkPZ4GT5JOcjs.comparePos.call(void 0, tr.doc, from, mapped2) > 0 ? from : mapped2;
+  return from === target.from && to === target.to ? target : { ...target, from, to };
+}
+var targetGone = (doc, target) => target.lost !== void 0 || target.selected && _chunkPZ4GT5JOcjs.comparePos.call(void 0, doc, target.from, target.to) === 0;
+function targetRanges(state, { from, to }) {
+  const { doc, schema } = state;
+  const start = doc.index.get(from.block);
+  const end = doc.index.get(to.block);
+  return doc.blocks.slice(start, end + 1).flatMap((block, i) => {
+    const region = i === 0 ? from.region : block.id === to.block ? to.region : _chunkPZ4GT5JOcjs.primaryRegion.call(void 0, schema, block);
+    if (region === null || !Object.hasOwn(block.regions, region)) return [];
+    const left = i === 0 ? from.offset : 0;
+    const right = block.id === to.block ? to.offset : _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, region);
+    return right > left ? [{ block: block.id, region, from: left, to: right }] : [];
+  });
+}
+
+// src/extensions/ai/ai-plugin.ts
+var aiKey = _chunkPZ4GT5JOcjs.createPluginKey.call(void 0, "ai");
+var AI = "ai";
+var IDLE = { target: null, menu: null, ghost: null, held: [] };
+var aiState = (state) => _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, aiKey);
+var aiTransaction = (state, act2) => new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setMeta(AI, act2).setMeta("addToHistory", false);
+function written(ghost, key, phase, output) {
+  return ghost.key !== key ? ghost : { ...ghost, phase, output, shown: closeStreaming(output) };
+}
+function act(value, action) {
+  switch (action.type) {
+    case "open":
+      return { ...value, target: action.target, menu: { fromSpace: action.fromSpace }, ghost: null };
+    case "close":
+      return value.ghost === null ? { ...value, target: null, menu: null } : { ...value, menu: null };
+    case "start": {
+      const ghost = { key: action.key, replace: action.replace, phase: "streaming", output: "", shown: "" };
+      return value.target === null ? value : { ...value, menu: null, ghost };
+    }
+    case "stream":
+    case "end": {
+      const { ghost } = value;
+      if (ghost === null || ghost.phase !== "streaming") return value;
+      const phase = action.type === "end" ? action.phase : "streaming";
+      return { ...value, ghost: written(ghost, action.key, phase, action.output) };
+    }
+    case "discard":
+      return { ...value, target: null, menu: null, ghost: null };
+    case "focus":
+      return value.held.length === 0 ? value : { ...value, held: [] };
+  }
+}
+function caretBlock(state) {
+  const { selection } = state;
+  return _optionalChain([selection, 'optionalAccess', _11 => _11.kind]) === "text" ? selection.head.block : null;
+}
+function hasText(state, id) {
+  const block = state.doc.blocks[_nullishCoalesce(state.doc.index.get(id), () => ( -1))];
+  return block !== void 0 && Object.keys(block.regions).some((region) => _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, region) > 0);
+}
+function heldText(tr, value, before, after) {
+  if (!tr.docChanged) return value.held;
+  const touched = [caretBlock(before), caretBlock(after)].filter(
+    (id) => id !== null && !value.held.includes(id) && (hasText(before, id) || hasText(after, id))
+  );
+  return touched.length === 0 ? value.held : [...value.held, ...new Set(touched)];
+}
+function mapped(tr, value) {
+  const { target, ghost } = value;
+  if (!tr.docChanged || target === null) return value;
+  const moved = mapTarget(tr, target);
+  if (moved === null || moved.lost && ghost === null) return { ...value, target: null, menu: null, ghost: null };
+  return moved === target ? value : { ...value, target: moved };
+}
+var aiPlugin = {
+  key: aiKey,
+  init: () => IDLE,
+  apply(tr, value, before, after) {
+    const held = heldText(tr, value, before, after);
+    const next = mapped(tr, held === value.held ? value : { ...value, held });
+    const action = tr.getMeta(AI);
+    return action === void 0 ? next : act(next, action);
+  }
+};
+
+// src/extensions/ai/ai-decorations.ts
+var REPLACED = { class: "quoin-ai-replaced" };
+var ROOM = "data-quoin-ai-room";
+var drawn = /* @__PURE__ */ new WeakMap();
+function decorate(state, { target, ghost }) {
+  if (target === null || ghost === null) return [];
+  const replaced = ghost.replace && !targetGone(state.doc, target) ? targetRanges(state, target).map((range) => ({ kind: "inline", ...range, attrs: REPLACED })) : [];
+  return [...replaced, { kind: "block", block: target.to.block, attrs: { [ROOM]: "" } }];
+}
+function aiDecorations(state) {
+  const value = aiState(state);
+  const last = drawn.get(value);
+  if (_optionalChain([last, 'optionalAccess', _12 => _12.doc]) === state.doc) return last.decorations;
+  const decorations = decorate(state, value);
+  drawn.set(value, { doc: state.doc, decorations });
+  return decorations;
+}
+
+// src/extensions/ai/ai-items.ts
+var _lucidereact = require('lucide-react');
+
+// src/extensions/ai/ai-actions.ts
+var MENU_ACTIONS = [
+  "continue",
+  "improve",
+  "fix",
+  "shorten",
+  "lengthen",
+  "simplify",
+  "tone",
+  "translate",
+  "summarize",
+  "explain"
+];
+var EMPTY_LINE_ACTIONS = ["continue", "summarize"];
+var TRANSFORMS = /* @__PURE__ */ new Set(["improve", "fix", "shorten", "lengthen", "simplify", "tone", "translate"]);
+var ASKS_FOR_PROMPT = /* @__PURE__ */ new Set(["tone", "translate"]);
+var replacesTarget = (action, selected) => TRANSFORMS.has(action) || action === "custom" && selected;
+
+// src/extensions/ai/ai-link.ts
+var links = /* @__PURE__ */ new WeakMap();
+function linkOf(editor) {
+  let link = links.get(editor);
+  if (link === void 0) {
+    link = { mounts: 0, run: null, last: null, report: (error) => console.error(error), ended: () => {
+    }, stopWatching: null };
+    links.set(editor, link);
+  }
+  return link;
+}
+
+// src/extensions/ai/ai-request.ts
+var CONTEXT_LIMIT = 8e3;
+var BOUNDARY = "\n\n";
+var isHigh = (code) => code >= 55296 && code <= 56319;
+var isLow = (code) => code >= 56320 && code <= 57343;
+function aroundSelection(text, start, end, limit = CONTEXT_LIMIT) {
+  if (text.length <= limit) return text;
+  let from = Math.max(0, Math.min(Math.round((start + end - limit) / 2), text.length - limit));
+  let to = from + limit;
+  if (from > 0) {
+    const boundary = text.indexOf(BOUNDARY, from);
+    if (boundary !== -1 && boundary + BOUNDARY.length <= Math.min(start, to)) from = boundary + BOUNDARY.length;
+  }
+  if (to < text.length) {
+    const boundary = text.lastIndexOf(BOUNDARY, to - BOUNDARY.length);
+    if (boundary >= Math.max(end, from)) to = boundary + 1;
+  }
+  if (isLow(text.charCodeAt(from))) from++;
+  if (to > from && isHigh(text.charCodeAt(to - 1))) to--;
+  return text.slice(from, to);
+}
+var WHITESPACE_ENTITY = /(?<!\\)&#(32|9);/g;
+var plain = (markdown) => markdown.replace(WHITESPACE_ENTITY, (_, code) => code === "32" ? " " : "	");
+var markdownOf = (state, blocks) => _chunkPZ4GT5JOcjs.toMarkdown.call(void 0, blocks, { schema: state.schema, comments: false });
+function rangeMarkdown(state, from, to) {
+  const slice = _chunkPZ4GT5JOcjs.sliceFromSelection.call(void 0, { ...state, selection: _chunkPZ4GT5JOcjs.textSelection.call(void 0, from, to) }, _chunkND5XJVK2cjs.createBlockCodec.call(void 0, state.schema));
+  return slice === null ? "" : markdownOf(state, slice.blocks).replace(/\n$/, "");
+}
+function documentContext(state, target, selection) {
+  const blocks = _chunkND5XJVK2cjs.createBlockCodec.call(void 0, state.schema).blocksFromDoc(state.doc);
+  const full = plain(markdownOf(state, blocks));
+  if (full.length <= CONTEXT_LIMIT) return full;
+  const index = _nullishCoalesce(state.doc.index.get(target.from.block), () => ( 0));
+  const blockStart = index === 0 ? 0 : plain(markdownOf(state, blocks.slice(0, index))).length + 1;
+  const lead = { ...target.from, offset: 0 };
+  const start = blockStart + plain(rangeMarkdown(state, lead, target.from)).length;
+  return aroundSelection(full, start, start + selection.length);
+}
+function buildRequest(state, target, input) {
+  const selection = plain(rangeMarkdown(state, target.from, target.to));
+  const request = { action: input.action, selection, context: documentContext(state, target, selection) };
+  if (input.prompt !== void 0) request.prompt = input.prompt;
+  if (input.language !== void 0) request.language = input.language;
+  return request;
+}
+
+// src/extensions/ai/ai-session.ts
+var nextKey = 0;
+function onNextFrame(draw) {
+  if (typeof requestAnimationFrame === "function") {
+    const frame = requestAnimationFrame(draw);
+    return () => cancelAnimationFrame(frame);
+  }
+  const timer = setTimeout(draw, 16);
+  return () => clearTimeout(timer);
+}
+function endRun(link, ended = false) {
+  const { run } = link;
+  if (run === null) return null;
+  link.run = null;
+  _optionalChain([run, 'access', _13 => _13.cancelFrame, 'optionalCall', _14 => _14()]);
+  run.cancelFrame = null;
+  if (!ended) run.abort.abort();
+  return run;
+}
+var send = (editor, act2) => editor.dispatch(aiTransaction(editor.state, act2));
+async function read(editor, link, run, stream, request) {
+  const live = () => link.run === run && link.mounts > 0;
+  const end = (phase) => {
+    endRun(link, true);
+    send(editor, { type: "end", key: run.key, phase, output: run.output });
+  };
+  const draw = () => {
+    run.cancelFrame = null;
+    if (live()) send(editor, { type: "stream", key: run.key, output: run.output });
+  };
+  try {
+    const chunks = await stream(request, run.abort.signal);
+    for await (const chunk of chunks) {
+      if (!live()) return;
+      if (typeof chunk !== "string") throw new TypeError(`The AI stream gave a chunk that is not text: ${typeof chunk}`);
+      run.output += chunk;
+      run.cancelFrame ??= onNextFrame(draw);
+    }
+    if (!live()) return;
+    end("done");
+    link.ended("done", run.output);
+  } catch (error) {
+    if (!live()) return;
+    end("error");
+    link.report(_chunk2VDK27IFcjs.toError.call(void 0, error));
+  }
+}
+function startStream(editor, link, stream, request, replace) {
+  endRun(link);
+  if (aiState(editor.state).target === null || link.mounts === 0) return;
+  const run = { key: ++nextKey, abort: new AbortController(), output: "", cancelFrame: null };
+  link.run = run;
+  link.last = request;
+  send(editor, { type: "start", key: run.key, replace });
+  void read(editor, link, run, stream, request);
+}
+function stopped(editor, link, key, output) {
+  const { ghost } = aiState(editor.state);
+  if (link.mounts === 0 || _optionalChain([ghost, 'optionalAccess', _15 => _15.key]) !== key || ghost.phase !== "streaming") return;
+  send(editor, { type: "end", key, phase: "stopped", output });
+  link.ended("stopped", output);
+}
+function stopStream(editor, link) {
+  const run = endRun(link);
+  const { ghost } = aiState(editor.state);
+  if (run !== null) stopped(editor, link, run.key, run.output);
+  else if (ghost !== null) stopped(editor, link, ghost.key, ghost.output);
+}
+function watchGhost(editor, link) {
+  return editor.subscribe((state, tr) => {
+    const { run } = link;
+    const { ghost, target } = aiState(state);
+    if (run === null) return;
+    if (_optionalChain([ghost, 'optionalAccess', _16 => _16.key]) !== run.key || ghost.phase !== "streaming") endRun(link);
+    else if (_optionalChain([target, 'optionalAccess', _17 => _17.lost]) !== void 0 && tr !== null && _optionalChain([aiState, 'call', _18 => _18(tr.before), 'access', _19 => _19.target, 'optionalAccess', _20 => _20.lost]) === void 0) {
+      endRun(link);
+      queueMicrotask(() => stopped(editor, link, run.key, run.output));
+    }
+  });
+}
+
+// src/extensions/ai/ai-flow.ts
+function openMenu(editor, target, fromSpace) {
+  editor.dispatch(aiTransaction(editor.state, { type: "open", target, fromSpace }));
+}
+function closeMenu(editor) {
+  editor.dispatch(aiTransaction(editor.state, { type: "close" }));
+}
+function ask(editor, stream, input) {
+  const { target } = aiState(editor.state);
+  if (target === null) return;
+  const request = buildRequest(editor.state, target, input);
+  startStream(editor, linkOf(editor), stream, request, replacesTarget(input.action, target.selected));
+}
+function retry(editor, stream) {
+  const link = linkOf(editor);
+  const { ghost } = aiState(editor.state);
+  if (ghost !== null && link.last !== null) startStream(editor, link, stream, link.last, ghost.replace);
+}
+function followUp(editor, stream, prompt) {
+  const link = linkOf(editor);
+  const { ghost } = aiState(editor.state);
+  if (ghost === null || link.last === null) return;
+  const { context, language } = link.last;
+  const request = { action: "custom", prompt, selection: ghost.output, context };
+  startStream(editor, link, stream, language === void 0 ? request : { ...request, language }, ghost.replace);
+}
+function stop(editor) {
+  stopStream(editor, linkOf(editor));
+}
+function noteFocus(editor) {
+  if (aiState(editor.state).held.length > 0) editor.dispatch(aiTransaction(editor.state, { type: "focus" }));
+}
+function discard(editor) {
+  editor.dispatch(aiTransaction(editor.state, { type: "discard" }));
+}
+
+// src/extensions/ai/ai-env.ts
+function languageOf(controller) {
+  return _optionalChain([controller, 'access', _21 => _21.root, 'optionalAccess', _22 => _22.closest, 'call', _23 => _23("[lang]"), 'optionalAccess', _24 => _24.getAttribute, 'call', _25 => _25("lang")]) || void 0;
+}
+function askFrom(env, action, prompt) {
+  const { controller, stream } = env;
+  const language = languageOf(controller);
+  ask(controller.editor, stream, { action, ...prompt === void 0 ? {} : { prompt }, ...language ? { language } : {} });
+}
+
+// src/extensions/ai/ai-items.ts
+function openFor(controller) {
+  const target = targetOfSelection(controller.editor.state);
+  if (target !== null) openMenu(controller.editor, target, false);
+  return target !== null;
+}
+var KEYWORDS = ["ai", "assistant", "write", "generate"];
+function aiSlashItems(labels, stream) {
+  return [
+    {
+      id: "ai",
+      title: labels.askAi,
+      description: labels.askAiDescription,
+      group: "ai",
+      icon: _lucidereact.Sparkles,
+      keywords: KEYWORDS,
+      run: ({ controller }) => void openFor(controller)
+    },
+    {
+      id: "ai-continue",
+      title: labels.actions.continue,
+      group: "ai",
+      icon: _lucidereact.PenLine,
+      keywords: [...KEYWORDS, "continue"],
+      run: ({ controller }) => {
+        if (openFor(controller)) askFrom({ controller, stream, labels }, "continue");
+      }
+    }
+  ];
+}
+var aiBubbleItem = (labels) => ({
+  id: "ai",
+  title: labels.askAi,
+  icon: _lucidereact.Sparkles,
+  available: (state) => aiState(state).ghost === null,
+  run: (controller) => void openFor(controller)
+});
+var aiBlockMenuItem = (labels) => ({
+  id: "ai",
+  label: labels.askAi,
+  icon: _lucidereact.Sparkles,
+  available: (state, blockIds) => targetOfBlocks(state, blockIds) !== null,
+  run: (controller, blockIds) => {
+    const target = targetOfBlocks(controller.editor.state, blockIds);
+    if (target !== null) openMenu(controller.editor, target, false);
+  }
+});
+
+// src/extensions/ai/ai-labels.ts
+var englishAiLabels = {
+  askAi: "Ask AI",
+  askAiDescription: "Write or edit with AI",
+  actions: {
+    continue: "Continue writing",
+    improve: "Improve writing",
+    fix: "Fix spelling and grammar",
+    shorten: "Make shorter",
+    lengthen: "Make longer",
+    simplify: "Simplify language",
+    tone: "Change tone",
+    translate: "Translate",
+    summarize: "Summarize",
+    explain: "Explain",
+    custom: "Ask AI"
+  },
+  menu: "AI actions",
+  prompt: "Ask AI to write or edit",
+  tonePrompt: "Tone to take, such as friendly",
+  translatePrompt: "Language to translate to",
+  ask: (prompt) => `Ask AI: ${prompt}`,
+  response: "AI response",
+  writing: "Writing",
+  stopped: "Stopped",
+  stop: "Stop",
+  accept: "Accept",
+  discard: "Discard",
+  retry: "Retry",
+  followUp: "Tell AI what to do next",
+  failed: "AI could not answer",
+  written: (text) => `AI response ready: ${text}`,
+  halted: (text) => `Stopped. AI response so far: ${text}`,
+  targetGone: "The text this was for was removed, so Accept inserts it where that text was"
+};
+function resolveAiLabels(overrides) {
+  const given = Object.entries(_nullishCoalesce(overrides, () => ( {}))).filter(([, value]) => value !== void 0);
+  return given.length === 0 ? englishAiLabels : { ...englishAiLabels, ...Object.fromEntries(given) };
+}
+
+// src/extensions/ai/ai-space.ts
+var openOnSpace = (state, dispatch) => {
+  const { selection, doc } = state;
+  const ai = aiState(state);
+  if (_optionalChain([selection, 'optionalAccess', _26 => _26.kind]) !== "text" || !_chunkPZ4GT5JOcjs.isCollapsed.call(void 0, selection) || ai.menu !== null || ai.ghost !== null) return false;
+  const { head } = selection;
+  const block = doc.blocks[doc.index.get(head.block)];
+  const paragraph = block.type === "MARKDOWN" && block.attrs.kind === "paragraph";
+  if (!paragraph || _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, head.region) > 0 || ai.held.includes(block.id)) return false;
+  _optionalChain([dispatch, 'optionalCall', _27 => _27(aiTransaction(state, { type: "open", target: { from: head, to: head, selected: false }, fromSpace: true }))]);
+  return true;
+};
+
+// src/extensions/ai/AiOverlay.tsx
+var _react = require('react');
+
+// src/extensions/ai/AiBar.tsx
+
+
+// src/extensions/ai/ai-accept.ts
+var isParagraph = (block) => _optionalChain([block, 'optionalAccess', _28 => _28.type]) === "MARKDOWN" && _chunkND5XJVK2cjs.parseLine.call(void 0, String(_nullishCoalesce(block.data.markdown, () => ( "")))).kind === "paragraph";
+var DISCARD = { type: "discard" };
+function insertBeside(tr, schema, target, pieces, makeId) {
+  const index = tr.doc.index.get(target.to.block);
+  const at = _optionalChain([target, 'access', _29 => _29.lost, 'optionalAccess', _30 => _30.after]) ? _chunkPZ4GT5JOcjs.descendantsEnd.call(void 0, tr.doc, index) : index;
+  const fresh = _chunkPZ4GT5JOcjs.freshBlocks.call(void 0, pieces, tr.doc.blocks[index].indent, makeId);
+  tr.step(_chunkPZ4GT5JOcjs.insertBlocksStep.call(void 0, at, fresh));
+  _chunkPZ4GT5JOcjs.capIndents.call(void 0, tr, at, at + fresh.length);
+  tr.setSelection(_chunkPZ4GT5JOcjs.endOf.call(void 0, tr.doc, schema, fresh[fresh.length - 1].id));
+}
+function acceptAnswer(editor) {
+  const { state } = editor;
+  const { target, ghost } = aiState(state);
+  if (target === null || ghost === null || ghost.phase === "streaming" || ghost.phase === "error") return null;
+  const { codec } = editor;
+  const makeId = codec.context.newId;
+  const blocks = _chunkND5XJVK2cjs.fromMarkdown.call(void 0, ghost.output, { newId: makeId });
+  const pieces = blocks.flatMap((block) => codec.toEngineBlocks(block));
+  const tr = editor.createTransaction().setOrigin("ai").setMeta(AI, DISCARD);
+  const gone = targetGone(state.doc, target);
+  if (pieces.length > 0 && target.lost !== void 0) {
+    insertBeside(tr, state.schema, target, pieces, makeId);
+  } else if (pieces.length > 0) {
+    const { schema } = state;
+    const open = { openStart: isParagraph(blocks[0]), openEnd: isParagraph(blocks[blocks.length - 1]) };
+    if (ghost.replace || gone) {
+      const caret = ghost.replace && !gone ? _chunkPZ4GT5JOcjs.deleteRange.call(void 0, tr, schema, target.from, target.to, makeId) : target.to;
+      _chunkPZ4GT5JOcjs.pasteAtCaret.call(void 0, tr, schema, caret, open, pieces, makeId);
+    } else {
+      const block = tr.doc.blocks[tr.doc.index.get(target.to.block)];
+      const end = { ...target.to, offset: _chunkPZ4GT5JOcjs.regionLength.call(void 0, block, target.to.region) };
+      _chunkPZ4GT5JOcjs.pasteAtCaret.call(void 0, tr, schema, end, { openStart: false, openEnd: false }, pieces, makeId);
+    }
+  }
+  editor.dispatch(tr);
+  return { gone };
+}
+
+// src/extensions/ai/AiBar.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var PRIMARY = "data-ai-primary";
+function AiBar({ env, ghost, gone, barId }) {
+  const { controller, stream, labels } = env;
+  const { editor } = controller;
+  const content = _react.useRef.call(void 0, null);
+  const inside = _react.useRef.call(void 0, false);
+  const [next, setNext] = _react.useState.call(void 0, "");
+  const { phase } = ghost;
+  const focusPrimary = () => _optionalChain([content, 'access', _31 => _31.current, 'optionalAccess', _32 => _32.querySelector, 'call', _33 => _33(`[${PRIMARY}]`), 'optionalAccess', _34 => _34.focus, 'call', _35 => _35()]);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const active = _optionalChain([content, 'access', _36 => _36.current, 'optionalAccess', _37 => _37.ownerDocument, 'access', _38 => _38.activeElement]);
+    inside.current = active == null || active === active.ownerDocument.body;
+    if (inside.current) focusPrimary();
+  }, []);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const active = _optionalChain([content, 'access', _39 => _39.current, 'optionalAccess', _40 => _40.ownerDocument, 'access', _41 => _41.activeElement]);
+    if (inside.current && !_optionalChain([content, 'access', _42 => _42.current, 'optionalAccess', _43 => _43.contains, 'call', _44 => _44(_nullishCoalesce(active, () => ( null)))])) focusPrimary();
+  }, [phase, ghost.key]);
+  const backToText = () => {
+    if (inside.current) controller.focus();
+    inside.current = false;
+  };
+  const onAccept = () => {
+    let gone2 = false;
+    controller.edit(() => {
+      const result = acceptAnswer(editor);
+      gone2 = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _45 => _45.gone]), () => ( false));
+      return result !== null;
+    });
+    controller.focus();
+    if (gone2) controller.announce(labels.targetGone);
+  };
+  const onDiscard = () => {
+    discard(editor);
+    backToText();
+  };
+  const onFollowUp = (event) => {
+    event.preventDefault();
+    if (next.trim() === "") return;
+    followUp(editor, stream, next.trim());
+    setNext("");
+  };
+  const primary = { [PRIMARY]: "" };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      ref: content,
+      id: barId,
+      role: "group",
+      "aria-label": labels.response,
+      className: "quoin-ai-bar flex flex-wrap items-center gap-2 rounded-md border bg-popover p-2 text-popover-foreground shadow-md",
+      onFocus: () => inside.current = true,
+      onBlur: (event) => inside.current = _nullishCoalesce(_optionalChain([content, 'access', _46 => _46.current, 'optionalAccess', _47 => _47.contains, 'call', _48 => _48(event.relatedTarget)]), () => ( false)),
+      onKeyDown: (event) => {
+        if (event.key !== "Escape" || event.nativeEvent.isComposing) return;
+        event.preventDefault();
+        if (phase === "streaming") stop(editor);
+        else onDiscard();
+      },
+      children: [
+        phase === "streaming" && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-sm text-muted-foreground", children: labels.writing }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { ...primary, size: "sm", variant: "outline", onClick: () => stop(editor), children: labels.stop })
+        ] }),
+        phase === "error" && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { role: "alert", className: "text-sm text-destructive", children: labels.failed }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { ...primary, size: "sm", onClick: () => retry(editor, stream), children: labels.retry }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { size: "sm", variant: "ghost", onClick: onDiscard, children: labels.discard })
+        ] }),
+        (phase === "done" || phase === "stopped") && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          phase === "stopped" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-sm text-muted-foreground", children: labels.stopped }),
+          gone && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "w-full text-xs text-muted-foreground", children: labels.targetGone }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { ...primary, size: "sm", onClick: onAccept, children: labels.accept }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { size: "sm", variant: "ghost", onClick: onDiscard, children: labels.discard }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { size: "sm", variant: "ghost", onClick: () => retry(editor, stream), children: labels.retry }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "form", { className: "w-full", onSubmit: onFollowUp, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _chunk2VDK27IFcjs.Input,
+            {
+              "aria-label": labels.followUp,
+              placeholder: labels.followUp,
+              value: next,
+              onChange: (event) => setNext(event.target.value),
+              onKeyDown: (event) => {
+                if (event.key === "Enter" && event.nativeEvent.isComposing) event.preventDefault();
+              }
+            }
+          ) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/extensions/ai/AiGhost.tsx
+
+
+// src/extensions/ai/ai-ghost-render.ts
+var reader = null;
+function readerOf() {
+  if (reader === null) {
+    const schema = _chunkND5XJVK2cjs.createSchema.call(void 0, );
+    reader = { schema, codec: _chunkND5XJVK2cjs.createBlockCodec.call(void 0, schema) };
+  }
+  return reader;
+}
+function fillGhost(ghost, markdown) {
+  const doc = ghost.ownerDocument;
+  const { schema, codec } = readerOf();
+  const drawn2 = [];
+  for (const block of _chunkND5XJVK2cjs.fromMarkdown.call(void 0, markdown)) {
+    for (const piece of codec.toEngineBlocks(block)) {
+      const element = doc.createElement("div");
+      element.className = "quoin-ai-ghost-block";
+      element.dataset.kind = String(_nullishCoalesce(piece.attrs.kind, () => ( piece.type.toLowerCase())));
+      if (piece.attrs.level !== void 0) element.dataset.level = String(piece.attrs.level);
+      if (piece.indent > 0) element.style.setProperty("--quoin-ai-indent", String(piece.indent));
+      const region = _chunkPZ4GT5JOcjs.primaryRegion.call(void 0, schema, piece);
+      if (region === null) element.textContent = _chunkPZ4GT5JOcjs.toPlainText.call(void 0, [codec.toQuoin(piece)], { schema });
+      else _chunkGTTPVJSDcjs.renderInline.call(void 0, element, piece.regions[region], []);
+      drawn2.push(element);
+    }
+  }
+  ghost.replaceChildren(...drawn2);
+}
+
+// src/extensions/ai/use-ghost-place.ts
+
+var ROOM2 = "--quoin-ai-room";
+var GAP = 4;
+function place(controller, root, layer, block, region) {
+  const shell = controller.blockElement(block);
+  if (shell === void 0 || !shell.isConnected) {
+    layer.style.visibility = "hidden";
+    return;
+  }
+  layer.style.visibility = "";
+  const host = _nullishCoalesce(controller.registry.get(block, region), () => ( shell));
+  const origin = root.getBoundingClientRect();
+  const scale = origin.width / root.offsetWidth || 1;
+  const below = shell.getBoundingClientRect();
+  const text = host.getBoundingClientRect();
+  const left = (text.left - origin.left) / scale - root.clientLeft + root.scrollLeft;
+  const top = (below.bottom - origin.top) / scale - root.clientTop + root.scrollTop + GAP;
+  layer.style.transform = `translate(${left}px, ${top}px)`;
+  layer.style.width = `${text.width / scale}px`;
+  clipAside(layer, text, _chunkQAW5NH6Scjs.clipOf.call(void 0, host, root), scale);
+  root.style.setProperty(ROOM2, `${layer.offsetHeight + 2 * GAP}px`);
+}
+function clipAside(layer, text, clip, scale) {
+  const area = _optionalChain([clip, 'optionalAccess', _49 => _49.getBoundingClientRect, 'call', _50 => _50()]);
+  const start = area === void 0 ? 0 : Math.max(0, area.left - text.left) / scale;
+  const end = area === void 0 ? 0 : Math.max(0, text.right - area.right) / scale;
+  layer.style.clipPath = start > 0 || end > 0 ? `inset(0 ${end}px 0 ${start}px)` : "";
+  if (start + end >= text.width / scale && text.width > 0) layer.style.visibility = "hidden";
+}
+function useGhostPlace(controller, layer, block, region) {
+  const placeNow = _react.useRef.call(void 0, () => {
+  });
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const root = controller.root;
+    const element = layer.current;
+    const view = _optionalChain([root, 'optionalAccess', _51 => _51.ownerDocument, 'access', _52 => _52.defaultView]);
+    if (!root || !element || !view) return void 0;
+    const update = () => place(controller, root, element, block, region);
+    let frame = 0;
+    const later = () => {
+      view.cancelAnimationFrame(frame);
+      frame = view.requestAnimationFrame(update);
+    };
+    update();
+    placeNow.current = update;
+    const observer = new ResizeObserver(later);
+    observer.observe(root);
+    observer.observe(element);
+    const host = controller.registry.get(block, region);
+    if (host) observer.observe(host);
+    const unsubscribe = controller.editor.subscribe(later);
+    const fonts = root.ownerDocument.fonts;
+    root.addEventListener("scroll", later, { capture: true, passive: true });
+    _optionalChain([fonts, 'optionalAccess', _53 => _53.addEventListener, 'call', _54 => _54("loadingdone", later)]);
+    return () => {
+      placeNow.current = () => {
+      };
+      view.cancelAnimationFrame(frame);
+      observer.disconnect();
+      unsubscribe();
+      root.removeEventListener("scroll", later, { capture: true });
+      _optionalChain([fonts, 'optionalAccess', _55 => _55.removeEventListener, 'call', _56 => _56("loadingdone", later)]);
+      root.style.removeProperty(ROOM2);
+    };
+  }, [controller, layer, block, region]);
+  return _react.useCallback.call(void 0, () => placeNow.current(), []);
+}
+
+// src/extensions/ai/AiGhost.tsx
+
+function AiGhost({ env, ghost, target, gone, barId }) {
+  const layer = _react.useRef.call(void 0, null);
+  const drawn2 = _react.useRef.call(void 0, null);
+  const place2 = useGhostPlace(env.controller, layer, target.to.block, target.to.region);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const element = drawn2.current;
+    if (element === null) return;
+    element.setAttribute("inert", "");
+    fillGhost(element, ghost.shown);
+    place2();
+  }, [ghost.shown, ghost.phase, gone, place2]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { ref: layer, className: "quoin-ai-layer", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ref: drawn2, className: "quoin-ai-ghost", "aria-hidden": "true", "data-phase": ghost.phase }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AiBar, { env, ghost, gone, barId })
+  ] });
+}
+
+// src/extensions/ai/AiMenu.tsx
+
+
+// src/extensions/ai/use-target-anchor.ts
+
+function useTargetAnchor(controller, target) {
+  const latest = _react.useRef.call(void 0, target);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    latest.current = target;
+  });
+  return _react.useMemo.call(void 0, () => {
+    const end = () => {
+      const { to } = latest.current;
+      return { block: to.block, region: to.region, from: to.offset, to: to.offset };
+    };
+    return {
+      current: _chunk2VDK27IFcjs.virtualAnchor.call(void 0, 
+        () => _chunk2VDK27IFcjs.rangeRect.call(void 0, controller, end()),
+        () => controller.registry.get(end().block, end().region)
+      )
+    };
+  }, [controller]);
+}
+
+// src/extensions/ai/AiMenu.tsx
+
+function choicesFor(env, target, query) {
+  const { labels } = env;
+  const emptyLine = !target.selected && target.to.offset === 0;
+  const wanted = query.trim().toLowerCase();
+  const actions = (emptyLine ? EMPTY_LINE_ACTIONS : MENU_ACTIONS).filter(
+    (action) => labels.actions[action].toLowerCase().includes(wanted)
+  );
+  const listed = actions.map((action) => ({ action, label: labels.actions[action] }));
+  return wanted === "" ? listed : [...listed, { action: "custom", label: labels.ask(query.trim()) }];
+}
+function AiMenu({ env, target, fromSpace }) {
+  const { controller, labels } = env;
+  const [query, setQuery] = _react.useState.call(void 0, "");
+  const [asking, setAsking] = _react.useState.call(void 0, null);
+  const [active, setActive] = _react.useState.call(void 0, 0);
+  const field = _react.useRef.call(void 0, null);
+  const anchor = useTargetAnchor(controller, target);
+  const id = _react.useId.call(void 0, );
+  const choices = asking === null ? choicesFor(env, target, query) : [];
+  const current = Math.min(active, choices.length - 1);
+  const optionId = (index) => `${id}-${index}`;
+  const close = (typeSpace) => {
+    closeMenu(controller.editor);
+    controller.focus();
+    if (typeSpace) controller.edit(() => controller.editor.insertText(" "));
+  };
+  const choose = ({ action }) => {
+    if (!ASKS_FOR_PROMPT.has(action)) return askFrom(env, action, action === "custom" ? query.trim() : void 0);
+    setAsking(action);
+    setQuery("");
+  };
+  const onKeyDown = (event) => {
+    if (event.nativeEvent.isComposing) return;
+    const step = event.key === "ArrowDown" ? 1 : event.key === "ArrowUp" ? -1 : 0;
+    if (step !== 0 && choices.length > 0) {
+      event.preventDefault();
+      setActive((current + step + choices.length) % choices.length);
+    } else if (event.key === "Enter") {
+      event.preventDefault();
+      if (asking !== null && query.trim() !== "") askFrom(env, asking, query.trim());
+      else if (choices[current] !== void 0) choose(choices[current]);
+    } else if (event.key === " " && fromSpace && query === "" && asking === null) {
+      event.preventDefault();
+      close(true);
+    }
+  };
+  const fieldLabel = asking === "tone" ? labels.tonePrompt : asking === "translate" ? labels.translatePrompt : labels.prompt;
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _chunk2VDK27IFcjs.Popover,
+    {
+      open: true,
+      modal: false,
+      onOpenChange: (next) => {
+        if (!next) closeMenu(controller.editor);
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.PopoverAnchor, { virtualRef: anchor }),
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _chunk2VDK27IFcjs.PopoverContent,
+          {
+            "aria-label": labels.askAi,
+            side: "bottom",
+            align: "start",
+            className: "w-80 p-1",
+            onOpenAutoFocus: (event) => {
+              event.preventDefault();
+              _optionalChain([field, 'access', _57 => _57.current, 'optionalAccess', _58 => _58.focus, 'call', _59 => _59()]);
+            },
+            onCloseAutoFocus: (event) => event.preventDefault(),
+            onEscapeKeyDown: (event) => {
+              event.preventDefault();
+              close(fromSpace);
+            },
+            children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _chunk2VDK27IFcjs.Input,
+                {
+                  ref: field,
+                  role: "combobox",
+                  "aria-label": fieldLabel,
+                  placeholder: fieldLabel,
+                  "aria-expanded": choices.length > 0,
+                  "aria-controls": choices.length > 0 ? `${id}-list` : void 0,
+                  "aria-autocomplete": "list",
+                  "aria-activedescendant": choices.length > 0 ? optionId(current) : void 0,
+                  value: query,
+                  onChange: (event) => {
+                    setQuery(event.target.value);
+                    setActive(0);
+                  },
+                  onKeyDown
+                }
+              ),
+              choices.length > 0 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "ul", { id: `${id}-list`, role: "listbox", "aria-label": labels.menu, className: "mt-1 max-h-72 overflow-y-auto", children: choices.map((choice, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                "li",
+                {
+                  id: optionId(index),
+                  role: "option",
+                  "aria-selected": index === current,
+                  className: _chunk2VDK27IFcjs.cn.call(void 0, _chunk2VDK27IFcjs.MENU_ITEM, index === current && "bg-accent text-accent-foreground"),
+                  onMouseDown: (event) => event.preventDefault(),
+                  onClick: () => choose(choice),
+                  children: choice.label
+                },
+                choice.action
+              )) })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/extensions/ai/AiOverlay.tsx
+
+var goneOf = (state) => {
+  const { target, ghost } = aiState(state);
+  return target !== null && ghost !== null && targetGone(state.doc, target);
+};
+var plainText = (markdown) => _chunkPZ4GT5JOcjs.toPlainText.call(void 0, _chunkND5XJVK2cjs.fromMarkdown.call(void 0, markdown));
+function AiOverlay({ controller, stream, labels }) {
+  const { onError } = _chunk2VDK27IFcjs.useQuoin.call(void 0, );
+  const link = linkOf(controller.editor);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    link.report = onError;
+    link.ended = (phase, output) => controller.announce((phase === "done" ? labels.written : labels.halted)(plainText(output)));
+  }, [link, onError, controller, labels]);
+  const value = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, aiState);
+  const gone = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, goneOf);
+  const readOnly = _chunkGTTPVJSDcjs.useReadOnly.call(void 0, controller);
+  const env = _react.useMemo.call(void 0, () => ({ controller, stream, labels }), [controller, stream, labels]);
+  const barId = _react.useId.call(void 0, );
+  const showing = value.ghost !== null;
+  _react.useEffect.call(void 0, () => {
+    if (!showing) return;
+    const toBar = (event) => {
+      if (event.key !== "Escape" || event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return false;
+      const bar = _optionalChain([controller, 'access', _60 => _60.root, 'optionalAccess', _61 => _61.ownerDocument, 'access', _62 => _62.getElementById, 'call', _63 => _63(barId)]);
+      _optionalChain([bar, 'optionalAccess', _64 => _64.querySelector, 'call', _65 => _65(`[${PRIMARY}]`), 'optionalAccess', _66 => _66.focus, 'call', _67 => _67()]);
+      return bar != null;
+    };
+    controller.keyInterceptors.add(toBar);
+    return () => void controller.keyInterceptors.delete(toBar);
+  }, [controller, showing, barId]);
+  _react.useEffect.call(void 0, () => {
+    const root = controller.root;
+    if (!root) return;
+    let away = true;
+    return _chunkWXMYDXPNcjs.watchCanvasFocus.call(void 0, controller, root.ownerDocument, (inside, node) => {
+      if (!inside) away = true;
+      else if (root.contains(node)) {
+        if (away) noteFocus(controller.editor);
+        away = false;
+      }
+    });
+  }, [controller]);
+  _react.useEffect.call(void 0, 
+    () => controller.subscribeReadOnly(() => {
+      if (!controller.readOnly) return;
+      endRun(link);
+      queueMicrotask(() => {
+        if (link.mounts > 0 && aiState(controller.editor.state).target !== null) discard(controller.editor);
+      });
+    }),
+    [controller, link]
+  );
+  if (readOnly || value.target === null) return null;
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+    value.menu !== null && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AiMenu, { env, target: value.target, fromSpace: value.menu.fromSpace }),
+    value.ghost !== null && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AiGhost, { env, ghost: value.ghost, target: value.target, gone, barId })
+  ] });
+}
+
+// src/extensions/ai/ai-extension.tsx
+
+function aiExtension(options) {
+  const { stream } = options;
+  const labels = resolveAiLabels(options.labels);
+  function Overlay({ controller }) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AiOverlay, { controller, stream, labels });
+  }
+  const ui = {
+    slashItems: aiSlashItems(labels, stream),
+    bubbleItems: [aiBubbleItem(labels)],
+    blockMenuItems: [aiBlockMenuItem(labels)],
+    overlays: [Overlay]
+  };
+  return _chunkPZ4GT5JOcjs.defineExtension.call(void 0, {
+    name: "ai",
+    plugins: [aiPlugin],
+    decorations: aiDecorations,
+    keymap: { " ": openOnSpace },
+    // One watcher per editor however many views mount it, and the stream ends with the last of them.
+    onMount(editor) {
+      const link = linkOf(editor);
+      if (link.mounts++ === 0) link.stopWatching = watchGhost(editor, link);
+      return () => {
+        if (--link.mounts > 0) return;
+        _optionalChain([link, 'access', _68 => _68.stopWatching, 'optionalCall', _69 => _69()]);
+        link.stopWatching = null;
+        endRun(link);
+      };
+    },
+    ui
+  });
+}
+
+
+
+exports.aiExtension = aiExtension; exports.englishAiLabels = englishAiLabels;
+//# sourceMappingURL=ai.cjs.map