zidane-ui 9.0.4 → 9.1.3

package/src/code/editor/find/find-highlight.ts

@@ -1,138 +0,0 @@
-/**
- * Paints find matches on the lines pierre has rendered, with the CSS Custom
- * Highlight API: ranges over text nodes inside pierre's shadow roots, no DOM
- * mutation, so its render cache and the editor never see them. Styled in
- * `DIFFS_UNSAFE_CSS` (`::highlight(zg-find)`, `::highlight(zg-find-current)`).
- *
- * The names are document-global; one find is open at a time (the bar of the
- * panel tab on screen), and `owner` keeps a closing one from wiping another's.
- */
-import { matchesIn, type FindOptions, type LineMatch } from './find-model';
-
-/** Highlight name for every match (`::highlight(zg-find)`). */
-export const FIND_HIGHLIGHT = 'zg-find';
-/** Highlight name for the current match, painted over the others (`::highlight(zg-find-current)`). */
-export const FIND_CURRENT = 'zg-find-current';
-
-type Registry = Map<string, unknown>;
-type HighlightCtor = new (...ranges: Range[]) => unknown;
-
-const registry = (): Registry | null =>
-  (typeof CSS !== 'undefined' ? (CSS as unknown as { highlights?: Registry }).highlights : undefined) ?? null;
-const HighlightClass = (): HighlightCtor | null =>
-  (globalThis as unknown as { Highlight?: HighlightCtor }).Highlight ?? null;
-
-let owner: object | null = null;
-
-/** A rendered diff (or file) and the part key its matches carry. */
-export interface FindSurface {
-  /** The part key (`LineMatch.part`) of the matches on this surface. */
-  part: string;
-  /** The shadow root pierre renders the rows into. */
-  root: ShadowRoot;
-}
-
-/** Content rows only: the gutter's line-number cells carry `data-column-number`. */
-const ROWS = '[data-line]:not([data-column-number])';
-
-function sideOf(row: Element): 'old' | 'new' {
-  return row.getAttribute('data-line-type') === 'change-deletion' ? 'old' : 'new';
-}
-
-function rangeIn(row: Element, start: number, end: number): Range | null {
-  const walker = document.createTreeWalker(row, NodeFilter.SHOW_TEXT);
-  const range = document.createRange();
-  let offset = 0;
-  let started = false;
-  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
-    const len = node.textContent?.length ?? 0;
-    if (!started && start < offset + len) {
-      range.setStart(node, start - offset);
-      started = true;
-    }
-    if (started && end <= offset + len) {
-      range.setEnd(node, end - offset);
-      return range;
-    }
-    offset += len;
-  }
-  return null;
-}
-
-/**
- * Highlight every occurrence of `query` on the rendered rows of `surfaces`,
- * and `current` more strongly. Returns the current match's row when rendered.
- * Does nothing (and returns `null`) where the Custom Highlight API is missing.
- *
- * @param who - The painting find; only it can {@link clearFind} these highlights.
- * @param surfaces - The rendered diffs or files to paint.
- * @param query - The literal string to highlight.
- * @param opts - Case sensitivity.
- * @param current - The match to paint as current, or `null`.
- */
-export function paintFind(
-  who: object,
-  surfaces: readonly FindSurface[],
-  query: string,
-  opts: FindOptions,
-  current: LineMatch | null,
-): HTMLElement | null {
-  const reg = registry();
-  const Highlight = HighlightClass();
-  if (!reg || !Highlight) return null;
-  owner = who;
-  const all: Range[] = [];
-  let currentRange: Range | null = null;
-  let currentRow: HTMLElement | null = null;
-  for (const { part, root } of surfaces) {
-    for (const row of root.querySelectorAll<HTMLElement>(ROWS)) {
-      const text = row.textContent ?? '';
-      const found = matchesIn(text, query, opts);
-      if (found.length === 0) continue;
-      const line = Number(row.getAttribute('data-line'));
-      const side = sideOf(row);
-      const isCurrentRow = current !== null && current.part === part && current.side === side && current.line === line;
-      if (isCurrentRow) currentRow = row;
-      for (const m of found) {
-        const range = rangeIn(row, m.start, m.end);
-        if (!range) continue;
-        if (isCurrentRow && m.start === current.start) currentRange = range;
-        else all.push(range);
-      }
-    }
-  }
-  reg.set(FIND_HIGHLIGHT, new Highlight(...all));
-  if (currentRange) reg.set(FIND_CURRENT, new Highlight(currentRange));
-  else reg.delete(FIND_CURRENT);
-  return currentRow;
-}
-
-/**
- * Clear the highlights, if `who` painted them last.
- *
- * @param who - The find closing; ignored when another find painted since.
- */
-export function clearFind(who: object): void {
-  if (owner !== who) return;
-  owner = null;
-  const reg = registry();
-  reg?.delete(FIND_HIGHLIGHT);
-  reg?.delete(FIND_CURRENT);
-}
-
-/**
- * The rendered row of `match`, if pierre has drawn it.
- *
- * @param surfaces - The rendered diffs or files to look in.
- * @param match - The match whose row to find.
- */
-export function rowOf(surfaces: readonly FindSurface[], match: LineMatch): HTMLElement | null {
-  const surface = surfaces.find((s) => s.part === match.part);
-  if (!surface) return null;
-  for (const row of surface.root.querySelectorAll<HTMLElement>(
-    `[data-line="${match.line}"]:not([data-column-number])`,
-  )) {
-    if (sideOf(row) === match.side) return row;
-  }
-  return null;
-}

