@adecore/editor 0.0.1 → 0.17.0-beta.1

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Bas Milius
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# @adecore/editor
+
+Read the [browser editor handbook](https://adecore.dev/editor/handbook/) for the complete setup, concepts, host integration and testing guides.
+
+The DOM view of the smart editor. It draws a `DocumentModel` from `@adecore/editor-core` with its own layout and implements the `EditorEngine` contract. Language features live in `@adecore/editor-react`; the engine itself needs no language service.
+
+```ts
+const engine = createSmartEditorEngine({
+    tokenizer: shikiTokenizers(() => highlighter),
+    handBack: shellShortcuts,
+    apple
+});
+const editor = engine.mount(element, { text, language: 'typescript', theme: 'github-dark' });
+```
+
+Import `@adecore/ui/theme.css`, then `@adecore/editor/editor.css`. The element needs a positioned box sized by its parent. Editor, find, change and attribution colors have defaults on Adecore theme tokens. The code face uses `--font-mono`, `--code-font-size` and `--code-line-height`; the latter two default to `--text-code` and `--text-code--line-height`. Override them after the editor CSS, and call `refreshFont()` when they change.
+
+## How it is put together
+
+- `layout.ts`: the rows of the document, free of the DOM. A row is a line, a widget or a fold's first line. It owns wrapping into visual lines, tab stops, inlays, folded lines, caret and selection boxes, hit testing and moving by visual line. Only the rows on screen are measured; the others stand on an estimate that the first draw corrects.
+- `view.ts`: the DOM, the scroll (native: the gutter and the pinned headers stick to the corner of the one scroll container, and the scroll event draws the rows, a viewport of them on each side, in the frame it shows in), the folds and what is drawn behind and above the text. `paint.ts` holds the drawing of rows, the gutter, the selection and the carets. Rows are absolutely placed runs of text, so the layout decides where each character is. A draw reads the viewport's scroll position and size once at its start, since a read after the first write of a frame makes the browser lay the page out again, and a host setter whose value did not change draws nothing. The horizontal scroll extent is the widest line measured since the text last changed, inlays included, plus three columns as on the platform; a host row follows the scroll and clips what it draws past its width, since an overflow there would grow the extent with every scroll and carry the sticky gutter out of view.
+- `controller.ts`: what a person does. Keys come from one table (`keymap-table.ts`, which the client prints in its menus as well) and are mapped in `keymap.ts` to the model's commands, typing goes through `DocumentModel.typeText`, a paste through `DocumentModel.paste`, the mouse through `pointer.ts`. A copy or cut of a bare caret remembers its text for every editor of the page, and pasting that same text again, in any of them, lands as whole lines. Adding a caret above or below is the double tap of a modifier and an arrow (`modifier-gesture.ts`). The smart keys (`EditorSmartKeys`: pairing, surrounding, tabbing out, smart Enter, indent on paste, the smart semicolon and the camel humps) are options of the editor, set at mounting and changed with `setSmartKeys`; all are on except the camel humps. The textarea (`native-input.ts`) is only the sink for the platform's typing, composition and paste, and carries the text around the caret for assistive technology.
+- `tokens.ts` and `shiki.ts`: coloring. A grammar needs the state the previous line ended in, so lines are colored from a frontier down, a slice at a time, on the screen plus a margin. An edit moves the frontier to the changed line and stops as soon as a line ends in the state it had before. The tokenizer is injected (`TokenizerSource`); `shikiTokenizers` adapts the viewer's Shiki highlighter. It loads the languages a grammar embeds only on demand (a style block's `lang="scss"`, a Markdown fence) when the document names them, since Shiki rebuilds the host grammar when one loads later, and a tokenizer says so with `stale` so the colors start over from the top. A language added to a document after it opened (a new fence) is colored once the file opens again. `php-html.ts` is the grammar for a PHP file as a document (HTML with PHP between its tags), which Shiki does not bundle; PHP inside an HTML attribute is not colored.
+- `outline.ts`: the blocks of the document with a header line, read from braces and indentation until the host hands over better ones with `setBlocks` (a language server's symbols). Sticky scroll pins the headers of the blocks scrolled out of sight, and `onScope` reports the named blocks around the caret for a breadcrumb.
+- `overview.ts`: the ticks in the scroll track for the host's change marks (`setChangeMarks`, also drawn in the gutter) and the find matches.
+- `find.ts`: the matches of the host's find bar. They are marked in the editor and never touch the selection until `endFind`.
+- `semantic.ts` and `theme-scopes.ts`: what a language server classified, drawn over the grammar's colors. The host hands scopes (`setSemanticTokens`), and the theme's own rules decide the color (`scopeColors`, `shikiScopeColors`), so a class is the theme's class color. A scope the theme says nothing about keeps what the grammar made.
+- `scroll.ts` and `scroll-animation.ts`: where a scroll goes (the platform's scrolling model: margins, and a jump a third from the top) and how it gets there, over up to a tenth of a second and never for a line or less.
+- `keymap-table.ts`: the keys of every editor and language command for macOS and the other platforms, which the client prints in its menus too (`@adecore/editor/keymap`).
+- `engine.ts`: the `Editor` contract over a model and a view.
+
+## What a language feature gets
+
+The editor knows no language server. It reports every change of the text as LSP content changes (`onTextChange`, with its source), says where the caret is (`getCaret`, `onCaret`) and where a character is on the screen (`rectAt`, in the page's pixels so a popup is right at any canvas zoom), and takes what a host draws or does: `setMarkers` (squiggles, faded and struck text, a lane in the scroll track), `setInlayHints`, `setSemanticTokens`, `setHighlights`, `setBlocks`, `setWidgets` (rows of the host's own DOM next to lines, drawn in the layout's block rows; `placement: 'above'` puts one over its line, and each owner has its own set, see below), `setCodeVision` (a quiet row above a declaration, see below), `setGhostText` (a suggestion after the caret, see below), `setGutterAction` (one button in the gutter, such as a lightbulb, which `onGutterAction` reports), `setGutterMarkers` (small buttons in the gutter per owner, such as the mark of a saved inline edit, which `onGutterMarker` reports by id; a marker stays on its line until its owner sets them again), `setLink` (a name underlined as a link while a modifier is held) `trackRange` (a range that follows the text through edits and reads null once an edit touched it, inside or across an end; text inserted exactly at an end does not count, so a range that was a selection still holds the same text) and `applyEdits`. A marker's `message` is what the tick of the problem says in the scroll track, where a press on the tick goes to the problem. `getSelection`, `getSelections`, `setSelections` (the last range is the primary one), `getVisibleRange` and `getIndentation` say what a feature asks about, and `setSelection` selects a range, such as the stop of a snippet. `onHover` reports the character under the pointer, `onClick` offers a press on a character first (Mod+click follows a name) and `onContextMenu` asks the host for its menu, which the editor does not draw, `onKeyDown` lets a host take a key before the editor does, and `onViewChange` says when the screen position of a character moved.
+
+`setText` applies the difference as a line diff in one batch (`changedSpans`), one undo step reported as an external change, so a reload from disk or a sync between two editors on a file keeps the scroll, carets, folds, markers, inlays and code vision rows wherever the text around them stayed. A language server hears it as the one stretch from the first change to the last.
+
+`runCommand` runs an editing command by name, which is how a menu or the palette reaches the editor; the folding commands (collapse and expand a region, all, recursively, a selection, documentation comments and "expand all to level 1 through 5") and column mode are the view's own.
+
+A collapsed fold is one row for the line commands, as the platform has it: delete, duplicate, comment, move and a copy or cut with no selection take the whole fold (a moved fold stays collapsed on its new lines), a word move steps over it and add caret above and below skips it. The view hands the commands its rows through `lineSpan`.
+
+Folds are kept by line (`getFolds`, and `folds` on mounting), the way scroll and caret are. A fold has a role (the file header, imports, documentation comments, regions, the body of a function, a method or a class, object and array literals, tags, attributes and so on, `FoldRole` of the core), and `foldDefaults` on mounting lists the roles that fold by themselves in a file that has no folds of its own. `setFoldHints` hands over a language server's symbols and folding ranges, which name the bodies and tags the text cannot, and the defaults fold what they name once: not a fold somebody opened or closed, not one that holds the caret, and nothing after the first edit. `foldOutline` (`off`, `hover` or `always`) says when the arrow shows in the gutter. Indent guides, whitespace and a right margin are options and setters (`guides`, `whitespace`, `rightMargin`). The find takes `inSelection`, `selectFindMatches` puts a caret on every match, `setReplacePreview` draws what a regular expression writes under the current match, and `findFromCursor` steps without a find bar.
+
+`handBack` shortcuts are not handled by the editor and not prevented, so the page's own listeners get them. Mod+S is `onSave`.
+
+## Agent marks
+
+`setAttributionMarks` draws a three pixel bar in the gutter, where the change marks are, for each run of lines (`id`, one-based `startLine` and `endLine`, `color`). The color is a custom property of the page (`--agent-1` to `--agent-6`, `AGENT_COLORS`, defined in `editor.css` for both themes, with `--agent-ink` for text on them) or any CSS color. On a line that has both, the bar stands in the place of the git change mark, which the scroll track still shows; a removal triangle between lines stays. A run follows its text through edits until the host sets the marks again, and an edit costs one mapping of two offsets per run, so thousands of runs stay smooth. `onAttributionHover` reports the id and the bar's box on the line under the pointer (a few pixels either side of the bar count), and null when it leaves.
+
+`setRemoteCursors` draws the caret of an agent (`id`, `position`, `name`, `color`, the same colors) over the text, two pixels wide with its name in a label above it, the label's lower left corner square. Where there is no room above the caret (the first line, or under the pinned headers) the name goes under it. It follows its text through edits until set again, is not interactive, and is left out on a line a fold hides. The editor's own caret and selection never move for it.
+
+## Review and conflict rows
+
+`setLineHighlights` tints lines behind the text (`startLine` and `endLine` one-based, a `color`, an optional `sign` such as `+` in the gutter beside the number, an optional `fill` that paints the rows as it stands instead of the 14% tint of the color), one box per row so a widget row between two tinted lines stays clear. It follows its text through edits like the marks do. `renderCode(container, text, options)` fills a widget row's element with lines that are not in the document, such as the lines an agent removed or the other side of a conflict, in the editor's face and token colors, with a gutter column as wide as the editor's, so the text lines up with the document's (`firstLine` for numbers, `sign`, `color` for the tint and the bar, `emphasis` for character ranges per line drawn in a stronger tint, such as the words a change replaced, and `faded` for text that is gone). Both take the same colors as the attribution marks. A widget has `placement: 'above'` for a row over its line. `setLineActions(actions, owner?)` puts the host's own DOM after the last character of a line (`id`, zero-based `line`, `render(container)` once per action), such as the buttons of a change under review. It is no row: it takes no height, follows its line through edits, is hidden where a fold hides the line, and a press on it never moves the caret. A long line with no wrap pushes it past the edge of the view.
+
+## Widgets per owner
+
+`setWidgets(widgets, owner?)` replaces the rows of one owner, `default` without one, and leaves every other owner's alone, so a peek, the review rows of an agent's change and a conflict stand together. Rows next to the same line are ordered by their owners' names and then in the order each owner gave them, not by who set them last, so they never swap places. An empty list takes the owner's rows away.
+
+## Code vision rows
+
+`setCodeVision` takes a row per declaration: the line, and the entries of the row (`id`, `text`, an optional `user` or `users` icon, and `activate`, which gets the box of the pressed entry in the page's pixels). The row is a block row above the line (`lens` on a `BlockWidget`, `lens.ts` for its buttons), one code line high whatever its entries are, placed at the indentation of the declaration and never measured, so it holds its height with no entries and the text does not move when they arrive. It follows its declaration through edits like every block does, is kept apart from `setWidgets` (a peek under a name never takes a row away), and is drawn again only when the words of its entries change. An entry stands a text size from the next one, is muted, and lights up as a link with an underline under the pointer; a press on it never moves the caret or takes the focus.
+
+## Ghost text
+
+`setGhostText({ position, text, accessory? })` draws a suggestion after the caret that is not in the document, such as a continuation from a model, and `null` takes it away. The first line of `text` sits in the line in the code face and the editor's faint color, italic, and the caret stays in front of it. Further lines are a row under the line, in the same color and with the gutter column of the document, so the lines below move down while it is shown. `accessory` fills an element drawn after the end of the line, such as the keys that take the suggestion. The editor never accepts it: the host binds the keys (Tab, `acceptGhostWord`) and inserts the text with `applyEdits`, which is one undo step. Any change of the text takes the suggestion away, so the host sets it again for the text it was made for; moving the caret does not, and the host decides what that means.
+
+## Limits
+
+- No rendered documentation blocks.
+- Wrapped lines break at spaces and inside a word that does not fit, and continue at the line's indentation plus two characters. A click past the end of a visual line draws the caret at its end until the caret moves; an arrow key onto that offset draws it at the start of the next line.
+- A line over 20,000 characters is not colored.
+- Every edit rebuilds the row list, which is linear in the number of lines.
+- No bidirectional text, and no screen reader testing beyond the textarea's own context.
+
+## Keymaps and package exports
+
+`@adecore/editor/keymap` exports `KEYMAP`, `resolveKeymap`, `chordOf` and `parseChord`. Pass the same resolved keymap and `apple` flag to the engine and to `ProjectLanguage` so editor keys, language commands and menu hints agree. Application collisions belong in host overrides. AI commands have no universal bindings. `handBack` remains the host's global shortcut list.
+
+The root exports the engine and its types. `/shiki` supplies the Shiki adapter, `/fake` supplies the DOM-free `FakeEditorEngine`, and `/testing` supplies DOM fixtures backed by LinkeDOM. `/editor.css` supplies the required editor chrome.
+
+This unpublished package is private at version `0.0.0` and retains FSL-1.1-MIT. Source consumers enable the `source` condition in the bundler, TypeScript and Bun. Default exports use compiled JavaScript and declarations. Run `bun run build`, `bun run typecheck` and `bun run test` from this package after workspace installation. See the editor migration guide for consumer adapters and the transferred revision.

package/dist/attribution.d.ts

@@ -0,0 +1,28 @@
+import type { DocumentChange } from '@adecore/editor-core';
+export declare const AGENT_COLORS: readonly ['--agent-1', '--agent-2', '--agent-3', '--agent-4', '--agent-5', '--agent-6'];
+export interface AttributedLines {
+    readonly id: string;
+    readonly color: string;
+    readonly sign?: string;
+    readonly fill?: string;
+}
+export declare function tintValue(color: string): string;
+export declare function colorValue(color: string): string;
+export declare class AttributionRuns {
+    private runs;
+    get size(): number;
+    set(marks: readonly {
+        id: string;
+        startLine: number;
+        endLine: number;
+        color: string;
+        sign?: string;
+        fill?: string;
+    }[], lineCount: number, lineBounds: (line: number) => {
+        start: number;
+        end: number;
+    }): void;
+    clear(): void;
+    map(changes: readonly DocumentChange[]): void;
+    linesIn(first: number, last: number, from: number, to: number, lineOf: (offset: number) => number): Map<number, AttributedLines>;
+}

package/dist/attribution.js

@@ -0,0 +1,55 @@
+import { mapOffset } from './offsets.js';
+/* The custom properties of the agent palette, defined in `editor.css` for both themes. */
+export const AGENT_COLORS = ['--agent-1', '--agent-2', '--agent-3', '--agent-4', '--agent-5', '--agent-6'];
+/* A color washed out to a background that text stays readable on in either theme. */
+export function tintValue(color) {
+    return `color-mix(in srgb, ${colorValue(color)} 14%, transparent)`;
+}
+/* The CSS value of a mark's color: `--agent-1` is the page's custom property of that name, anything else is a color as it stands. */
+export function colorValue(color) {
+    return color.startsWith('--') ? `var(${color})` : color;
+}
+/*
+ * The runs of lines a host attributed, anchored by offsets so they follow their text through edits. An
+ * edit costs one mapping of two offsets per run, and a read works out the lines of only the runs that
+ * reach the lines asked for.
+ */
+export class AttributionRuns {
+    runs = [];
+    get size() {
+        return this.runs.length;
+    }
+    /* Marks name lines one-based and inclusive; `lineBounds` answers for the document as it is now. */
+    set(marks, lineCount, lineBounds) {
+        const clamp = (line) => Math.min(lineCount, Math.max(1, Math.trunc(line) || 1)) - 1;
+        this.runs = marks.map((mark) => {
+            const start = clamp(mark.startLine);
+            const end = Math.max(start, clamp(mark.endLine));
+            return { id: mark.id, color: mark.color, sign: mark.sign, fill: mark.fill, from: lineBounds(start).start, to: lineBounds(end).end };
+        });
+    }
+    clear() {
+        this.runs = [];
+    }
+    map(changes) {
+        for (const run of this.runs) {
+            run.from = mapOffset(run.from, changes);
+            run.to = mapOffset(run.to, changes);
+        }
+    }
+    /* The run on each line from `first` to `last`, zero-based, where `from` and `to` are the offsets they span; where runs overlap the one set last wins. */
+    linesIn(first, last, from, to, lineOf) {
+        const lines = new Map();
+        for (const run of this.runs) {
+            if (run.to < from || run.from > to) {
+                continue;
+            }
+            const value = { id: run.id, color: run.color, sign: run.sign, fill: run.fill };
+            const end = Math.min(Math.max(lineOf(run.from), lineOf(run.to)), last);
+            for (let line = Math.max(lineOf(run.from), first); line <= end; line++) {
+                lines.set(line, value);
+            }
+        }
+        return lines;
+    }
+}

package/dist/code-block.d.ts

@@ -0,0 +1,2 @@
+import type { EditorCodeBlockOptions, LineToken } from './types.ts';
+export declare function renderCodeBlock(container: HTMLElement, text: string, tokens: readonly (readonly LineToken[])[] | null, tabSize: number, options: EditorCodeBlockOptions): void;

package/dist/code-block.js

@@ -0,0 +1,89 @@
+import { colorValue, tintValue } from './attribution.js';
+import { styleSpan } from './paint.js';
+/*
+ * Lines of code that are not part of the document, in the editor's own face, colors and gutter, for a
+ * widget row to show text that is not in the file: lines an agent removed, or the other side of a
+ * conflict. The gutter column is as wide as the editor's, so the text lines up with the document's.
+ */
+export function renderCodeBlock(container, text, tokens, tabSize, options) {
+    const document = container.ownerDocument;
+    const block = document.createElement('div');
+    block.className = 'se-code-block';
+    block.style.tabSize = String(tabSize);
+    const lines = text.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const row = document.createElement('div');
+        row.className = 'se-code-row';
+        if (options.color !== undefined) {
+            row.style.background = tintValue(options.color);
+        }
+        const gutter = document.createElement('div');
+        gutter.className = 'se-code-gutter';
+        if (options.firstLine !== undefined) {
+            const number = document.createElement('span');
+            number.textContent = String(options.firstLine + index);
+            gutter.append(number);
+        }
+        if (options.sign) {
+            const sign = document.createElement('span');
+            sign.className = 'se-line-sign';
+            sign.textContent = options.sign;
+            if (options.color !== undefined) {
+                sign.style.color = colorValue(options.color);
+            }
+            gutter.append(sign);
+        }
+        if (options.color !== undefined) {
+            const bar = document.createElement('span');
+            bar.className = 'se-attribution';
+            bar.style.background = colorValue(options.color);
+            gutter.append(bar);
+        }
+        const code = document.createElement('div');
+        code.className = 'se-code-text';
+        if (options.faded) {
+            code.dataset.faded = 'true';
+        }
+        const emphasis = options.emphasis?.[index] ?? [];
+        if (emphasis.length > 0 && options.color !== undefined) {
+            row.style.setProperty('--se-emphasis', colorValue(options.color));
+        }
+        fill(code, line, tokens?.[index] ?? null, emphasis);
+        row.append(gutter, code);
+        block.append(row);
+    });
+    container.append(block);
+}
+function fill(element, line, tokens, emphasis) {
+    if (tokens === null && emphasis.length === 0) {
+        element.textContent = line;
+        return;
+    }
+    const spans = [];
+    let start = 0;
+    for (const token of tokens ?? []) {
+        const end = Math.min(line.length, start + token.length);
+        if (end > start) {
+            spans.push({ start, end, token });
+        }
+        start = end;
+    }
+    if (start < line.length) {
+        spans.push({ start, end: line.length, token: null });
+    }
+    for (const { start: from, end: to, token } of spans) {
+        // A token is cut at the edges of every emphasis that crosses it, so each piece is one color and either on or off.
+        const cuts = [...new Set([from, to, ...emphasis.flatMap((range) => range).filter((cut) => cut > from && cut < to)])].sort((left, right) => left - right);
+        for (let i = 0; i < cuts.length - 1; i++) {
+            const piece = element.ownerDocument.createElement('span');
+            piece.textContent = line.slice(cuts[i], cuts[i + 1]);
+            if (token !== null) {
+                styleSpan(piece, token);
+            }
+            if (emphasis.some(([emphasisStart, emphasisEnd]) => emphasisStart <= cuts[i] && cuts[i + 1] <= emphasisEnd)) {
+                piece.className = 'se-code-emphasis';
+            }
+            element.append(piece);
+        }
+    }
+}

package/dist/column-selection.d.ts

@@ -0,0 +1,9 @@
+import type { Selection } from '@adecore/editor-core';
+import { type EditorLayout } from './layout.ts';
+export interface ContentPoint {
+    x: number;
+    y: number;
+}
+export declare function cellAt(layout: EditorLayout, x: number): number;
+export declare function columnSelections(layout: EditorLayout, from: ContentPoint, to: ContentPoint): Selection[];
+export declare function sameCell(layout: EditorLayout, from: ContentPoint, to: ContentPoint): boolean;

package/dist/column-selection.js

@@ -0,0 +1,52 @@
+import { TEXT_PADDING } from './layout.js';
+/* The cell of a monospaced grid an x falls in, which stands in for the visual column since a tab is a whole number of cells. */
+export function cellAt(layout, x) {
+    return Math.max(0, Math.round((x - TEXT_PADDING) / layout.metrics.charWidth));
+}
+/*
+ * One selection per line between two points, each spanning the same visual columns, the way a column
+ * (box) selection works. A line that ends before the box starts has no text in it: it gets a caret at
+ * its end when the box is only a column of carets, and none otherwise.
+ */
+export function columnSelections(layout, from, to) {
+    const { charWidth } = layout.metrics;
+    const document = layout.document;
+    const fromLine = document.positionAt(layout.hitTest(from.x, from.y)).line;
+    const toLine = document.positionAt(layout.hitTest(to.x, to.y)).line;
+    const fromCell = cellAt(layout, from.x);
+    const toCell = cellAt(layout, to.x);
+    const left = Math.min(fromCell, toCell);
+    const right = Math.max(fromCell, toCell);
+    const reversed = toCell < fromCell;
+    const result = [];
+    for (let line = Math.min(fromLine, toLine); line <= Math.max(fromLine, toLine); line++) {
+        const row = layout.rowForLine(line);
+        if (row.kind !== 'text' || layout.isHidden(line)) {
+            continue;
+        }
+        const geometry = layout.geometry(row);
+        const endX = geometry.rowStarts.length > 1 ? geometry.rowEnds[0] : geometry.before[geometry.before.length - 1];
+        const offsetAt = (cell) => layout.offsetAtX(geometry, 0, TEXT_PADDING + cell * charWidth).offset;
+        if (cellAt(layout, endX + TEXT_PADDING) < left) {
+            if (left === right) {
+                const end = document.getLine(line).end;
+                result.push({ anchor: end, head: end });
+            }
+            continue;
+        }
+        const start = offsetAt(left);
+        const end = offsetAt(right);
+        result.push(reversed ? { anchor: end, head: start } : { anchor: start, head: end });
+    }
+    if (result.length === 0) {
+        const end = document.getLine(toLine).end;
+        result.push({ anchor: end, head: end });
+    }
+    return result;
+}
+/* Whether two points are in the same cell of the same line, which makes a press with alt a click and not yet a box. */
+export function sameCell(layout, from, to) {
+    const document = layout.document;
+    return (cellAt(layout, from.x) === cellAt(layout, to.x) &&
+        document.positionAt(layout.hitTest(from.x, from.y)).line === document.positionAt(layout.hitTest(to.x, to.y)).line);
+}

package/dist/controller.d.ts

@@ -0,0 +1,64 @@
+import type { Keymap } from './keymap-table.ts';
+import type { EditorClickHandler, EditorContextMenu, EditorKeyHandler, EditorRunCommand, EditorSelectionRanges, KeyChord } from './types.ts';
+import type { EditorView } from './view.ts';
+export interface ControllerOptions {
+    keymap?: Keymap;
+    handBack: readonly KeyChord[];
+    apple: boolean;
+    save(): void;
+    blur(): void;
+}
+export declare class InputController {
+    private readonly native;
+    private readonly pointer;
+    private readonly cleanup;
+    private readonly keyHandlers;
+    private readonly gesture;
+    private readonly clickHandlers;
+    private readonly contextListeners;
+    private readonly subscription;
+    private historyGroup;
+    private block;
+    private selectionRanges;
+    private expansions;
+    private lastInputAt;
+    private desiredXs;
+    private keepDesiredXs;
+    private readonly view;
+    private readonly options;
+    constructor(view: EditorView, options: ControllerOptions);
+    private listen;
+    private attach;
+    dispose(): void;
+    private blockedByReadOnly;
+    private inputGroup;
+    private applyEdits;
+    private replaceSelections;
+    private paste;
+    private commandOptions;
+    private viewCommand;
+    command(name: EditorRunCommand): boolean;
+    setSelectionRanges(provider: EditorSelectionRanges | null): void;
+    private expandThrough;
+    private modelCommand;
+    private typeText;
+    private movePages;
+    private toggleColumnMode;
+    private extendBlock;
+    private moveCarets;
+    private dropText;
+    private goToMatchingBracket;
+    private run;
+    onKeyDown(handler: EditorKeyHandler): () => void;
+    onClick(handler: EditorClickHandler): () => void;
+    onContextMenu(listener: (menu: EditorContextMenu) => void): () => void;
+    private keydown;
+    private beforeInput;
+    private copy;
+    private pointerDown;
+    private takenByHost;
+    private positionOf;
+    private contextMenu;
+    private stickyDown;
+    private gutterDown;
+}