@adecore/editor 0.0.1 → 0.17.0-beta.1

package/dist/find.js

@@ -0,0 +1,108 @@
+import { mapOffset } from './offsets.js';
+/* Past this a count means nothing to a reader, and marking every match would stall the editor. */
+export const FIND_LIMIT = 10000;
+/*
+ * The find of the host's find bar: every match marked, one of them current. It searches the model on
+ * its own and never touches the selection until the find ends.
+ */
+export class FindController {
+    query = null;
+    marks = [];
+    index = null;
+    /* The text a search in the selection is held to, which follows the text through edits; null when nothing was selected. */
+    bounds = null;
+    /* Where the next refresh looks for the current match from, once: right after what a replace wrote. */
+    pendingAnchor;
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    get activeQuery() {
+        return this.query;
+    }
+    get active() {
+        return this.query !== null;
+    }
+    get matches() {
+        return this.marks;
+    }
+    get current() {
+        return this.index;
+    }
+    get state() {
+        return { count: this.marks.length, current: this.index, ...(this.query?.inSelection === true && this.bounds === null ? { noSelection: true } : {}) };
+    }
+    /* The range a search in the selection is held to. */
+    get scope() {
+        return this.query?.inSelection === true ? this.bounds : null;
+    }
+    get currentMark() {
+        return this.index === null ? null : (this.marks[this.index] ?? null);
+    }
+    /* A new query, or null to end the find. */
+    set(query) {
+        const wasInSelection = this.query?.inSelection === true;
+        this.query = query === null || query.text === '' ? null : query;
+        if (this.query?.inSelection !== true) {
+            this.bounds = null;
+        }
+        else if (!wasInSelection) {
+            const selection = this.model.getPrimary();
+            this.bounds =
+                selection.anchor === selection.head
+                    ? null
+                    : { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+        }
+        this.refresh();
+    }
+    /* The text of a search in the selection moved with an edit. */
+    mapBounds(changes) {
+        if (this.bounds !== null) {
+            this.bounds = { from: mapOffset(this.bounds.from, changes), to: mapOffset(this.bounds.to, changes) };
+        }
+    }
+    /*
+     * The matches again, after a new query or an edit. The current one is the first from where the
+     * previous one was, or from the cursor, so each letter typed keeps the place instead of starting over.
+     */
+    refresh() {
+        const previous = this.currentMark;
+        const query = this.query;
+        if (query === null) {
+            this.marks = [];
+            this.index = null;
+            return;
+        }
+        let found = [];
+        try {
+            const inSelection = query.inSelection === true;
+            if (!inSelection || this.bounds !== null) {
+                found = this.model
+                    .find(query.text, {
+                    caseSensitive: query.caseSensitive,
+                    wholeWord: query.wholeWord,
+                    regex: query.regex,
+                    maxResults: FIND_LIMIT,
+                    ...(inSelection ? this.bounds : {})
+                })
+                    .map((match) => ({ from: match.from, to: match.to }));
+            }
+        }
+        catch {
+            // A pattern that does not parse finds nothing; the find bar says it is invalid.
+        }
+        this.marks = found;
+        const selection = this.model.getPrimary();
+        const anchor = this.pendingAnchor ?? previous?.from ?? Math.min(selection.anchor, selection.head);
+        this.pendingAnchor = undefined;
+        const next = found.findIndex((mark) => mark.from >= anchor);
+        this.index = found.length === 0 ? null : Math.max(0, next);
+    }
+    step(direction) {
+        const count = this.marks.length;
+        if (count === 0) {
+            return;
+        }
+        this.index = this.index === null ? (direction === 1 ? 0 : count - 1) : (this.index + direction + count) % count;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { AGENT_COLORS } from './attribution.ts';
+export { createSmartEditorEngine } from './engine.ts';
+export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
+export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
+export type { Editor, EditorAttributionHover, EditorAttributionMark, EditorMarkColor, EditorBlock, EditorChangeKind, EditorChangeMark, EditorCodeVision, EditorCodeVisionEntry, EditorClick, EditorCodeBlockOptions, EditorClickHandler, EditorCommand, EditorContextMenu, EditorEngine, EditorFindQuery, EditorFoldHints, EditorFoldOutline, EditorFoldRange, EditorFoldSymbol, EditorFolds, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorIndentation, EditorContentChange, EditorHighlight, EditorHighlightKind, EditorHover, EditorGhostText, EditorInlayHint, EditorKeyHandler, EditorLineAction, EditorLineHighlight, EditorMarker, EditorMessages, EditorMarkerSeverity, EditorReveal, EditorRect, EditorSmartKeys, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorTextChange, EditorTrackedRange, EditorRunCommand, EditorSelectionRanges, EditorTheme, EditorViewCommand, EditorWidget, FoldRole, KeyChord, LineToken, ScopeColorSource, ScopeColors, ScopeStyle, EditorSemanticToken, LineTokenizer, SmartEditorEngineOptions, TokenizedLine, TokenizerSource } from './types.ts';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { AGENT_COLORS } from './attribution.js';
+export { createSmartEditorEngine } from './engine.js';
+export { DEFAULT_SMART_KEYS } from './smart-keys.js';
+export { shikiScopeColors, shikiTokenizers } from './shiki.js';

package/dist/input.d.ts

@@ -0,0 +1,9 @@
+import type { Selection, TextEdit } from '@adecore/editor-core';
+export declare function findChange(before: string, after: string): TextEdit;
+export declare function replacementEdits(selections: readonly Selection[], text: string): {
+    edits: TextEdit[];
+    selections: Selection[];
+};
+export declare function textareaText(text: string): string;
+export declare function modelOffset(text: string, nativeOffset: number): number;
+export declare function textareaOffset(text: string, offset: number): number;

package/dist/input.js

@@ -0,0 +1,57 @@
+/* The one stretch two texts differ in, found from both ends and never inside a surrogate pair. */
+export function findChange(before, after) {
+    let from = 0;
+    while (from < before.length && from < after.length && before[from] === after[from]) {
+        from++;
+    }
+    if (from > 0 && /[\uDC00-\uDFFF]/.test(before[from] ?? '') && /[\uD800-\uDBFF]/.test(before[from - 1])) {
+        from--;
+    }
+    let endBefore = before.length;
+    let endAfter = after.length;
+    while (endBefore > from && endAfter > from && before[endBefore - 1] === after[endAfter - 1]) {
+        endBefore--;
+        endAfter--;
+    }
+    if (endBefore < before.length && /[\uDC00-\uDFFF]/.test(before[endBefore] ?? '') && /[\uD800-\uDBFF]/.test(before[endBefore - 1] ?? '')) {
+        endBefore++;
+        endAfter++;
+    }
+    return { from, to: endBefore, text: after.slice(from, endAfter) };
+}
+/* One replacement per selection, with the carets after what each inserted. */
+export function replacementEdits(selections, text) {
+    const sorted = selections
+        .map((selection, index) => ({ from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head), index }))
+        .sort((left, right) => left.from - right.from);
+    const edits = [];
+    const positions = [];
+    let delta = 0;
+    for (const range of sorted) {
+        edits.push({ from: range.from, to: range.to, text });
+        const head = range.from + delta + text.length;
+        positions[range.index] = { anchor: head, head };
+        delta += text.length - (range.to - range.from);
+    }
+    return { edits, selections: positions };
+}
+export function textareaText(text) {
+    return text.replace(/\r\n?/g, '\n');
+}
+/* A textarea normalizes CRLF; the model keeps its own UTF-16 offsets. */
+export function modelOffset(text, nativeOffset) {
+    let native = 0;
+    for (let index = 0; index < text.length; index++) {
+        if (native === nativeOffset) {
+            return index;
+        }
+        if (text[index] === '\r' && text[index + 1] === '\n') {
+            continue;
+        }
+        native++;
+    }
+    return text.length;
+}
+export function textareaOffset(text, offset) {
+    return textareaText(text.slice(0, offset)).length;
+}

package/dist/keymap-table.d.ts

@@ -0,0 +1,102 @@
+import type { KeyChord } from './types.ts';
+export interface TakenKey {
+    readonly platform: string;
+    readonly by: string;
+}
+export interface KeyBinding {
+    readonly mac: string | null;
+    readonly other: string | null;
+    readonly takenMac?: TakenKey;
+    readonly takenOther?: TakenKey;
+}
+export declare const KEYMAP: {
+    readonly undo: KeyBinding;
+    readonly redo: KeyBinding;
+    readonly selectAll: KeyBinding;
+    readonly save: KeyBinding;
+    readonly duplicateLine: KeyBinding;
+    readonly deleteLine: KeyBinding;
+    readonly moveLineUp: KeyBinding;
+    readonly moveLineDown: KeyBinding;
+    readonly toggleLineComment: KeyBinding;
+    readonly toggleBlockComment: KeyBinding;
+    readonly joinLines: KeyBinding;
+    readonly startNewLine: KeyBinding;
+    readonly startNewLineBefore: KeyBinding;
+    readonly splitLine: KeyBinding;
+    readonly toggleCase: KeyBinding;
+    readonly autoIndentLines: KeyBinding;
+    readonly expandSelection: KeyBinding;
+    readonly shrinkSelection: KeyBinding;
+    readonly matchBrace: KeyBinding;
+    readonly selectNextOccurrence: KeyBinding;
+    readonly unselectOccurrence: KeyBinding;
+    readonly selectAllOccurrences: KeyBinding;
+    readonly addCaretPerSelectedLine: KeyBinding;
+    readonly addCaretAbove: KeyBinding;
+    readonly addCaretBelow: KeyBinding;
+    readonly toggleColumnMode: KeyBinding;
+    readonly wordLeft: KeyBinding;
+    readonly wordRight: KeyBinding;
+    readonly selectWordLeft: KeyBinding;
+    readonly selectWordRight: KeyBinding;
+    readonly deleteWordLeft: KeyBinding;
+    readonly deleteWordRight: KeyBinding;
+    readonly smartHome: KeyBinding;
+    readonly selectSmartHome: KeyBinding;
+    readonly smartEnd: KeyBinding;
+    readonly selectSmartEnd: KeyBinding;
+    readonly textStart: KeyBinding;
+    readonly selectTextStart: KeyBinding;
+    readonly textEnd: KeyBinding;
+    readonly selectTextEnd: KeyBinding;
+    readonly collapse: KeyBinding;
+    readonly expand: KeyBinding;
+    readonly collapseAll: KeyBinding;
+    readonly expandAll: KeyBinding;
+    readonly collapseRecursively: KeyBinding;
+    readonly expandRecursively: KeyBinding;
+    readonly foldSelection: KeyBinding;
+    readonly collapseDocComments: KeyBinding;
+    readonly expandDocComments: KeyBinding;
+    readonly expandAllToLevel1: KeyBinding;
+    readonly expandAllToLevel2: KeyBinding;
+    readonly expandAllToLevel3: KeyBinding;
+    readonly expandAllToLevel4: KeyBinding;
+    readonly expandAllToLevel5: KeyBinding;
+    readonly triggerCompletion: KeyBinding;
+    readonly parameterInfo: KeyBinding;
+    readonly quickInfo: KeyBinding;
+    readonly codeActions: KeyBinding;
+    readonly refactorThis: KeyBinding;
+    readonly renameSymbol: KeyBinding;
+    readonly organizeImports: KeyBinding;
+    readonly formatDocument: KeyBinding;
+    readonly selectionToChat: KeyBinding;
+    readonly inlineEdit: KeyBinding;
+    readonly suggestInline: KeyBinding;
+    readonly acceptGhostWord: KeyBinding;
+    readonly goToSymbol: KeyBinding;
+    readonly goToDefinition: KeyBinding;
+    readonly goToTypeDefinition: KeyBinding;
+    readonly goToImplementation: KeyBinding;
+    readonly peekDefinition: KeyBinding;
+    readonly peekReferences: KeyBinding;
+    readonly historyBack: KeyBinding;
+    readonly historyForward: KeyBinding;
+    readonly recentLocations: KeyBinding;
+    readonly nextProblem: KeyBinding;
+    readonly previousProblem: KeyBinding;
+    readonly nextHighlight: KeyBinding;
+    readonly previousHighlight: KeyBinding;
+    readonly findNext: KeyBinding;
+    readonly findPrevious: KeyBinding;
+    readonly replace: KeyBinding;
+};
+export type KeymapId = keyof typeof KEYMAP;
+export type Keymap = Readonly<Record<KeymapId, KeyBinding>>;
+export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;
+export declare const KEYMAP_IDS: KeymapId[];
+export declare function resolveKeymap(overrides?: KeymapOverrides): Keymap;
+export declare function chordOf(id: KeymapId, apple: boolean, keymap?: Keymap): string | null;
+export declare function parseChord(text: string): KeyChord;

package/dist/keymap-table.js

@@ -0,0 +1,130 @@
+function bind(mac, other = mac, taken = {}) {
+    return {
+        mac,
+        other,
+        ...(taken.mac === undefined ? {} : { takenMac: taken.mac }),
+        ...(taken.other === undefined ? {} : { takenOther: taken.other })
+    };
+}
+export const KEYMAP = {
+    undo: bind('Mod+Z'),
+    redo: bind('Mod+Shift+Z'),
+    selectAll: bind('Mod+A'),
+    save: bind('Mod+S'),
+    duplicateLine: bind('Mod+D'),
+    deleteLine: bind('Mod+Backspace', 'Mod+Y'),
+    moveLineUp: bind('Alt+Shift+ArrowUp'),
+    moveLineDown: bind('Alt+Shift+ArrowDown'),
+    toggleLineComment: bind('Mod+/'),
+    toggleBlockComment: bind('Mod+Alt+/', 'Mod+Shift+/'),
+    joinLines: bind('Ctrl+Shift+J'),
+    startNewLine: bind('Shift+Enter'),
+    startNewLineBefore: bind('Mod+Alt+Enter'),
+    splitLine: bind('Mod+Enter'),
+    toggleCase: bind('Mod+Shift+U'),
+    autoIndentLines: bind('Ctrl+Alt+I'),
+    expandSelection: bind('Alt+ArrowUp', 'Ctrl+W'),
+    shrinkSelection: bind('Alt+ArrowDown'),
+    matchBrace: bind('Ctrl+M', 'Ctrl+Shift+M'),
+    selectNextOccurrence: bind('Ctrl+G', 'Alt+J'),
+    unselectOccurrence: bind('Ctrl+Shift+G', 'Alt+Shift+J'),
+    selectAllOccurrences: bind('Meta+Ctrl+G', 'Ctrl+Alt+Shift+J'),
+    addCaretPerSelectedLine: bind('Alt+Shift+G'),
+    // Tap the modifier twice, hold it and press an arrow: Option on macOS, Ctrl elsewhere (`modifier-gesture.ts`). It has no chord to print.
+    addCaretAbove: bind(null),
+    addCaretBelow: bind(null),
+    toggleColumnMode: bind('Mod+Shift+8'),
+    wordLeft: bind('Alt+ArrowLeft', 'Ctrl+ArrowLeft'),
+    wordRight: bind('Alt+ArrowRight', 'Ctrl+ArrowRight'),
+    selectWordLeft: bind('Alt+Shift+ArrowLeft', 'Ctrl+Shift+ArrowLeft'),
+    selectWordRight: bind('Alt+Shift+ArrowRight', 'Ctrl+Shift+ArrowRight'),
+    deleteWordLeft: bind('Alt+Backspace', 'Ctrl+Backspace'),
+    deleteWordRight: bind('Alt+Delete', 'Ctrl+Delete'),
+    smartHome: bind('Meta+ArrowLeft', null),
+    selectSmartHome: bind('Meta+Shift+ArrowLeft', null),
+    smartEnd: bind('Meta+ArrowRight', null),
+    selectSmartEnd: bind('Meta+Shift+ArrowRight', null),
+    textStart: bind('Meta+ArrowUp', null),
+    selectTextStart: bind('Meta+Shift+ArrowUp', null),
+    textEnd: bind('Meta+ArrowDown', null),
+    selectTextEnd: bind('Meta+Shift+ArrowDown', null),
+    collapse: bind('Mod+-'),
+    expand: bind('Mod+='),
+    collapseAll: bind('Mod+Shift+-'),
+    expandAll: bind('Mod+Shift+='),
+    collapseRecursively: bind('Mod+Alt+-'),
+    expandRecursively: bind('Mod+Alt+='),
+    foldSelection: bind('Mod+.'),
+    // The platform binds the levels to a chord of two strokes, which this table cannot write, so they live in the menu and the palette.
+    collapseDocComments: bind(null),
+    expandDocComments: bind(null),
+    expandAllToLevel1: bind(null),
+    expandAllToLevel2: bind(null),
+    expandAllToLevel3: bind(null),
+    expandAllToLevel4: bind(null),
+    expandAllToLevel5: bind(null),
+    triggerCompletion: bind('Ctrl+Space'),
+    parameterInfo: bind('Mod+P'),
+    quickInfo: bind('Ctrl+J', 'Ctrl+Q'),
+    codeActions: bind('Alt+Enter'),
+    refactorThis: bind('Ctrl+T', 'Ctrl+Alt+Shift+T'),
+    renameSymbol: bind('Shift+F6'),
+    organizeImports: bind('Ctrl+Alt+O'),
+    formatDocument: bind('Mod+Alt+L'),
+    selectionToChat: bind(null),
+    inlineEdit: bind(null),
+    suggestInline: bind(null),
+    acceptGhostWord: bind(null),
+    goToSymbol: bind('Mod+F12'),
+    goToDefinition: bind('Mod+B'),
+    goToTypeDefinition: bind('Ctrl+Shift+B'),
+    goToImplementation: bind('Mod+Alt+B'),
+    peekDefinition: bind('Alt+Space', 'Ctrl+Shift+I'),
+    peekReferences: bind('Alt+F7'),
+    historyBack: bind('Mod+[', 'Ctrl+Alt+ArrowLeft'),
+    historyForward: bind('Mod+]', 'Ctrl+Alt+ArrowRight'),
+    recentLocations: bind('Mod+Shift+E'),
+    nextProblem: bind('F2'),
+    previousProblem: bind('Alt+Shift+F2'),
+    nextHighlight: bind('Ctrl+Alt+ArrowDown', 'Alt+F3'),
+    previousHighlight: bind('Ctrl+Alt+ArrowUp', 'Alt+Shift+F3'),
+    findNext: bind('Mod+G', 'Ctrl+L'),
+    findPrevious: bind('Mod+Shift+G', 'Ctrl+Shift+L'),
+    replace: bind('Mod+R')
+};
+export const KEYMAP_IDS = Object.keys(KEYMAP);
+export function resolveKeymap(overrides = {}) {
+    return Object.fromEntries(KEYMAP_IDS.map((id) => [id, { ...KEYMAP[id], ...overrides[id] }]));
+}
+/* The chord of a command on a platform, or null when the platform has none. */
+export function chordOf(id, apple, keymap = KEYMAP) {
+    return keymap[id][apple ? 'mac' : 'other'];
+}
+const MODIFIERS = new Map([
+    ['Mod', 'mod'],
+    ['Ctrl', 'ctrl'],
+    ['Meta', 'meta'],
+    ['Alt', 'alt'],
+    ['Shift', 'shift']
+]);
+/* Reads `Mod+Shift+K`. Throws on a text it cannot read, so a typo fails before a binding is used. */
+export function parseChord(text) {
+    const words = text.endsWith('++') ? [...text.slice(0, -2).split('+'), '+'] : text.split('+');
+    const chord = { mod: false, ctrl: false, meta: false, alt: false, shift: false, key: '' };
+    for (const word of words) {
+        const modifier = MODIFIERS.get(word);
+        if (modifier !== undefined) {
+            chord[modifier] = true;
+        }
+        else if (word === '' || chord.key !== '') {
+            throw new Error(`Cannot read the chord "${text}"`);
+        }
+        else {
+            chord.key = word.length === 1 ? word.toUpperCase() : word;
+        }
+    }
+    if (chord.key === '') {
+        throw new Error(`The chord "${text}" names no key`);
+    }
+    return chord;
+}

package/dist/keymap.d.ts

@@ -0,0 +1,36 @@
+import type { EditorCommand } from '@adecore/editor-core';
+import type { EditorViewCommand } from './types.ts';
+import { type Keymap } from './keymap-table.ts';
+import type { KeyChord } from './types.ts';
+export interface KeyLike {
+    key: string;
+    code?: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+}
+export type MoveKey = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'PageUp' | 'PageDown';
+export type KeyAction = {
+    readonly type: 'command';
+    readonly command: EditorCommand;
+} | {
+    readonly type: 'move';
+    readonly key: MoveKey;
+    readonly extend: boolean;
+} | {
+    readonly type: 'edge';
+    readonly end: boolean;
+    readonly extend: boolean;
+} | {
+    readonly type: 'bracket';
+} | {
+    readonly type: 'view';
+    readonly command: EditorViewCommand;
+} | {
+    readonly type: 'save';
+} | {
+    readonly type: 'escape';
+};
+export declare function chordMatches(chord: KeyChord, event: KeyLike, apple: boolean): boolean;
+export declare function keyAction(event: KeyLike, apple: boolean, keymap?: Keymap): KeyAction | null;

package/dist/keymap.js

@@ -0,0 +1,163 @@
+import { chordOf, KEYMAP, KEYMAP_IDS, parseChord } from './keymap-table.js';
+const MOVES = new Set(['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'PageUp', 'PageDown']);
+function command(name) {
+    return { type: 'command', command: name };
+}
+/* What each key of the table does in the editor. A key of the table that is not here is a language command, which the host answers. */
+const ACTIONS = {
+    undo: command('undo'),
+    redo: command('redo'),
+    selectAll: command('selectAll'),
+    save: { type: 'save' },
+    duplicateLine: command('duplicateLine'),
+    deleteLine: command('deleteLine'),
+    moveLineUp: command('moveLineUp'),
+    moveLineDown: command('moveLineDown'),
+    toggleLineComment: command('toggleLineComment'),
+    toggleBlockComment: command('toggleBlockComment'),
+    joinLines: command('joinLines'),
+    startNewLine: command('startNewLine'),
+    startNewLineBefore: command('startNewLineBefore'),
+    splitLine: command('splitLine'),
+    toggleCase: command('toggleCase'),
+    autoIndentLines: command('autoIndentLines'),
+    expandSelection: command('expandSelection'),
+    shrinkSelection: command('shrinkSelection'),
+    matchBrace: { type: 'bracket' },
+    selectNextOccurrence: command('selectNextOccurrence'),
+    unselectOccurrence: command('unselectOccurrence'),
+    selectAllOccurrences: command('selectAllOccurrences'),
+    addCaretPerSelectedLine: command('addCaretPerSelectedLine'),
+    wordLeft: command('wordLeft'),
+    wordRight: command('wordRight'),
+    selectWordLeft: command('selectWordLeft'),
+    selectWordRight: command('selectWordRight'),
+    deleteWordLeft: command('deleteWordLeft'),
+    deleteWordRight: command('deleteWordRight'),
+    smartHome: command('smartHome'),
+    selectSmartHome: command('selectSmartHome'),
+    smartEnd: command('smartEnd'),
+    selectSmartEnd: command('selectSmartEnd'),
+    textStart: { type: 'edge', end: false, extend: false },
+    selectTextStart: { type: 'edge', end: false, extend: true },
+    textEnd: { type: 'edge', end: true, extend: false },
+    selectTextEnd: { type: 'edge', end: true, extend: true },
+    collapse: { type: 'view', command: 'collapseRegion' },
+    expand: { type: 'view', command: 'expandRegion' },
+    collapseAll: { type: 'view', command: 'collapseAllRegions' },
+    expandAll: { type: 'view', command: 'expandAllRegions' },
+    collapseRecursively: { type: 'view', command: 'collapseRegionRecursively' },
+    expandRecursively: { type: 'view', command: 'expandRegionRecursively' },
+    foldSelection: { type: 'view', command: 'foldSelection' },
+    collapseDocComments: { type: 'view', command: 'collapseDocComments' },
+    expandDocComments: { type: 'view', command: 'expandDocComments' },
+    expandAllToLevel1: { type: 'view', command: 'expandAllToLevel1' },
+    expandAllToLevel2: { type: 'view', command: 'expandAllToLevel2' },
+    expandAllToLevel3: { type: 'view', command: 'expandAllToLevel3' },
+    expandAllToLevel4: { type: 'view', command: 'expandAllToLevel4' },
+    expandAllToLevel5: { type: 'view', command: 'expandAllToLevel5' },
+    toggleColumnMode: { type: 'view', command: 'toggleColumnMode' }
+};
+const PUNCTUATION_CODES = {
+    ',': 'Comma',
+    '.': 'Period',
+    '/': 'Slash',
+    ';': 'Semicolon',
+    "'": 'Quote',
+    '`': 'Backquote',
+    '\\': 'Backslash',
+    '[': 'BracketLeft',
+    ']': 'BracketRight'
+};
+/* The fold keys sit on the minus and the equals key, which Shift and Option turn into other characters. */
+const FOLD_CODES = { '-': ['Minus', 'NumpadSubtract'], '=': ['Equal', 'NumpadAdd'] };
+/* Letters and punctuation by the physical key when the event has one, since Option changes the character on macOS and Shift on every platform. */
+function keyMatches(chordKey, event) {
+    const code = event.code;
+    if (/^[A-Z]$/.test(chordKey)) {
+        return code ? code === `Key${chordKey}` : event.key.toUpperCase() === chordKey;
+    }
+    if (/^[0-9]$/.test(chordKey)) {
+        return code ? code === `Digit${chordKey}` || code === `Numpad${chordKey}` : event.key === chordKey;
+    }
+    const fold = FOLD_CODES[chordKey];
+    if (fold !== undefined) {
+        return (code !== undefined && fold.includes(code)) || event.key === chordKey || (chordKey === '=' && event.key === '+');
+    }
+    const punctuation = PUNCTUATION_CODES[chordKey];
+    if (punctuation !== undefined) {
+        return code ? code === punctuation : event.key === chordKey;
+    }
+    if (chordKey === 'Space') {
+        return event.key === ' ' || code === 'Space';
+    }
+    return event.key === chordKey;
+}
+/* Whether an event is a chord, with `mod` as Cmd on macOS and Ctrl elsewhere and every modifier the chord does not name up. */
+export function chordMatches(chord, event, apple) {
+    const wantsMeta = chord.meta || (chord.mod && apple);
+    const wantsCtrl = chord.ctrl || (chord.mod && !apple);
+    return (wantsMeta === event.metaKey &&
+        wantsCtrl === event.ctrlKey &&
+        chord.alt === event.altKey &&
+        chord.shift === event.shiftKey &&
+        keyMatches(chord.key, event));
+}
+const bindings = new WeakMap();
+function bound(apple, keymap) {
+    return KEYMAP_IDS.flatMap((id) => {
+        const text = chordOf(id, apple, keymap);
+        const action = ACTIONS[id];
+        return text === null || action === undefined ? [] : [{ chord: parseChord(text), action }];
+    });
+}
+/*
+ * What a key does in the editor, or null when it is not the editor's, which leaves it to the page and
+ * to the textarea. Movement of the caret is the view's, since it depends on how the lines are drawn.
+ */
+export function keyAction(event, apple, keymap = KEYMAP) {
+    let resolved = bindings.get(keymap);
+    if (resolved === undefined) {
+        resolved = { mac: bound(true, keymap), other: bound(false, keymap) };
+        bindings.set(keymap, resolved);
+    }
+    for (const { chord, action } of resolved[apple ? 'mac' : 'other']) {
+        if (chordMatches(chord, event, apple)) {
+            return action;
+        }
+    }
+    const key = event.key.toLowerCase();
+    const mod = apple ? event.metaKey : event.ctrlKey;
+    const { altKey: alt, shiftKey: shift, ctrlKey: ctrl, metaKey: meta } = event;
+    if (mod && !alt && (key === 'home' || key === 'end')) {
+        return { type: 'edge', end: key === 'end', extend: shift };
+    }
+    if (mod || alt || ctrl || meta) {
+        return null;
+    }
+    if (key === 'home') {
+        return command(shift ? 'selectSmartHome' : 'smartHome');
+    }
+    if (key === 'end') {
+        return command(shift ? 'selectSmartEnd' : 'smartEnd');
+    }
+    if (key === 'tab') {
+        return command(shift ? 'outdent' : 'insertTab');
+    }
+    if (key === 'enter') {
+        return command('insertNewline');
+    }
+    if (key === 'backspace') {
+        return command('smartBackspace');
+    }
+    if (key === 'delete') {
+        return command('deleteForward');
+    }
+    if (MOVES.has(event.key)) {
+        return { type: 'move', key: event.key, extend: shift };
+    }
+    if (key === 'escape') {
+        return { type: 'escape' };
+    }
+    return null;
+}