package/src/code/editor/find/find-model.ts

@@ -1,123 +0,0 @@
-/**
- * Find in a file or a diff: every match in the model (the whole text, every
- * diff line), not just the lines pierre has rendered, so the count is right
- * and next / previous can reach a match far off screen.
- */
-import type { FileDiffMetadata } from '@pierre/diffs';
-
-/** How a query matches text. */
-export interface FindOptions {
-  /** Match letter case exactly; otherwise both sides are lowercased first. */
-  caseSensitive: boolean;
-}
-
-/** One match on one rendered line. `side` tells a diff's old line from its new one. */
-export interface LineMatch {
-  /** Which diff a match is in (a file key and the diff's index in it); `''` for a lone file. */
-  part: string;
-  /** The diff side the line is on; always `new` in a lone file. */
-  side: 'old' | 'new';
-  /** 1-based line number on that side, as pierre's `data-line`. */
-  line: number;
-  /** UTF-16 offset in the line where the match starts. */
-  start: number;
-  /** UTF-16 offset in the line just past the match. */
-  end: number;
-}
-
-/** Searching stops here: past it the count reads `N+` and painting stays cheap. */
-export const MAX_FIND_MATCHES = 5000;
-
-/**
- * Every occurrence of `query` in `text`, as UTF-16 offsets. Matches don't overlap; an empty
- * query matches nothing.
- *
- * @param text - The text to search, such as one line.
- * @param query - The literal string to look for (not a pattern).
- * @param opts - Case sensitivity.
- */
-export function matchesIn(text: string, query: string, opts: FindOptions): { start: number; end: number }[] {
-  if (!query) return [];
-  const hay = opts.caseSensitive ? text : text.toLowerCase();
-  const needle = opts.caseSensitive ? query : query.toLowerCase();
-  const out: { start: number; end: number }[] = [];
-  for (let at = hay.indexOf(needle); at !== -1; at = hay.indexOf(needle, at + needle.length)) {
-    out.push({ start: at, end: at + needle.length });
-  }
-  return out;
-}
-
-/** One searchable line of a file or diff, numbered the way pierre numbers its rows. */
-export interface FindLine {
-  /** The diff side the line is on; `new` for a file's lines and a diff's context. */
-  side: 'old' | 'new';
-  /** 1-based line number on that side. */
-  line: number;
-  /** The line's text, without its line ending. */
-  text: string;
-}
-
-/**
- * A file's lines, numbered from 1.
- *
- * @param contents - The whole file; `\r\n` endings are stripped.
- */
-export function fileLines(contents: string): FindLine[] {
-  return contents.split('\n').map((text, i) => ({ side: 'new' as const, line: i + 1, text: text.replace(/\r$/, '') }));
-}
-
-/**
- * A diff's lines in the order the unified view shows them: context, then each change's deletions and additions.
- *
- * @param diff - The parsed diff of one file.
- */
-export function diffLines(diff: FileDiffMetadata): FindLine[] {
-  const out: FindLine[] = [];
-  const strip = (s: string | undefined) => (s ?? '').replace(/\r?\n$/, '');
-  for (const hunk of diff.hunks) {
-    let oldLine = hunk.deletionStart;
-    let newLine = hunk.additionStart;
-    for (const block of hunk.hunkContent) {
-      if (block.type === 'context') {
-        for (let i = 0; i < block.lines; i++) {
-          out.push({ side: 'new', line: newLine++, text: strip(diff.additionLines[block.additionLineIndex + i]) });
-          oldLine++;
-        }
-      } else {
-        for (let i = 0; i < block.deletions; i++) {
-          out.push({ side: 'old', line: oldLine++, text: strip(diff.deletionLines[block.deletionLineIndex + i]) });
-        }
-        for (let i = 0; i < block.additions; i++) {
-          out.push({ side: 'new', line: newLine++, text: strip(diff.additionLines[block.additionLineIndex + i]) });
-        }
-      }
-    }
-  }
-  return out;
-}
-
-/**
- * Every match across `parts` in order, capped at `MAX_FIND_MATCHES`. `capped` says the cap cut the
- * search short.
- *
- * @param parts - The lines to search, grouped by the diff (or file) they belong to.
- * @param query - The literal string to look for.
- * @param opts - Case sensitivity.
- */
-export function findAll(
-  parts: readonly { part: string; lines: readonly FindLine[] }[],
-  query: string,
-  opts: FindOptions,
-): { matches: LineMatch[]; capped: boolean } {
-  const matches: LineMatch[] = [];
-  if (!query) return { matches, capped: false };
-  for (const { part, lines } of parts) {
-    for (const l of lines) {
-      for (const m of matchesIn(l.text, query, opts)) {
-        if (matches.length >= MAX_FIND_MATCHES) return { matches, capped: true };
-        matches.push({ part, side: l.side, line: l.line, start: m.start, end: m.end });
-      }
-    }
-  }
-  return { matches, capped: false };
-}

