@adecore/editor 0.42.0 → 0.44.0

package/src/controller.ts

@@ -15,7 +15,9 @@ import type {
     EditorInlayClick,
     EditorInlayClickHandler,
     EditorContextMenu,
+    EditorCopy,
     EditorKeyHandler,
+    EditorPasteOptions,
     EditorPosition,
     EditorRunCommand,
     EditorSelectionRanges,
@@ -45,9 +47,12 @@ const MODIFYING = new Set<EditorCommand>([
     'deleteLine',
     'moveLineUp',
     'moveLineDown',
+    'moveStatementUp',
+    'moveStatementDown',
     'toggleLineComment',
     'toggleBlockComment',
     'startNewLine',
+    'completeCurrentStatement',
     'startNewLineBefore',
     'splitLine',
     'joinLines',
@@ -63,9 +68,13 @@ const MODIFYING = new Set<EditorCommand>([
     'reverseLines',
     'uniqueLines',
     'convertIndentsToSpaces',
-    'convertIndentsToTabs'
+    'convertIndentsToTabs',
+    'hippieCompletion',
+    'hippieBackwardCompletion'
 ]);
 
+const CODE_BLOCK_COMMANDS = new Set<EditorCommand>(['codeBlockStart', 'codeBlockEnd', 'codeBlockStartWithSelection', 'codeBlockEndWithSelection']);
+
 const VIEW_COMMANDS = new Set<EditorViewCommand>([
     'collapseRegion',
     'expandRegion',
@@ -84,7 +93,12 @@ const VIEW_COMMANDS = new Set<EditorViewCommand>([
     'toggleColumnMode',
     'increaseFontSize',
     'decreaseFontSize',
-    'resetFontSize'
+    'resetFontSize',
+    'methodUp',
+    'methodDown',
+    'nextChange',
+    'previousChange',
+    'pasteAsPlainText'
 ]);
 
 const ZOOM_STEPS = { increaseFontSize: 1, decreaseFontSize: -1, resetFontSize: 0 } as const satisfies Partial<Record<EditorViewCommand, -1 | 0 | 1>>;
@@ -92,6 +106,14 @@ const ZOOM_STEPS = { increaseFontSize: 1, decreaseFontSize: -1, resetFontSize: 0
 /* The clipboard text of the last copy or cut of a bare caret, which pastes back as whole lines. Shared, since it can be pasted in another editor. */
 let lineClip: string | null = null;
 
+/*
+ * Makes `text` the copy that pastes back as whole lines (or not), for a paste from a history that kept what the
+ * copy was. The clipboard itself is the caller's.
+ */
+export function rememberCopy(text: string, wholeLines: boolean): void {
+    lineClip = wholeLines ? text : null;
+}
+
 function selectionSignature(selections: readonly Selection[]): string {
     return selections.map((selection) => `${selection.anchor}:${selection.head}`).join(',');
 }
@@ -111,6 +133,9 @@ export class InputController {
     private readonly touch: TouchSelection;
     private readonly cleanup: (() => void)[] = [];
     private readonly keyHandlers = new Set<EditorKeyHandler>();
+    private readonly navigateListeners = new Set<(from: number) => void>();
+    private readonly copyListeners = new Set<(copy: EditorCopy) => void>();
+    private wordSources: (() => readonly string[]) | null = null;
     private readonly gesture: DoubleModifierGesture;
     private readonly clickHandlers = new Set<EditorClickHandler>();
     private readonly inlayHandlers = new Set<EditorInlayClickHandler>();
@@ -240,7 +265,7 @@ export class InputController {
 
         this.listen(input, 'paste', (event) => {
             event.preventDefault();
-            this.paste(event.clipboardData?.getData('text/plain') ?? '');
+            this.pasteText(event.clipboardData?.getData('text/plain') ?? '');
         });
 
         this.listen(input, 'copy', (event) => this.copy(event, false));
@@ -312,6 +337,8 @@ export class InputController {
 
         this.cleanup.length = 0;
         this.keyHandlers.clear();
+        this.navigateListeners.clear();
+        this.copyListeners.clear();
     }
 
     private blockedByReadOnly(): boolean {
@@ -356,16 +383,30 @@ export class InputController {
         }
     }
 
-    private paste(text: string): void {
+    /* Pastes as a paste from the clipboard does; false when a read-only editor refused. */
+    pasteText(text: string, options: EditorPasteOptions = {}): boolean {
         if (this.blockedByReadOnly()) {
-            return;
+            return false;
         }
 
         this.unfoldCarets();
         this.historyGroup++;
-        this.view.model.paste(this.native.normalizeNewlines(text), { ...this.commandOptions(), wholeLines: text !== '' && text === lineClip });
+
+        const pasted = this.view.model.paste(this.native.normalizeNewlines(text), {
+            ...this.commandOptions(),
+            ...(options.reindent === false ? { indentOnPaste: false } : {}),
+            wholeLines: options.wholeLines ?? (text !== '' && text === lineClip)
+        });
+
         this.historyGroup++;
         this.view.revealCaret();
+
+        return pasted;
+    }
+
+    /* Told what a copy or cut put on the clipboard. */
+    onCopy(listener: (copy: EditorCopy) => void): () => void {
+        return subscribe(this.copyListeners, listener);
     }
 
     private commandOptions(): CommandOptions {
@@ -381,15 +422,23 @@ export class InputController {
             tabOutOfClosers: keys.tabOutOfClosers,
             smartEnter: keys.smartIndentOnEnter,
             indentOnPaste: keys.indentOnPaste,
+            indentGuides: settings.guides,
             smartSemicolon: keys.smartSemicolon,
             smartArrow: keys.smartArrow,
             language: settings.language ?? 'plaintext',
             camelCase: keys.camelHumps,
             visualLine: (offset) => this.view.rowOf(offset),
-            lineSpan: (line) => this.view.lineSpan(line)
+            lineSpan: (line) => this.view.lineSpan(line),
+            structure: () => this.view.structureRanges(),
+            ...(this.wordSources === null ? {} : { wordSources: this.wordSources })
         };
     }
 
+    /* The texts Hippie completion takes words from after those of this document; null takes them away. */
+    setWordSources(source: (() => readonly string[]) | null): void {
+        this.wordSources = source;
+    }
+
     /* Folding is the view's, since it knows where the ranges are. */
     private viewCommand(name: EditorViewCommand): boolean {
         const { view } = this;
@@ -400,11 +449,43 @@ export class InputController {
             return true;
         }
 
+        if (name === 'methodUp' || name === 'methodDown') {
+            const from = view.model.getPrimary().head;
+            const moved = view.goToMethod(name === 'methodUp' ? -1 : 1);
+
+            if (moved) {
+                emit(this.navigateListeners, from);
+            }
+
+            return moved;
+        }
+
+        if (name === 'pasteAsPlainText') {
+            // The clipboard is read once a person asks, and an editor with no way to read it does nothing.
+            if (this.blockedByReadOnly() || globalThis.navigator?.clipboard?.readText === undefined) {
+                return false;
+            }
+
+            void navigator.clipboard.readText().then(
+                (text) => this.pasteText(text, { reindent: false }),
+                () => undefined
+            );
+
+            return true;
+        }
+
+        if (name === 'nextChange' || name === 'previousChange') {
+            return view.goToChange(name === 'nextChange' ? 1 : -1);
+        }
+
         if (view.settings.folding === false && name !== 'toggleColumnMode') {
             return false;
         }
 
-        const run: Record<Exclude<EditorViewCommand, keyof typeof ZOOM_STEPS>, () => void> = {
+        const run: Record<
+            Exclude<EditorViewCommand, keyof typeof ZOOM_STEPS | 'methodUp' | 'methodDown' | 'nextChange' | 'previousChange' | 'pasteAsPlainText'>,
+            () => void
+        > = {
             collapseRegion: () => view.collapseRegion(),
             expandRegion: () => view.expandRegion(),
             collapseAllRegions: () => view.foldAll(true),
@@ -529,7 +610,11 @@ export class InputController {
             }
         }
 
-        const folded = name === 'moveLineUp' || name === 'moveLineDown' ? this.view.getFolds().collapsed : [];
+        const before = model.getPrimary().head;
+        const folded =
+            name === 'moveLineUp' || name === 'moveLineDown' || name === 'moveStatementUp' || name === 'moveStatementDown'
+                ? this.view.getFolds().collapsed
+                : [];
 
         const result = model.execute(name, {
             ...this.commandOptions(),
@@ -544,11 +629,24 @@ export class InputController {
             this.view.markRowEnd(model.getPrimary().head);
         }
 
+        if (name === 'hippieCompletion' || name === 'hippieBackwardCompletion') {
+            this.view.setHippieSource(model.hippieSource);
+        }
+
         this.view.revealCaret();
 
+        if (CODE_BLOCK_COMMANDS.has(name) && model.getPrimary().head !== before) {
+            emit(this.navigateListeners, before);
+        }
+
         return result;
     }
 
+    /* Told the offset the primary caret left when a command that navigates moved it. */
+    onNavigate(listener: (from: number) => void): () => void {
+        return subscribe(this.navigateListeners, listener);
+    }
+
     private typeText(text: string): void {
         if (this.blockedByReadOnly()) {
             return;
@@ -837,6 +935,8 @@ export class InputController {
             return;
         }
 
+        this.view.setHippieSource(null);
+
         const added = this.gesture.keydown(event);
 
         if (added !== null) {
@@ -933,6 +1033,7 @@ export class InputController {
 
         event.clipboardData?.setData('text/plain', text);
         lineClip = empty ? text : null;
+        emit(this.copyListeners, { text, wholeLines: empty, cut });
 
         if (!cut || this.blockedByReadOnly()) {
             return;

package/src/editor.css

@@ -652,11 +652,16 @@
 .se-find-match,
 .se-find-current,
 .se-occurrence,
+.se-hippie-source,
 .se-bracket-match,
 .se-bracket-unmatched {
     position: absolute;
     border-radius: var(--radius-xs);
 }
+.se-hippie-source {
+    background: color-mix(in srgb, var(--accent) 22%, transparent);
+    border-radius: var(--radius-sm);
+}
 .se-find-match {
     background: var(--find-match);
 }
@@ -747,6 +752,14 @@
     white-space: pre;
     cursor: default;
 }
+.se-swatch {
+    height: 12px;
+    margin-top: calc((var(--code-line-height, 20px) - 12px) / 2);
+    padding: 0;
+    border-radius: var(--radius-sm);
+    box-shadow: inset 0 0 0 1px var(--border);
+    cursor: pointer;
+}
 .se-inlay-link {
     text-decoration: underline;
     text-underline-offset: 2px;

package/src/engine.ts

@@ -1,5 +1,6 @@
 import { changedSpans, DocumentModel, type EditorSnapshot, type FoldHints, replacementText } from '@adecore/editor-core';
 import { MAX_REPLACEMENT_CHARACTERS } from './search-protocol.ts';
+import { placeAt, postfixOperands, surroundShape, unwrapTargets } from './text-queries.ts';
 import { GrammarPreparation } from './grammar-preparation.ts';
 import { InputController } from './controller.ts';
 import { resolveSmartKeys } from './smart-keys.ts';
@@ -17,6 +18,7 @@ import type {
     EditorCodeVision,
     EditorClickHandler,
     EditorContextMenu,
+    EditorCopy,
     EditorContentChange,
     EditorEngine,
     EditorFindQuery,
@@ -36,11 +38,16 @@ import type {
     EditorInlayHint,
     EditorInlayTarget,
     EditorKeyHandler,
+    EditorPasteOptions,
     EditorInputPopup,
     EditorMarker,
     EditorMessages,
     EditorOptions,
     EditorPosition,
+    EditorPostfixOperand,
+    EditorSurroundShape,
+    EditorTextPlace,
+    EditorUnwrapTarget,
     EditorRemoteCursor,
     EditorRange,
     EditorReveal,
@@ -90,6 +97,8 @@ class SmartEditor implements Editor {
     private lensRevisions = new Map<string, { signature: string; revision: number }>();
     private tokenizerRequest = 0;
     private settingText = false;
+    /* The hints of each owner, in the order the owners first set theirs. */
+    private readonly inlayOwners = new Map<string, readonly EditorInlayHint[]>();
     private disposed = false;
 
     private readonly engine: SmartEditorEngineOptions;
@@ -429,15 +438,21 @@ class SmartEditor implements Editor {
         );
     }
 
-    setInlayHints(hints: readonly EditorInlayHint[]): void {
+    setInlayHints(hints: readonly EditorInlayHint[], owner: string = DEFAULT_WIDGET_OWNER): void {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        } else {
+            this.inlayOwners.set(owner, hints);
+        }
         this.view.setInlays(
-            hints.map((hint, index) => ({
+            [...this.inlayOwners.values()].flat().map((hint, index) => ({
                 id: hint.id ?? `hint-${index}`,
                 at: this.offsetAt(hint.position),
                 text: hint.label,
                 ...(hint.parts === undefined ? {} : { parts: hint.parts }),
                 ...(hint.paddingLeft ? { gapLeft: INLAY_GAP } : {}),
-                ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {})
+                ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {}),
+                ...(hint.swatch === undefined ? {} : { swatch: hint.swatch })
             }))
         );
     }
@@ -938,6 +953,30 @@ class SmartEditor implements Editor {
         this.view.setFoldHints(hints === null ? null : this.foldHintsByOffset(hints));
     }
 
+    setDeclarations(positions: readonly EditorPosition[] | null): void {
+        this.view.setDeclarations(positions === null ? null : positions.map((position) => this.offsetAt(position)));
+    }
+
+    onNavigate(listener: (from: EditorPosition) => void): () => void {
+        return this.controller.onNavigate((from) => listener(this.positionAt(from)));
+    }
+
+    hasFocus(): boolean {
+        return this.view.focused;
+    }
+
+    setWordSources(source: (() => readonly string[]) | null): void {
+        this.controller.setWordSources(source);
+    }
+
+    onCopy(listener: (copy: EditorCopy) => void): () => void {
+        return this.controller.onCopy(listener);
+    }
+
+    paste(text: string, options?: EditorPasteOptions): boolean {
+        return this.controller.pasteText(text, options);
+    }
+
     private foldHintsByOffset(hints: EditorFoldHints): FoldHints {
         const lineOf = (line: number): { start: number; end: number } => this.model.getLine(Math.min(line, this.model.getLineCount() - 1));
 
@@ -1033,6 +1072,24 @@ class SmartEditor implements Editor {
         return this.settings.readOnly;
     }
 
+    placeAt(position: EditorPosition): EditorTextPlace {
+        return placeAt(this.model, this, position, this.settings.language ?? 'plaintext');
+    }
+
+    postfixOperands(dot: EditorPosition): readonly EditorPostfixOperand[] {
+        return postfixOperands(this.model, this, dot, this.settings.language ?? 'plaintext');
+    }
+
+    surroundShape(range: EditorRange): EditorSurroundShape | null {
+        return surroundShape(this.model, this, range, this.settings.language ?? 'plaintext');
+    }
+
+    unwrapTargets(position: EditorPosition): readonly EditorUnwrapTarget[] {
+        const unit = this.settings.insertSpaces ? ' '.repeat(this.settings.tabSize) : '\t';
+
+        return unwrapTargets(this.model, this, position, this.settings.language ?? 'plaintext', unit);
+    }
+
     runCommand(command: EditorRunCommand): boolean {
         return this.controller.command(command);
     }

package/src/fake.ts

@@ -34,6 +34,10 @@ import type {
     EditorMessages,
     EditorOptions,
     EditorPosition,
+    EditorPostfixOperand,
+    EditorSurroundShape,
+    EditorTextPlace,
+    EditorUnwrapTarget,
     EditorRemoteCursor,
     EditorRange,
     EditorReveal,
@@ -46,6 +50,8 @@ import type {
     EditorSemanticToken,
     EditorSmartKeys,
     EditorApplyEditsOptions,
+    EditorCopy,
+    EditorPasteOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
@@ -53,7 +59,8 @@ import type {
     EditorWidget
 } from './types.ts';
 import { emit, type Listener, subscribe } from './listeners.ts';
-import { changedSpan, changedSpans } from '@adecore/editor-core';
+import { changedSpan, changedSpans, DocumentModel } from '@adecore/editor-core';
+import { placeAt, postfixOperands, surroundShape, unwrapTargets } from './text-queries.ts';
 import { mapTrackedRange } from './tracked-range.ts';
 
 interface OffsetSelection {
@@ -823,6 +830,78 @@ export class FakeEditor implements Editor {
         this.foldHints = hints;
     }
 
+    declarations: readonly EditorPosition[] | null = null;
+
+    setDeclarations(positions: readonly EditorPosition[] | null): void {
+        this.declarations = positions;
+    }
+
+    private readonly navigations = new Set<(from: EditorPosition) => void>();
+
+    onNavigate(listener: (from: EditorPosition) => void): () => void {
+        return subscribe(this.navigations, listener);
+    }
+
+    /* Stands for a command that navigated: tells the listeners the caret left `from`. */
+    navigate(from: EditorPosition): void {
+        emit(this.navigations, from);
+    }
+
+    hasFocus(): boolean {
+        return this.focused;
+    }
+
+    private readonly copies = new Set<(copy: EditorCopy) => void>();
+
+    onCopy(listener: (copy: EditorCopy) => void): () => void {
+        return subscribe(this.copies, listener);
+    }
+
+    /* Stands for a copy or cut of a person: tells the listeners what went on the clipboard. */
+    copy(text: string, wholeLines = false, cut = false): void {
+        emit(this.copies, { text, wholeLines, cut });
+    }
+
+    /* Every paste a host asked for, with its options. */
+    readonly pastes: Array<{ text: string; options: EditorPasteOptions | undefined }> = [];
+
+    /* Puts the text at every caret, one line per caret when the lines are as many as the carets, and leaves the carets behind it. */
+    paste(text: string, options?: EditorPasteOptions): boolean {
+        this.assertLive();
+        this.pastes.push({ text, options });
+
+        if (this.readOnly || text === '') {
+            return false;
+        }
+
+        const lines = text.split('\n');
+        const selections = [...this.selections].sort((left, right) => Math.min(left.anchor, left.head) - Math.min(right.anchor, right.head));
+        const perCaret = lines.length === selections.length;
+
+        const edits = selections.map((selection, index) => ({
+            from: Math.min(selection.anchor, selection.head),
+            to: Math.max(selection.anchor, selection.head),
+            text: perCaret ? lines[index]! : text
+        }));
+
+        return this.edit(edits, 'command', false, () => {
+            let shift = 0;
+
+            return edits.map((edit) => {
+                const caret = edit.from + shift + edit.text.length;
+                shift += edit.text.length - (edit.to - edit.from);
+
+                return { anchor: caret, head: caret };
+            });
+        });
+    }
+
+    wordSources: (() => readonly string[]) | null = null;
+
+    setWordSources(source: (() => readonly string[]) | null): void {
+        this.wordSources = source;
+    }
+
     setSmartKeys(keys: Partial<EditorSmartKeys>): void {
         this.smartKeys = keys;
     }
@@ -847,11 +926,17 @@ export class FakeEditor implements Editor {
         this.markers = markers;
     }
 
-    /* What the host drew as hints last. */
+    /* What the host drew as hints last, every owner's together. */
     inlayHints: readonly EditorInlayHint[] = [];
+    private readonly inlayOwners = new Map<string, readonly EditorInlayHint[]>();
 
-    setInlayHints(hints: readonly EditorInlayHint[]): void {
-        this.inlayHints = hints;
+    setInlayHints(hints: readonly EditorInlayHint[], owner = 'default'): void {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        } else {
+            this.inlayOwners.set(owner, hints);
+        }
+        this.inlayHints = [...this.inlayOwners.values()].flat();
     }
 
     private readonly inlayHovers = new Set<(target: EditorInlayTarget | null) => void>();
@@ -1190,6 +1275,24 @@ export class FakeEditor implements Editor {
         return this.readOnly;
     }
 
+    placeAt(position: EditorPosition): EditorTextPlace {
+        return placeAt(new DocumentModel(this.text), this, position, this.language ?? 'plaintext');
+    }
+
+    postfixOperands(dot: EditorPosition): readonly EditorPostfixOperand[] {
+        return postfixOperands(new DocumentModel(this.text), this, dot, this.language ?? 'plaintext');
+    }
+
+    surroundShape(range: EditorRange): EditorSurroundShape | null {
+        return surroundShape(new DocumentModel(this.text), this, range, this.language ?? 'plaintext');
+    }
+
+    unwrapTargets(position: EditorPosition): readonly EditorUnwrapTarget[] {
+        const unit = this.indentation.insertSpaces ? ' '.repeat(this.indentation.tabSize) : '\t';
+
+        return unwrapTargets(new DocumentModel(this.text), this, position, this.language ?? 'plaintext', unit);
+    }
+
     /* The commands run, in order; of its own the fake carries out only undo and redo. */
     readonly commands: EditorRunCommand[] = [];
 
@@ -1208,6 +1311,8 @@ export class FakeEditor implements Editor {
         this.changes.clear();
         this.textChanges.clear();
         this.carets.clear();
+        this.navigations.clear();
+        this.copies.clear();
         this.hovers.clear();
         this.inlayHovers.clear();
         this.inlayHandlers.clear();

package/src/index.ts

@@ -3,7 +3,9 @@ export { AGENT_COLORS } from './attribution.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from '@adecore/editor-core';
 export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from '@adecore/editor-core';
 export { detectIndentation, type DetectedIndentation } from '@adecore/editor-core';
+export { commentSyntax, type CommentSyntax } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.ts';
+export { rememberCopy } from './controller.ts';
 export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
 export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
 
@@ -61,6 +63,12 @@ export type {
     EditorRemoteCursor,
     EditorRange,
     EditorApplyEditsOptions,
+    EditorCopy,
+    EditorPasteOptions,
+    EditorPostfixOperand,
+    EditorSurroundShape,
+    EditorTextPlace,
+    EditorUnwrapTarget,
     EditorTextChange,
     EditorTrackedRange,
     EditorRunCommand,

package/src/keymap-table.ts

@@ -33,10 +33,15 @@ export const KEYMAP = {
     deleteLine: bind('Mod+Backspace', 'Mod+Y'),
     moveLineUp: bind('Alt+Shift+ArrowUp'),
     moveLineDown: bind('Alt+Shift+ArrowDown'),
+    moveStatementUp: bind('Mod+Shift+ArrowUp'),
+    moveStatementDown: bind('Mod+Shift+ArrowDown'),
     toggleLineComment: bind('Mod+/'),
     toggleBlockComment: bind('Mod+Alt+/', 'Mod+Shift+/'),
     joinLines: bind('Ctrl+Shift+J'),
     startNewLine: bind('Shift+Enter'),
+    completeCurrentStatement: bind('Mod+Shift+Enter'),
+    hippieCompletion: bind('Alt+/'),
+    hippieBackwardCompletion: bind('Alt+Shift+/'),
     startNewLineBefore: bind('Mod+Alt+Enter'),
     splitLine: bind('Mod+Enter'),
     toggleCase: bind('Mod+Shift+U'),
@@ -49,8 +54,21 @@ export const KEYMAP = {
     convertIndentsToTabs: bind(null),
 
     expandSelection: bind('Alt+ArrowUp', 'Ctrl+W'),
-    shrinkSelection: bind('Alt+ArrowDown'),
+    // Off macOS Alt+ArrowDown is Next Method, as in IntelliJ, so Shrink Selection takes its own chord there.
+    shrinkSelection: bind('Alt+ArrowDown', 'Ctrl+Shift+W'),
     matchBrace: bind('Ctrl+M', 'Ctrl+Shift+M'),
+    methodUp: bind('Ctrl+Shift+ArrowUp', 'Alt+ArrowUp'),
+    methodDown: bind('Ctrl+Shift+ArrowDown', 'Alt+ArrowDown'),
+    lastEditLocation: bind('Mod+Shift+Backspace'),
+    nextEditLocation: bind(null),
+    pasteFromHistory: bind('Mod+Shift+V'),
+    pasteAsPlainText: bind('Mod+Alt+Shift+V'),
+    nextChange: bind('Ctrl+Alt+Shift+ArrowDown'),
+    previousChange: bind('Ctrl+Alt+Shift+ArrowUp'),
+    codeBlockStart: bind('Mod+Alt+[', 'Ctrl+['),
+    codeBlockEnd: bind('Mod+Alt+]', 'Ctrl+]'),
+    codeBlockStartWithSelection: bind('Mod+Alt+Shift+[', 'Ctrl+Shift+['),
+    codeBlockEndWithSelection: bind('Mod+Alt+Shift+]', 'Ctrl+Shift+]'),
 
     selectNextOccurrence: bind('Ctrl+G', 'Alt+J'),
     unselectOccurrence: bind('Ctrl+Shift+G', 'Alt+Shift+J'),
@@ -72,9 +90,10 @@ export const KEYMAP = {
     smartEnd: bind('Meta+ArrowRight', null),
     selectSmartEnd: bind('Meta+Shift+ArrowRight', null),
     textStart: bind('Meta+ArrowUp', null),
-    selectTextStart: bind('Meta+Shift+ArrowUp', null),
+    // IntelliJ binds Cmd+Shift+ArrowUp and ArrowDown to Move Statement on macOS, where Cmd+Shift+Home and End still select to the text edges.
+    selectTextStart: bind(null),
     textEnd: bind('Meta+ArrowDown', null),
-    selectTextEnd: bind('Meta+Shift+ArrowDown', null),
+    selectTextEnd: bind(null),
 
     collapse: bind('Mod+-'),
     expand: bind('Mod+='),
@@ -104,6 +123,13 @@ export const KEYMAP = {
     renameSymbol: bind('Shift+F6'),
     organizeImports: bind('Ctrl+Alt+O'),
     formatDocument: bind('Mod+Alt+L'),
+    insertLiveTemplate: bind('Mod+J'),
+    surroundWith: bind('Mod+Alt+T'),
+    surroundWithLiveTemplate: bind('Mod+Alt+J'),
+    unwrap: bind('Mod+Shift+Delete'),
+    saveAsLiveTemplate: bind(null),
+    // Surround with Emmet has no chord of its own: it is a row of Surround with Live Template, which has this one.
+    wrapWithAbbreviation: bind(null),
     selectionToChat: bind(null),
     inlineEdit: bind(null),
     suggestInline: bind(null),
@@ -116,6 +142,7 @@ export const KEYMAP = {
     peekDefinition: bind('Alt+Space', 'Ctrl+Shift+I'),
     peekReferences: bind('Alt+F7'),
     callHierarchy: bind('Ctrl+Alt+H'),
+    typeHierarchy: bind('Ctrl+H'),
     toggleRenderedDocs: bind('Ctrl+Alt+Q'),
     historyBack: bind('Mod+[', 'Ctrl+Alt+ArrowLeft'),
     historyForward: bind('Mod+]', 'Ctrl+Alt+ArrowRight'),
@@ -142,7 +169,31 @@ export type OptionalKeymapId =
     | 'reverseLines'
     | 'uniqueLines'
     | 'convertIndentsToSpaces'
-    | 'convertIndentsToTabs';
+    | 'convertIndentsToTabs'
+    | 'completeCurrentStatement'
+    | 'hippieCompletion'
+    | 'hippieBackwardCompletion'
+    | 'moveStatementUp'
+    | 'moveStatementDown'
+    | 'lastEditLocation'
+    | 'nextEditLocation'
+    | 'methodUp'
+    | 'methodDown'
+    | 'pasteFromHistory'
+    | 'pasteAsPlainText'
+    | 'nextChange'
+    | 'previousChange'
+    | 'codeBlockStart'
+    | 'codeBlockEnd'
+    | 'codeBlockStartWithSelection'
+    | 'codeBlockEndWithSelection'
+    | 'wrapWithAbbreviation'
+    | 'insertLiveTemplate'
+    | 'surroundWith'
+    | 'surroundWithLiveTemplate'
+    | 'unwrap'
+    | 'saveAsLiveTemplate'
+    | 'typeHierarchy';
 
 export type Keymap = Readonly<Record<Exclude<KeymapId, OptionalKeymapId>, KeyBinding> & Partial<Record<OptionalKeymapId, KeyBinding>>>;
 export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;