@gregorlohaus/codemirror-helix 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# @gregorlohaus/codemirror-helix
+
+[Helix](https://helix-editor.com/)-style modal editing for [CodeMirror 6](https://codemirror.net/).
+
+Selection-first editing with multiple selections, Normal/Insert/Select modes,
+goto & match modes, textobjects, surround, registers, counts, and search.
+
+> A **core motions subset** — broad coverage of everyday Helix keys, not full
+> parity. No tree-sitter textobjects, LSP gotos, macros, or jumplist.
+
+## Install
+
+```sh
+bun add @gregorlohaus/codemirror-helix
+# peers: @codemirror/{state,view,commands,language,search}
+```
+
+## Usage
+
+```ts
+import { EditorView, basicSetup } from "codemirror";
+import { helix } from "@gregorlohaus/codemirror-helix";
+
+new EditorView({
+  doc: "hello world",
+  extensions: [basicSetup, helix()],
+  parent: document.body,
+});
+```
+
+`helix()` needs a selection drawer for multi-cursor rendering — `basicSetup`
+(or `drawSelection()`) covers it.
+
+### Options
+
+```ts
+helix({
+  startInInsert: false, // start in Normal mode (default)
+  statusBar: true,      // show the bottom mode line
+  // Let an open autocomplete popup eat the first Escape instead of leaving Insert:
+  escapeGuard: (state) => completionStatus(state) === "active",
+});
+```
+
+## Keys
+
+Starts in **Normal** mode. The status line shows the mode, pending count,
+register, and selection count.
+
+| Group | Keys |
+| --- | --- |
+| Modes | `i`/`a` insert before/after, `I`/`A` line start/end, `o`/`O` open line, `v` select (extend), `Esc` normal |
+| Motion | `h j k l`, `w W b B e E`, `f t F T {char}`, `Alt-.` repeat find, `Home`/`End`, counts (`3w`) |
+| Goto `g` | `gg`/`Ng` line, `ge` end, `gh`/`gl` line ends, `gs` first non-blank, `gt`/`gc`/`gb` view top/center/bottom |
+| Select | `x` line (repeat extends), `X` line bounds, `%` all, `;` collapse, `Alt-;` flip, `Alt-:` forward, `,` keep primary, `Alt-,` remove primary, `(`/`)` rotate, `_` trim |
+| Multi | `s` select regex, `S` split, `K`/`Alt-K` keep/remove, `C` copy selection below, `Alt-C` above |
+| Match `m` | `mm` matching bracket, `mi{o}`/`ma{o}` inside/around (`w W p ( [ { < " ' \` m`), `ms{c}` surround, `md{c}` delete, `mr{c}{c}` replace |
+| Edit | `d` delete, `c` change, `y` yank, `p`/`P` paste, `R` replace w/ register, `r{c}` replace char, `~`/`` ` ``/`Alt-`` ` `` case, `J` join, `>`/`<` indent, `u`/`U` undo/redo |
+| Registers | `"{c}` select register for the next yank/delete/paste |
+| Search | `/` `?` search, `n`/`N` next/prev, `*` search selection |
+| View | `zz`/`zt`/`zb` center/top/bottom, `Ctrl-d`/`Ctrl-u` half page, `Ctrl-f`/`Ctrl-b` page |
+| Clipboard | `space y` copy, `space p`/`space P` paste (system clipboard) |
+
+`s`/`S`/`K`/`Alt-K` open a prompt and preview live as you type the regex;
+`Enter` commits, `Esc` restores the original selection.
+
+## License
+
+MIT

package/dist/commands.d.ts

@@ -0,0 +1,72 @@
+import { EditorSelection, type EditorState, type SelectionRange } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { type HelixMode } from "./state";
+/** After leaving an edit, choose the resting mode. */
+declare function restMode(current: HelixMode, target?: HelixMode): HelixMode;
+export type PointFn = (state: EditorState, pos: number) => number;
+export interface MotionOpts {
+    extend: boolean;
+    span: boolean;
+    count: number;
+}
+export declare function moveByPoint(view: EditorView, fn: PointFn, opts: MotionOpts): void;
+export declare function moveVertical(view: EditorView, forward: boolean, opts: {
+    extend: boolean;
+    count: number;
+}): void;
+export declare function enterInsert(view: EditorView, posOf: (state: EditorState, r: SelectionRange) => number): void;
+export declare function openLine(view: EditorView, above: boolean): void;
+interface DeleteOpts {
+    insert?: boolean;
+}
+export declare function deleteSelection(view: EditorView, opts?: DeleteOpts): void;
+export declare function yankSelection(view: EditorView): void;
+export declare function paste(view: EditorView, before: boolean): void;
+/** R: replace selections with the register contents. */
+export declare function replaceWithYank(view: EditorView): void;
+/** r{char}: replace every selected character with `char`. */
+export declare function replaceChar(view: EditorView, char: string): void;
+type CaseMode = "toggle" | "lower" | "upper";
+export declare function changeCase(view: EditorView, mode: CaseMode): void;
+/** J: join the lines spanned by each selection into one. */
+export declare function joinLines(view: EditorView): void;
+export declare function indent(view: EditorView, less: boolean): void;
+export declare function undoCmd(view: EditorView): void;
+export declare function redoCmd(view: EditorView): void;
+export declare function collapseToCursor(view: EditorView): void;
+export declare function flipSelections(view: EditorView): void;
+export declare function ensureForward(view: EditorView): void;
+export declare function keepPrimary(view: EditorView): void;
+export declare function removePrimary(view: EditorView): void;
+export declare function rotatePrimary(view: EditorView, forward: boolean): void;
+export declare function selectAll(view: EditorView): void;
+export declare function trimSelections(view: EditorView): void;
+/** x: extend each selection to whole line(s); repeat grows downward. */
+export declare function selectLine(view: EditorView, count: number): void;
+/** X: extend selections to cover full lines without crossing into the next. */
+export declare function extendToLineBounds(view: EditorView): void;
+/** C / Alt-C: copy each selection onto the next/previous line at the same columns. */
+export declare function copySelectionToLine(view: EditorView, below: boolean): void;
+/**
+ * s: keep only the regex matches found within each selection of `base`.
+ * `base` is the selection captured when the prompt opened, so this can be
+ * called live on every keystroke without compounding.
+ */
+export declare function selectRegexInSelections(view: EditorView, pattern: string, base?: EditorSelection): void;
+/** S: split each selection of `base` on the regex, keeping the pieces between. */
+export declare function splitOnRegex(view: EditorView, pattern: string, base?: EditorSelection): void;
+/** Keep (or remove) selections of `base` whose text matches the regex. */
+export declare function filterSelections(view: EditorView, pattern: string, keep: boolean, base?: EditorSelection): void;
+/** ms{char}: wrap each selection in the chosen pair. */
+export declare function surroundAdd(view: EditorView, ch: string): void;
+/** md{char}: remove the surrounding pair around each selection. */
+export declare function surroundDelete(view: EditorView, ch: string): void;
+/** mr{from}{to}: replace the surrounding pair. */
+export declare function surroundReplace(view: EditorView, fromCh: string, toCh: string): void;
+export declare function runSearch(view: EditorView, query: string, reverse: boolean): void;
+export declare function searchNext(view: EditorView, reverse: boolean): void;
+export declare function searchSelection(view: EditorView, reverse: boolean): void;
+export declare function scrollTo(view: EditorView, y: "center" | "start" | "end"): void;
+export declare function halfPage(view: EditorView, forward: boolean, extend: boolean): void;
+export { restMode };
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAML,KAAK,SAAS,EACf,MAAM,SAAS,CAAC;AAmBjB,sDAAsD;AACtD,iBAAS,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,CAGnE;AAID,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,QAa1E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,QAYxG;AAID,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,cAAc,KAAK,MAAM,QAOrG;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,QA2BxD;AAID,UAAU,UAAU;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,GAAE,UAAe,QAuBtE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,QAW7C;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,QAwBtD;AAED,wDAAwD;AACxD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,QAa/C;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAazD;AAED,KAAK,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAE7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,QAkB1D;AAED,4DAA4D;AAC5D,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,QAgBzC;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,QAGrD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,QAEvC;AACD,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,QAEvC;AAYD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,QAMhD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,QAM9C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,QAM7C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,QAG3C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,QAK7C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,QAK/D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,QAEzC;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,QAY9C;AAED,wEAAwE;AACxE,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,QAgBzD;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,QAMlD;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,QAwBnE;AAMD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,eAAsC,QAsB7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,eAAsC,QAyB7C;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,EACb,IAAI,GAAE,eAAsC,QAgB7C;AAmBD,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,QAcvD;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,QAa1D;AAED,kDAAkD;AAClD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAc7E;AAID,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,QAI1E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,QAE5D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,QAOjE;AAID,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,KAAK,QAGvE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,QAI3E;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/commands.js

@@ -0,0 +1,506 @@
+import { EditorSelection, } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { indentLess, indentMore, redo, undo } from "@codemirror/commands";
+import { findNext, findPrevious, SearchQuery, setSearchQuery } from "@codemirror/search";
+import { clearPending, getHelix, helixEffect, readRegister, setRegister, } from "./state";
+import * as M from "./motions";
+const settle = { ...clearPending() };
+function clamp(n, state) {
+    return Math.max(0, Math.min(n, state.doc.length));
+}
+function rangesText(state, ranges) {
+    return ranges.map((r) => state.doc.sliceString(r.from, r.to)).join("\n");
+}
+function maybeClipboard(register, text) {
+    if ((register === "+" || register === "*") && typeof navigator !== "undefined" && navigator.clipboard) {
+        void navigator.clipboard.writeText(text).catch(() => { });
+    }
+}
+/** After leaving an edit, choose the resting mode. */
+function restMode(current, target) {
+    if (target)
+        return target;
+    return current === "select" ? "normal" : current;
+}
+export function moveByPoint(view, fn, opts) {
+    const { state } = view;
+    const selection = EditorSelection.create(state.selection.ranges.map((r) => {
+        let head = r.head;
+        for (let i = 0; i < Math.max(1, opts.count); i++)
+            head = fn(state, head);
+        head = clamp(head, state);
+        const anchor = opts.extend ? r.anchor : opts.span ? r.head : head;
+        return EditorSelection.range(clamp(anchor, state), head);
+    }), state.selection.mainIndex);
+    view.dispatch({ selection, scrollIntoView: true });
+}
+export function moveVertical(view, forward, opts) {
+    const selection = EditorSelection.create(view.state.selection.ranges.map((r) => {
+        let cur = EditorSelection.cursor(r.head);
+        for (let i = 0; i < Math.max(1, opts.count); i++)
+            cur = view.moveVertically(cur, forward);
+        return opts.extend
+            ? EditorSelection.range(r.anchor, cur.head)
+            : EditorSelection.cursor(cur.head);
+    }), view.state.selection.mainIndex);
+    view.dispatch({ selection, scrollIntoView: true });
+}
+// --- insertion entry points --------------------------------------------------
+export function enterInsert(view, posOf) {
+    const { state } = view;
+    const selection = EditorSelection.create(state.selection.ranges.map((r) => EditorSelection.cursor(clamp(posOf(state, r), state))), state.selection.mainIndex);
+    view.dispatch({ selection, effects: helixEffect.of({ mode: "insert", ...settle }) });
+}
+export function openLine(view, above) {
+    const { state } = view;
+    const seen = new Set();
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        const line = state.doc.lineAt(r.head);
+        if (seen.has(line.number))
+            continue;
+        seen.add(line.number);
+        const indent = line.text.match(/^\s*/)?.[0] ?? "";
+        changes.push(above ? { from: line.from, insert: `${indent}\n` } : { from: line.to, insert: `\n${indent}` });
+    }
+    const changeSet = state.changes(changes);
+    // Place a cursor on each newly opened line.
+    const selection = EditorSelection.create([...seen].map((n) => {
+        const line = state.doc.line(n);
+        const pos = above ? line.from : line.to;
+        const mapped = changeSet.mapPos(pos, 1);
+        return EditorSelection.cursor(mapped);
+    }));
+    view.dispatch({
+        changes: changeSet,
+        selection,
+        effects: helixEffect.of({ mode: "insert", ...settle }),
+        scrollIntoView: true,
+    });
+}
+export function deleteSelection(view, opts = {}) {
+    const { state } = view;
+    const helix = getHelix(state);
+    const specs = state.selection.ranges.map((r) => ({
+        from: r.from,
+        to: r.empty ? Math.min(r.to + 1, state.doc.length) : r.to,
+    }));
+    const yanked = specs.map((s) => state.doc.sliceString(s.from, s.to)).join("\n");
+    const changeSet = state.changes(specs.map((s) => ({ from: s.from, to: s.to, insert: "" })));
+    const selection = EditorSelection.create(specs.map((s) => EditorSelection.cursor(changeSet.mapPos(s.from, -1))), state.selection.mainIndex);
+    view.dispatch({
+        changes: changeSet,
+        selection,
+        effects: [
+            setRegister.of({ name: helix.register ?? '"', text: yanked }),
+            helixEffect.of({ mode: opts.insert ? "insert" : restMode(helix.mode), ...settle }),
+        ],
+        scrollIntoView: true,
+    });
+    maybeClipboard(helix.register, yanked);
+}
+export function yankSelection(view) {
+    const { state } = view;
+    const helix = getHelix(state);
+    const text = rangesText(state, state.selection.ranges);
+    view.dispatch({
+        effects: [
+            setRegister.of({ name: helix.register ?? '"', text }),
+            helixEffect.of({ mode: restMode(helix.mode), ...settle }),
+        ],
+    });
+    maybeClipboard(helix.register, text);
+}
+export function paste(view, before) {
+    const { state } = view;
+    const helix = getHelix(state);
+    const text = readRegister(state, helix.register);
+    if (!text)
+        return;
+    const linewise = text.endsWith("\n");
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        if (linewise) {
+            const line = state.doc.lineAt(before ? r.from : r.to);
+            if (before)
+                changes.push({ from: line.from, to: line.from, insert: text });
+            else
+                changes.push({ from: line.to, to: line.to, insert: `\n${text.replace(/\n$/, "")}` });
+        }
+        else {
+            const at = before ? r.from : r.to;
+            changes.push({ from: at, to: at, insert: text });
+        }
+    }
+    const changeSet = state.changes(changes);
+    view.dispatch({
+        changes: changeSet,
+        selection: state.selection.map(changeSet),
+        effects: helixEffect.of(settle),
+        scrollIntoView: true,
+    });
+}
+/** R: replace selections with the register contents. */
+export function replaceWithYank(view) {
+    const { state } = view;
+    const helix = getHelix(state);
+    const text = readRegister(state, helix.register);
+    if (!text)
+        return;
+    const changes = state.selection.ranges.map((r) => ({ from: r.from, to: r.to, insert: text }));
+    const changeSet = state.changes(changes);
+    view.dispatch({
+        changes: changeSet,
+        selection: state.selection.map(changeSet),
+        effects: helixEffect.of(settle),
+        scrollIntoView: true,
+    });
+}
+/** r{char}: replace every selected character with `char`. */
+export function replaceChar(view, char) {
+    if (char.length !== 1)
+        return;
+    const { state } = view;
+    const changes = state.selection.ranges
+        .map((r) => {
+        const from = r.from;
+        const to = r.empty ? Math.min(r.to + 1, state.doc.length) : r.to;
+        const text = state.doc.sliceString(from, to).replace(/[^\n]/g, char);
+        return { from, to, insert: text };
+    })
+        .filter((c) => c.to > c.from);
+    if (!changes.length)
+        return;
+    view.dispatch({ changes, effects: helixEffect.of(settle) });
+}
+export function changeCase(view, mode) {
+    const { state } = view;
+    const changes = state.selection.ranges
+        .map((r) => {
+        const from = r.from;
+        const to = r.empty ? Math.min(r.to + 1, state.doc.length) : r.to;
+        const text = state.doc.sliceString(from, to);
+        const next = mode === "lower"
+            ? text.toLowerCase()
+            : mode === "upper"
+                ? text.toUpperCase()
+                : text.replace(/[a-zA-Z]/g, (c) => (c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase()));
+        return { from, to, insert: next };
+    })
+        .filter((c) => c.to > c.from);
+    if (!changes.length)
+        return;
+    view.dispatch({ changes, effects: helixEffect.of(settle) });
+}
+/** J: join the lines spanned by each selection into one. */
+export function joinLines(view) {
+    const { state } = view;
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        const startLine = state.doc.lineAt(r.from).number;
+        const endLine = state.doc.lineAt(r.to).number;
+        const last = Math.max(endLine, startLine + 1);
+        for (let n = startLine; n < last && n < state.doc.lines; n++) {
+            const line = state.doc.line(n);
+            const nextLine = state.doc.line(n + 1);
+            const trimmed = nextLine.text.match(/^\s*/)?.[0].length ?? 0;
+            changes.push({ from: line.to, to: nextLine.from + trimmed, insert: " " });
+        }
+    }
+    if (!changes.length)
+        return;
+    view.dispatch({ changes, effects: helixEffect.of(settle), scrollIntoView: true });
+}
+export function indent(view, less) {
+    (less ? indentLess : indentMore)(view);
+    view.dispatch({ effects: helixEffect.of(settle) });
+}
+export function undoCmd(view) {
+    undo(view);
+}
+export function redoCmd(view) {
+    redo(view);
+}
+// --- selection manipulation --------------------------------------------------
+function setSelection(view, ranges, mainIndex) {
+    if (!ranges.length)
+        return;
+    view.dispatch({
+        selection: EditorSelection.create(ranges, mainIndex ?? ranges.length - 1),
+        scrollIntoView: true,
+    });
+}
+export function collapseToCursor(view) {
+    setSelection(view, view.state.selection.ranges.map((r) => EditorSelection.cursor(r.head)), view.state.selection.mainIndex);
+}
+export function flipSelections(view) {
+    setSelection(view, view.state.selection.ranges.map((r) => EditorSelection.range(r.head, r.anchor)), view.state.selection.mainIndex);
+}
+export function ensureForward(view) {
+    setSelection(view, view.state.selection.ranges.map((r) => EditorSelection.range(r.from, r.to)), view.state.selection.mainIndex);
+}
+export function keepPrimary(view) {
+    const main = view.state.selection.main;
+    setSelection(view, [main], 0);
+}
+export function removePrimary(view) {
+    const { ranges, mainIndex } = view.state.selection;
+    if (ranges.length < 2)
+        return;
+    const remaining = ranges.filter((_, i) => i !== mainIndex);
+    setSelection(view, remaining, Math.min(mainIndex, remaining.length - 1));
+}
+export function rotatePrimary(view, forward) {
+    const { ranges, mainIndex } = view.state.selection;
+    if (ranges.length < 2)
+        return;
+    const next = (mainIndex + (forward ? 1 : -1) + ranges.length) % ranges.length;
+    setSelection(view, [...ranges], next);
+}
+export function selectAll(view) {
+    setSelection(view, [EditorSelection.range(0, view.state.doc.length)], 0);
+}
+export function trimSelections(view) {
+    const { state } = view;
+    const ranges = [];
+    for (const r of state.selection.ranges) {
+        const text = state.doc.sliceString(r.from, r.to);
+        const lead = text.match(/^\s*/)?.[0].length ?? 0;
+        const trail = text.match(/\s*$/)?.[0].length ?? 0;
+        const from = r.from + lead;
+        const to = Math.max(from, r.to - trail);
+        ranges.push(EditorSelection.range(from, to));
+    }
+    setSelection(view, ranges, state.selection.mainIndex);
+}
+/** x: extend each selection to whole line(s); repeat grows downward. */
+export function selectLine(view, count) {
+    const { state } = view;
+    const ranges = state.selection.ranges.map((r) => {
+        const startLine = state.doc.lineAt(r.from);
+        let endLine = state.doc.lineAt(r.to);
+        const from = startLine.from;
+        let to = Math.min(endLine.to + 1, state.doc.length);
+        const whole = r.from === from && r.to === to;
+        const steps = whole ? Math.max(1, count) : Math.max(0, count - 1);
+        for (let i = 0; i < steps && endLine.number < state.doc.lines; i++) {
+            endLine = state.doc.line(endLine.number + 1);
+            to = Math.min(endLine.to + 1, state.doc.length);
+        }
+        return EditorSelection.range(from, to);
+    });
+    setSelection(view, ranges, state.selection.mainIndex);
+}
+/** X: extend selections to cover full lines without crossing into the next. */
+export function extendToLineBounds(view) {
+    const { state } = view;
+    const ranges = state.selection.ranges.map((r) => EditorSelection.range(state.doc.lineAt(r.from).from, state.doc.lineAt(r.to).to));
+    setSelection(view, ranges, state.selection.mainIndex);
+}
+/** C / Alt-C: copy each selection onto the next/previous line at the same columns. */
+export function copySelectionToLine(view, below) {
+    const { state } = view;
+    const additions = [];
+    for (const r of state.selection.ranges) {
+        const anchorLine = state.doc.lineAt(r.anchor);
+        const headLine = state.doc.lineAt(r.head);
+        const anchorCol = r.anchor - anchorLine.from;
+        const headCol = r.head - headLine.from;
+        const targetAnchorNo = anchorLine.number + (below ? 1 : -1);
+        const targetHeadNo = headLine.number + (below ? 1 : -1);
+        if (targetAnchorNo < 1 || targetAnchorNo > state.doc.lines)
+            continue;
+        if (targetHeadNo < 1 || targetHeadNo > state.doc.lines)
+            continue;
+        const ta = state.doc.line(targetAnchorNo);
+        const th = state.doc.line(targetHeadNo);
+        additions.push(EditorSelection.range(Math.min(ta.from + anchorCol, ta.to), Math.min(th.from + headCol, th.to)));
+    }
+    if (!additions.length)
+        return;
+    const all = [...state.selection.ranges, ...additions];
+    setSelection(view, all, all.length - 1);
+}
+function restoreBase(view, base) {
+    view.dispatch({ selection: base, scrollIntoView: true });
+}
+/**
+ * s: keep only the regex matches found within each selection of `base`.
+ * `base` is the selection captured when the prompt opened, so this can be
+ * called live on every keystroke without compounding.
+ */
+export function selectRegexInSelections(view, pattern, base = view.state.selection) {
+    if (!pattern)
+        return restoreBase(view, base);
+    let re;
+    try {
+        re = new RegExp(pattern, "g");
+    }
+    catch {
+        return; // incomplete/invalid regex: leave the last good preview in place
+    }
+    const { state } = view;
+    const ranges = [];
+    for (const r of base.ranges) {
+        const text = state.doc.sliceString(r.from, r.to);
+        for (const m of text.matchAll(re)) {
+            const from = r.from + (m.index ?? 0);
+            const to = from + m[0].length;
+            ranges.push(EditorSelection.range(from, Math.max(from, to)));
+            if (m[0].length === 0)
+                re.lastIndex++;
+        }
+    }
+    if (ranges.length)
+        setSelection(view, ranges, ranges.length - 1);
+    else
+        restoreBase(view, base);
+}
+/** S: split each selection of `base` on the regex, keeping the pieces between. */
+export function splitOnRegex(view, pattern, base = view.state.selection) {
+    if (!pattern)
+        return restoreBase(view, base);
+    let re;
+    try {
+        re = new RegExp(pattern, "g");
+    }
+    catch {
+        return;
+    }
+    const { state } = view;
+    const ranges = [];
+    for (const r of base.ranges) {
+        const text = state.doc.sliceString(r.from, r.to);
+        let last = 0;
+        for (const m of text.matchAll(re)) {
+            const idx = m.index ?? 0;
+            ranges.push(EditorSelection.range(r.from + last, r.from + idx));
+            last = idx + m[0].length;
+            if (m[0].length === 0)
+                re.lastIndex++;
+        }
+        ranges.push(EditorSelection.range(r.from + last, r.to));
+    }
+    const filtered = ranges.filter((r) => r.to >= r.from);
+    if (filtered.length)
+        setSelection(view, filtered, filtered.length - 1);
+    else
+        restoreBase(view, base);
+}
+/** Keep (or remove) selections of `base` whose text matches the regex. */
+export function filterSelections(view, pattern, keep, base = view.state.selection) {
+    if (!pattern)
+        return restoreBase(view, base);
+    let re;
+    try {
+        re = new RegExp(pattern);
+    }
+    catch {
+        return;
+    }
+    const { state } = view;
+    const ranges = base.ranges.filter((r) => {
+        const matches = re.test(state.doc.sliceString(r.from, r.to));
+        return keep ? matches : !matches;
+    });
+    if (ranges.length)
+        setSelection(view, ranges, ranges.length - 1);
+    else
+        restoreBase(view, base);
+}
+// --- surround ----------------------------------------------------------------
+const SURROUND_PAIRS = {
+    "(": ["(", ")"],
+    ")": ["(", ")"],
+    "[": ["[", "]"],
+    "]": ["[", "]"],
+    "{": ["{", "}"],
+    "}": ["{", "}"],
+    "<": ["<", ">"],
+    ">": ["<", ">"],
+};
+function surroundPair(ch) {
+    return SURROUND_PAIRS[ch] ?? [ch, ch];
+}
+/** ms{char}: wrap each selection in the chosen pair. */
+export function surroundAdd(view, ch) {
+    const [open, close] = surroundPair(ch);
+    const { state } = view;
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        changes.push({ from: r.from, insert: open });
+        changes.push({ from: r.to, insert: close });
+    }
+    const changeSet = state.changes(changes);
+    view.dispatch({
+        changes: changeSet,
+        selection: state.selection.map(changeSet),
+        effects: helixEffect.of(settle),
+    });
+}
+/** md{char}: remove the surrounding pair around each selection. */
+export function surroundDelete(view, ch) {
+    const [open, close] = surroundPair(ch);
+    const { state } = view;
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        const openPos = M.findOpen(state, r.head, open, close);
+        const closePos = openPos === null ? null : M.findClose(state, openPos, open, close);
+        if (openPos === null || closePos === null)
+            continue;
+        changes.push({ from: openPos, to: openPos + 1, insert: "" });
+        changes.push({ from: closePos, to: closePos + 1, insert: "" });
+    }
+    if (!changes.length)
+        return;
+    view.dispatch({ changes, effects: helixEffect.of(settle) });
+}
+/** mr{from}{to}: replace the surrounding pair. */
+export function surroundReplace(view, fromCh, toCh) {
+    const [open, close] = surroundPair(fromCh);
+    const [newOpen, newClose] = surroundPair(toCh);
+    const { state } = view;
+    const changes = [];
+    for (const r of state.selection.ranges) {
+        const openPos = M.findOpen(state, r.head, open, close);
+        const closePos = openPos === null ? null : M.findClose(state, openPos, open, close);
+        if (openPos === null || closePos === null)
+            continue;
+        changes.push({ from: openPos, to: openPos + 1, insert: newOpen });
+        changes.push({ from: closePos, to: closePos + 1, insert: newClose });
+    }
+    if (!changes.length)
+        return;
+    view.dispatch({ changes, effects: helixEffect.of(settle) });
+}
+// --- search ------------------------------------------------------------------
+export function runSearch(view, query, reverse) {
+    if (!query)
+        return;
+    view.dispatch({ effects: setSearchQuery.of(new SearchQuery({ search: query, regexp: true })) });
+    (reverse ? findPrevious : findNext)(view);
+}
+export function searchNext(view, reverse) {
+    (reverse ? findPrevious : findNext)(view);
+}
+export function searchSelection(view, reverse) {
+    const text = view.state.sliceDoc(view.state.selection.main.from, view.state.selection.main.to);
+    if (!text)
+        return;
+    view.dispatch({
+        effects: setSearchQuery.of(new SearchQuery({ search: text, regexp: false })),
+    });
+    (reverse ? findPrevious : findNext)(view);
+}
+// --- view scrolling ----------------------------------------------------------
+export function scrollTo(view, y) {
+    const pos = view.state.selection.main.head;
+    view.dispatch({ effects: EditorView.scrollIntoView(pos, { y }) });
+}
+export function halfPage(view, forward, extend) {
+    const lineHeight = view.defaultLineHeight || 16;
+    const lines = Math.max(1, Math.floor(view.dom.clientHeight / lineHeight / 2));
+    moveVertical(view, forward, { extend, count: lines });
+}
+export { restMode };
+//# sourceMappingURL=commands.js.map