package/src/code/editor/find/settle-scroll.ts

@@ -1,77 +0,0 @@
-/**
- * Scroll `root` until `target()` sits `offset` px below its top, and keep it
- * there while the content above settles.
- *
- * `scrollIntoView({ behavior: 'smooth' })` aims once. In a virtualized pane
- * the diffs between here and the target render on the way, their heights
- * change, and the virtualizer's own instant scroll corrections cancel the
- * smooth scroll, so a click lands short and needs several more to
- * arrive. This re-measures the target every frame and closes part of the
- * remaining distance (all of it with `smooth: false`), stopping once the
- * target has held still for a few frames, after a time cap, or as soon as
- * the user scrolls themselves.
- *
- * Returns a cancel function.
- */
-const STILL_FRAMES = 6;
-const MAX_MS = 2000;
-/** Share of the remaining distance covered per frame: ~300ms to close most of any distance. */
-const EASE = 0.3;
-
-/**
- * Where to go: an element, or an estimated position in the scroll content
- * (`top`, in `scrollTop` terms) for a line that is not rendered yet.
- */
-export type ScrollTarget = HTMLElement | { top: number } | null | undefined;
-
-/**
- * Scrolls `root` so the target ends `offset` px below its top and holds it there while the content
- * above settles; stops on stillness, after two seconds, or when the user scrolls.
- *
- * @param root - The scroll container.
- * @param target - Read every frame, so it can return a freshly rendered element; `null` stops.
- * @param options - `offset`: gap above the target, or a function of `root` for one that changes;
- *   `smooth`: ease in over several frames (default) or jump at once.
- * @returns A function that cancels the scroll.
- */
-export function settleScroll(
-  root: HTMLElement,
-  target: () => ScrollTarget,
-  { offset = 0, smooth = true }: { offset?: number | ((root: HTMLElement) => number); smooth?: boolean } = {},
-): () => void {
-  let raf = 0;
-  let still = 0;
-  const started = performance.now();
-  const stop = () => {
-    cancelAnimationFrame(raf);
-    root.removeEventListener('wheel', stop);
-    root.removeEventListener('pointerdown', stop);
-    root.removeEventListener('keydown', stop);
-  };
-  root.addEventListener('wheel', stop, { passive: true });
-  root.addEventListener('pointerdown', stop);
-  root.addEventListener('keydown', stop);
-
-  const tick = () => {
-    const at = target();
-    if (!at || performance.now() - started > MAX_MS) return stop();
-    if (at instanceof HTMLElement && !at.isConnected) return stop();
-    const top =
-      at instanceof HTMLElement
-        ? root.scrollTop + at.getBoundingClientRect().top - root.getBoundingClientRect().top
-        : at.top;
-    const max = root.scrollHeight - root.clientHeight;
-    const wanted = Math.max(0, Math.min(max, top - (typeof offset === 'function' ? offset(root) : offset)));
-    const left = wanted - root.scrollTop;
-    if (Math.abs(left) < 1) {
-      if (++still >= STILL_FRAMES) return stop();
-    } else {
-      still = 0;
-      const step = smooth && Math.abs(left) > 2 ? left * EASE : left;
-      root.scrollTop += Math.abs(step) < 1 ? Math.sign(step) : step;
-    }
-    raf = requestAnimationFrame(tick);
-  };
-  raf = requestAnimationFrame(tick);
-  return stop;
-}

