@coze-editor/preset-code 0.1.0-alpha.02803c

package/dist/esm/index.js

@@ -0,0 +1,1278 @@
+// src/index.ts
+import universal from "@coze-editor/preset-universal";
+import {
+  scrollBeyondLastLine,
+  colorizationBrackets,
+  matchingBrackets
+} from "@coze-editor/extensions";
+import { scrollbar } from "@coze-editor/extension-scrollbar";
+import { icons } from "@coze-editor/extension-completion-icons";
+import { maxHeight, minHeight, height } from "@coze-editor/core-plugins";
+import {
+  api,
+  extension,
+  option
+} from "@coze-editor/core";
+import {
+  uriFacet,
+  languageIdFacet,
+  transformerFacet,
+  textDocumentField as textDocumentField2
+} from "@coze-editor/code-language-shared";
+import { EditorView as EditorView4, lineNumbers } from "@codemirror/view";
+import { Prec } from "@codemirror/state";
+import { foldGutter } from "@codemirror/language";
+
+// src/themes.ts
+var Themes = class {
+  _store = /* @__PURE__ */ Object.create(null);
+  register(name, theme) {
+    this._store[name] = theme;
+  }
+  get(name) {
+    return this._store[name];
+  }
+};
+var symbol = Symbol.for("codemirror.themes");
+if (!globalThis[symbol]) {
+  globalThis[symbol] = new Themes();
+}
+var themes = globalThis[symbol];
+
+// src/theme-vscode.ts
+import {
+  darkSyntaxTheme,
+  darkTheme,
+  lightSyntaxTheme,
+  lightTheme
+} from "@coze-editor/vscode";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+var vscodeLight = [
+  syntaxHighlighting(HighlightStyle.define(lightSyntaxTheme)),
+  lightTheme()
+];
+var vscodeDark = [
+  syntaxHighlighting(HighlightStyle.define(darkSyntaxTheme)),
+  darkTheme()
+];
+
+// src/language-registry.ts
+import {
+  MarkupContent as MarkupContent2
+} from "vscode-languageserver-types";
+import createFuzzySearch from "@nozbe/microfuzz";
+import { linter } from "@coze-editor/extension-lint";
+import { links } from "@coze-editor/extension-links";
+import {
+  MarkerTag,
+  textDocumentField
+} from "@coze-editor/code-language-shared";
+import {
+  EditorView as EditorView2,
+  hoverTooltip,
+  ViewPlugin as ViewPlugin3
+} from "@codemirror/view";
+import { oneDarkHighlightStyle } from "@codemirror/theme-one-dark";
+import {
+  EditorSelection,
+  StateField as StateField2
+} from "@codemirror/state";
+import { LanguageSupport, syntaxHighlighting as syntaxHighlighting2 } from "@codemirror/language";
+import {
+  autocompletion,
+  insertCompletionText,
+  snippet
+} from "@codemirror/autocomplete";
+
+// src/signature-help.ts
+import {
+  MarkupContent
+} from "vscode-languageserver-types";
+import {
+  EditorView,
+  ViewPlugin,
+  keymap,
+  showTooltip
+} from "@codemirror/view";
+import {
+  Facet,
+  StateEffect,
+  StateField
+} from "@codemirror/state";
+
+// src/markdown.ts
+import markedShiki from "marked-shiki";
+import { Marked } from "marked";
+
+// src/highlighter.ts
+import { createOnigurumaEngine } from "shiki/engine/oniguruma";
+import { createHighlighterCore } from "shiki/core";
+var highlighterPromise = createHighlighterCore({
+  langs: [
+    () => import("@shikijs/langs/markdown"),
+    () => import("@shikijs/langs/javascript"),
+    () => import("@shikijs/langs/typescript"),
+    () => import("@shikijs/langs/python"),
+    () => import("@shikijs/langs/sql")
+  ],
+  themes: [
+    () => import("@shikijs/themes/github-dark"),
+    () => import("@shikijs/themes/one-dark-pro")
+  ],
+  engine: createOnigurumaEngine(import("shiki/wasm"))
+});
+
+// src/const.ts
+var LINT_REFRESH_USER_EVENT = "sdk.lint.refresh";
+var DEFAULT_SYNTAX_THEME = "one-dark-pro";
+
+// src/markdown.ts
+var marked = new Marked().use(
+  markedShiki({
+    async highlight(code, lang, props) {
+      const highlighter = await highlighterPromise;
+      return (await highlighter).codeToHtml(code, {
+        lang,
+        theme: DEFAULT_SYNTAX_THEME,
+        transformers: [
+          {
+            pre(node) {
+              delete node.properties.style;
+              node.properties.style = "white-space: pre-wrap;";
+            }
+          }
+        ]
+      });
+    }
+  })
+).use({
+  renderer: {
+    link(link) {
+      return `<a title="${link.title ?? ""}" target="_blank" href="${link.href}">${link.text}</a>`;
+    }
+  }
+});
+async function renderMarkdown(content) {
+  return await marked.parse(content);
+}
+
+// src/signature-help.ts
+var setSignatureHelpRequestPosition = StateEffect.define({});
+var setSignatureHelpResult = StateEffect.define({});
+var SignatureHelpState = class {
+  pos;
+  // maybe stale
+  result;
+  constructor(pos, result) {
+    if (result && pos === -1) {
+      throw new Error("Invalid state");
+    }
+    this.pos = pos;
+    this.result = result;
+  }
+};
+var signatureHelpTooltipField = StateField.define({
+  create: () => new SignatureHelpState(-1, null),
+  update(state, tr) {
+    let { pos, result } = state;
+    for (const effect of tr.effects) {
+      if (effect.is(setSignatureHelpRequestPosition)) {
+        pos = effect.value;
+      } else if (effect.is(setSignatureHelpResult)) {
+        result = effect.value;
+        if (!result) {
+          pos = -1;
+        }
+      }
+    }
+    if (pos === -1) {
+      result = null;
+    }
+    pos = pos === -1 ? -1 : tr.changes.mapPos(pos);
+    if (state.pos === pos && state.result === result) {
+      return state;
+    }
+    return new SignatureHelpState(pos, result);
+  },
+  provide: (f) => showTooltip.compute([f], (state) => {
+    const val = state.field(signatureHelpTooltipField);
+    const { result, pos } = val;
+    if (result) {
+      return {
+        pos,
+        above: true,
+        create: () => {
+          const dom = document.createElement("div");
+          dom.className = "cm-signature-tooltip";
+          dom.style.cssText = "font-size: 12px;max-width: 320px;";
+          const div = document.createElement("div");
+          div.innerHTML = result;
+          dom.appendChild(div);
+          return { dom };
+        }
+      };
+    }
+    return null;
+  })
+});
+async function renderSignatureHelp(state, help) {
+  const {
+    signatures,
+    activeSignature: activeSignatureIndex,
+    activeParameter: activeParameterIndex
+  } = help;
+  if (typeof activeSignatureIndex !== "number" || typeof activeParameterIndex !== "number") {
+    return;
+  }
+  const activeSignature = signatures[activeSignatureIndex];
+  if (!activeSignature || !Array.isArray(activeSignature.parameters)) {
+    return;
+  }
+  const { label } = activeSignature;
+  const keyword = getParameterLabel(
+    activeSignature.label,
+    activeSignature.parameters[activeParameterIndex]
+  );
+  const documentation = MarkupContent.is(activeSignature.documentation) ? activeSignature.documentation.value : activeSignature.documentation ?? "";
+  const rendered = await renderMarkdown(highlightByKeyword(label, keyword)) + await renderMarkdown(documentation.trim().split("\n")[0]);
+  return rendered;
+}
+function getParameterLabel(fullText, parameter) {
+  let keyword = (parameter == null ? void 0 : parameter.label) ?? "";
+  if (Array.isArray(keyword)) {
+    const [from, to] = keyword;
+    keyword = fullText.slice(from, to);
+  }
+  return keyword;
+}
+function highlightByKeyword(content, keyword) {
+  if (!keyword) {
+    return content;
+  }
+  return content.split(keyword).join(`<span class="cm-signature-parameter-active">${keyword}</span>`);
+}
+var closeSignatureHelp = (view2) => {
+  if (view2.state.field(signatureHelpTooltipField).pos !== -1) {
+    view2.dispatch({
+      effects: setSignatureHelpRequestPosition.of(-1)
+    });
+    return true;
+  }
+  return false;
+};
+var signatureHelpKeymap = [
+  { key: "Escape", run: closeSignatureHelp }
+];
+var SignatureHelpView = class {
+  constructor(view2) {
+    this.view = view2;
+  }
+  update(update) {
+    if ((update.docChanged || update.selectionSet) && this.view.state.field(signatureHelpTooltipField).pos !== -1) {
+      triggerSignatureHelpRequest(this.view, update.state);
+    } else if (update.docChanged) {
+      const last = update.transactions[update.transactions.length - 1];
+      if (last.isUserEvent("input")) {
+        update.changes.iterChanges((_fromA, _toA, _fromB, _toB, inserted) => {
+          if (inserted.sliceString(0).trim().endsWith("()") || inserted.toString() === ",") {
+            triggerSignatureHelpRequest(this.view, update.state);
+          }
+        });
+      }
+    }
+  }
+};
+var doSignatureHelpFacet = Facet.define({
+  combine(values) {
+    return values[values.length - 1];
+  }
+});
+var triggerSignatureHelpRequest = async (view2, state) => {
+  const doSignatureHelp = state.facet(doSignatureHelpFacet);
+  const pos = state.selection.main.from;
+  try {
+    queueMicrotask(() => {
+      view2.dispatch({
+        effects: [setSignatureHelpRequestPosition.of(pos)]
+      });
+    });
+    const info = await doSignatureHelp(state, pos);
+    if (!info || !info.signatures || info.signatures.length === 0) {
+      queueMicrotask(() => {
+        view2.dispatch({
+          effects: [setSignatureHelpResult.of(null)]
+        });
+      });
+      return;
+    }
+    const result = await renderSignatureHelp(state, info) ?? "";
+    queueMicrotask(() => {
+      view2.dispatch({
+        effects: [setSignatureHelpResult.of(result)]
+      });
+    });
+  } catch (e) {
+    queueMicrotask(() => {
+      view2.dispatch({
+        effects: [setSignatureHelpResult.of(null)]
+      });
+    });
+  }
+};
+var signatureHelpToolTipBaseTheme = EditorView.baseTheme({
+  ".cm-tooltip.cm-signature-tooltip": {
+    padding: "3px 9px",
+    width: "max-content",
+    maxWidth: "500px"
+  },
+  ".cm-tooltip .cm-signature-parameter-active": {
+    fontWeight: "bold"
+  }
+});
+function signatureHelp(doSignatureHelp) {
+  return [
+    doSignatureHelpFacet.of(doSignatureHelp),
+    ViewPlugin.fromClass(SignatureHelpView),
+    signatureHelpTooltipField,
+    signatureHelpToolTipBaseTheme,
+    keymap.of(signatureHelpKeymap),
+    EditorView.domEventHandlers({
+      blur(event, view2) {
+        if (!(event.relatedTarget instanceof Element) || !event.relatedTarget.closest(".cm-signature-tooltip")) {
+          queueMicrotask(() => {
+            view2.dispatch({
+              effects: setSignatureHelpRequestPosition.of(-1)
+            });
+          });
+        }
+      }
+    })
+  ];
+}
+
+// src/goto-definition.ts
+import { FacetCombineStrategy } from "@coze-editor/utils";
+import { ViewPlugin as ViewPlugin2 } from "@codemirror/view";
+import { Facet as Facet2 } from "@codemirror/state";
+var handlerFacet = Facet2.define({
+  combine: FacetCombineStrategy.Last
+});
+var view = ViewPlugin2.fromClass(
+  class {
+    dispose;
+    constructor(view2) {
+      function trigger(e) {
+        const target = e.target;
+        if (!e.metaKey || !target.closest(".cm-content")) {
+          return;
+        }
+        const pos = view2.posAtCoords({
+          x: e.clientX,
+          y: e.clientY
+        });
+        if (typeof pos !== "number") {
+          return;
+        }
+        const handler = view2.state.facet(handlerFacet);
+        handler({
+          view: view2,
+          pos
+        });
+      }
+      document.addEventListener("click", trigger, false);
+      this.dispose = () => {
+        document.removeEventListener("click", trigger, false);
+      };
+    }
+    destroy() {
+      if (typeof this.dispose === "function") {
+        this.dispose();
+      }
+    }
+  }
+);
+function gotoDefinition(handler) {
+  return [handlerFacet.of(handler), view];
+}
+
+// src/language-registry.ts
+function formatContents(contents) {
+  if (MarkupContent2.is(contents)) {
+    const { value } = contents;
+    if (contents.kind === "markdown") {
+    }
+    return value;
+  } else if (Array.isArray(contents)) {
+    return contents.map((c) => `${formatContents(c)}
+
+`).join("");
+  } else if (typeof contents === "string") {
+    return contents;
+  }
+  return "";
+}
+var identRe = /^[\w$]+$/;
+var LanguagesRegistry = class {
+  languages = {};
+  register(id, options) {
+    if (!this.languages[id]) {
+      this.languages[id] = options;
+    }
+    return () => {
+      delete this.languages[id];
+    };
+  }
+  get(languageId) {
+    return this.languages[languageId];
+  }
+  getExtension(id) {
+    var _a;
+    if (!this.languages[id]) {
+      return [];
+    }
+    const { languageService, language, extensions } = this.languages[id];
+    const langaugeExtensions = [];
+    langaugeExtensions.push(new LanguageSupport(language));
+    langaugeExtensions.push(syntaxHighlighting2(oneDarkHighlightStyle));
+    langaugeExtensions.push(
+      StateField2.define({
+        create(state) {
+          if (languageService == null ? void 0 : languageService.onTextDocumentDidChange) {
+            const { textDocument } = state.field(textDocumentField);
+            languageService.onTextDocumentDidChange({
+              textDocument
+            });
+          }
+        },
+        update(_value, tr) {
+          if (tr.docChanged) {
+            if (languageService == null ? void 0 : languageService.onTextDocumentDidChange) {
+              const { textDocument } = tr.state.field(textDocumentField);
+              languageService.onTextDocumentDidChange({
+                textDocument
+              });
+            }
+          }
+        }
+      })
+    );
+    if (languageService && languageService.doValidation) {
+      langaugeExtensions.push(
+        ViewPlugin3.fromClass(
+          class {
+            toDispose;
+            constructor(view2) {
+              var _a2;
+              function onRefreshDiagnostics() {
+                view2.dispatch({
+                  userEvent: LINT_REFRESH_USER_EVENT
+                });
+              }
+              (_a2 = languageService.events) == null ? void 0 : _a2.on(
+                "refresh-diagnostics",
+                onRefreshDiagnostics
+              );
+              this.toDispose = () => {
+                var _a3;
+                (_a3 = languageService.events) == null ? void 0 : _a3.off(
+                  "refresh-diagnostics",
+                  onRefreshDiagnostics
+                );
+              };
+            }
+            destroy() {
+              if (typeof this.toDispose === "function") {
+                this.toDispose();
+              }
+            }
+          }
+        ),
+        EditorView2.theme({
+          ".cm-tooltip-lint": {
+            maxWidth: "360px"
+          },
+          ".cm-lint-tag-unnecessary": {
+            opacity: "0.5"
+          },
+          ".cm-lint-tag-deprecated": {
+            textDecoration: "line-through"
+          },
+          ".cm-lintRange-hint.cm-lint-tag-deprecated": {
+            backgroundImage: "unset"
+          },
+          ".cm-lintRange-hint.cm-lint-tag-unnecessary": {
+            backgroundImage: "unset"
+          }
+        })
+      );
+      langaugeExtensions.push(
+        linter(
+          async (view2) => {
+            var _a2;
+            const { textDocument, originalRangeFor } = view2.state.field(textDocumentField);
+            const diagnostics = await languageService.doValidation({
+              textDocument
+            });
+            const finalDiagnostics = diagnostics.map((diagnostic) => {
+              var _a3, _b;
+              const range = originalRangeFor({
+                from: diagnostic.from,
+                to: diagnostic.to
+              });
+              if (range) {
+                let markClass = "";
+                if ((_a3 = diagnostic.tags) == null ? void 0 : _a3.includes(MarkerTag.Unnecessary)) {
+                  markClass += "cm-lint-tag-unnecessary";
+                }
+                if ((_b = diagnostic.tags) == null ? void 0 : _b.includes(MarkerTag.Deprecated)) {
+                  markClass += "cm-lint-tag-deprecated";
+                }
+                return {
+                  ...diagnostic,
+                  markClass,
+                  ...range
+                };
+              }
+            }).filter((v) => isDiagnostic(v));
+            (_a2 = languageService.events) == null ? void 0 : _a2.emit("diagnostics", {
+              uri: textDocument.uri,
+              diagnostics: finalDiagnostics.map((d) => ({
+                from: d.from,
+                to: d.to,
+                message: d.message,
+                severity: d.severity
+              }))
+            });
+            return finalDiagnostics;
+          },
+          {
+            delay: ((_a = languageService.options) == null ? void 0 : _a.lintDelay) ?? 100,
+            needsRefresh(update) {
+              return update.transactions.some(
+                (tr) => tr.isUserEvent(LINT_REFRESH_USER_EVENT)
+              );
+            }
+          }
+        )
+      );
+    }
+    if (languageService == null ? void 0 : languageService.doHover) {
+      langaugeExtensions.push(
+        hoverTooltip(async (view2, pos) => {
+          const { textDocument, generatedOffsetFor } = view2.state.field(textDocumentField);
+          const offset = generatedOffsetFor(pos);
+          if (typeof offset !== "number") {
+            return null;
+          }
+          const result = await languageService.doHover({
+            textDocument,
+            offset
+          });
+          if (!result) {
+            return null;
+          }
+          const html = await renderMarkdown(formatContents(result));
+          const word = view2.state.wordAt(offset);
+          return {
+            pos: (word == null ? void 0 : word.from) ?? offset,
+            end: (word == null ? void 0 : word.to) ?? offset,
+            create() {
+              const dom = document.createElement("div");
+              dom.classList.add("cm-code-hover");
+              dom.innerHTML = html;
+              dom.style.cssText = "padding: 5px 10px;max-width: 360px;";
+              return {
+                dom
+              };
+            }
+          };
+        }),
+        EditorView2.theme({
+          ".cm-code-hover a": {
+            color: "#3b98ff"
+          },
+          ".cm-code-hover pre": {
+            margin: "0"
+          }
+        })
+      );
+    }
+    if (languageService == null ? void 0 : languageService.doSignatureHelp) {
+      langaugeExtensions.push(
+        signatureHelp(async (state, pos) => {
+          const { textDocument, generatedRangeFor } = state.field(textDocumentField);
+          const range = generatedRangeFor({ from: pos, to: pos });
+          const offset = range == null ? void 0 : range.from;
+          if (typeof offset !== "number") {
+            return null;
+          }
+          const result = await languageService.doSignatureHelp({
+            textDocument,
+            offset
+          });
+          return result;
+        })
+      );
+    }
+    if (languageService == null ? void 0 : languageService.doComplete) {
+      langaugeExtensions.push(
+        EditorView2.theme({
+          ".cm-completionInfo p": {
+            margin: 0
+          },
+          ".cm-completionMatchedText": {
+            textDecoration: "none",
+            color: "#4daafc"
+          }
+        }),
+        autocompletion({
+          override: [
+            async function({ state, pos, view: view2 }) {
+              var _a2;
+              const { textDocument, originalRangeFor, generatedRangeFor } = state.field(textDocumentField);
+              const range = generatedRangeFor({ from: pos, to: pos });
+              const offset = range == null ? void 0 : range.from;
+              if (typeof offset !== "number") {
+                return null;
+              }
+              const completionResult = await languageService.doComplete({
+                textDocument,
+                offset
+              });
+              if (!completionResult || !Array.isArray(completionResult.items) || completionResult.items.length === 0) {
+                return null;
+              }
+              let { items } = completionResult;
+              const content = textDocument.getText();
+              const charBefore = content.slice(offset - 1, offset);
+              const triggerCharacters = languageService.triggerCharacters ?? [];
+              if (!triggerCharacters.includes(charBefore)) {
+                let i = offset - 1;
+                let query = "";
+                while (i >= 0) {
+                  const char = content.slice(i, i + 1);
+                  if (char === "\n") {
+                    break;
+                  }
+                  if (!identRe.test(char) && i + 1 <= offset) {
+                    break;
+                  }
+                  i--;
+                }
+                query = content.slice(i + 1, offset);
+                if (query) {
+                  const fuzzySearch = createFuzzySearch(items, {
+                    key: "label"
+                  });
+                  items = fuzzySearch(query).map((v) => {
+                    const finalItem = {
+                      ...v.item,
+                      data: {
+                        matches: v.matches.reduce((memo, current) => {
+                          if (!current) {
+                            return memo;
+                          }
+                          return [
+                            ...memo,
+                            ...current.reduce(
+                              (m, c) => [...m, c[0], c[1] + 1],
+                              []
+                            )
+                          ];
+                        }, [])
+                      }
+                    };
+                    if (!finalItem.textEdit) {
+                      finalItem.textEdit = {
+                        range: {
+                          start: textDocument.positionAt(i + 1),
+                          end: textDocument.positionAt(offset)
+                        },
+                        newText: v.item.label
+                      };
+                    }
+                    return finalItem;
+                  });
+                } else if (Array.isArray(languageService.triggerCharacters)) {
+                  items = [];
+                }
+              }
+              const completionOptions = [];
+              const mapping = /* @__PURE__ */ new WeakMap();
+              let resolveCompletion = void 0;
+              if (typeof languageService.resolveCompletionItem === "function") {
+                resolveCompletion = createResolveCompletion(
+                  view2,
+                  languageService,
+                  mapping
+                );
+              }
+              const matchesMapping = /* @__PURE__ */ new WeakMap();
+              for (const item of items) {
+                const { kind, label, textEdit, textEditText } = item;
+                const completion = {
+                  label,
+                  type: defaultFromCompletionItemKind(kind),
+                  detail: item.detail ?? ""
+                };
+                mapping.set(completion, item);
+                matchesMapping.set(completion, (_a2 = item.data) == null ? void 0 : _a2.matches);
+                if (textEdit) {
+                  const range2 = "range" in textEdit ? textEdit.range : textEdit.replace;
+                  const from = textDocument.offsetAt(range2.start);
+                  const to = textDocument.offsetAt(range2.end);
+                  const oRange = originalRangeFor({
+                    from,
+                    to
+                  });
+                  if (!oRange) {
+                    continue;
+                  }
+                  const insert = textEdit.newText;
+                  const { insertTextFormat } = item;
+                  completion.apply = (view3) => {
+                    if (insertTextFormat === 2) {
+                      snippet(
+                        addAnchor(
+                          insert.replace(/\$(\d+)/g, "$${$1}").replace(/\\\$/g, "$")
+                        )
+                      )(view3, completion, oRange.from, oRange.to);
+                    } else {
+                      view3.dispatch(
+                        insertCompletionText(
+                          view3.state,
+                          insert,
+                          oRange.from,
+                          oRange.to
+                        )
+                      );
+                    }
+                  };
+                } else if (textEditText) {
+                  completion.apply = textEditText;
+                }
+                completion.info = resolveCompletion;
+                completionOptions.push(completion);
+              }
+              return {
+                from: pos,
+                options: completionOptions,
+                filter: false,
+                getMatch(completion) {
+                  return matchesMapping.get(completion) ?? [];
+                }
+              };
+            }
+          ]
+        })
+      );
+    }
+    if (languageService == null ? void 0 : languageService.findDefinition) {
+      langaugeExtensions.push(
+        gotoDefinition(async ({ pos, view: view2 }) => {
+          const { textDocument, originalRangeFor, generatedRangeFor } = view2.state.field(textDocumentField);
+          const range = generatedRangeFor({ from: pos, to: pos });
+          const offset = range == null ? void 0 : range.from;
+          if (typeof offset !== "number") {
+            return null;
+          }
+          const definitions = await languageService.findDefinition({
+            textDocument,
+            offset
+          });
+          if (!Array.isArray(definitions) || definitions.length === 0) {
+            return;
+          }
+          const definition = definitions[0];
+          const oRange = originalRangeFor({
+            from: definition.from,
+            to: definition.to
+          });
+          if (!oRange) {
+            return;
+          }
+          view2.dispatch({
+            effects: EditorView2.scrollIntoView(oRange.from, {
+              y: "center"
+            }),
+            selection: EditorSelection.range(oRange.from, oRange.to)
+          });
+        })
+      );
+    }
+    if (languageService == null ? void 0 : languageService.findLinks) {
+      langaugeExtensions.push(
+        links(async (view2) => {
+          const { textDocument, originalRangeFor } = view2.state.field(textDocumentField);
+          const links2 = await languageService.findLinks({
+            textDocument
+          });
+          return links2.map((link) => {
+            const range = originalRangeFor(link.range);
+            if (!range) {
+              return;
+            }
+            return {
+              range,
+              target: link.target
+            };
+          }).filter((v) => isLink(v));
+        })
+      );
+    }
+    if (extensions) {
+      langaugeExtensions.push(extensions);
+    }
+    return langaugeExtensions;
+  }
+};
+function createResolveCompletion(view2, languageService, mapping) {
+  const dom = document.createElement("div");
+  let controller = new AbortController();
+  function hideDOM(controller2) {
+    if (!controller2.signal.aborted) {
+      dom.style.display = "none";
+    }
+  }
+  function showDOM(html, controller2) {
+    if (!controller2.signal.aborted) {
+      dom.innerHTML = html;
+      dom.style.display = "block";
+    }
+  }
+  return (completion) => {
+    controller.abort();
+    controller = new AbortController();
+    const closureController = controller;
+    (async () => {
+      const completionItem = mapping.get(completion);
+      if (!view2 || !completionItem || typeof languageService.resolveCompletionItem !== "function") {
+        hideDOM(closureController);
+        return;
+      }
+      const { textDocument, originalRangeFor } = view2.state.field(textDocumentField);
+      const oRange = originalRangeFor({
+        from: view2.state.selection.main.from,
+        to: view2.state.selection.main.from
+      });
+      if (!oRange) {
+        hideDOM(closureController);
+        return;
+      }
+      const details = await languageService.resolveCompletionItem(
+        {
+          textDocument,
+          offset: oRange.from
+        },
+        completionItem
+      );
+      if (!details.detail && !details.documentation) {
+        hideDOM(closureController);
+        return;
+      }
+      const documentationString = MarkupContent2.is(details.documentation) ? await renderMarkdown(details.documentation.value) : details.documentation ?? "";
+      const html = [
+        `<div style="opacity: 0.8;white-space: pre-wrap;">${details.detail ?? ""}</div>`,
+        details.documentation ? "<br />" : "",
+        `<div>${documentationString}</div>`
+      ].join("");
+      if (!closureController.signal.aborted) {
+        showDOM(html, closureController);
+      }
+    })();
+    return dom;
+  };
+}
+function isDiagnostic(v) {
+  return Boolean(v);
+}
+function isLink(v) {
+  return Boolean(v);
+}
+function addAnchor(str) {
+  if (!str.includes("${")) {
+    return `${str}\${0}`;
+  }
+  return str;
+}
+function defaultFromCompletionItemKind(kind) {
+  switch (kind) {
+    case 1:
+      return "text";
+    case 15:
+      return "snippet";
+    case 2:
+      return "method";
+    case 3:
+      return "function";
+    case 4:
+      return "constructor";
+    case 7:
+      return "class";
+    case 5:
+      return "field";
+    case 10:
+      return "property";
+    case 6:
+      return "variable";
+    case 18:
+      return "reference";
+    case 23:
+      return "event";
+    case 8:
+      return "interface";
+    case 22:
+      return "struct";
+    case 25:
+      return "typeParameter";
+    case 9:
+      return "module";
+    case 12:
+      return "value";
+    case 13:
+    case 20:
+      return "enum";
+    case 11:
+      return "unit";
+    case 14:
+      return "keyword";
+    case 24:
+      return "operator";
+    case 16:
+      return "color";
+    case 21:
+      return "constant";
+    default:
+      return "value";
+  }
+}
+var languages = new LanguagesRegistry();
+
+// src/extension/tab-size/index.ts
+import { EditorState } from "@codemirror/state";
+import { indentUnit } from "@codemirror/language";
+var tabSize = (size = 2) => [
+  EditorState.tabSize.of(size),
+  indentUnit.of(" ".repeat(size))
+];
+
+// src/extension/basic-setup.ts
+import {
+  crosshairCursor,
+  drawSelection,
+  dropCursor,
+  highlightActiveLine,
+  highlightActiveLineGutter,
+  highlightSpecialChars,
+  keymap as keymap2,
+  rectangularSelection
+} from "@codemirror/view";
+import { EditorState as EditorState2 } from "@codemirror/state";
+import {
+  defaultHighlightStyle,
+  foldKeymap,
+  indentOnInput,
+  syntaxHighlighting as syntaxHighlighting3
+} from "@codemirror/language";
+import {
+  defaultKeymap,
+  history,
+  historyKeymap,
+  indentWithTab
+} from "@codemirror/commands";
+import {
+  acceptCompletion,
+  autocompletion as autocompletion2,
+  closeBrackets,
+  closeBracketsKeymap,
+  completionKeymap
+} from "@codemirror/autocomplete";
+var basicSetup = (() => [
+  highlightActiveLineGutter(),
+  highlightSpecialChars(),
+  history(),
+  drawSelection(),
+  dropCursor(),
+  EditorState2.allowMultipleSelections.of(true),
+  indentOnInput(),
+  syntaxHighlighting3(defaultHighlightStyle, { fallback: true }),
+  closeBrackets(),
+  autocompletion2(),
+  rectangularSelection(),
+  crosshairCursor(),
+  highlightActiveLine(),
+  keymap2.of([
+    ...defaultKeymap,
+    ...closeBracketsKeymap,
+    ...historyKeymap,
+    ...foldKeymap,
+    ...completionKeymap,
+    indentWithTab,
+    { key: "Tab", run: acceptCompletion }
+  ])
+])();
+
+// src/create-theme.ts
+import { EditorView as EditorView3 } from "@codemirror/view";
+import {
+  HighlightStyle as HighlightStyle2,
+  syntaxHighlighting as syntaxHighlighting4
+} from "@codemirror/language";
+var createTheme = ({ variant, settings, styles }) => {
+  const bracketTheme = (settings.bracketColors ?? []).reduce(
+    (memo, color, index) => ({
+      ...memo,
+      [`.colorization-bracket-${index}`]: { color },
+      [`.colorization-bracket-${index} > span`]: { color }
+    }),
+    {}
+  );
+  const tooltipTheme = {
+    ".cm-tooltip": settings.tooltip ?? {},
+    ".cm-tooltip-autocomplete": settings.tooltipCompletion ?? {},
+    ".cm-tooltip a": settings.link ?? {
+      color: "#4daafc"
+    }
+  };
+  const completionTheme = {
+    ".cm-tooltip-autocomplete ul li[aria-selected]": settings.completionItemSelected ?? {},
+    ".cm-tooltip-autocomplete ul li:not([aria-selected]):hover": settings.completionItemHover ?? {},
+    ".cm-completionIcon": settings.completionItemIcon ?? {},
+    ".cm-completionLabel": settings.completionItemLabel ?? {},
+    ".cm-completionDetail": settings.completionItemDetail ?? {},
+    ".cm-completionInfo": settings.completionItemInfo ?? {}
+  };
+  const theme = EditorView3.theme(
+    {
+      "&": {
+        backgroundColor: settings.background,
+        color: settings.foreground
+      },
+      ".cm-content": {
+        caretColor: settings.caret
+      },
+      ".cm-cursor, .cm-dropCursor": {
+        borderLeftColor: settings.caret
+      },
+      "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": {
+        backgroundColor: settings.selection
+      },
+      ".cm-activeLine": {
+        backgroundColor: settings.lineHighlight
+      },
+      ".cm-gutters": {
+        backgroundColor: settings.gutterBackground,
+        color: settings.gutterForeground,
+        borderRightColor: settings.gutterBorderColor,
+        borderRightWidth: `${settings.gutterBorderWidth}px`
+      },
+      ".cm-activeLineGutter": {
+        backgroundColor: settings.lineHighlight
+      },
+      ...bracketTheme,
+      ...tooltipTheme,
+      ...completionTheme
+    },
+    {
+      dark: variant === "dark"
+    }
+  );
+  const highlightStyle = HighlightStyle2.define(styles);
+  const extension2 = [theme, syntaxHighlighting4(highlightStyle)];
+  return extension2;
+};
+var create_theme_default = createTheme;
+
+// src/index.ts
+import "@coze-editor/extension-scrollbar/dist/index.css";
+import "@coze-editor/extension-completion-icons/dist/index.css";
+
+// src/transformer.ts
+import { Text } from "@coze-editor/utils";
+var transformerCreator = (processor) => (source) => {
+  const text = processor(new Text(source));
+  return {
+    code: text.toString(),
+    mapping: {
+      originalRangeFor: text.originalRangeFor.bind(text),
+      generatedRangeFor: text.generatedRangeFor.bind(text),
+      originalOffsetFor: text.originalOffsetFor.bind(text),
+      generatedOffsetFor: text.generatedOffsetFor.bind(text)
+    }
+  };
+};
+
+// src/index.ts
+import { tags } from "@lezer/highlight";
+var SVG_FOLD_CLOSE = '<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 16 16"><path fill="currentColor" fill-rule="evenodd" d="M10.072 8.024L5.715 3.667l.618-.62L11 7.716v.618L6.333 13l-.618-.619z" clip-rule="evenodd"/></svg>';
+var SVG_FOLD_OPEN = '<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 16 16"><path fill="currentColor" fill-rule="evenodd" d="m7.976 10.072l4.357-4.357l.62.618L8.284 11h-.618L3 6.333l.619-.618z" clip-rule="evenodd"/></svg>';
+var preset = [
+  ...universal,
+  extension([
+    basicSetup,
+    matchingBrackets,
+    // indentGuides(),
+    icons,
+    textDocumentField2,
+    Prec.low(
+      EditorView4.theme({
+        ".cm-foldGutter .cm-gutterElement": {
+          display: "flex",
+          alignItems: "center",
+          cursor: "pointer"
+        }
+      })
+    ),
+    Prec.low(
+      EditorView4.theme({
+        ".cm-link": {
+          textDecoration: "underline"
+        }
+      })
+    ),
+    Prec.low(
+      EditorView4.theme({
+        ".cm-tooltip": {
+          borderRadius: "5px",
+          fontSize: "12px"
+        },
+        ".cm-diagnostic-error": {
+          borderLeft: "none"
+        },
+        ".cm-diagnostic": {
+          padding: "5px 10px"
+        },
+        ".cm-lineNumbers": {
+          userSelect: "none"
+        },
+        ".cm-tooltip.cm-tooltip-autocomplete > ul": {
+          width: "264px",
+          padding: "4px"
+        },
+        ".cm-completionInfo": {
+          minWidth: "200px",
+          margin: "0 2px"
+        },
+        ".cm-tooltip.cm-completionInfo": {
+          padding: "6px 9px"
+        },
+        ".cm-completionInfo p:last-child": {
+          display: "inline-block"
+        },
+        ".cm-tooltip.cm-tooltip-autocomplete > ul > li[aria-selected]": {
+          color: "inherit"
+        },
+        ".cm-tooltip.cm-tooltip-autocomplete > ul > li": {
+          padding: "1px 9px",
+          height: "24px",
+          display: "flex",
+          alignItems: "center",
+          borderRadius: "5px"
+        },
+        ".cm-tooltip.cm-tooltip-autocomplete > ul > li:not(:first-child)": {
+          marginTop: "2px"
+        },
+        ".cm-completionIcon": {
+          fontSize: "11px",
+          opacity: "1",
+          display: "flex"
+        },
+        ".cm-completionLabel": {
+          flex: 1,
+          overflow: "hidden",
+          textOverflow: "ellipsis"
+        },
+        ".cm-completionDetail": {
+          maxWidth: "86px",
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          textAlign: "right",
+          fontStyle: "initial"
+        },
+        ".cm-tooltip-autocomplete": {
+          borderRadius: "8px"
+        },
+        ".cm-tooltip-hover": {
+          overflowY: "auto",
+          maxHeight: "360px",
+          wordBreak: "break-word"
+        },
+        ".cm-tooltip-hover p": {
+          margin: 0
+        },
+        ".cm-tooltip-section:not(:first-child)": {
+          "border-top": "solid 0.5px #666666ab"
+        }
+      })
+    )
+  ]),
+  option("tabSize", tabSize),
+  option("height", height),
+  option("minHeight", minHeight),
+  option("maxHeight", maxHeight),
+  option(
+    "scrollBeyondLastLine",
+    (use) => use ? scrollBeyondLastLine() : []
+  ),
+  option("uri", (id) => uriFacet.of(id)),
+  option("theme", (themeName) => themes.get(themeName) ?? []),
+  option("languageId", (id) => [
+    languageIdFacet.of(id),
+    languages.getExtension(id)
+  ]),
+  option(
+    "transformer",
+    (transformer) => transformerFacet.of(transformer)
+  ),
+  option("overlayScrollbar", (enable = true) => enable ? [scrollbar()] : []),
+  option(
+    "lineNumbersGutter",
+    (enable = true) => enable ? lineNumbers({
+      domEventHandlers: {
+        // avoid blur
+        mousedown: (view2, line, event) => {
+          event.preventDefault();
+          return false;
+        }
+      }
+    }) : []
+  ),
+  option(
+    "foldGutter",
+    (enable = true) => enable ? foldGutter({
+      markerDOM(open) {
+        const dom = document.createElement("div");
+        dom.innerHTML = open ? SVG_FOLD_OPEN : SVG_FOLD_CLOSE;
+        return dom;
+      },
+      domEventHandlers: {
+        // avoid blur
+        mousedown: (view2, line, event) => {
+          event.preventDefault();
+          return false;
+        }
+      }
+    }) : []
+  ),
+  option(
+    "colorizeBrackets",
+    (enable = true) => enable ? colorizationBrackets : []
+  ),
+  api("validate", ({ view: view2 }) => () => {
+    view2.dispatch({
+      userEvent: LINT_REFRESH_USER_EVENT
+    });
+  })
+];
+themes.register("_light", vscodeLight);
+themes.register("_dark", vscodeDark);
+var index_default = preset;
+export {
+  create_theme_default as createTheme,
+  index_default as default,
+  languages,
+  tags,
+  themes,
+  transformerCreator
+};
+//# sourceMappingURL=index.js.map