@adecore/editor-core 0.17.0-beta.2 → 0.17.0

package/dist/document.d.ts

@@ -37,6 +37,7 @@ export declare class DocumentModel {
     private selectionHistory;
     private typingContexts;
     private statementClosers;
+    private arrows;
     private cloneSession;
     private occurrenceSession;
     occurrencesExhausted: boolean;
@@ -67,6 +68,8 @@ export declare class DocumentModel {
     replaceAll(query: string, replacement: string, options?: ReplaceAllOptions): number;
     getFoldingRanges(options?: FoldingOptions): FoldingRange[];
     typeText(text: string, options?: TypeTextOptions): boolean;
+    private takeBackArrows;
+    private completeArrows;
     paste(text: string, options?: CommandOptions & {
         wholeLines?: boolean;
     }): boolean;
@@ -78,6 +81,7 @@ export declare class DocumentModel {
     private shouldClosePair;
     private completesTripleQuote;
     private hasMatch;
+    private endsOperand;
     private rememberStatementClosers;
     private rememberPairs;
     private insertTab;
@@ -108,6 +112,7 @@ export declare class DocumentModel {
     private editSource;
     private bracketIndex;
     private deleteCharacter;
+    private unindent;
     private isEmptyPair;
     private backspaceStart;
     private deleteRanges;

package/dist/document.js

@@ -1,7 +1,7 @@
 import { CloserTracker } from './closer-tracker.js';
 import { planBlockComment, planLineComments } from './comments.js';
 import { planEnter } from './enter.js';
-import { planAutoIndent, planJoinLines, planToggleCase } from './line-commands.js';
+import { planAutoIndent, planJoinLines, planToggleCase, properIndent, spacingBetween } from './line-commands.js';
 import { mapOffset } from './offsets.js';
 import { planPaste } from './paste.js';
 import { isPlainText, vueRegionAt } from './languages.js';
@@ -10,7 +10,7 @@ import { applyFoldHints, markFileHeader } from './fold-roles.js';
 import { lexicalFolds } from './lexical-folds.js';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.js';
 import { scanBrackets } from './brackets.js';
-import { hasSmartSemicolon } from './lexical.js';
+import { hasSmartSemicolon, isPhp } from './lexical.js';
 import { clampInteger, TextRope } from './rope.js';
 import { findMatches, replacementText, splitsSurrogate } from './search.js';
 import { dedupeFoldingRanges, deriveFoldingRanges, indentationColumn, scanStructure, tabWidth } from './structure.js';
@@ -27,6 +27,8 @@ const bracketScanLimit = 2_000_000;
 const matchScanLimit = 400_000;
 const pairs = { '(': ')', '[': ']', '{': '}', '"': '"', "'": "'", '`': '`' };
 const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
+/* What can follow `->`: the first letter of a member name, or the `{` of a dynamic one. */
+const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
 const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 function rangeOf(selection) {
@@ -223,6 +225,8 @@ export class DocumentModel {
     selectionHistory = [];
     typingContexts = new TypingContexts((line) => this.getLine(line));
     statementClosers = new Map();
+    /* The carets that stand right after a `->` the editor completed, where the next keystroke decides whether it stays. */
+    arrows = new Set();
     cloneSession;
     occurrenceSession;
     /* The last select next occurrence found no more, which a host may say. */
@@ -291,6 +295,7 @@ export class DocumentModel {
         this.cloneSession = undefined;
         this.selectionHistory = [];
         this.statementClosers.clear();
+        this.arrows.clear();
         if (sameSelections(this.selections, normalized)) {
             return;
         }
@@ -459,8 +464,8 @@ export class DocumentModel {
     /*
      * Types `text` at every caret as one keystroke would: it wraps a selection in a bracket or quote,
      * closes an opener, types over a closer that is already there and, in TypeScript, JavaScript and
-     * PHP, moves a `;` to the end of a statement. Comments and string contents are left alone.
-     * Returns whether anything changed, a swallowed closer included.
+     * PHP, moves a `;` to the end of a statement. In PHP a `-` after a variable becomes `->`. Comments
+     * and string contents are left alone. Returns whether anything changed, a swallowed closer included.
      */
     typeText(text, options = {}) {
         if (options.expectedRevision !== undefined && options.expectedRevision !== this.revision) {
@@ -469,6 +474,11 @@ export class DocumentModel {
         if (!text) {
             return false;
         }
+        const arrows = this.arrows;
+        this.arrows = new Set();
+        if (arrows.size > 0 && text !== '>' && !arrowContinues.test(text)) {
+            this.takeBackArrows();
+        }
         const language = options.language ?? 'typescript';
         const single = text.length === 1;
         const pairing = options.autoClosingPairs !== false && single && !isPlainText(language);
@@ -479,6 +489,8 @@ export class DocumentModel {
             quotes: pairing && options.autoClosingQuotes !== false,
             surround: options.surroundSelection !== false && single,
             smartSemicolon: options.smartSemicolon !== false && hasSmartSemicolon(language),
+            smartArrow: options.smartArrow !== false && single && isPhp(language),
+            overArrows: text === '>' ? arrows : new Set(),
             dedent: options.smartEnter !== false
         };
         const plans = this.selections.map((selection) => this.planTyping(selection, input));
@@ -490,9 +502,31 @@ export class DocumentModel {
         if (this.revision === appliedRevision) {
             this.rememberStatementClosers(plans, transaction, language);
             this.rememberPairs(plans, transaction);
+            this.completeArrows(plans, transaction);
         }
         return changed || plans.some((plan) => plan.consumed);
     }
+    /*
+     * A key after a `->` the editor completed that cannot follow it means the `-` was a minus. The `>` is the
+     * last undo step, so it goes without a redo, and the key joins the typing of the `-`.
+     */
+    takeBackArrows() {
+        this.undo();
+        this.redoStack.pop();
+        this.groupOpen = true;
+    }
+    /* Adds the `>` after every `-` that became an arrow, as its own undo step, so the first undo leaves the `-` that was typed. */
+    completeArrows(plans, transaction) {
+        const at = transaction.selections.flatMap((selection, index) => (plans[index]?.arrow ? [selection.head] : [])).sort((left, right) => left - right);
+        if (at.length === 0) {
+            return;
+        }
+        const moved = (offset) => offset + at.filter((inserted) => inserted <= offset).length;
+        const selections = this.selections.map((selection) => ({ anchor: moved(selection.anchor), head: moved(selection.head) }));
+        if (this.applyEdits(at.map((offset) => ({ from: offset, to: offset, text: '>' })), { source: 'input', selections })) {
+            this.arrows = new Set(at.map(moved));
+        }
+    }
     /*
      * Pastes `text` at every selection. With as many lines as carets each caret takes one; `wholeLines`
      * marks text copied from a bare caret, which goes above the lines of bare carets.
@@ -549,11 +583,11 @@ export class DocumentModel {
         }
         const tabSize = tabWidth(options);
         const language = options.language ?? 'typescript';
+        const unit = options.insertSpaces === false ? '\t' : ' '.repeat(tabSize);
         if (command === 'smartBackspace' || command === 'deleteForward') {
             const pairing = options.autoClosingPairs !== false && !isPlainText(language);
-            return this.deleteCharacter(command === 'smartBackspace', tabSize, { brackets: pairing && options.autoClosingBrackets !== false, quotes: pairing && options.autoClosingQuotes !== false }, language);
+            return this.deleteCharacter(command === 'smartBackspace', { tabSize, unit }, { brackets: pairing && options.autoClosingBrackets !== false, quotes: pairing && options.autoClosingQuotes !== false }, language);
         }
-        const unit = options.insertSpaces === false ? '\t' : ' '.repeat(tabSize);
         const enter = { language, unit, tabSize, smart: options.smartEnter !== false, reach: true };
         if (command === 'insertNewline' || command === 'startNewLine' || command === 'splitLine') {
             return this.insertNewline(enter, command === 'insertNewline' ? 'enter' : command === 'startNewLine' ? 'below' : 'split');
@@ -615,12 +649,19 @@ export class DocumentModel {
         const after = this.rope.charAt(to);
         const quote = isQuote(text);
         const pairing = quote ? input.quotes : input.brackets;
+        if (text === '>' && from === to && input.overArrows.has(from)) {
+            return { from, to, text: '', anchor: 0, head: 0, skip: true, consumed: true };
+        }
         const pendingClosers = this.statementClosers.get(from);
         if (input.brackets && smartSemicolon && from === to && pendingClosers?.language === language && pendingClosers.text.startsWith(text)) {
             return { from, to, text: '', anchor: 0, head: 0, skip: true, consumed: true, completedClosers: pendingClosers.text.slice(1) };
         }
-        const needsContext = text.length === 1 && (/[()[\]{}'"`<]/.test(text) || (text === ';' && smartSemicolon));
+        const arrow = text === '-' && input.smartArrow && from === to;
+        const needsContext = text.length === 1 && (/[()[\]{}'"`<]/.test(text) || (text === ';' && smartSemicolon) || arrow);
         const context = needsContext ? this.typingContext(from, language) : undefined;
+        if (arrow && context?.mode === 'code' && context.word !== 'control-close' && this.endsOperand(from)) {
+            return { from, to, text, anchor: 1, head: 1, arrow: true };
+        }
         const insideQuote = context && (context.mode === 'quote' || context.mode === 'template') && context.quote === text && !context.escaped;
         if (pairing && from === to && after === text && (quote ? insideQuote : context?.mode === 'code' && context.bracket?.close === text)) {
             return { from, to, text: '', anchor: 1, head: 1, skip: true };
@@ -723,6 +764,23 @@ export class DocumentModel {
         const scanned = scanBrackets(text.slice(0, offset) + opener + text.slice(offset), language);
         return scanned.pairs.has(offset);
     }
+    /*
+     * Whether the text before `offset` ends in something a member is read from: a variable, the name of a
+     * property or method after `->` or `?->`, or a `)` or `]`.
+     */
+    endsOperand(offset) {
+        const line = this.rope.lineBounds(this.rope.lineAt(offset));
+        const before = this.slice(line.start, offset);
+        if (/[)\]]$/.test(before)) {
+            return true;
+        }
+        const name = /[\p{L}_][\p{L}\p{N}_]*$/u.exec(before);
+        if (name === null) {
+            return false;
+        }
+        const ahead = before.slice(0, name.index);
+        return ahead.endsWith('$') || ahead.endsWith('->');
+    }
     /* Remembers the closers a smart semicolon stepped over for the caret that did it, so typing them again is absorbed. */
     rememberStatementClosers(plans, transaction, language) {
         for (const [index, selection] of transaction.selections.entries()) {
@@ -1275,24 +1333,60 @@ export class DocumentModel {
         this.bracketCache = { revision: this.revision, language, index };
         return index;
     }
-    deleteCharacter(backwards, tabSize, pairing, language) {
+    deleteCharacter(backwards, indent, pairing, language) {
         return this.deleteRanges(this.selections.map((selection) => {
             let { from, to } = rangeOf(selection);
             if (from === to) {
                 if (!backwards) {
                     to = deletionStep(this.rope, to, 1);
                 }
+                else if (this.arrows.has(from)) {
+                    from -= 2;
+                }
                 else if ((isQuote(this.rope.charAt(from - 1)) ? pairing.quotes : pairing.brackets) && this.isEmptyPair(from, language)) {
                     from--;
                     to++;
                 }
                 else {
-                    from = this.backspaceStart(from, tabSize);
+                    return this.unindent(from, indent, language) ?? { from: this.backspaceStart(from, indent.tabSize), to, text: '' };
                 }
             }
             return { from, to, text: '' };
         }));
     }
+    /*
+     * Backspace with only whitespace before the caret, after the platform's smart backspace: a line indented past
+     * where its brackets put it goes back to there, and one at or before it joins the line above, or takes the place
+     * of that line when it is blank. Null where the brackets say nothing.
+     */
+    unindent(offset, indent, language) {
+        const index = this.rope.lineAt(offset);
+        const line = this.rope.lineBounds(index);
+        if (!/^[\t ]*$/.test(this.slice(line.start, offset))) {
+            return null;
+        }
+        const proper = properIndent(this.editSource(language), index, { language, unit: indent.unit });
+        if (proper === null) {
+            return null;
+        }
+        let end = offset;
+        while (end < line.end && /[\t ]/.test(this.rope.charAt(end))) {
+            end++;
+        }
+        if (indentationColumn(this.slice(line.start, end), indent.tabSize) > indentationColumn(proper, indent.tabSize)) {
+            return { from: line.start, to: end, text: proper };
+        }
+        if (index === 0) {
+            return { from: 0, to: end, text: '' };
+        }
+        const previous = this.getLine(index - 1);
+        const start = previous.end - trailingBlankLength(previous.text);
+        if (start !== previous.start || start === 0) {
+            const before = this.slice(previous.start, start);
+            return { from: start, to: end, text: before === '' ? '' : spacingBetween(before, this.slice(end, line.end).trimEnd()) };
+        }
+        return { from: start, to: end, text: proper };
+    }
     /* Whether the caret sits between an opener and its own closer, which backspace removes together. */
     isEmptyPair(offset, language) {
         const opener = this.rope.charAt(offset - 1);
@@ -1699,6 +1793,7 @@ export class DocumentModel {
         this.structureCache = undefined;
         this.selectionHistory = [];
         this.statementClosers.clear();
+        this.arrows.clear();
     }
     restore(state, changes) {
         const previous = this.rope;

package/dist/fold-roles.js

@@ -100,6 +100,12 @@ export function applyFoldHints(ranges, hints, lineAt, getLine, slice, minimum) {
     for (const hint of hints.ranges ?? []) {
         const startLine = lineAt(hint.from);
         const endLine = lineAt(hint.to);
+        const same = result.find((range) => range.startLine === startLine && range.endLine === endLine);
+        // The text's own fold of the same lines keeps its kind and role, and takes where the server hides from and shows again from.
+        if (same !== undefined) {
+            Object.assign(same, edgesOf(hint));
+            continue;
+        }
         if (endLine - startLine < minimum || starts.has(startLine)) {
             continue;
         }
@@ -113,11 +119,15 @@ export function applyFoldHints(ranges, hints, lineAt, getLine, slice, minimum) {
             from: first.start + indent,
             to: getLine(endLine).end,
             kind: 'server',
-            ...(role === undefined ? {} : { role })
+            ...(role === undefined ? {} : { role }),
+            ...edgesOf(hint)
         });
     }
     return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
+function edgesOf(hint) {
+    return { ...(hint.head === undefined ? {} : { head: hint.head }), ...(hint.tail === undefined ? {} : { tail: hint.tail }) };
+}
 /* The fold that is the body of a symbol, and what kind of body it is. */
 function bodyOf(ranges, symbol, startLine, endLine, slice) {
     const brace = ranges

package/dist/line-commands.d.ts

@@ -4,6 +4,8 @@ export interface LineCommandOptions {
     language: string;
     unit: string;
 }
+export declare function spacingBetween(previous: string, next: string): string;
 export declare function planJoinLines(source: EditSource, selections: readonly Selection[], options: LineCommandOptions): EditPlan | null;
 export declare function planToggleCase(source: EditSource, selections: readonly Selection[]): EditPlan | null;
 export declare function planAutoIndent(source: EditSource, lines: readonly number[], options: LineCommandOptions): EditPlan | null;
+export declare function properIndent(source: EditSource, line: number, options: LineCommandOptions): string | null;

package/dist/line-commands.js

@@ -27,7 +27,7 @@ function skipWhitespace(source, from) {
     return offset;
 }
 /* What goes where two lines meet: nothing before a closer, a comma or a dot and after an opener, else a space. */
-function spacingBetween(previous, next) {
+export function spacingBetween(previous, next) {
     if (next === '' || /^[)\],;]/.test(next) || /^\.(?![.\d])/.test(next) || /[([]$/.test(previous)) {
         return '';
     }
@@ -236,6 +236,14 @@ export function planAutoIndent(source, lines, options) {
     }
     return edits.length === 0 ? null : { edits, selections: [] };
 }
+/* The indentation the brackets give a line, or null where they say nothing: outside code, in markup and in a language that is not bracketed. */
+export function properIndent(source, line, options) {
+    const context = source.context(source.line(line).start);
+    if (!indentsByBrackets(options.language) || context.mode !== 'code' || markupGuard(source, options.language)(line)) {
+        return null;
+    }
+    return targetIndent(source, options, line, context, (index) => whitespaceOf(source.line(index).text));
+}
 function targetIndent(source, options, line, context, indentOf) {
     const text = source.line(line).text.trimStart();
     const open = frames(context);

package/dist/structure.d.ts

@@ -14,6 +14,8 @@ export interface FoldingRange {
     to: number;
     kind: 'bracket' | 'comment' | 'indentation' | 'imports' | 'line-comments' | 'region' | 'block' | 'section' | 'server';
     role?: FoldRole;
+    head?: number;
+    tail?: number;
 }
 export interface FoldingOptions {
     brackets?: boolean;
@@ -36,6 +38,8 @@ export interface FoldRangeHint {
     from: number;
     to: number;
     kind?: string;
+    head?: number;
+    tail?: number;
 }
 export interface FoldHints {
     symbols?: readonly FoldSymbolHint[];

package/dist/types.d.ts

@@ -52,6 +52,7 @@ export interface CommandOptions {
     surroundSelection?: boolean;
     language?: string;
     smartSemicolon?: boolean;
+    smartArrow?: boolean;
     tabOutOfClosers?: boolean;
     smartEnter?: boolean;
     indentOnPaste?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.17.0-beta.2",
+  "version": "0.17.0",
   "type": "module",
   "exports": {
     ".": {

package/src/document.ts

@@ -1,7 +1,7 @@
 import { CloserTracker } from './closer-tracker.ts';
 import { planBlockComment, planLineComments } from './comments.ts';
 import { planEnter } from './enter.ts';
-import { planAutoIndent, planJoinLines, planToggleCase } from './line-commands.ts';
+import { planAutoIndent, planJoinLines, planToggleCase, properIndent, spacingBetween } from './line-commands.ts';
 import { mapOffset } from './offsets.ts';
 import { planPaste } from './paste.ts';
 import type { EnterOptions, EnterPlan } from './enter.ts';
@@ -13,7 +13,7 @@ import { lexicalFolds } from './lexical-folds.ts';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.ts';
 import { scanBrackets } from './brackets.ts';
 import type { BracketIndex } from './brackets.ts';
-import { hasSmartSemicolon } from './lexical.ts';
+import { hasSmartSemicolon, isPhp } from './lexical.ts';
 import { clampInteger, TextRope } from './rope.ts';
 import type { DocumentLine } from './rope.ts';
 import { findMatches, replacementText, splitsSurrogate } from './search.ts';
@@ -88,6 +88,8 @@ interface SelectionEdit extends TextEdit {
     consumed?: boolean;
     /* An opener and the closer the editor added with it, with the caret between them. */
     paired?: boolean;
+    /* A `-` the editor completes to `->` in a step of its own, once the `-` is in. */
+    arrow?: boolean;
 }
 
 interface SelectionTransaction {
@@ -108,6 +110,9 @@ interface TypingInput {
     quotes: boolean;
     surround: boolean;
     smartSemicolon: boolean;
+    smartArrow: boolean;
+    /* The carets right after a `->` the editor completed, where a typed `>` goes over the one that is there. */
+    overArrows: ReadonlySet<number>;
     /* A closing bracket typed on a line of its own goes back to the indentation of its opener. */
     dedent: boolean;
 }
@@ -144,6 +149,8 @@ const bracketScanLimit = 2_000_000;
 const matchScanLimit = 400_000;
 const pairs: Readonly<Record<string, string>> = { '(': ')', '[': ']', '{': '}', '"': '"', "'": "'", '`': '`' };
 const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
+/* What can follow `->`: the first letter of a member name, or the `{` of a dynamic one. */
+const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
 const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
@@ -362,6 +369,8 @@ export class DocumentModel {
     private selectionHistory: Selection[][] = [];
     private typingContexts = new TypingContexts((line) => this.getLine(line));
     private statementClosers = new Map<number, { text: string; language: string }>();
+    /* The carets that stand right after a `->` the editor completed, where the next keystroke decides whether it stays. */
+    private arrows = new Set<number>();
     private cloneSession: { signature: string; frames: { direction: -1 | 1; carets: CaretClone[] }[] } | undefined;
     private occurrenceSession: { wholeWord: boolean; notFound: boolean; signature: string } | undefined;
     /* The last select next occurrence found no more, which a host may say. */
@@ -442,6 +451,7 @@ export class DocumentModel {
         this.cloneSession = undefined;
         this.selectionHistory = [];
         this.statementClosers.clear();
+        this.arrows.clear();
         if (sameSelections(this.selections, normalized)) {
             return;
         }
@@ -630,8 +640,8 @@ export class DocumentModel {
     /*
      * Types `text` at every caret as one keystroke would: it wraps a selection in a bracket or quote,
      * closes an opener, types over a closer that is already there and, in TypeScript, JavaScript and
-     * PHP, moves a `;` to the end of a statement. Comments and string contents are left alone.
-     * Returns whether anything changed, a swallowed closer included.
+     * PHP, moves a `;` to the end of a statement. In PHP a `-` after a variable becomes `->`. Comments
+     * and string contents are left alone. Returns whether anything changed, a swallowed closer included.
      */
     typeText(text: string, options: TypeTextOptions = {}): boolean {
         if (options.expectedRevision !== undefined && options.expectedRevision !== this.revision) {
@@ -640,6 +650,11 @@ export class DocumentModel {
         if (!text) {
             return false;
         }
+        const arrows = this.arrows;
+        this.arrows = new Set();
+        if (arrows.size > 0 && text !== '>' && !arrowContinues.test(text)) {
+            this.takeBackArrows();
+        }
         const language = options.language ?? 'typescript';
         const single = text.length === 1;
         const pairing = options.autoClosingPairs !== false && single && !isPlainText(language);
@@ -650,6 +665,8 @@ export class DocumentModel {
             quotes: pairing && options.autoClosingQuotes !== false,
             surround: options.surroundSelection !== false && single,
             smartSemicolon: options.smartSemicolon !== false && hasSmartSemicolon(language),
+            smartArrow: options.smartArrow !== false && single && isPhp(language),
+            overArrows: text === '>' ? arrows : new Set(),
             dedent: options.smartEnter !== false
         };
         const plans = this.selections.map((selection) => this.planTyping(selection, input));
@@ -665,10 +682,39 @@ export class DocumentModel {
         if (this.revision === appliedRevision) {
             this.rememberStatementClosers(plans, transaction, language);
             this.rememberPairs(plans, transaction);
+            this.completeArrows(plans, transaction);
         }
         return changed || plans.some((plan) => plan.consumed);
     }
 
+    /*
+     * A key after a `->` the editor completed that cannot follow it means the `-` was a minus. The `>` is the
+     * last undo step, so it goes without a redo, and the key joins the typing of the `-`.
+     */
+    private takeBackArrows(): void {
+        this.undo();
+        this.redoStack.pop();
+        this.groupOpen = true;
+    }
+
+    /* Adds the `>` after every `-` that became an arrow, as its own undo step, so the first undo leaves the `-` that was typed. */
+    private completeArrows(plans: readonly SelectionEdit[], transaction: SelectionTransaction): void {
+        const at = transaction.selections.flatMap((selection, index) => (plans[index]?.arrow ? [selection.head] : [])).sort((left, right) => left - right);
+        if (at.length === 0) {
+            return;
+        }
+        const moved = (offset: number): number => offset + at.filter((inserted) => inserted <= offset).length;
+        const selections = this.selections.map((selection) => ({ anchor: moved(selection.anchor), head: moved(selection.head) }));
+        if (
+            this.applyEdits(
+                at.map((offset) => ({ from: offset, to: offset, text: '>' })),
+                { source: 'input', selections }
+            )
+        ) {
+            this.arrows = new Set(at.map(moved));
+        }
+    }
+
     /*
      * Pastes `text` at every selection. With as many lines as carets each caret takes one; `wholeLines`
      * marks text copied from a bare caret, which goes above the lines of bare carets.
@@ -726,16 +772,16 @@ export class DocumentModel {
         }
         const tabSize = tabWidth(options);
         const language = options.language ?? 'typescript';
+        const unit = options.insertSpaces === false ? '\t' : ' '.repeat(tabSize);
         if (command === 'smartBackspace' || command === 'deleteForward') {
             const pairing = options.autoClosingPairs !== false && !isPlainText(language);
             return this.deleteCharacter(
                 command === 'smartBackspace',
-                tabSize,
+                { tabSize, unit },
                 { brackets: pairing && options.autoClosingBrackets !== false, quotes: pairing && options.autoClosingQuotes !== false },
                 language
             );
         }
-        const unit = options.insertSpaces === false ? '\t' : ' '.repeat(tabSize);
         const enter = { language, unit, tabSize, smart: options.smartEnter !== false, reach: true };
         if (command === 'insertNewline' || command === 'startNewLine' || command === 'splitLine') {
             return this.insertNewline(enter, command === 'insertNewline' ? 'enter' : command === 'startNewLine' ? 'below' : 'split');
@@ -799,13 +845,20 @@ export class DocumentModel {
         const after = this.rope.charAt(to);
         const quote = isQuote(text);
         const pairing = quote ? input.quotes : input.brackets;
+        if (text === '>' && from === to && input.overArrows.has(from)) {
+            return { from, to, text: '', anchor: 0, head: 0, skip: true, consumed: true };
+        }
         const pendingClosers = this.statementClosers.get(from);
         if (input.brackets && smartSemicolon && from === to && pendingClosers?.language === language && pendingClosers.text.startsWith(text)) {
             return { from, to, text: '', anchor: 0, head: 0, skip: true, consumed: true, completedClosers: pendingClosers.text.slice(1) };
         }
 
-        const needsContext = text.length === 1 && (/[()[\]{}'"`<]/.test(text) || (text === ';' && smartSemicolon));
+        const arrow = text === '-' && input.smartArrow && from === to;
+        const needsContext = text.length === 1 && (/[()[\]{}'"`<]/.test(text) || (text === ';' && smartSemicolon) || arrow);
         const context = needsContext ? this.typingContext(from, language) : undefined;
+        if (arrow && context?.mode === 'code' && context.word !== 'control-close' && this.endsOperand(from)) {
+            return { from, to, text, anchor: 1, head: 1, arrow: true };
+        }
         const insideQuote = context && (context.mode === 'quote' || context.mode === 'template') && context.quote === text && !context.escaped;
         if (pairing && from === to && after === text && (quote ? insideQuote : context?.mode === 'code' && context.bracket?.close === text)) {
             return { from, to, text: '', anchor: 1, head: 1, skip: true };
@@ -920,6 +973,24 @@ export class DocumentModel {
         return scanned.pairs.has(offset);
     }
 
+    /*
+     * Whether the text before `offset` ends in something a member is read from: a variable, the name of a
+     * property or method after `->` or `?->`, or a `)` or `]`.
+     */
+    private endsOperand(offset: number): boolean {
+        const line = this.rope.lineBounds(this.rope.lineAt(offset));
+        const before = this.slice(line.start, offset);
+        if (/[)\]]$/.test(before)) {
+            return true;
+        }
+        const name = /[\p{L}_][\p{L}\p{N}_]*$/u.exec(before);
+        if (name === null) {
+            return false;
+        }
+        const ahead = before.slice(0, name.index);
+        return ahead.endsWith('$') || ahead.endsWith('->');
+    }
+
     /* Remembers the closers a smart semicolon stepped over for the caret that did it, so typing them again is absorbed. */
     private rememberStatementClosers(plans: readonly SelectionEdit[], transaction: SelectionTransaction, language: string): void {
         for (const [index, selection] of transaction.selections.entries()) {
@@ -1531,18 +1602,25 @@ export class DocumentModel {
         return index;
     }
 
-    private deleteCharacter(backwards: boolean, tabSize: number, pairing: { brackets: boolean; quotes: boolean }, language: string): boolean {
+    private deleteCharacter(
+        backwards: boolean,
+        indent: { tabSize: number; unit: string },
+        pairing: { brackets: boolean; quotes: boolean },
+        language: string
+    ): boolean {
         return this.deleteRanges(
             this.selections.map((selection) => {
                 let { from, to } = rangeOf(selection);
                 if (from === to) {
                     if (!backwards) {
                         to = deletionStep(this.rope, to, 1);
+                    } else if (this.arrows.has(from)) {
+                        from -= 2;
                     } else if ((isQuote(this.rope.charAt(from - 1)) ? pairing.quotes : pairing.brackets) && this.isEmptyPair(from, language)) {
                         from--;
                         to++;
                     } else {
-                        from = this.backspaceStart(from, tabSize);
+                        return this.unindent(from, indent, language) ?? { from: this.backspaceStart(from, indent.tabSize), to, text: '' };
                     }
                 }
                 return { from, to, text: '' };
@@ -1550,6 +1628,40 @@ export class DocumentModel {
         );
     }
 
+    /*
+     * Backspace with only whitespace before the caret, after the platform's smart backspace: a line indented past
+     * where its brackets put it goes back to there, and one at or before it joins the line above, or takes the place
+     * of that line when it is blank. Null where the brackets say nothing.
+     */
+    private unindent(offset: number, indent: { tabSize: number; unit: string }, language: string): TextEdit | null {
+        const index = this.rope.lineAt(offset);
+        const line = this.rope.lineBounds(index);
+        if (!/^[\t ]*$/.test(this.slice(line.start, offset))) {
+            return null;
+        }
+        const proper = properIndent(this.editSource(language), index, { language, unit: indent.unit });
+        if (proper === null) {
+            return null;
+        }
+        let end = offset;
+        while (end < line.end && /[\t ]/.test(this.rope.charAt(end))) {
+            end++;
+        }
+        if (indentationColumn(this.slice(line.start, end), indent.tabSize) > indentationColumn(proper, indent.tabSize)) {
+            return { from: line.start, to: end, text: proper };
+        }
+        if (index === 0) {
+            return { from: 0, to: end, text: '' };
+        }
+        const previous = this.getLine(index - 1);
+        const start = previous.end - trailingBlankLength(previous.text);
+        if (start !== previous.start || start === 0) {
+            const before = this.slice(previous.start, start);
+            return { from: start, to: end, text: before === '' ? '' : spacingBetween(before, this.slice(end, line.end).trimEnd()) };
+        }
+        return { from: start, to: end, text: proper };
+    }
+
     /* Whether the caret sits between an opener and its own closer, which backspace removes together. */
     private isEmptyPair(offset: number, language: string): boolean {
         const opener = this.rope.charAt(offset - 1);
@@ -1989,6 +2101,7 @@ export class DocumentModel {
         this.structureCache = undefined;
         this.selectionHistory = [];
         this.statementClosers.clear();
+        this.arrows.clear();
     }
 
     private restore(state: State, changes: readonly (readonly DocumentChange[])[]): void {

package/src/fold-roles.ts

@@ -1,6 +1,6 @@
 import { isImportLine } from './lexical-folds.ts';
 import type { DocumentLine } from './rope.ts';
-import type { FoldHints, FoldRole, FoldingRange } from './structure.ts';
+import type { FoldHints, FoldRangeHint, FoldRole, FoldingRange } from './structure.ts';
 
 const SCRIPT_LANGUAGES = /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|mjs|cjs|mts|cts)$/i;
 /* How far back from a bracket the text before it is read. */
@@ -116,6 +116,12 @@ export function applyFoldHints(
     for (const hint of hints.ranges ?? []) {
         const startLine = lineAt(hint.from);
         const endLine = lineAt(hint.to);
+        const same = result.find((range) => range.startLine === startLine && range.endLine === endLine);
+        // The text's own fold of the same lines keeps its kind and role, and takes where the server hides from and shows again from.
+        if (same !== undefined) {
+            Object.assign(same, edgesOf(hint));
+            continue;
+        }
         if (endLine - startLine < minimum || starts.has(startLine)) {
             continue;
         }
@@ -129,12 +135,17 @@ export function applyFoldHints(
             from: first.start + indent,
             to: getLine(endLine).end,
             kind: 'server',
-            ...(role === undefined ? {} : { role })
+            ...(role === undefined ? {} : { role }),
+            ...edgesOf(hint)
         });
     }
     return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
 
+function edgesOf(hint: FoldRangeHint): Pick<FoldingRange, 'head' | 'tail'> {
+    return { ...(hint.head === undefined ? {} : { head: hint.head }), ...(hint.tail === undefined ? {} : { tail: hint.tail }) };
+}
+
 /* The fold that is the body of a symbol, and what kind of body it is. */
 function bodyOf(
     ranges: FoldingRange[],

package/src/line-commands.ts

@@ -43,7 +43,7 @@ function skipWhitespace(source: EditSource, from: number): number {
 }
 
 /* What goes where two lines meet: nothing before a closer, a comma or a dot and after an opener, else a space. */
-function spacingBetween(previous: string, next: string): string {
+export function spacingBetween(previous: string, next: string): string {
     if (next === '' || /^[)\],;]/.test(next) || /^\.(?![.\d])/.test(next) || /[([]$/.test(previous)) {
         return '';
     }
@@ -279,6 +279,15 @@ export function planAutoIndent(source: EditSource, lines: readonly number[], opt
     return edits.length === 0 ? null : { edits, selections: [] };
 }
 
+/* The indentation the brackets give a line, or null where they say nothing: outside code, in markup and in a language that is not bracketed. */
+export function properIndent(source: EditSource, line: number, options: LineCommandOptions): string | null {
+    const context = source.context(source.line(line).start);
+    if (!indentsByBrackets(options.language) || context.mode !== 'code' || markupGuard(source, options.language)(line)) {
+        return null;
+    }
+    return targetIndent(source, options, line, context, (index) => whitespaceOf(source.line(index).text));
+}
+
 function targetIndent(source: EditSource, options: LineCommandOptions, line: number, context: TypingContext, indentOf: (line: number) => string): string {
     const text = source.line(line).text.trimStart();
     const open = frames(context);

package/src/structure.ts

@@ -44,6 +44,9 @@ export interface FoldingRange {
     kind: 'bracket' | 'comment' | 'indentation' | 'imports' | 'line-comments' | 'region' | 'block' | 'section' | 'server';
     /* What the range is, where the text or a language server says; most ranges have none. */
     role?: FoldRole;
+    /* Where a collapsed fold hides from on its first line and shows again from on its last, when a server says; else whole lines. */
+    head?: number;
+    tail?: number;
 }
 
 export interface FoldingOptions {
@@ -79,6 +82,9 @@ export interface FoldRangeHint {
     to: number;
     /* The LSP kind: `comment`, `imports` or `region`. */
     kind?: string;
+    /* Where it hides from on its first line and shows again from on its last, from the LSP `startCharacter` and `endCharacter`. */
+    head?: number;
+    tail?: number;
 }
 
 export interface FoldHints {

package/src/types.ts

@@ -123,6 +123,8 @@ export interface CommandOptions {
     /* A language id such as `typescript` or `php`; it decides what counts as a comment or a string. */
     language?: string;
     smartSemicolon?: boolean;
+    /* In PHP a `-` typed after a variable, a member or a `)` or `]` becomes `->`. On unless false. */
+    smartArrow?: boolean;
     /* Tab steps over a closer the editor inserted. On unless false. */
     tabOutOfClosers?: boolean;
     /* Enter computes the indentation of the new line, continues comments and closes braces. On unless false. */