@esportsplus/ui 0.56.4 → 0.57.0

package/build/components/editor/code/folding.js

@@ -0,0 +1,433 @@
+import { EditorDocument, floorIndex, lineStarts } from './document.js';
+import { SyntaxCache } from './syntax.js';
+const COMMENT_LINE = /^\s*#/;
+const HEADER = /:\s*(?:#.*)?$/;
+const HEADING = /^#{1,6}\s/;
+const TRIPLE = new Set(["'''", '"""']);
+function better(a, b) {
+    if (!a || !b) {
+        return a ?? b;
+    }
+    if (a.endLine !== b.endLine) {
+        return a.endLine > b.endLine ? a : b;
+    }
+    if (a.to - a.from !== b.to - b.from) {
+        return a.to - a.from > b.to - b.from ? a : b;
+    }
+    return b.from < a.from ? b : a;
+}
+function bracketFold(cache, index, tag) {
+    let best = null, nesting = cache.nesting(index), open = [], start = cache.document.lineStart(index);
+    let frame = tag ? nesting.tags : nesting.brackets;
+    while (frame && frame.entry === nesting.entry) {
+        open.push(frame);
+        frame = frame.parent;
+    }
+    for (let i = open.length - 1; i >= 0; i--) {
+        let close = closing(cache, open[i], index, tag);
+        if (close >= 0) {
+            return range(cache.document, start + open[i].at, close);
+        }
+    }
+    for (let i = 0, n = nesting.closed.length; i < n; i++) {
+        let { at, frame } = nesting.closed[i];
+        if (frame.entry === nesting.entry && isTag(frame) === tag) {
+            best = better(best, range(cache.document, start + frame.at, start + at));
+        }
+    }
+    return best;
+}
+function closedAt(nesting, at) {
+    for (let i = 0, n = nesting.closed.length; i < n; i++) {
+        let closed = nesting.closed[i];
+        if (closed.at === at && !isTag(closed.frame)) {
+            return closed.frame;
+        }
+    }
+    return null;
+}
+function closeOf(cache, frame, index) {
+    let nesting = cache.nesting(index);
+    for (let i = 0, n = nesting.closed.length; i < n; i++) {
+        if (nesting.closed[i].frame === frame) {
+            return cache.document.lineStart(index) + nesting.closed[i].at;
+        }
+    }
+    return closing(cache, frame, index, false);
+}
+function closing(cache, frame, index, tag) {
+    for (let j = index + 1, n = cache.lineCount; j < n; j++) {
+        let nesting = cache.nesting(j);
+        if ((tag ? nesting.tagLow : nesting.low) >= frame.depth) {
+            continue;
+        }
+        for (let k = 0, m = nesting.closed.length; k < m; k++) {
+            if (nesting.closed[k].frame === frame) {
+                return cache.document.lineStart(j) + nesting.closed[k].at;
+            }
+        }
+        return -1;
+    }
+    return -1;
+}
+function commentFold(cache, index) {
+    let entry = cache.line(index);
+    if (entry.start.includes('comment') || !entry.end.includes('comment')) {
+        return null;
+    }
+    for (let j = index + 1, n = cache.lineCount; j < n; j++) {
+        if (!cache.line(j).end.includes('comment')) {
+            return range(cache.document, cache.document.lineStart(index), cache.document.lineStart(j));
+        }
+    }
+    return null;
+}
+function fenceFold(cache, index) {
+    let entry = cache.line(index);
+    if (entry.start.startsWith('fence:') || !entry.end.startsWith('fence:')) {
+        return null;
+    }
+    for (let j = index + 1, n = cache.lineCount; j < n; j++) {
+        if (!cache.line(j).end.startsWith('fence:')) {
+            return range(cache.document, cache.document.lineStart(index), cache.document.lineStart(j));
+        }
+    }
+    return null;
+}
+function headingFold(cache, index) {
+    let document = cache.document, level = headingLevel(cache, index);
+    if (!level) {
+        return null;
+    }
+    for (let j = index + 1, n = document.lineCount; j < n; j++) {
+        let next = headingLevel(cache, j);
+        if (next && next <= level) {
+            return section(document, index, j);
+        }
+    }
+    return section(document, index, document.lineCount);
+}
+function headingLevel(cache, index) {
+    let text = cache.document.lineText(index);
+    if (!HEADING.test(text) || cache.stateAt(index).startsWith('fence:')) {
+        return 0;
+    }
+    let level = 0;
+    while (text[level] === '#') {
+        level++;
+    }
+    return level;
+}
+function indentFold(cache, index) {
+    let document = cache.document, indent = indentOf(cache, index);
+    if (indent < 0 || !HEADER.test(document.lineText(index))) {
+        return null;
+    }
+    for (let j = index + 1, n = document.lineCount; j < n; j++) {
+        let next = indentOf(cache, j);
+        if (next >= 0 && next <= indent) {
+            return section(document, index, j);
+        }
+    }
+    return section(document, index, document.lineCount);
+}
+function indentOf(cache, index) {
+    let text = cache.document.lineText(index);
+    if (!text.trim() || COMMENT_LINE.test(text) || TRIPLE.has(cache.stateAt(index))) {
+        return -1;
+    }
+    let indent = 0;
+    for (let i = 0, n = text.length; i < n; i++) {
+        if (text[i] === '\t') {
+            indent += 4 - (indent % 4);
+        }
+        else if (text[i] === ' ') {
+            indent++;
+        }
+        else {
+            break;
+        }
+    }
+    return indent;
+}
+function isTag(frame) {
+    return frame.name !== '(' && frame.name !== '[' && frame.name !== '{';
+}
+function lineOf(cache, entry, index) {
+    for (let j = index; j >= 0; j--) {
+        if (cache.line(j) === entry) {
+            return j;
+        }
+    }
+    return -1;
+}
+function openedAt(nesting, at) {
+    for (let i = 0, n = nesting.closed.length; i < n; i++) {
+        let frame = nesting.closed[i].frame;
+        if (frame.entry === nesting.entry && frame.at === at && !isTag(frame)) {
+            return frame;
+        }
+    }
+    for (let frame = nesting.brackets; frame && frame.entry === nesting.entry; frame = frame.parent) {
+        if (frame.at === at) {
+            return frame;
+        }
+    }
+    return null;
+}
+function openOf(cache, frame, index) {
+    return cache.document.lineStart(lineOf(cache, frame.entry, index)) + frame.at;
+}
+function range(document, open, close) {
+    if (close <= open + 1) {
+        return null;
+    }
+    let endLine = document.lineAt(close) + 1, line = document.lineAt(open) + 1;
+    if (endLine === line) {
+        return null;
+    }
+    return { close, endLine, from: open + 1, line, open, to: close };
+}
+function section(document, index, end) {
+    if (end <= index + 1) {
+        return null;
+    }
+    let to = end < document.lineCount ? document.lineStart(end) : document.value.length;
+    return { endLine: document.lineAt(to) + 1, from: document.lineStart(index + 1), line: index + 1, to };
+}
+function stackAt(cache, index, at, inclusive) {
+    let marks = cache.marks(index), nesting = cache.nesting(index), stack = nesting.from;
+    for (let i = 0, n = marks.length; i < n; i++) {
+        let mark = marks[i];
+        if (mark.tag) {
+            continue;
+        }
+        if (mark.at > at || (mark.at === at && (mark.close || !inclusive))) {
+            break;
+        }
+        if (mark.close) {
+            let popped = closedAt(nesting, mark.at);
+            if (popped) {
+                stack = popped.parent;
+            }
+        }
+        else {
+            stack = openedAt(nesting, mark.at) ?? stack;
+        }
+    }
+    return stack;
+}
+const enclosingFold = (cache, line) => {
+    if (line < 1 || line > cache.lineCount) {
+        return null;
+    }
+    let start = cache.document.lineStart(line - 1);
+    for (let l = line; l >= 1; l--) {
+        let fold = foldAt(cache, l);
+        if (fold && fold.to > start) {
+            return fold;
+        }
+    }
+    return null;
+};
+const foldAt = (cache, line) => {
+    if (line < 1 || line > cache.lineCount) {
+        return null;
+    }
+    let index = line - 1, language = cache.language, best = better(bracketFold(cache, index, false), bracketFold(cache, index, true));
+    best = better(best, commentFold(cache, index));
+    if (language === 'markdown') {
+        best = better(best, fenceFold(cache, index));
+        best = better(best, headingFold(cache, index));
+    }
+    if (language === 'python') {
+        best = better(best, indentFold(cache, index));
+    }
+    return best;
+};
+const mapFolds = (folds, batches, source) => {
+    let mapped = [...folds];
+    for (let i = 0, n = batches.length; i < n; i++) {
+        let batch = batches[i], next = [];
+        let shift = (offset, right) => {
+            let delta = 0;
+            for (let k = 0, m = batch.length; k < m; k++) {
+                let edit = batch[k];
+                if (edit.to < offset || (edit.to === offset && (right || edit.from !== edit.to))) {
+                    delta += edit.insert.length - (edit.to - edit.from);
+                }
+            }
+            return delta;
+        };
+        for (let j = 0, m = mapped.length; j < m; j++) {
+            let fold = mapped[j];
+            if (batch.some((edit) => edit.from === edit.to
+                ? edit.from > fold.from && edit.from < fold.to
+                : (edit.from < fold.to && edit.to > fold.from) ||
+                    (fold.open !== undefined && edit.from <= fold.open && edit.to > fold.open) ||
+                    (fold.close !== undefined && edit.from <= fold.close && edit.to > fold.close))) {
+                continue;
+            }
+            next.push({
+                ...fold,
+                close: fold.close === undefined ? undefined : fold.close + shift(fold.close, true),
+                from: fold.from + shift(fold.from, true),
+                open: fold.open === undefined ? undefined : fold.open + shift(fold.open, true),
+                to: fold.to + shift(fold.to, false)
+            });
+        }
+        mapped = next;
+    }
+    let starts = typeof source === 'string' ? lineStarts(source) : source.starts;
+    return mapped.map((fold) => ({
+        ...fold,
+        endLine: floorIndex(starts, fold.close ?? fold.to) + 1,
+        line: floorIndex(starts, fold.open ?? Math.max(0, fold.from - 1)) + 1
+    }));
+};
+const matchingPair = (pairs, offset) => {
+    for (let i = 0, n = pairs.length; i < n; i++) {
+        let pair = pairs[i];
+        if (pair.from === offset || pair.to === offset || pair.from === offset - 1 || pair.to === offset - 1) {
+            return pair;
+        }
+    }
+    return null;
+};
+const openBracket = (cache, offset) => {
+    let document = cache.document, index = document.lineAt(offset), top = stackAt(cache, index, offset - document.lineStart(index), false);
+    return top ? { from: openOf(cache, top, index), name: top.name } : null;
+};
+const outerFolds = (folds) => {
+    let reach = -1, result = [], sorted = [...folds].sort((a, b) => a.from - b.from || b.to - a.to);
+    for (let i = 0, n = sorted.length; i < n; i++) {
+        let fold = sorted[i];
+        if (fold.to > reach) {
+            result.push(fold);
+            reach = fold.to;
+        }
+    }
+    return result;
+};
+const pairAround = (cache, from, to) => {
+    let document = cache.document, index = document.lineAt(from);
+    for (let frame = stackAt(cache, index, from - document.lineStart(index), true); frame; frame = frame.parent) {
+        let close = closeOf(cache, frame, index), open = openOf(cache, frame, index);
+        if (close >= to && (open < from || close > to)) {
+            return { from: open, to: close };
+        }
+    }
+    return null;
+};
+const pairAt = (cache, offset) => {
+    let best = null, document = cache.document, index = document.lineAt(offset), marks = cache.marks(index), nesting = cache.nesting(index), start = document.lineStart(index);
+    for (let i = 0, n = marks.length; i < n; i++) {
+        let mark = marks[i], pair = null;
+        if (mark.tag || (mark.at !== offset - start && mark.at !== offset - start - 1)) {
+            continue;
+        }
+        if (mark.close) {
+            let frame = closedAt(nesting, mark.at);
+            if (frame) {
+                pair = { from: openOf(cache, frame, index), to: start + mark.at };
+            }
+        }
+        else {
+            let frame = openedAt(nesting, mark.at), close = frame ? closeOf(cache, frame, index) : -1;
+            if (close >= 0) {
+                pair = { from: start + mark.at, to: close };
+            }
+        }
+        if (pair && (!best || pair.to < best.to)) {
+            best = pair;
+        }
+    }
+    return best;
+};
+const stickyFolds = (folds, top, cap) => {
+    let out = [];
+    for (let i = 0, n = folds.length; i < n && out.length < cap; i++) {
+        let fold = folds[i], row = top + out.length;
+        if (fold.line >= row) {
+            break;
+        }
+        let last = out[out.length - 1];
+        if (fold.endLine > row && (!last || (fold.line > last.line && fold.endLine <= last.endLine))) {
+            out.push(fold);
+        }
+    }
+    return out;
+};
+const structureOf = (cache) => {
+    let comment = -1, document = cache.document, fence = -1, folds = [], headings = [], language = cache.language, lines = new Map(), n = document.lineCount, pairs = [], python = [];
+    let add = (fold) => {
+        if (fold) {
+            folds.push(fold);
+        }
+    };
+    for (let j = 0; j < n; j++) {
+        let entry = cache.line(j), nesting = cache.nesting(j), start = document.lineStart(j);
+        lines.set(entry, j);
+        if (entry.end.includes('comment') && !entry.start.includes('comment')) {
+            comment = start;
+        }
+        if (comment >= 0 && !entry.end.includes('comment')) {
+            add(range(document, comment, start));
+            comment = -1;
+        }
+        if (language === 'markdown') {
+            if (entry.end.startsWith('fence:') && !entry.start.startsWith('fence:')) {
+                fence = start;
+            }
+            if (fence >= 0 && !entry.end.startsWith('fence:')) {
+                add(range(document, fence, start));
+                fence = -1;
+            }
+        }
+        for (let tags = 0; tags < 2; tags++) {
+            for (let k = 0, m = nesting.closed.length; k < m; k++) {
+                let { at, frame } = nesting.closed[k];
+                if (isTag(frame) !== !!tags) {
+                    continue;
+                }
+                let open = document.lineStart(lines.get(frame.entry)) + frame.at;
+                if (!tags) {
+                    pairs.push({ from: open, to: start + at });
+                }
+                add(range(document, open, start + at));
+            }
+        }
+        if (language === 'python') {
+            let indent = indentOf(cache, j);
+            if (indent >= 0) {
+                while (python.length && python[python.length - 1].indent >= indent) {
+                    add(section(document, python.pop().index, j));
+                }
+                if (HEADER.test(document.lineText(j))) {
+                    python.push({ index: j, indent });
+                }
+            }
+        }
+        if (language === 'markdown') {
+            let level = headingLevel(cache, j);
+            if (level) {
+                while (headings.length && headings[headings.length - 1].level >= level) {
+                    add(section(document, headings.pop().index, j));
+                }
+                headings.push({ index: j, level });
+            }
+        }
+    }
+    for (let i = 0, m = python.length; i < m; i++) {
+        add(section(document, python[i].index, n));
+    }
+    for (let i = 0, m = headings.length; i < m; i++) {
+        add(section(document, headings[i].index, n));
+    }
+    folds.sort((a, b) => a.line - b.line || b.endLine - a.endLine || b.to - b.from - (a.to - a.from) || a.from - b.from);
+    return { folds, pairs };
+};
+const structures = (source, language) => {
+    return structureOf(new SyntaxCache(new EditorDocument(source), language));
+};
+export { enclosingFold, foldAt, mapFolds, matchingPair, openBracket, outerFolds, pairAround, pairAt, stickyFolds, structureOf, structures };

package/build/components/editor/code/goto.d.ts

@@ -0,0 +1,22 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+declare class ReactiveObject_1a74cgn0 extends reactivity_u0.ReactiveObject<any> {
+    #private;
+    constructor();
+    get invalid(): boolean;
+    set invalid(_v0: boolean);
+    get open(): boolean;
+    set open(_v1: boolean);
+    get value(): string;
+    set value(_v2: string);
+}
+type Host = {
+    focus: VoidFunction;
+    go: (line: number, column: number) => void;
+};
+declare const goto: (host: Host) => {
+    close: () => void;
+    open: (line: number) => void;
+    state: ReactiveObject_1a74cgn0;
+    template: () => DocumentFragment | Text;
+};
+export { goto };

package/build/components/editor/code/goto.js

@@ -0,0 +1,91 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { flush } from '@esportsplus/reactivity';
+import * as template_u1 from '@esportsplus/template';
+import input from '../../input/index.js';
+import { action } from './find.js';
+import close from '@esportsplus/ui/svg/close.svg';
+const template_1a74cgn2 = template_u1.template(`<form aria-label='Go to line' class='code-editor-goto'><!--$--><button class='button code-editor-find-button code-editor-find-button--text' type='submit'>Go`);
+class ReactiveObject_1a74cgn0 extends reactivity_u0.ReactiveObject {
+    #invalid = this[reactivity_u0.SIGNAL](false);
+    #open = this[reactivity_u0.SIGNAL](false);
+    #value = this[reactivity_u0.SIGNAL]('');
+    constructor() {
+        super(null);
+    }
+    get invalid() {
+        return reactivity_u0.read(this.#invalid);
+    }
+    set invalid(_v0) {
+        reactivity_u0.write(this.#invalid, _v0);
+    }
+    get open() {
+        return reactivity_u0.read(this.#open);
+    }
+    set open(_v1) {
+        reactivity_u0.write(this.#open, _v1);
+    }
+    get value() {
+        return reactivity_u0.read(this.#value);
+    }
+    set value(_v2) {
+        reactivity_u0.write(this.#value, _v2);
+    }
+}
+const TARGET = /^\s*(\d+)(?::(\d+))?\s*$/;
+const goto = (host) => {
+    let field, state = new ReactiveObject_1a74cgn0();
+    let api = {
+        close: () => {
+            state.open = false;
+            host.focus();
+        },
+        open: (line) => {
+            state.invalid = false;
+            state.open = true;
+            state.value = String(line);
+            flush();
+            field?.focus();
+            field?.select();
+        },
+        state,
+        template: () => {
+            let root_1a74cgn1 = template_1a74cgn2(), element_1a74cgn3 = root_1a74cgn1.firstChild, element_1a74cgn4 = element_1a74cgn3.firstChild;
+            template_u1.slot(element_1a74cgn4, input({
+                'aria-invalid': () => state.invalid ? 'true' : 'false',
+                'aria-label': 'Go to line and optional column',
+                autocomplete: 'off',
+                class: 'code-editor-goto-input',
+                inputmode: 'numeric',
+                onconnect: (element) => {
+                    field = element;
+                },
+                oninput: (e) => {
+                    state.invalid = false;
+                    state.value = e.target.value;
+                },
+                placeholder: 'Line:column',
+                value: () => state.value
+            }));
+            template_u1.slot(element_1a74cgn3, action('Close go to line', close, () => api.close()), 2);
+            template_u1.setList(element_1a74cgn3, 'class', () => state.open && '--active');
+            template_u1.delegate(element_1a74cgn3, 'keydown', (e) => {
+                if (e.key === 'Escape' && !e.isComposing) {
+                    e.preventDefault();
+                    api.close();
+                }
+            });
+            template_u1.on(element_1a74cgn3, 'submit', (e) => {
+                e.preventDefault();
+                let match = TARGET.exec(state.value);
+                state.invalid = !match;
+                if (match) {
+                    state.open = false;
+                    host.go(Number(match[1]), Number(match[2] ?? 1));
+                }
+            });
+            return root_1a74cgn1;
+        }
+    };
+    return api;
+};
+export { goto };

package/build/components/editor/code/gutter.d.ts

@@ -0,0 +1,5 @@
+import * as template_u1 from '@esportsplus/template';
+import type { Reactive } from '@esportsplus/reactivity';
+import type { Slot } from './rows.js';
+declare const gutter: (slots: Reactive<Slot[]>, toggle: (slot: Slot) => void, peek: (slot: Slot) => void) => template_u1.ArraySlot<Slot>;
+export { gutter };

package/build/components/editor/code/gutter.js

@@ -0,0 +1,22 @@
+import * as template_u1 from '@esportsplus/template';
+import icon from '../../icon/index.js';
+import chevron from '@esportsplus/ui/svg/chevron-down.svg';
+const template_0sd455b1 = template_u1.template(`<div class='code-editor-number'><span class='code-editor-change'></span><span class='code-editor-number-text'></span><span class='code-editor-fold'>`);
+function keep(e) {
+    e.preventDefault();
+}
+const gutter = (slots, toggle, peek) => new template_u1.ArraySlot(slots, (slot) => {
+    let root_0sd455b0 = template_0sd455b1(), element_0sd455b2 = root_0sd455b0.firstChild, element_0sd455b3 = element_0sd455b2.firstElementChild, element_0sd455b4 = element_0sd455b3.nextElementSibling, element_0sd455b5 = element_0sd455b4.nextElementSibling;
+    new template_u1.EffectSlot(element_0sd455b4, () => slot.number, 1);
+    template_u1.slot(element_0sd455b5, icon({ class: 'code-editor-fold-icon' }, chevron), 1);
+    template_u1.setList(element_0sd455b5, 'class', [() => slot.fold === 0 && 'code-editor-fold--none', () => slot.fold === 2 && '--active']);
+    template_u1.delegate(element_0sd455b5, 'click', () => toggle(slot));
+    template_u1.delegate(element_0sd455b5, 'mousedown', keep);
+    template_u1.setList(element_0sd455b3, 'class', () => slot.change && `code-editor-change--${slot.change}`);
+    template_u1.delegate(element_0sd455b3, 'click', () => peek(slot));
+    template_u1.delegate(element_0sd455b3, 'mousedown', keep);
+    template_u1.setList(element_0sd455b2, 'class', [() => slot.active && '--active', () => slot.line < 0 && 'code-editor-number--unused']);
+    template_u1.setList(element_0sd455b2, 'style', () => `height: ${slot.height}px; top: ${slot.top}px;`);
+    return root_0sd455b0;
+});
+export { gutter };

package/build/components/editor/code/index.d.ts

@@ -0,0 +1,17 @@
+import editor from './editor.js';
+import '../../../css-utilities/scrollbar/scss/index.scss';
+import './scss/index.scss';
+export default editor;
+export { EditorDocument } from './document.js';
+export { COMMANDS as commands } from './keymap.js';
+export { fileUri, languageIdFor, referenceRpcTransport } from './services/index.js';
+export type { CodeEditorAttributes } from './editor.js';
+export type { Conflict, Resolution as ConflictResolution } from './conflicts.js';
+export type { Change, Edit, Selection, Snapshot, TransactionOptions, TransactionResult } from './document.js';
+export type { BracketPair, FoldRange } from './folding.js';
+export type { Command, CommandInfo } from './keymap.js';
+export type { LayoutLine, Rect } from './layout.js';
+export type { Match, SearchOptions, SearchResult } from './search.js';
+export type { CompletionItem, Diagnostic, Hover, LanguageServiceOptions, LanguageTransport, Notification, Position, Range, TextEdit } from './services/index.js';
+export type { Language, Token } from './syntax.js';
+export type { Callbacks, CodeController as Controller, Options, State as CodeEditorState } from './view.js';

package/build/components/editor/code/index.js

@@ -0,0 +1,7 @@
+import editor from './editor.js';
+import '../../../css-utilities/scrollbar/scss/index.scss';
+import './scss/index.scss';
+export default editor;
+export { EditorDocument } from './document.js';
+export { COMMANDS as commands } from './keymap.js';
+export { fileUri, languageIdFor, referenceRpcTransport } from './services/index.js';

package/build/components/editor/code/keymap.d.ts

@@ -0,0 +1,30 @@
+import { type Language, type SyntaxCache } from './syntax.js';
+import type { EditorDocument, Selection } from './document.js';
+import type { CodeController, Controller, Options } from './view.js';
+type Command = 'addCursorAbove' | 'addCursorBelow' | 'autocomplete' | 'blankLine' | 'blockComment' | 'copyLineDown' | 'copyLineUp' | 'deleteCharacterBackward' | 'deleteCharacterForward' | 'deleteLine' | 'deleteLineEnd' | 'deleteWordBackward' | 'deleteWordForward' | 'find' | 'findNext' | 'findPrevious' | 'fold' | 'foldAll' | 'goToLine' | 'indent' | 'jumpToBracket' | 'lineEnd' | 'lineStart' | 'moveDown' | 'moveLeft' | 'moveLineDown' | 'moveLineUp' | 'moveRight' | 'moveUp' | 'nextChange' | 'nextConflict' | 'nextOccurrence' | 'nextProblem' | 'outdent' | 'pageDown' | 'pageUp' | 'previousChange' | 'previousConflict' | 'previousProblem' | 'redo' | 'redoSelection' | 'reindent' | 'replace' | 'save' | 'selectAll' | 'selectAllOccurrences' | 'selectLine' | 'selectPair' | 'splitLine' | 'toggleComment' | 'toggleTabCapture' | 'transpose' | 'undo' | 'undoSelection' | 'unfold' | 'unfoldAll' | 'wordLeft' | 'wordRight';
+type CommandInfo = {
+    id: Command;
+    keys: readonly string[];
+    label: string;
+};
+type Host = {
+    cache: () => SyntaxCache;
+    capture: VoidFunction;
+    controller: CodeController | Controller;
+    deleteVisible: (backwards: boolean, word: boolean) => boolean;
+    document: EditorDocument;
+    edit: (run: () => boolean) => boolean;
+    language: () => Language;
+    move: (key: string, extend: boolean, word?: boolean, add?: boolean) => void;
+    navigate?: (kind: Navigation, backward: boolean) => void;
+    options: () => Options;
+    select: (selection: Partial<Selection>) => void;
+};
+type Navigation = 'change' | 'conflict' | 'problem';
+declare function chord(keys: string, apple: boolean): string | null;
+declare function combo(e: KeyboardEvent, apple: boolean): string;
+declare const keymap: (apple: boolean, overrides?: Readonly<Record<string, Command | null>>) => (e: KeyboardEvent) => Command | null;
+declare const COMMANDS: readonly CommandInfo[];
+declare const commands: (host: Host) => (command: Command, e: KeyboardEvent) => void;
+export { chord, combo, COMMANDS, commands, keymap };
+export type { Command, CommandInfo, Host, Navigation };