@coze-editor/extension-lint 0.1.0-alpha.09ffeb

package/dist/index.js

@@ -0,0 +1,1038 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  closeLintPanel: () => closeLintPanel,
+  diagnosticCount: () => diagnosticCount,
+  forEachDiagnostic: () => forEachDiagnostic,
+  forceLinting: () => forceLinting,
+  lintGutter: () => lintGutter,
+  lintKeymap: () => lintKeymap,
+  linter: () => linter,
+  nextDiagnostic: () => nextDiagnostic,
+  openLintPanel: () => openLintPanel,
+  previousDiagnostic: () => previousDiagnostic,
+  setDiagnostics: () => setDiagnostics,
+  setDiagnosticsEffect: () => setDiagnosticsEffect
+});
+module.exports = __toCommonJS(index_exports);
+var import_crelt = __toESM(require("crelt"));
+var import_view2 = require("@codemirror/view");
+var import_state = require("@codemirror/state");
+
+// src/merge-decorations.ts
+var import_view = require("@codemirror/view");
+var splitDiagnosticBySeverity = (decorations) => {
+  const diagnosticMap = /* @__PURE__ */ new Map();
+  const decoration = decorations.iter();
+  while (decoration.value) {
+    const { severity } = decoration.value.spec.diagnostic;
+    if (!diagnosticMap.has(severity)) {
+      diagnosticMap.set(severity, []);
+    }
+    diagnosticMap.get(severity).push(decoration.value.spec.diagnostic);
+    decoration.next();
+  }
+  return diagnosticMap;
+};
+var createDecoration = (from, to, severity, diagnostics) => {
+  const last = diagnostics[diagnostics.length - 1];
+  return import_view.Decoration.mark({
+    attributes: {
+      class: `cm-lintRange cm-lintRange-${severity}${last.markClass ? ` ${last.markClass}` : ""}`
+    },
+    sourceDiagnostics: diagnostics
+  }).range(from, to);
+};
+var mergeDecoration = (diagnostics) => {
+  const cloned = diagnostics.map((e) => ({
+    from: e.from,
+    to: e.to
+  }));
+  const merged = [];
+  cloned.sort((a, b) => a.from - b.from);
+  let current = cloned[0];
+  let currentSourceDiagnostics = [diagnostics[0]];
+  for (let i = 1; i < cloned.length; i++) {
+    const next = cloned[i];
+    if (next.from <= current.to) {
+      currentSourceDiagnostics.push(diagnostics[i]);
+      current.to = Math.max(current.to, next.to);
+    } else {
+      merged.push({ ...current, sourceDiagnostics: currentSourceDiagnostics });
+      current = next;
+      currentSourceDiagnostics = [diagnostics[i]];
+    }
+  }
+  merged.push({ ...current, sourceDiagnostics: currentSourceDiagnostics });
+  return merged;
+};
+var mergeDecorations = (decorations) => {
+  try {
+    const diagnosticMap = splitDiagnosticBySeverity(decorations);
+    const merge = [];
+    diagnosticMap.forEach((value, key) => {
+      mergeDecoration(value).forEach((diagnostic) => {
+        if (typeof diagnostic.from !== "number" || typeof diagnostic.to !== "number") {
+          return;
+        }
+        if (diagnostic.from < diagnostic.to) {
+          merge.push(
+            createDecoration(
+              diagnostic.from,
+              diagnostic.to,
+              key,
+              diagnostic.sourceDiagnostics
+            )
+          );
+        }
+      });
+    });
+    merge.sort((a, b) => {
+      if (a.from !== b.from) {
+        return a.from - b.from;
+      }
+      return a.value.startSide - b.value.startSide;
+    });
+    return import_view.Decoration.set(merge);
+  } catch (e) {
+    console.error("linter mergeDecorations error", e);
+    return decorations;
+  }
+};
+
+// src/index.ts
+var SelectedDiagnostic = class {
+  constructor(from, to, diagnostic) {
+    this.from = from;
+    this.to = to;
+    this.diagnostic = diagnostic;
+  }
+};
+var LintState = class _LintState {
+  constructor(diagnostics, panel, selected) {
+    this.diagnostics = diagnostics;
+    this.panel = panel;
+    this.selected = selected;
+  }
+  static init(diagnostics, panel, state) {
+    let markedDiagnostics = diagnostics;
+    const diagnosticFilter = state.facet(lintConfig).markerFilter;
+    if (diagnosticFilter) {
+      markedDiagnostics = diagnosticFilter(markedDiagnostics, state);
+    }
+    const ranges = import_view2.Decoration.set(
+      markedDiagnostics.map((d) => {
+        if (d.from == d.to || d.from == d.to - 1 && state.doc.lineAt(d.from).to == d.from) {
+          return import_view2.Decoration.widget({
+            widget: new DiagnosticWidget(d),
+            diagnostic: d
+          }).range(d.from);
+        }
+        return import_view2.Decoration.mark({
+          attributes: {
+            class: `cm-lintRange cm-lintRange-${d.severity}${d.markClass ? ` ${d.markClass}` : ""}`
+          },
+          diagnostic: d
+        }).range(d.from, d.to);
+      }),
+      true
+    );
+    return new _LintState(ranges, panel, findDiagnostic(ranges));
+  }
+};
+function findDiagnostic(diagnostics, diagnostic = null, after = 0) {
+  let found = null;
+  diagnostics.between(after, 1e9, (from, to, { spec }) => {
+    if (diagnostic && spec.diagnostic != diagnostic) {
+      return;
+    }
+    found = new SelectedDiagnostic(from, to, spec.diagnostic);
+    return false;
+  });
+  return found;
+}
+function hideTooltip(tr, tooltip) {
+  const from = tooltip.pos, to = tooltip.end || from;
+  const result = tr.state.facet(lintConfig).hideOn(tr, from, to);
+  if (result != null) {
+    return result;
+  }
+  const line = tr.startState.doc.lineAt(tooltip.pos);
+  return !!(tr.effects.some((e) => e.is(setDiagnosticsEffect)) || tr.changes.touchesRange(line.from, Math.max(line.to, to)));
+}
+function maybeEnableLint(state, effects) {
+  return state.field(lintState, false) ? effects : effects.concat(import_state.StateEffect.appendConfig.of(lintExtensions));
+}
+function setDiagnostics(state, diagnostics) {
+  return {
+    effects: maybeEnableLint(state, [setDiagnosticsEffect.of(diagnostics)])
+  };
+}
+var setDiagnosticsEffect = import_state.StateEffect.define();
+var togglePanel = import_state.StateEffect.define();
+var movePanelSelection = import_state.StateEffect.define();
+var lintState = import_state.StateField.define({
+  create() {
+    return new LintState(import_view2.Decoration.none, null, null);
+  },
+  update(value, tr) {
+    if (tr.docChanged && value.diagnostics.size) {
+      const mapped = value.diagnostics.map(tr.changes);
+      let selected = null, { panel } = value;
+      if (value.selected) {
+        const selPos = tr.changes.mapPos(value.selected.from, 1);
+        selected = findDiagnostic(mapped, value.selected.diagnostic, selPos) || findDiagnostic(mapped, null, selPos);
+      }
+      if (!mapped.size && panel && tr.state.facet(lintConfig).autoPanel) {
+        panel = null;
+      }
+      value = new LintState(mapped, panel, selected);
+    }
+    for (const effect of tr.effects) {
+      if (effect.is(setDiagnosticsEffect)) {
+        const panel = !tr.state.facet(lintConfig).autoPanel ? value.panel : effect.value.length ? LintPanel.open : null;
+        value = LintState.init(effect.value, panel, tr.state);
+      } else if (effect.is(togglePanel)) {
+        value = new LintState(
+          value.diagnostics,
+          effect.value ? LintPanel.open : null,
+          value.selected
+        );
+      } else if (effect.is(movePanelSelection)) {
+        value = new LintState(value.diagnostics, value.panel, effect.value);
+      }
+    }
+    return value;
+  },
+  provide: (f) => [
+    import_view2.showPanel.from(f, (val) => val.panel),
+    // mergeDecorations 中合并了相同 severity 的 diagnostic 在编辑器中的下划线样式，以前会重复绘制下划线，现在只会绘制一次。
+    import_view2.EditorView.decorations.from(f, (s) => mergeDecorations(s.diagnostics))
+  ]
+});
+function diagnosticCount(state) {
+  const lint = state.field(lintState, false);
+  return lint ? lint.diagnostics.size : 0;
+}
+var activeMark = import_view2.Decoration.mark({
+  class: "cm-lintRange cm-lintRange-active"
+});
+function lintTooltip(view, pos, side) {
+  const { diagnostics } = view.state.field(lintState);
+  let found = [], stackStart = 2e8, stackEnd = 0;
+  diagnostics.between(
+    pos - (side < 0 ? 1 : 0),
+    pos + (side > 0 ? 1 : 0),
+    (from, to, { spec }) => {
+      if (pos >= from && pos <= to && (from == to || (pos > from || side > 0) && (pos < to || side < 0))) {
+        found.push(spec.diagnostic);
+        stackStart = Math.min(from, stackStart);
+        stackEnd = Math.max(to, stackEnd);
+      }
+    }
+  );
+  const diagnosticFilter = view.state.facet(lintConfig).tooltipFilter;
+  if (diagnosticFilter) {
+    found = diagnosticFilter(found, view.state);
+  }
+  if (!found.length) {
+    return null;
+  }
+  return {
+    pos: stackStart,
+    end: stackEnd,
+    above: view.state.doc.lineAt(stackStart).to < stackEnd,
+    create() {
+      return { dom: diagnosticsTooltip(view, found) };
+    }
+  };
+}
+function diagnosticsTooltip(view, diagnostics) {
+  return (0, import_crelt.default)(
+    "ul",
+    { class: "cm-tooltip-lint" },
+    diagnostics.map((d) => renderDiagnostic(view, d, false))
+  );
+}
+var openLintPanel = (view) => {
+  const field = view.state.field(lintState, false);
+  if (!field || !field.panel) {
+    view.dispatch({
+      effects: maybeEnableLint(view.state, [togglePanel.of(true)])
+    });
+  }
+  const panel = (0, import_view2.getPanel)(view, LintPanel.open);
+  if (panel) {
+    panel.dom.querySelector(".cm-panel-lint ul").focus();
+  }
+  return true;
+};
+var closeLintPanel = (view) => {
+  const field = view.state.field(lintState, false);
+  if (!field || !field.panel) {
+    return false;
+  }
+  view.dispatch({ effects: togglePanel.of(false) });
+  return true;
+};
+var nextDiagnostic = (view) => {
+  const field = view.state.field(lintState, false);
+  if (!field) {
+    return false;
+  }
+  const sel = view.state.selection.main;
+  let next = field.diagnostics.iter(sel.to + 1);
+  if (!next.value) {
+    next = field.diagnostics.iter(0);
+    if (!next.value || next.from == sel.from && next.to == sel.to) {
+      return false;
+    }
+  }
+  view.dispatch({
+    selection: { anchor: next.from, head: next.to },
+    scrollIntoView: true
+  });
+  return true;
+};
+var previousDiagnostic = (view) => {
+  const { state } = view, field = state.field(lintState, false);
+  if (!field) {
+    return false;
+  }
+  const sel = state.selection.main;
+  let prevFrom, prevTo, lastFrom, lastTo;
+  field.diagnostics.between(0, state.doc.length, (from, to) => {
+    if (to < sel.to && (prevFrom == null || prevFrom < from)) {
+      prevFrom = from;
+      prevTo = to;
+    }
+    if (lastFrom == null || from > lastFrom) {
+      lastFrom = from;
+      lastTo = to;
+    }
+  });
+  if (lastFrom == null || prevFrom == null && lastFrom == sel.from) {
+    return false;
+  }
+  view.dispatch({
+    selection: { anchor: prevFrom ?? lastFrom, head: prevTo ?? lastTo },
+    scrollIntoView: true
+  });
+  return true;
+};
+var lintKeymap = [
+  { key: "Mod-Shift-m", run: openLintPanel, preventDefault: true },
+  { key: "F8", run: nextDiagnostic }
+];
+var lintPlugin = import_view2.ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      this.view = view;
+      const { delay } = view.state.facet(lintConfig);
+      this.lintTime = Date.now() + delay;
+      this.run = this.run.bind(this);
+      this.timeout = window.setTimeout(this.run, delay);
+    }
+    lintTime;
+    timeout = -1;
+    set = true;
+    run() {
+      clearTimeout(this.timeout);
+      const now = Date.now();
+      if (now < this.lintTime - 10) {
+        this.timeout = window.setTimeout(this.run, this.lintTime - now);
+      } else {
+        this.set = false;
+        const { state } = this.view, { sources } = state.facet(lintConfig);
+        if (sources.length) {
+          Promise.all(
+            sources.map((source) => Promise.resolve(source(this.view)))
+          ).then(
+            (annotations) => {
+              const all = annotations.reduce((a, b) => a.concat(b));
+              if (this.view.state.doc == state.doc) {
+                this.view.dispatch(setDiagnostics(this.view.state, all));
+              }
+            },
+            (error) => {
+              (0, import_view2.logException)(this.view.state, error);
+            }
+          );
+        }
+      }
+    }
+    update(update) {
+      const config = update.state.facet(lintConfig);
+      if (update.docChanged || config != update.startState.facet(lintConfig) || config.needsRefresh && config.needsRefresh(update)) {
+        this.lintTime = Date.now() + config.delay;
+        if (!this.set) {
+          this.set = true;
+          this.timeout = window.setTimeout(this.run, config.delay);
+        }
+      }
+    }
+    force() {
+      if (this.set) {
+        this.lintTime = Date.now();
+        this.run();
+      }
+    }
+    destroy() {
+      clearTimeout(this.timeout);
+    }
+  }
+);
+var lintConfig = import_state.Facet.define({
+  combine(input) {
+    return {
+      sources: input.map((i) => i.source).filter((x) => x != null),
+      ...(0, import_state.combineConfig)(
+        input.map((i) => i.config),
+        {
+          delay: 750,
+          markerFilter: null,
+          tooltipFilter: null,
+          needsRefresh: null,
+          hideOn: () => null
+        },
+        {
+          needsRefresh: (a, b) => !a ? b : !b ? a : (u) => a(u) || b(u)
+        }
+      )
+    };
+  }
+});
+function linter(source, config = {}) {
+  return [lintConfig.of({ source, config }), lintPlugin, lintExtensions];
+}
+function forceLinting(view) {
+  const plugin = view.plugin(lintPlugin);
+  if (plugin) {
+    plugin.force();
+  }
+}
+function assignKeys(actions) {
+  const assigned = [];
+  if (actions) {
+    actions: for (const { name } of actions) {
+      for (let i = 0; i < name.length; i++) {
+        const ch = name[i];
+        if (/[a-zA-Z]/.test(ch) && !assigned.some((c) => c.toLowerCase() == ch.toLowerCase())) {
+          assigned.push(ch);
+          continue actions;
+        }
+      }
+      assigned.push("");
+    }
+  }
+  return assigned;
+}
+function renderDiagnostic(view, diagnostic, inPanel) {
+  var _a;
+  const keys = inPanel ? assignKeys(diagnostic.actions) : [];
+  return (0, import_crelt.default)(
+    "li",
+    { class: `cm-diagnostic cm-diagnostic-${diagnostic.severity}` },
+    (0, import_crelt.default)(
+      "span",
+      { class: "cm-diagnosticText" },
+      diagnostic.renderMessage ? diagnostic.renderMessage(view) : diagnostic.message
+    ),
+    (_a = diagnostic.actions) == null ? void 0 : _a.map((action, i) => {
+      let fired = false;
+      const click = (e) => {
+        e.preventDefault();
+        if (fired) {
+          return;
+        }
+        fired = true;
+        const found = findDiagnostic(
+          view.state.field(lintState).diagnostics,
+          diagnostic
+        );
+        if (found) {
+          action.apply(view, found.from, found.to);
+        }
+      };
+      const { name } = action, keyIndex = keys[i] ? name.indexOf(keys[i]) : -1;
+      const nameElt = keyIndex < 0 ? name : [
+        name.slice(0, keyIndex),
+        (0, import_crelt.default)("u", name.slice(keyIndex, keyIndex + 1)),
+        name.slice(keyIndex + 1)
+      ];
+      return (0, import_crelt.default)(
+        "button",
+        {
+          type: "button",
+          class: "cm-diagnosticAction",
+          onclick: click,
+          onmousedown: click,
+          "aria-label": ` Action: ${name}${keyIndex < 0 ? "" : ` (access key "${keys[i]})"`}.`
+        },
+        nameElt
+      );
+    }),
+    diagnostic.source && (0, import_crelt.default)("div", { class: "cm-diagnosticSource" }, diagnostic.source)
+  );
+}
+var DiagnosticWidget = class extends import_view2.WidgetType {
+  constructor(diagnostic) {
+    super();
+    this.diagnostic = diagnostic;
+  }
+  eq(other) {
+    return other.diagnostic == this.diagnostic;
+  }
+  toDOM() {
+    return (0, import_crelt.default)("span", {
+      class: `cm-lintPoint cm-lintPoint-${this.diagnostic.severity}`
+    });
+  }
+};
+var PanelItem = class {
+  constructor(view, diagnostic) {
+    this.diagnostic = diagnostic;
+    this.dom = renderDiagnostic(view, diagnostic, true);
+    this.dom.id = this.id;
+    this.dom.setAttribute("role", "option");
+  }
+  id = `item_${Math.floor(Math.random() * 4294967295).toString(16)}`;
+  dom;
+};
+var LintPanel = class _LintPanel {
+  constructor(view) {
+    this.view = view;
+    const onkeydown = (event) => {
+      if (event.keyCode == 27) {
+        closeLintPanel(this.view);
+        this.view.focus();
+      } else if (event.keyCode == 38 || event.keyCode == 33) {
+        this.moveSelection(
+          (this.selectedIndex - 1 + this.items.length) % this.items.length
+        );
+      } else if (event.keyCode == 40 || event.keyCode == 34) {
+        this.moveSelection((this.selectedIndex + 1) % this.items.length);
+      } else if (event.keyCode == 36) {
+        this.moveSelection(0);
+      } else if (event.keyCode == 35) {
+        this.moveSelection(this.items.length - 1);
+      } else if (event.keyCode == 13) {
+        this.view.focus();
+      } else if (event.keyCode >= 65 && event.keyCode <= 90 && this.selectedIndex >= 0) {
+        const { diagnostic } = this.items[this.selectedIndex], keys = assignKeys(diagnostic.actions);
+        for (let i = 0; i < keys.length; i++) {
+          if (keys[i].toUpperCase().charCodeAt(0) == event.keyCode) {
+            const found = findDiagnostic(
+              this.view.state.field(lintState).diagnostics,
+              diagnostic
+            );
+            if (found) {
+              diagnostic.actions[i].apply(view, found.from, found.to);
+            }
+          }
+        }
+      } else {
+        return;
+      }
+      event.preventDefault();
+    };
+    const onclick = (event) => {
+      for (let i = 0; i < this.items.length; i++) {
+        if (this.items[i].dom.contains(event.target)) {
+          this.moveSelection(i);
+        }
+      }
+    };
+    this.list = (0, import_crelt.default)("ul", {
+      tabIndex: 0,
+      role: "listbox",
+      "aria-label": this.view.state.phrase("Diagnostics"),
+      onkeydown,
+      onclick
+    });
+    this.dom = (0, import_crelt.default)(
+      "div",
+      { class: "cm-panel-lint" },
+      this.list,
+      (0, import_crelt.default)(
+        "button",
+        {
+          type: "button",
+          name: "close",
+          "aria-label": this.view.state.phrase("close"),
+          onclick: () => closeLintPanel(this.view)
+        },
+        "\xD7"
+      )
+    );
+    this.update();
+  }
+  items = [];
+  dom;
+  list;
+  get selectedIndex() {
+    const { selected } = this.view.state.field(lintState);
+    if (!selected) {
+      return -1;
+    }
+    for (let i = 0; i < this.items.length; i++) {
+      if (this.items[i].diagnostic == selected.diagnostic) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  update() {
+    const { diagnostics, selected } = this.view.state.field(lintState);
+    let i = 0, needsSync = false, newSelectedItem = null;
+    diagnostics.between(
+      0,
+      this.view.state.doc.length,
+      (_start, _end, { spec }) => {
+        let found = -1, item;
+        for (let j = i; j < this.items.length; j++) {
+          if (this.items[j].diagnostic == spec.diagnostic) {
+            found = j;
+            break;
+          }
+        }
+        if (found < 0) {
+          item = new PanelItem(this.view, spec.diagnostic);
+          this.items.splice(i, 0, item);
+          needsSync = true;
+        } else {
+          item = this.items[found];
+          if (found > i) {
+            this.items.splice(i, found - i);
+            needsSync = true;
+          }
+        }
+        if (selected && item.diagnostic == selected.diagnostic) {
+          if (!item.dom.hasAttribute("aria-selected")) {
+            item.dom.setAttribute("aria-selected", "true");
+            newSelectedItem = item;
+          }
+        } else if (item.dom.hasAttribute("aria-selected")) {
+          item.dom.removeAttribute("aria-selected");
+        }
+        i++;
+      }
+    );
+    while (i < this.items.length && !(this.items.length == 1 && this.items[0].diagnostic.from < 0)) {
+      needsSync = true;
+      this.items.pop();
+    }
+    if (this.items.length == 0) {
+      this.items.push(
+        new PanelItem(this.view, {
+          from: -1,
+          to: -1,
+          severity: "info",
+          message: this.view.state.phrase("No diagnostics")
+        })
+      );
+      needsSync = true;
+    }
+    if (newSelectedItem) {
+      this.list.setAttribute("aria-activedescendant", newSelectedItem.id);
+      this.view.requestMeasure({
+        key: this,
+        read: () => ({
+          sel: newSelectedItem.dom.getBoundingClientRect(),
+          panel: this.list.getBoundingClientRect()
+        }),
+        write: ({ sel, panel }) => {
+          const scaleY = panel.height / this.list.offsetHeight;
+          if (sel.top < panel.top) {
+            this.list.scrollTop -= (panel.top - sel.top) / scaleY;
+          } else if (sel.bottom > panel.bottom) {
+            this.list.scrollTop += (sel.bottom - panel.bottom) / scaleY;
+          }
+        }
+      });
+    } else if (this.selectedIndex < 0) {
+      this.list.removeAttribute("aria-activedescendant");
+    }
+    if (needsSync) {
+      this.sync();
+    }
+  }
+  sync() {
+    let domPos = this.list.firstChild;
+    function rm() {
+      const prev = domPos;
+      domPos = prev.nextSibling;
+      prev.remove();
+    }
+    for (const item of this.items) {
+      if (item.dom.parentNode == this.list) {
+        while (domPos != item.dom) {
+          rm();
+        }
+        domPos = item.dom.nextSibling;
+      } else {
+        this.list.insertBefore(item.dom, domPos);
+      }
+    }
+    while (domPos) {
+      rm();
+    }
+  }
+  moveSelection(selectedIndex) {
+    if (this.selectedIndex < 0) {
+      return;
+    }
+    const field = this.view.state.field(lintState);
+    const selection = findDiagnostic(
+      field.diagnostics,
+      this.items[selectedIndex].diagnostic
+    );
+    if (!selection) {
+      return;
+    }
+    this.view.dispatch({
+      selection: { anchor: selection.from, head: selection.to },
+      scrollIntoView: true,
+      effects: movePanelSelection.of(selection)
+    });
+  }
+  static open(view) {
+    return new _LintPanel(view);
+  }
+};
+function svg(content, attrs = 'viewBox="0 0 40 40"') {
+  return `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" ${attrs}>${encodeURIComponent(content)}</svg>')`;
+}
+function underline(color) {
+  return svg(
+    `<path d="m0 2.5 l2 -1.5 l1 0 l2 1.5 l1 0" stroke="${color}" fill="none" stroke-width=".7"/>`,
+    'width="6" height="3"'
+  );
+}
+var baseTheme = import_view2.EditorView.baseTheme({
+  ".cm-diagnostic": {
+    padding: "3px 6px 3px 8px",
+    marginLeft: "-1px",
+    display: "block",
+    whiteSpace: "pre-wrap"
+  },
+  ".cm-diagnostic-error": { borderLeft: "5px solid #d11" },
+  ".cm-diagnostic-warning": { borderLeft: "5px solid orange" },
+  ".cm-diagnostic-info": { borderLeft: "5px solid #999" },
+  ".cm-diagnostic-hint": { borderLeft: "5px solid #66d" },
+  ".cm-diagnosticAction": {
+    font: "inherit",
+    border: "none",
+    padding: "2px 4px",
+    backgroundColor: "#444",
+    color: "white",
+    borderRadius: "3px",
+    marginLeft: "8px",
+    cursor: "pointer"
+  },
+  ".cm-diagnosticSource": {
+    fontSize: "70%",
+    opacity: 0.7
+  },
+  ".cm-lintRange": {
+    backgroundPosition: "left bottom",
+    backgroundRepeat: "repeat-x",
+    paddingBottom: "0.7px"
+  },
+  ".cm-lintRange-error": { backgroundImage: underline("#d11") },
+  ".cm-lintRange-warning": { backgroundImage: underline("orange") },
+  ".cm-lintRange-info": { backgroundImage: underline("#999") },
+  ".cm-lintRange-hint": { backgroundImage: underline("#66d") },
+  ".cm-lintRange-active": { backgroundColor: "#ffdd9980" },
+  ".cm-tooltip-lint": {
+    padding: 0,
+    margin: 0
+  },
+  ".cm-lintPoint": {
+    position: "relative",
+    "&:after": {
+      content: '""',
+      position: "absolute",
+      bottom: 0,
+      left: "-2px",
+      borderLeft: "3px solid transparent",
+      borderRight: "3px solid transparent",
+      borderBottom: "4px solid #d11"
+    }
+  },
+  ".cm-lintPoint-warning": {
+    "&:after": { borderBottomColor: "orange" }
+  },
+  ".cm-lintPoint-info": {
+    "&:after": { borderBottomColor: "#999" }
+  },
+  ".cm-lintPoint-hint": {
+    "&:after": { borderBottomColor: "#66d" }
+  },
+  ".cm-panel.cm-panel-lint": {
+    position: "relative",
+    "& ul": {
+      maxHeight: "100px",
+      overflowY: "auto",
+      "& [aria-selected]": {
+        backgroundColor: "#ddd",
+        "& u": { textDecoration: "underline" }
+      },
+      "&:focus [aria-selected]": {
+        background_fallback: "#bdf",
+        backgroundColor: "Highlight",
+        color_fallback: "white",
+        color: "HighlightText"
+      },
+      "& u": { textDecoration: "none" },
+      padding: 0,
+      margin: 0
+    },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "2px",
+      background: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    }
+  }
+});
+function severityWeight(sev) {
+  return sev == "error" ? 4 : sev == "warning" ? 3 : sev == "info" ? 2 : 1;
+}
+var LintGutterMarker = class extends import_view2.GutterMarker {
+  constructor(diagnostics) {
+    super();
+    this.diagnostics = diagnostics;
+    this.severity = diagnostics.reduce(
+      (max, d) => severityWeight(max) < severityWeight(d.severity) ? d.severity : max,
+      "hint"
+    );
+  }
+  severity;
+  toDOM(view) {
+    const elt2 = document.createElement("div");
+    elt2.className = `cm-lint-marker cm-lint-marker-${this.severity}`;
+    let { diagnostics } = this;
+    const diagnosticsFilter = view.state.facet(lintGutterConfig).tooltipFilter;
+    if (diagnosticsFilter) {
+      diagnostics = diagnosticsFilter(diagnostics, view.state);
+    }
+    if (diagnostics.length) {
+      elt2.onmouseover = () => gutterMarkerMouseOver(view, elt2, diagnostics);
+    }
+    return elt2;
+  }
+};
+function trackHoverOn(view, marker) {
+  const mousemove = (event) => {
+    const rect = marker.getBoundingClientRect();
+    if (event.clientX > rect.left - 10 /* Margin */ && event.clientX < rect.right + 10 /* Margin */ && event.clientY > rect.top - 10 /* Margin */ && event.clientY < rect.bottom + 10 /* Margin */) {
+      return;
+    }
+    for (let target = event.target; target; target = target.parentNode) {
+      if (target.nodeType == 1 && target.classList.contains("cm-tooltip-lint")) {
+        return;
+      }
+    }
+    window.removeEventListener("mousemove", mousemove);
+    if (view.state.field(lintGutterTooltip)) {
+      view.dispatch({ effects: setLintGutterTooltip.of(null) });
+    }
+  };
+  window.addEventListener("mousemove", mousemove);
+}
+function gutterMarkerMouseOver(view, marker, diagnostics) {
+  function hovered() {
+    const line = view.elementAtHeight(
+      marker.getBoundingClientRect().top + 5 - view.documentTop
+    );
+    const linePos = view.coordsAtPos(line.from);
+    if (linePos) {
+      view.dispatch({
+        effects: setLintGutterTooltip.of({
+          pos: line.from,
+          above: false,
+          create() {
+            return {
+              dom: diagnosticsTooltip(view, diagnostics),
+              getCoords: () => marker.getBoundingClientRect()
+            };
+          }
+        })
+      });
+    }
+    marker.onmouseout = marker.onmousemove = null;
+    trackHoverOn(view, marker);
+  }
+  const { hoverTime } = view.state.facet(lintGutterConfig);
+  let hoverTimeout = setTimeout(hovered, hoverTime);
+  marker.onmouseout = () => {
+    clearTimeout(hoverTimeout);
+    marker.onmouseout = marker.onmousemove = null;
+  };
+  marker.onmousemove = () => {
+    clearTimeout(hoverTimeout);
+    hoverTimeout = setTimeout(hovered, hoverTime);
+  };
+}
+function markersForDiagnostics(doc, diagnostics) {
+  const byLine = /* @__PURE__ */ Object.create(null);
+  for (const diagnostic of diagnostics) {
+    const line = doc.lineAt(diagnostic.from);
+    (byLine[line.from] || (byLine[line.from] = [])).push(diagnostic);
+  }
+  const markers = [];
+  for (const line in byLine) {
+    markers.push(new LintGutterMarker(byLine[line]).range(+line));
+  }
+  return import_state.RangeSet.of(markers, true);
+}
+var lintGutterExtension = (0, import_view2.gutter)({
+  class: "cm-gutter-lint",
+  markers: (view) => view.state.field(lintGutterMarkers)
+});
+var lintGutterMarkers = import_state.StateField.define({
+  create() {
+    return import_state.RangeSet.empty;
+  },
+  update(markers, tr) {
+    markers = markers.map(tr.changes);
+    const diagnosticFilter = tr.state.facet(lintGutterConfig).markerFilter;
+    for (const effect of tr.effects) {
+      if (effect.is(setDiagnosticsEffect)) {
+        let diagnostics = effect.value;
+        if (diagnosticFilter) {
+          diagnostics = diagnosticFilter(diagnostics || [], tr.state);
+        }
+        markers = markersForDiagnostics(tr.state.doc, diagnostics.slice(0));
+      }
+    }
+    return markers;
+  }
+});
+var setLintGutterTooltip = import_state.StateEffect.define();
+var lintGutterTooltip = import_state.StateField.define({
+  create() {
+    return null;
+  },
+  update(tooltip, tr) {
+    if (tooltip && tr.docChanged) {
+      tooltip = hideTooltip(tr, tooltip) ? null : { ...tooltip, pos: tr.changes.mapPos(tooltip.pos) };
+    }
+    return tr.effects.reduce(
+      (t, e) => e.is(setLintGutterTooltip) ? e.value : t,
+      tooltip
+    );
+  },
+  provide: (field) => import_view2.showTooltip.from(field)
+});
+var lintGutterTheme = import_view2.EditorView.baseTheme({
+  ".cm-gutter-lint": {
+    width: "1.4em",
+    "& .cm-gutterElement": {
+      padding: ".2em"
+    }
+  },
+  ".cm-lint-marker": {
+    width: "1em",
+    height: "1em"
+  },
+  ".cm-lint-marker-info": {
+    content: svg(
+      '<path fill="#aaf" stroke="#77e" stroke-width="6" stroke-linejoin="round" d="M5 5L35 5L35 35L5 35Z"/>'
+    )
+  },
+  ".cm-lint-marker-warning": {
+    content: svg(
+      '<path fill="#fe8" stroke="#fd7" stroke-width="6" stroke-linejoin="round" d="M20 6L37 35L3 35Z"/>'
+    )
+  },
+  ".cm-lint-marker-error": {
+    content: svg(
+      '<circle cx="20" cy="20" r="15" fill="#f87" stroke="#f43" stroke-width="6"/>'
+    )
+  }
+});
+var lintExtensions = [
+  lintState,
+  import_view2.EditorView.decorations.compute([lintState], (state) => {
+    const { selected, panel } = state.field(lintState);
+    return !selected || !panel || selected.from == selected.to ? import_view2.Decoration.none : import_view2.Decoration.set([activeMark.range(selected.from, selected.to)]);
+  }),
+  (0, import_view2.hoverTooltip)(lintTooltip, { hideOn: hideTooltip }),
+  baseTheme
+];
+var lintGutterConfig = import_state.Facet.define({
+  combine(configs) {
+    return (0, import_state.combineConfig)(configs, {
+      hoverTime: 300 /* Time */,
+      markerFilter: null,
+      tooltipFilter: null
+    });
+  }
+});
+function lintGutter(config = {}) {
+  return [
+    lintGutterConfig.of(config),
+    lintGutterMarkers,
+    lintGutterExtension,
+    lintGutterTheme,
+    lintGutterTooltip
+  ];
+}
+function forEachDiagnostic(state, f) {
+  const lState = state.field(lintState, false);
+  if (lState && lState.diagnostics.size) {
+    for (let iter = import_state.RangeSet.iter([lState.diagnostics]); iter.value; iter.next()) {
+      f(iter.value.spec.diagnostic, iter.from, iter.to);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  closeLintPanel,
+  diagnosticCount,
+  forEachDiagnostic,
+  forceLinting,
+  lintGutter,
+  lintKeymap,
+  linter,
+  nextDiagnostic,
+  openLintPanel,
+  previousDiagnostic,
+  setDiagnostics,
+  setDiagnosticsEffect
+});
+//# sourceMappingURL=index.js.map