@adecore/editor 0.42.0 → 0.44.0

package/dist/controller.d.ts

@@ -1,5 +1,5 @@
 import type { Keymap } from './keymap-table.ts';
-import type { EditorClickHandler, EditorInlayClickHandler, EditorContextMenu, EditorKeyHandler, EditorRunCommand, EditorSelectionRanges, KeyChord } from './types.ts';
+import type { EditorClickHandler, EditorInlayClickHandler, EditorContextMenu, EditorCopy, EditorKeyHandler, EditorPasteOptions, EditorRunCommand, EditorSelectionRanges, KeyChord } from './types.ts';
 import type { EditorView } from './view.ts';
 export interface ControllerOptions {
     keymap?: Keymap;
@@ -10,12 +10,16 @@ export interface ControllerOptions {
     zoom(step: -1 | 0 | 1): void;
     wheelZooms(): boolean;
 }
+export declare function rememberCopy(text: string, wholeLines: boolean): void;
 export declare class InputController {
     private readonly native;
     private readonly pointer;
     private readonly touch;
     private readonly cleanup;
     private readonly keyHandlers;
+    private readonly navigateListeners;
+    private readonly copyListeners;
+    private wordSources;
     private readonly gesture;
     private readonly clickHandlers;
     private readonly inlayHandlers;
@@ -41,14 +45,17 @@ export declare class InputController {
     private applyEdits;
     private replaceSelections;
     private unfoldCarets;
-    private paste;
+    pasteText(text: string, options?: EditorPasteOptions): boolean;
+    onCopy(listener: (copy: EditorCopy) => void): () => void;
     private commandOptions;
+    setWordSources(source: (() => readonly string[]) | null): void;
     private viewCommand;
     private wheel;
     command(name: EditorRunCommand): boolean;
     setSelectionRanges(provider: EditorSelectionRanges | null): void;
     private expandThrough;
     private modelCommand;
+    onNavigate(listener: (from: number) => void): () => void;
     private typeText;
     private movePages;
     private toggleColumnMode;

package/dist/controller.js

@@ -16,9 +16,12 @@ const MODIFYING = new Set([
     'deleteLine',
     'moveLineUp',
     'moveLineDown',
+    'moveStatementUp',
+    'moveStatementDown',
     'toggleLineComment',
     'toggleBlockComment',
     'startNewLine',
+    'completeCurrentStatement',
     'startNewLineBefore',
     'splitLine',
     'joinLines',
@@ -34,8 +37,11 @@ const MODIFYING = new Set([
     'reverseLines',
     'uniqueLines',
     'convertIndentsToSpaces',
-    'convertIndentsToTabs'
+    'convertIndentsToTabs',
+    'hippieCompletion',
+    'hippieBackwardCompletion'
 ]);
+const CODE_BLOCK_COMMANDS = new Set(['codeBlockStart', 'codeBlockEnd', 'codeBlockStartWithSelection', 'codeBlockEndWithSelection']);
 const VIEW_COMMANDS = new Set([
     'collapseRegion',
     'expandRegion',
@@ -54,11 +60,23 @@ const VIEW_COMMANDS = new Set([
     'toggleColumnMode',
     'increaseFontSize',
     'decreaseFontSize',
-    'resetFontSize'
+    'resetFontSize',
+    'methodUp',
+    'methodDown',
+    'nextChange',
+    'previousChange',
+    'pasteAsPlainText'
 ]);
 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 = 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, wholeLines) {
+    lineClip = wholeLines ? text : null;
+}
 function selectionSignature(selections) {
     return selections.map((selection) => `${selection.anchor}:${selection.head}`).join(',');
 }
@@ -76,6 +94,9 @@ export class InputController {
     touch;
     cleanup = [];
     keyHandlers = new Set();
+    navigateListeners = new Set();
+    copyListeners = new Set();
+    wordSources = null;
     gesture;
     clickHandlers = new Set();
     inlayHandlers = new Set();
@@ -186,7 +207,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));
         this.listen(input, 'cut', (event) => this.copy(event, true));
@@ -245,6 +266,8 @@ export class InputController {
         }
         this.cleanup.length = 0;
         this.keyHandlers.clear();
+        this.navigateListeners.clear();
+        this.copyListeners.clear();
     }
     blockedByReadOnly() {
         return this.view.blockedByReadOnly();
@@ -278,15 +301,25 @@ export class InputController {
             this.view.ensureVisible(selection.head);
         }
     }
-    paste(text) {
+    /* Pastes as a paste from the clipboard does; false when a read-only editor refused. */
+    pasteText(text, options = {}) {
         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) {
+        return subscribe(this.copyListeners, listener);
     }
     commandOptions() {
         const { settings } = this.view;
@@ -300,14 +333,21 @@ 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) {
+        this.wordSources = source;
+    }
     /* Folding is the view's, since it knows where the ranges are. */
     viewCommand(name) {
         const { view } = this;
@@ -315,6 +355,25 @@ export class InputController {
             this.options.zoom(ZOOM_STEPS[name]);
             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;
         }
@@ -413,7 +472,10 @@ 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(),
             onLinesMoved: (moves) => this.view.refoldMoved(folded, moves)
@@ -424,9 +486,19 @@ export class InputController {
         if (name === 'smartEnd' || name === 'selectSmartEnd') {
             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) {
+        return subscribe(this.navigateListeners, listener);
+    }
     typeText(text) {
         if (this.blockedByReadOnly()) {
             return;
@@ -651,6 +723,7 @@ export class InputController {
         if (event.isComposing || this.native.composing) {
             return;
         }
+        this.view.setHippieSource(null);
         const added = this.gesture.keydown(event);
         if (added !== null) {
             event.preventDefault();
@@ -726,6 +799,7 @@ export class InputController {
             : selections.map((selection) => model.slice(Math.min(selection.anchor, selection.head), Math.max(selection.anchor, selection.head))).join('\n');
         event.clipboardData?.setData('text/plain', text);
         lineClip = empty ? text : null;
+        emit(this.copyListeners, { text, wholeLines: empty, cut });
         if (!cut || this.blockedByReadOnly()) {
             return;
         }

package/dist/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/dist/engine.js

@@ -1,5 +1,6 @@
 import { changedSpans, DocumentModel, replacementText } from '@adecore/editor-core';
 import { MAX_REPLACEMENT_CHARACTERS } from './search-protocol.js';
+import { placeAt, postfixOperands, surroundShape, unwrapTargets } from './text-queries.js';
 import { GrammarPreparation } from './grammar-preparation.js';
 import { InputController } from './controller.js';
 import { resolveSmartKeys } from './smart-keys.js';
@@ -35,6 +36,8 @@ class SmartEditor {
     lensRevisions = new Map();
     tokenizerRequest = 0;
     settingText = false;
+    /* The hints of each owner, in the order the owners first set theirs. */
+    inlayOwners = new Map();
     disposed = false;
     engine;
     constructor(engine, element, options) {
@@ -302,14 +305,21 @@ class SmartEditor {
             ...(marker.message === undefined ? {} : { message: marker.message })
         })));
     }
-    setInlayHints(hints) {
-        this.view.setInlays(hints.map((hint, index) => ({
+    setInlayHints(hints, owner = DEFAULT_WIDGET_OWNER) {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        }
+        else {
+            this.inlayOwners.set(owner, hints);
+        }
+        this.view.setInlays([...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 })
         })));
     }
     onInlayHover(listener) {
@@ -681,6 +691,24 @@ class SmartEditor {
     setFoldHints(hints) {
         this.view.setFoldHints(hints === null ? null : this.foldHintsByOffset(hints));
     }
+    setDeclarations(positions) {
+        this.view.setDeclarations(positions === null ? null : positions.map((position) => this.offsetAt(position)));
+    }
+    onNavigate(listener) {
+        return this.controller.onNavigate((from) => listener(this.positionAt(from)));
+    }
+    hasFocus() {
+        return this.view.focused;
+    }
+    setWordSources(source) {
+        this.controller.setWordSources(source);
+    }
+    onCopy(listener) {
+        return this.controller.onCopy(listener);
+    }
+    paste(text, options) {
+        return this.controller.pasteText(text, options);
+    }
     foldHintsByOffset(hints) {
         const lineOf = (line) => this.model.getLine(Math.min(line, this.model.getLineCount() - 1));
         const within = (line, character) => Math.min(line.end, line.start + Math.max(0, character));
@@ -757,6 +785,19 @@ class SmartEditor {
     isReadOnly() {
         return this.settings.readOnly;
     }
+    placeAt(position) {
+        return placeAt(this.model, this, position, this.settings.language ?? 'plaintext');
+    }
+    postfixOperands(dot) {
+        return postfixOperands(this.model, this, dot, this.settings.language ?? 'plaintext');
+    }
+    surroundShape(range) {
+        return surroundShape(this.model, this, range, this.settings.language ?? 'plaintext');
+    }
+    unwrapTargets(position) {
+        const unit = this.settings.insertSpaces ? ' '.repeat(this.settings.tabSize) : '\t';
+        return unwrapTargets(this.model, this, position, this.settings.language ?? 'plaintext', unit);
+    }
     runCommand(command) {
         return this.controller.command(command);
     }

package/dist/fake.d.ts

@@ -1,4 +1,4 @@
-import type { Editor, EditorAttributionHover, EditorAttributionMark, EditorBlock, EditorCodeBlockOptions, EditorLineAction, EditorReplacement, EditorLineHighlight, LineToken, EditorChangeMark, EditorCodeVision, EditorClick, EditorClickHandler, EditorContextMenu, EditorContentChange, EditorEngine, EditorFindQuery, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorHighlight, EditorHover, EditorIndentation, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorInputPopup, EditorMarker, EditorMessages, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorReveal, EditorRect, EditorRunCommand, EditorSelectionRanges, EditorFoldHints, EditorFoldOutline, EditorFolds, EditorSemanticToken, EditorSmartKeys, EditorApplyEditsOptions, EditorTextChange, EditorTrackedRange, EditorTheme, EditorWhitespaceCleanup, EditorWidget } from './types.ts';
+import type { Editor, EditorAttributionHover, EditorAttributionMark, EditorBlock, EditorCodeBlockOptions, EditorLineAction, EditorReplacement, EditorLineHighlight, LineToken, EditorChangeMark, EditorCodeVision, EditorClick, EditorClickHandler, EditorContextMenu, EditorContentChange, EditorEngine, EditorFindQuery, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorHighlight, EditorHover, EditorIndentation, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorInputPopup, EditorMarker, EditorMessages, EditorOptions, EditorPosition, EditorPostfixOperand, EditorSurroundShape, EditorTextPlace, EditorUnwrapTarget, EditorRemoteCursor, EditorRange, EditorReveal, EditorRect, EditorRunCommand, EditorSelectionRanges, EditorFoldHints, EditorFoldOutline, EditorFolds, EditorSemanticToken, EditorSmartKeys, EditorApplyEditsOptions, EditorCopy, EditorPasteOptions, EditorTextChange, EditorTrackedRange, EditorTheme, EditorWhitespaceCleanup, EditorWidget } from './types.ts';
 import { type Listener } from './listeners.ts';
 export declare class FakeEditor implements Editor {
     readonly element: HTMLElement;
@@ -142,6 +142,22 @@ export declare class FakeEditor implements Editor {
     todoWords: readonly string[] | undefined;
     setTodoWords(words: readonly string[]): void;
     setFoldHints(hints: EditorFoldHints | null): void;
+    declarations: readonly EditorPosition[] | null;
+    setDeclarations(positions: readonly EditorPosition[] | null): void;
+    private readonly navigations;
+    onNavigate(listener: (from: EditorPosition) => void): () => void;
+    navigate(from: EditorPosition): void;
+    hasFocus(): boolean;
+    private readonly copies;
+    onCopy(listener: (copy: EditorCopy) => void): () => void;
+    copy(text: string, wholeLines?: boolean, cut?: boolean): void;
+    readonly pastes: Array<{
+        text: string;
+        options: EditorPasteOptions | undefined;
+    }>;
+    paste(text: string, options?: EditorPasteOptions): boolean;
+    wordSources: (() => readonly string[]) | null;
+    setWordSources(source: (() => readonly string[]) | null): void;
     setSmartKeys(keys: Partial<EditorSmartKeys>): void;
     setIndentation(indentation: EditorIndentation): void;
     markers: readonly EditorMarker[];
@@ -161,7 +177,8 @@ export declare class FakeEditor implements Editor {
     private readonly keys;
     setMarkers(markers: readonly EditorMarker[]): void;
     inlayHints: readonly EditorInlayHint[];
-    setInlayHints(hints: readonly EditorInlayHint[]): void;
+    private readonly inlayOwners;
+    setInlayHints(hints: readonly EditorInlayHint[], owner?: string): void;
     private readonly inlayHovers;
     private readonly inlayHandlers;
     inlayLink: {
@@ -240,6 +257,10 @@ export declare class FakeEditor implements Editor {
     zoomTo(size: number | null): void;
     setReadOnly(readOnly: boolean, reason?: string): void;
     isReadOnly(): boolean;
+    placeAt(position: EditorPosition): EditorTextPlace;
+    postfixOperands(dot: EditorPosition): readonly EditorPostfixOperand[];
+    surroundShape(range: EditorRange): EditorSurroundShape | null;
+    unwrapTargets(position: EditorPosition): readonly EditorUnwrapTarget[];
     readonly commands: EditorRunCommand[];
     runCommand(command: EditorRunCommand): boolean;
     focus(): void;

package/dist/fake.js

@@ -1,5 +1,6 @@
 import { emit, subscribe } from './listeners.js';
-import { changedSpan, changedSpans } from '@adecore/editor-core';
+import { changedSpan, changedSpans, DocumentModel } from '@adecore/editor-core';
+import { placeAt, postfixOperands, surroundShape, unwrapTargets } from './text-queries.js';
 import { mapTrackedRange } from './tracked-range.js';
 const LINE_BREAK = /\r\n|\r|\n/g;
 /* Where each line starts and where its text ends, before its line break: `\r\n`, a lone `\r` or `\n`, as the real document counts them. */
@@ -581,6 +582,59 @@ export class FakeEditor {
     setFoldHints(hints) {
         this.foldHints = hints;
     }
+    declarations = null;
+    setDeclarations(positions) {
+        this.declarations = positions;
+    }
+    navigations = new Set();
+    onNavigate(listener) {
+        return subscribe(this.navigations, listener);
+    }
+    /* Stands for a command that navigated: tells the listeners the caret left `from`. */
+    navigate(from) {
+        emit(this.navigations, from);
+    }
+    hasFocus() {
+        return this.focused;
+    }
+    copies = new Set();
+    onCopy(listener) {
+        return subscribe(this.copies, listener);
+    }
+    /* Stands for a copy or cut of a person: tells the listeners what went on the clipboard. */
+    copy(text, wholeLines = false, cut = false) {
+        emit(this.copies, { text, wholeLines, cut });
+    }
+    /* Every paste a host asked for, with its options. */
+    pastes = [];
+    /* 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, options) {
+        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 = null;
+    setWordSources(source) {
+        this.wordSources = source;
+    }
     setSmartKeys(keys) {
         this.smartKeys = keys;
     }
@@ -601,10 +655,17 @@ export class FakeEditor {
     setMarkers(markers) {
         this.markers = markers;
     }
-    /* What the host drew as hints last. */
+    /* What the host drew as hints last, every owner's together. */
     inlayHints = [];
-    setInlayHints(hints) {
-        this.inlayHints = hints;
+    inlayOwners = new Map();
+    setInlayHints(hints, owner = 'default') {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        }
+        else {
+            this.inlayOwners.set(owner, hints);
+        }
+        this.inlayHints = [...this.inlayOwners.values()].flat();
     }
     inlayHovers = new Set();
     inlayHandlers = new Set();
@@ -858,6 +919,19 @@ export class FakeEditor {
     isReadOnly() {
         return this.readOnly;
     }
+    placeAt(position) {
+        return placeAt(new DocumentModel(this.text), this, position, this.language ?? 'plaintext');
+    }
+    postfixOperands(dot) {
+        return postfixOperands(new DocumentModel(this.text), this, dot, this.language ?? 'plaintext');
+    }
+    surroundShape(range) {
+        return surroundShape(new DocumentModel(this.text), this, range, this.language ?? 'plaintext');
+    }
+    unwrapTargets(position) {
+        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. */
     commands = [];
     runCommand(command) {
@@ -872,6 +946,8 @@ export class FakeEditor {
         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/dist/index.d.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';
-export type { Editor, EditorAttributionHover, EditorAttributionMark, EditorMarkColor, EditorBlock, EditorChangeKind, EditorChangeMark, EditorCodeVision, EditorCodeVisionEntry, EditorClick, EditorCodeBlockOptions, EditorClickHandler, EditorCommand, EditorContextMenu, EditorEngine, EditorFindQuery, EditorFoldHints, EditorFoldRangeHint, EditorFoldOutline, EditorFoldRange, EditorFoldSymbol, EditorFolds, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterIcon, EditorGutterMarker, EditorReplacement, EditorIndentation, EditorContentChange, EditorHighlight, EditorHighlightKind, EditorHover, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorLineAction, EditorLineHighlight, EditorMarker, EditorInputPopup, EditorMessages, EditorMarkerSeverity, EditorReveal, EditorRect, EditorSmartKeys, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorApplyEditsOptions, EditorTextChange, EditorTrackedRange, EditorRunCommand, EditorSelectionRanges, EditorTheme, EditorViewCommand, EditorWhitespaceCleanup, EditorWidget, EditorZoom, FoldRole, KeyChord, LineToken, LineTokenKind, ScopeColorSource, ScopeColors, ScopeStyle, EditorSemanticToken, LineTokenizer, SmartEditorEngineOptions, TokenizedLine, TokenizerSource } from './types.ts';
+export type { Editor, EditorAttributionHover, EditorAttributionMark, EditorMarkColor, EditorBlock, EditorChangeKind, EditorChangeMark, EditorCodeVision, EditorCodeVisionEntry, EditorClick, EditorCodeBlockOptions, EditorClickHandler, EditorCommand, EditorContextMenu, EditorEngine, EditorFindQuery, EditorFoldHints, EditorFoldRangeHint, EditorFoldOutline, EditorFoldRange, EditorFoldSymbol, EditorFolds, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterIcon, EditorGutterMarker, EditorReplacement, EditorIndentation, EditorContentChange, EditorHighlight, EditorHighlightKind, EditorHover, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorLineAction, EditorLineHighlight, EditorMarker, EditorInputPopup, EditorMessages, EditorMarkerSeverity, EditorReveal, EditorRect, EditorSmartKeys, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorApplyEditsOptions, EditorCopy, EditorPasteOptions, EditorPostfixOperand, EditorSurroundShape, EditorTextPlace, EditorUnwrapTarget, EditorTextChange, EditorTrackedRange, EditorRunCommand, EditorSelectionRanges, EditorTheme, EditorViewCommand, EditorWhitespaceCleanup, EditorWidget, EditorZoom, FoldRole, KeyChord, LineToken, LineTokenKind, ScopeColorSource, ScopeColors, ScopeStyle, EditorSemanticToken, LineTokenizer, SmartEditorEngineOptions, TokenizedLine, TokenizerSource } from './types.ts';

package/dist/index.js

@@ -3,6 +3,8 @@ export { AGENT_COLORS } from './attribution.js';
 export { findDocComments, MAX_DOC_COMMENTS } from '@adecore/editor-core';
 export { DEFAULT_TODO_WORDS, findTodos } from '@adecore/editor-core';
 export { detectIndentation } from '@adecore/editor-core';
+export { commentSyntax } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.js';
+export { rememberCopy } from './controller.js';
 export { DEFAULT_SMART_KEYS } from './smart-keys.js';
 export { shikiScopeColors, shikiTokenizers } from './shiki.js';

package/dist/keymap-table.d.ts

@@ -18,10 +18,15 @@ export declare const KEYMAP: {
     readonly deleteLine: KeyBinding;
     readonly moveLineUp: KeyBinding;
     readonly moveLineDown: KeyBinding;
+    readonly moveStatementUp: KeyBinding;
+    readonly moveStatementDown: KeyBinding;
     readonly toggleLineComment: KeyBinding;
     readonly toggleBlockComment: KeyBinding;
     readonly joinLines: KeyBinding;
     readonly startNewLine: KeyBinding;
+    readonly completeCurrentStatement: KeyBinding;
+    readonly hippieCompletion: KeyBinding;
+    readonly hippieBackwardCompletion: KeyBinding;
     readonly startNewLineBefore: KeyBinding;
     readonly splitLine: KeyBinding;
     readonly toggleCase: KeyBinding;
@@ -34,6 +39,18 @@ export declare const KEYMAP: {
     readonly expandSelection: KeyBinding;
     readonly shrinkSelection: KeyBinding;
     readonly matchBrace: KeyBinding;
+    readonly methodUp: KeyBinding;
+    readonly methodDown: KeyBinding;
+    readonly lastEditLocation: KeyBinding;
+    readonly nextEditLocation: KeyBinding;
+    readonly pasteFromHistory: KeyBinding;
+    readonly pasteAsPlainText: KeyBinding;
+    readonly nextChange: KeyBinding;
+    readonly previousChange: KeyBinding;
+    readonly codeBlockStart: KeyBinding;
+    readonly codeBlockEnd: KeyBinding;
+    readonly codeBlockStartWithSelection: KeyBinding;
+    readonly codeBlockEndWithSelection: KeyBinding;
     readonly selectNextOccurrence: KeyBinding;
     readonly unselectOccurrence: KeyBinding;
     readonly selectAllOccurrences: KeyBinding;
@@ -80,6 +97,12 @@ export declare const KEYMAP: {
     readonly renameSymbol: KeyBinding;
     readonly organizeImports: KeyBinding;
     readonly formatDocument: KeyBinding;
+    readonly insertLiveTemplate: KeyBinding;
+    readonly surroundWith: KeyBinding;
+    readonly surroundWithLiveTemplate: KeyBinding;
+    readonly unwrap: KeyBinding;
+    readonly saveAsLiveTemplate: KeyBinding;
+    readonly wrapWithAbbreviation: KeyBinding;
     readonly selectionToChat: KeyBinding;
     readonly inlineEdit: KeyBinding;
     readonly suggestInline: KeyBinding;
@@ -91,6 +114,7 @@ export declare const KEYMAP: {
     readonly peekDefinition: KeyBinding;
     readonly peekReferences: KeyBinding;
     readonly callHierarchy: KeyBinding;
+    readonly typeHierarchy: KeyBinding;
     readonly toggleRenderedDocs: KeyBinding;
     readonly historyBack: KeyBinding;
     readonly historyForward: KeyBinding;
@@ -104,7 +128,7 @@ export declare const KEYMAP: {
     readonly replace: KeyBinding;
 };
 export type KeymapId = keyof typeof KEYMAP;
-export type OptionalKeymapId = 'toggleRenderedDocs' | 'increaseFontSize' | 'decreaseFontSize' | 'resetFontSize' | 'sortLines' | 'reverseLines' | 'uniqueLines' | 'convertIndentsToSpaces' | 'convertIndentsToTabs';
+export type OptionalKeymapId = 'toggleRenderedDocs' | 'increaseFontSize' | 'decreaseFontSize' | 'resetFontSize' | 'sortLines' | 'reverseLines' | 'uniqueLines' | 'convertIndentsToSpaces' | '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>>>;
 export declare const KEYMAP_IDS: KeymapId[];