@adecore/editor 0.0.1 → 0.17.0-beta.1

package/src/find.ts

@@ -0,0 +1,128 @@
+import type { DocumentChange, DocumentModel } from '@adecore/editor-core';
+import { mapOffset } from './offsets.ts';
+import type { EditorFindQuery, EditorFindState } from './types.ts';
+
+export interface FindMark {
+    from: number;
+    to: number;
+}
+
+/* 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 {
+    private query: EditorFindQuery | null = null;
+    private marks: FindMark[] = [];
+    private index: number | null = null;
+    /* The text a search in the selection is held to, which follows the text through edits; null when nothing was selected. */
+    private bounds: { from: number; to: number } | null = null;
+    /* Where the next refresh looks for the current match from, once: right after what a replace wrote. */
+    pendingAnchor: number | undefined;
+
+    private readonly model: DocumentModel;
+
+    constructor(model: DocumentModel) {
+        this.model = model;
+    }
+
+    get activeQuery(): EditorFindQuery | null {
+        return this.query;
+    }
+
+    get active(): boolean {
+        return this.query !== null;
+    }
+
+    get matches(): readonly FindMark[] {
+        return this.marks;
+    }
+
+    get current(): number | null {
+        return this.index;
+    }
+
+    get state(): EditorFindState {
+        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(): { from: number; to: number } | null {
+        return this.query?.inSelection === true ? this.bounds : null;
+    }
+
+    get currentMark(): FindMark | null {
+        return this.index === null ? null : (this.marks[this.index] ?? null);
+    }
+
+    /* A new query, or null to end the find. */
+    set(query: EditorFindQuery | null): void {
+        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: readonly DocumentChange[]): void {
+        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(): void {
+        const previous = this.currentMark;
+        const query = this.query;
+        if (query === null) {
+            this.marks = [];
+            this.index = null;
+            return;
+        }
+        let found: FindMark[] = [];
+        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: 1 | -1): void {
+        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/src/index.ts

@@ -0,0 +1,69 @@
+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/src/input.ts

@@ -0,0 +1,63 @@
+import type { Selection, TextEdit } from '@adecore/editor-core';
+
+/* The one stretch two texts differ in, found from both ends and never inside a surrogate pair. */
+export function findChange(before: string, after: string): TextEdit {
+    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: readonly Selection[], text: string): { edits: TextEdit[]; selections: Selection[] } {
+    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: TextEdit[] = [];
+    const positions: Selection[] = [];
+    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: string): string {
+    return text.replace(/\r\n?/g, '\n');
+}
+
+/* A textarea normalizes CRLF; the model keeps its own UTF-16 offsets. */
+export function modelOffset(text: string, nativeOffset: number): number {
+    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: string, offset: number): number {
+    return textareaText(text.slice(0, offset)).length;
+}

package/src/keymap-table.ts

@@ -0,0 +1,163 @@
+import type { KeyChord } from './types.ts';
+
+export interface TakenKey {
+    /* The chord the platform binds on the platform this entry is for. */
+    readonly platform: string;
+    /* The host command that owns the chord. */
+    readonly by: string;
+}
+
+export interface KeyBinding {
+    readonly mac: string | null;
+    readonly other: string | null;
+    readonly takenMac?: TakenKey;
+    readonly takenOther?: TakenKey;
+}
+
+function bind(mac: string | null, other: string | null = mac, taken: { mac?: TakenKey; other?: TakenKey } = {}): KeyBinding {
+    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')
+} as const satisfies Record<string, KeyBinding>;
+
+export type KeymapId = keyof typeof KEYMAP;
+
+export type Keymap = Readonly<Record<KeymapId, KeyBinding>>;
+export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;
+
+export const KEYMAP_IDS = Object.keys(KEYMAP) as KeymapId[];
+
+export function resolveKeymap(overrides: KeymapOverrides = {}): Keymap {
+    return Object.fromEntries(KEYMAP_IDS.map((id) => [id, { ...KEYMAP[id], ...overrides[id] }])) as unknown as Keymap;
+}
+
+/* The chord of a command on a platform, or null when the platform has none. */
+export function chordOf(id: KeymapId, apple: boolean, keymap: Keymap = KEYMAP): string | null {
+    return keymap[id][apple ? 'mac' : 'other'];
+}
+
+const MODIFIERS = new Map<string, 'mod' | 'ctrl' | 'meta' | 'alt' | 'shift'>([
+    ['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: string): KeyChord {
+    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/src/keymap.ts

@@ -0,0 +1,204 @@
+import type { EditorCommand } from '@adecore/editor-core';
+import type { EditorViewCommand } from './types.ts';
+import { chordOf, KEYMAP, KEYMAP_IDS, type Keymap, type KeymapId, parseChord } from './keymap-table.ts';
+import type { KeyChord } from './types.ts';
+
+export interface KeyLike {
+    key: string;
+    /* The physical key, for a chord whose character depends on the layout or on Option. */
+    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' };
+
+const MOVES = new Set<string>(['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'PageUp', 'PageDown']);
+
+function command(name: EditorCommand): KeyAction {
+    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: Partial<Record<KeymapId, KeyAction>> = {
+    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: Readonly<Record<string, string>> = {
+    ',': '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: Readonly<Record<string, readonly string[]>> = { '-': ['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: string, event: KeyLike): boolean {
+    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: KeyChord, event: KeyLike, apple: boolean): boolean {
+    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)
+    );
+}
+
+interface BoundAction {
+    readonly chord: KeyChord;
+    readonly action: KeyAction;
+}
+
+const bindings = new WeakMap<Keymap, Record<'mac' | 'other', readonly BoundAction[]>>();
+
+function bound(apple: boolean, keymap: Keymap): BoundAction[] {
+    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: KeyLike, apple: boolean, keymap: Keymap = KEYMAP): KeyAction | null {
+    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 as MoveKey, extend: shift };
+    }
+    if (key === 'escape') {
+        return { type: 'escape' };
+    }
+    return null;
+}