package/src/code/editor/find/useFind.ts

@@ -1,203 +0,0 @@
-/**
- * The find engine behind `FindBar`, for a pierre file view or a column of
- * diffs: matches from the model (`findAll`), highlights on whatever is
- * rendered (`paintFind`), and the current match scrolled into view.
- *
- * Repaints run once per frame at most, on: query or cursor change, scroll
- * of `scroller`, and any re-render inside the surfaces' shadow roots
- * (pierre draws lines as they near the viewport).
- */
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
-
-import { settleScroll, type ScrollTarget } from './settle-scroll';
-import { clearFind, paintFind, rowOf, type FindSurface } from './find-highlight';
-import { findAll, type FindLine, type FindOptions, type LineMatch } from './find-model';
-
-const QUERY_DEBOUNCE_MS = 80;
-/** The current match lands this far down the pane, so what follows it is in view too. */
-const LAND_AT = 0.35;
-
-/** One diff (or the file) to search: its lines and the part key its matches carry. */
-export interface FindParts {
-  /** Ties matches to the rendered surface with the same `FindSurface.part`; `''` for a lone file. */
-  part: string;
-  /** The searchable lines (`fileLines`, `diffLines`). */
-  lines: readonly FindLine[];
-}
-
-/** What {@link useFind} searches, paints and scrolls. */
-export interface UseFindArgs {
-  /** The searchable model; only built while find is open. */
-  parts: () => readonly FindParts[];
-  /** Bumps when `parts` would change (new file contents, new diffs). */
-  version: unknown;
-  /** Rendered surfaces, read at paint time. */
-  surfaces: () => readonly FindSurface[];
-  /** The scroll box holding the surfaces. */
-  scroller: () => HTMLElement | null;
-  /** Where a match's part is when its line is not rendered: an element, or an estimate. */
-  fallback: (match: LineMatch, scroller: HTMLElement) => ScrollTarget;
-  /** Ease the scroll to the current match over several frames; `false` jumps (reduced motion). */
-  smooth: boolean;
-}
-
-/**
- * Find state for a file view or a column of diffs: counts every match in the model, highlights
- * the rendered ones and scrolls the current match into view. Pass the result to {@link FindBar}.
- *
- * @param args - See {@link UseFindArgs}.
- */
-export function useFind({ parts, version, surfaces, scroller, fallback, smooth }: UseFindArgs) {
-  const [open, setOpen] = useState(false);
-  // Bumps on every ask (⌘F again while open re-selects the query).
-  const [asked, setAsked] = useState(0);
-  const show = useCallback(() => {
-    setOpen(true);
-    setAsked((n) => n + 1);
-  }, []);
-  const [query, setQuery] = useState('');
-  const [needle, setNeedle] = useState('');
-  const [opts, setOpts] = useState<FindOptions>({ caseSensitive: false });
-  const [index, setIndex] = useState(0);
-  const latest = useRef({ parts, surfaces, scroller, fallback });
-  latest.current = { parts, surfaces, scroller, fallback };
-
-  useEffect(() => {
-    const t = window.setTimeout(() => setNeedle(query), QUERY_DEBOUNCE_MS);
-    return () => window.clearTimeout(t);
-  }, [query]);
-
-  const { matches, capped } = useMemo(
-    () => (open && needle ? findAll(latest.current.parts(), needle, opts) : { matches: [], capped: false }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- `version` stands for `parts`
-    [open, needle, opts, version],
-  );
-  // A jump (from search results) lands on its match; otherwise a new query starts at the first.
-  // The diffs refreshing under an open find keeps the cursor where it is.
-  const jump = useRef<Omit<LineMatch, 'end'> | null>(null);
-  const [jumps, setJumps] = useState(0);
-  const searched = useRef('');
-  useEffect(() => {
-    const want = jump.current;
-    jump.current = null;
-    const key = `${needle}\0${opts.caseSensitive}`;
-    const fresh = key !== searched.current;
-    searched.current = key;
-    if (want) {
-      const at = matches.findIndex(
-        (m) => m.part === want.part && m.side === want.side && m.line === want.line && m.start === want.start,
-      );
-      setIndex(Math.max(0, at));
-    } else if (fresh) {
-      setIndex(0);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- per new match list or jump
-  }, [matches, jumps]);
-  const current: LineMatch | null = matches[Math.min(index, matches.length - 1)] ?? null;
-
-  // Paint, at most once a frame.
-  const me = useRef({});
-  const frame = useRef(0);
-  const paint = useCallback(() => {
-    cancelAnimationFrame(frame.current);
-    frame.current = requestAnimationFrame(() => {
-      if (!open || !needle) return clearFind(me.current);
-      paintFind(me.current, latest.current.surfaces(), needle, opts, current);
-    });
-  }, [open, needle, opts, current]);
-  useEffect(() => {
-    paint();
-  }, [paint]);
-  useEffect(() => () => clearFind(me.current), []);
-  useEffect(() => {
-    if (!open) return;
-    const root = latest.current.scroller();
-    const watched = new WeakSet<ShadowRoot>();
-    const observer = new MutationObserver(() => {
-      watch();
-      paint();
-    });
-    const watch = () => {
-      for (const s of latest.current.surfaces()) {
-        if (watched.has(s.root)) continue;
-        watched.add(s.root);
-        observer.observe(s.root, { childList: true, subtree: true, characterData: true });
-      }
-    };
-    watch();
-    const onScroll = () => {
-      watch();
-      paint();
-    };
-    root?.addEventListener('scroll', onScroll, { passive: true });
-    return () => {
-      observer.disconnect();
-      root?.removeEventListener('scroll', onScroll);
-    };
-  }, [open, paint]);
-
-  // Bring the current match into view: when it changes (by value, so the
-  // diffs refreshing under it doesn't scroll), or a result is clicked again.
-  const stop = useRef<(() => void) | null>(null);
-  const currentRef = useRef(current);
-  useLayoutEffect(() => {
-    currentRef.current = current;
-  });
-  const currentKey = current ? `${current.part}\0${current.side}\0${current.line}\0${current.start}` : '';
-  useEffect(() => {
-    stop.current?.();
-    const root = latest.current.scroller();
-    const target = currentRef.current;
-    if (!open || !target || !root) return;
-    stop.current = settleScroll(
-      root,
-      () => rowOf(latest.current.surfaces(), target) ?? latest.current.fallback(target, root),
-      { offset: (r) => r.clientHeight * LAND_AT, smooth },
-    );
-    return () => stop.current?.();
-  }, [open, currentKey, jumps, smooth]);
-
-  const step = useCallback(
-    (direction: 1 | -1) => {
-      if (matches.length === 0) return;
-      setIndex((i) => (i + direction + matches.length) % matches.length);
-    },
-    [matches.length],
-  );
-  /** Open on `query` at one match (a search result clicked). */
-  const jumpTo = useCallback((q: string, o: FindOptions, at: Omit<LineMatch, 'end'>) => {
-    jump.current = at;
-    setJumps((n) => n + 1);
-    setQuery(q);
-    setNeedle(q);
-    setOpts(o);
-    setOpen(true);
-  }, []);
-  const close = useCallback(() => {
-    setOpen(false);
-    clearFind(me.current);
-  }, []);
-
-  return {
-    open,
-    asked,
-    show,
-    query,
-    setQuery,
-    caseSensitive: opts.caseSensitive,
-    toggleCase: () => setOpts((o) => ({ ...o, caseSensitive: !o.caseSensitive })),
-    index: current ? Math.min(index, matches.length - 1) : -1,
-    total: matches.length,
-    capped,
-    searching: query !== needle,
-    step,
-    jumpTo,
-    close,
-  };
-}
-
-/**
- * What {@link useFind} returns: open state, the query and match case, the current index and total
- * (`capped` when the total reads `N+`), and the actions `show`, `step`, `jumpTo` and `close`.
- */
-export type FindState = ReturnType<typeof useFind>;

package/src/code/editor/fs-adapter.ts

@@ -1,37 +0,0 @@
-/**
- * The files an `EditorColumn` shows and saves, wherever they live (a
- * WebContainer, a server, a test's memory). Paths are relative to the
- * adapter's root, `/`-separated.
- *
- * `version` is the conflict signal: an mtime, an etag or a content hash,
- * anything that changes when the file does. A save checks it first (with
- * `stat`), so a file that moved on since it was opened raises the editor's
- * Reload / Overwrite bar instead of being overwritten.
- */
-import type { TreeEntry } from './FileTree';
-
-/** A file's version stamp. */
-export interface FileVersion {
-  /** Changes whenever the file does (an mtime, an etag, a content hash); saves compare it to spot conflicts. */
-  version: number;
-}
-
-/** A file's text with the version it was read at. */
-export interface FileContents extends FileVersion {
-  /** The file's text. */
-  contents: string;
-}
-
-/** The file operations an `EditorColumn` needs: list, read and write, plus optional change events and conflict checks. */
-export interface FileSystemAdapter {
-  /** Every entry under `dir` (`''`: the root), recursively, as paths from the root. */
-  list: (dir: string) => Promise<TreeEntry[]>;
-  /** The file's text and current version; rejects when it cannot be read. */
-  read: (path: string) => Promise<FileContents>;
-  /** Writes `text` (creating folders) and returns the file's new version. */
-  write: (path: string, text: string) => Promise<FileVersion>;
-  /** Paths that changed (written, created, removed) from anywhere; returns the unsubscribe. */
-  watch?: (listener: (paths: readonly string[]) => void) => () => void;
-  /** The file's version now; `null` when it is gone. Without it, saves never detect a conflict. */
-  stat?: (path: string) => Promise<FileVersion | null>;
-}

package/src/code/editor/index.ts

@@ -1,36 +0,0 @@
-/**
- * `zidane-ui/code/editor`: the code editor, file view and file tree (pierre),
- * with find, diagnostics, hovers, completions and definitions. The app passes
- * pierre's highlight worker to `HighlightWorkers` and backs files with an
- * `EditorFs` (`fs-adapter`).
- */
-export * from './CodeCompletion';
-export * from './CodeEditor';
-export * from './CodeHover';
-export * from './DiagnosticAnnotation';
-export * from './diagnostics';
-export * from './DiagnosticsChip';
-export * from './DiffView';
-export * from './edit-session';
-export * from './EditorColumn';
-export * from './environment';
-export * from './FileIcon';
-export * from './FileTabPill';
-export * from './FileTree';
-export * from './FileView';
-export * from './find/find-model';
-export * from './find/FindBar';
-export * from './find/settle-scroll';
-export * from './find/useFind';
-export * from './fs-adapter';
-export * from './HighlightWorkers';
-export * from './language';
-export * from './LanguageEditor';
-export * from './patch-parse';
-export * from './pierre-theme';
-export * from './reveal';
-export * from './useCodeDocument';
-export * from './useDefinition';
-export * from './useDetachCleanup';
-export * from './useFileDocument';
-export * from './useRevealLine';

package/src/code/editor/language.ts

@@ -1,31 +0,0 @@
-/**
- * A language service behind an `EditorColumn` (a type checker in a worker,
- * a language server): the column sends it each open file's text and shows
- * its findings, hovers, definitions and references. Every call is best
- * effort: a failure shows nothing.
- */
-import type { EditorDefinition, EditorDiagnostic, EditorLocation } from './diagnostics';
-
-/** The language service an `EditorColumn` talks to; see the module comment. */
-export interface EditorLanguage {
-  /** Whether it serves this path (by extension, usually). */
-  handles: (path: string) => boolean;
-  /** An open file's text: on open, then after each burst of edits (debounced by the editor). */
-  update: (path: string, text: string) => void;
-  /** Hears a file's findings (`null` while a check runs); returns the unsubscribe. */
-  diagnostics: (path: string, listener: (items: readonly EditorDiagnostic[] | null) => void) => () => void;
-  /** Markdown for the symbol at a 1-based (line, column), or `null`. */
-  hover: (path: string, line: number, column: number) => Promise<string | null>;
-  /** Where the symbol at a 1-based (line, column) is defined, with the symbol's extent when known; empty when unknown. */
-  definition: (path: string, line: number, column: number) => Promise<readonly EditorDefinition[]>;
-  /** Every use of the symbol at a 1-based (line, column); empty when unknown. */
-  references: (path: string, line: number, column: number) => Promise<readonly EditorLocation[]>;
-  /** Who checks, for the chip's tooltip (`TypeScript`). */
-  name: string;
-}
-
-/** A navigation into a file, from a definition or a reference. */
-export interface EditorReveal extends EditorLocation {
-  /** Bump it to reveal the same location again. */
-  nonce: number;
-}