@texuli/core 0.1.0-next.0 → 0.1.0-next.2

package/dist/editor/history.d.ts

@@ -0,0 +1,57 @@
+import { type EditorIssue, type EditorSelection, type EditorState, type EditorTransformResult } from './types.js';
+/**
+ * What an edit was, for undo grouping. Consecutive `typing` (or `deletion`)
+ * in one block within `EDITOR_HISTORY_MERGE_MS` is one undo step; an
+ * `input-rule` is always its own step, so undo right after it restores the
+ * characters the user typed.
+ */
+export type EditorEditKind = 'typing' | 'deletion' | 'input-rule' | 'other';
+/** Pause after which typing starts a new undo step. */
+export declare const EDITOR_HISTORY_MERGE_MS = 500;
+export interface EditorHistory {
+    past: readonly EditorState[];
+    present: EditorState;
+    future: readonly EditorState[];
+    /** Why the last refused edit was refused (cleared by the next accepted action). */
+    errors: readonly EditorIssue[];
+    /** Snapshots kept in `past` (default 200). */
+    limit: number;
+    /** The last accepted edit, while it can still merge. */
+    last: {
+        kind: EditorEditKind;
+        block: string | null;
+        at: number;
+    } | null;
+}
+export type EditorHistoryAction = {
+    type: 'apply';
+    result: EditorTransformResult;
+    kind?: EditorEditKind;
+    at?: number;
+}
+/** A selection change: no undo step, and the next edit starts a new one. */
+ | {
+    type: 'select';
+    selection: EditorSelection;
+} | {
+    type: 'undo';
+} | {
+    type: 'redo';
+}
+/** A new document from outside: history restarts. */
+ | {
+    type: 'replace';
+    state: EditorState;
+};
+/** A history whose present is `state`. */
+export declare function createEditorHistory(state: EditorState, options?: {
+    limit?: number;
+}): EditorHistory;
+/**
+ * Snapshot-stack undo and redo (ADR-003). States are immutable and share
+ * unchanged blocks, so a snapshot costs only what changed. A refused edit
+ * keeps `present` and records `errors`.
+ */
+export declare function editorHistoryReducer(history: EditorHistory, action: EditorHistoryAction): EditorHistory;
+export declare const canUndo: (history: EditorHistory) => boolean;
+export declare const canRedo: (history: EditorHistory) => boolean;

package/dist/editor/history.js

@@ -0,0 +1,83 @@
+import { EDITOR_LIMITS, } from "./types.js";
+/** Pause after which typing starts a new undo step. */
+export const EDITOR_HISTORY_MERGE_MS = 500;
+/** A history whose present is `state`. */
+export function createEditorHistory(state, options = {}) {
+    const limit = Math.max(1, Math.trunc(options.limit ?? EDITOR_LIMITS.history));
+    return { past: [], present: state, future: [], errors: [], limit, last: null };
+}
+const focusBlock = (state) => state.selection.kind === 'text' ? state.selection.focus.block : null;
+/**
+ * Snapshot-stack undo and redo (ADR-003). States are immutable and share
+ * unchanged blocks, so a snapshot costs only what changed. A refused edit
+ * keeps `present` and records `errors`.
+ */
+export function editorHistoryReducer(history, action) {
+    switch (action.type) {
+        case 'apply': {
+            if (!action.result.ok)
+                return { ...history, errors: action.result.errors };
+            const state = action.result.state;
+            // A change that leaves the document as it was (a caret mark toggle) is
+            // no undo step, but like a selection change it ends the running typing
+            // step: undo after "a **b**" stops at the format change, not at "".
+            if (state.doc === history.present.doc) {
+                return { ...history, present: state, errors: [], last: null };
+            }
+            const kind = action.kind ?? 'other';
+            const at = action.at ?? 0;
+            const block = focusBlock(state);
+            const { last } = history;
+            const merge = last !== null &&
+                (kind === 'typing' || kind === 'deletion') &&
+                last.kind === kind &&
+                last.block === block &&
+                at - last.at <= EDITOR_HISTORY_MERGE_MS;
+            const past = merge ? history.past : [...history.past, history.present].slice(-history.limit);
+            return {
+                ...history,
+                past,
+                present: state,
+                future: [],
+                errors: [],
+                last: { kind, block, at },
+            };
+        }
+        case 'select':
+            return {
+                ...history,
+                present: { ...history.present, selection: action.selection, storedMarks: null },
+                last: null,
+            };
+        case 'undo': {
+            const previous = history.past.at(-1);
+            if (!previous)
+                return history;
+            return {
+                ...history,
+                past: history.past.slice(0, -1),
+                present: previous,
+                future: [history.present, ...history.future],
+                errors: [],
+                last: null,
+            };
+        }
+        case 'redo': {
+            const [next, ...future] = history.future;
+            if (!next)
+                return history;
+            return {
+                ...history,
+                past: [...history.past, history.present].slice(-history.limit),
+                present: next,
+                future,
+                errors: [],
+                last: null,
+            };
+        }
+        case 'replace':
+            return createEditorHistory(action.state, { limit: history.limit });
+    }
+}
+export const canUndo = (history) => history.past.length > 0;
+export const canRedo = (history) => history.future.length > 0;

package/dist/editor/inline.d.ts

@@ -0,0 +1,56 @@
+import { type EditorInline, type EditorMark, type EditorMarkType } from './types.js';
+type Text = Extract<EditorInline, {
+    type: 'text';
+}>;
+/**
+ * Remove the characters the model never stores. `keep` lists control
+ * characters that stay (`'\n\t'` for code). Line and paragraph separators and
+ * `\r\n` become `\n` first.
+ */
+export declare function cleanText(text: string, keep?: string): {
+    text: string;
+    stripped: boolean;
+};
+/** The identity of a mark: its type, plus the href for links. */
+export declare const markKey: (mark: EditorMark) => string;
+export declare const hasMark: (marks: readonly EditorMark[], type: EditorMarkType) => boolean;
+/**
+ * Canonical mark set: one mark per type (the first wins), sorted in
+ * `EDITOR_MARK_ORDER`, and `code` excludes every mark but `link`.
+ */
+export declare function sortMarks(marks: readonly EditorMark[]): readonly EditorMark[];
+export declare const sameMarks: (a: readonly EditorMark[], b: readonly EditorMark[]) => boolean;
+export declare const withMark: (marks: readonly EditorMark[], mark: EditorMark) => readonly EditorMark[];
+export declare const withoutMark: (marks: readonly EditorMark[], type: EditorMarkType) => EditorMark[];
+/** Length in UTF-16 code units; a break counts 1. */
+export declare const inlineLength: (content: readonly EditorInline[]) => number;
+/** The text of inline content; a break is `\n`. */
+export declare const inlineText: (content: readonly EditorInline[]) => string;
+/**
+ * Canonical inline content: marks sorted, empty runs dropped, neighbors with
+ * equal marks merged. Returns `content` itself when it is already canonical.
+ */
+export declare function normalizeInline(content: readonly EditorInline[]): readonly EditorInline[];
+/** Inline content between two offsets. */
+export declare function sliceInline(content: readonly EditorInline[], from: number, to?: number): EditorInline[];
+export declare const concatInline: (...parts: (readonly EditorInline[])[]) => readonly EditorInline[];
+/** Replace `[from, to)` with `insert`. */
+export declare const spliceInline: (content: readonly EditorInline[], from: number, to: number, insert?: readonly EditorInline[]) => readonly EditorInline[];
+/**
+ * The marks text typed at `offset` gets: those of the character before (the
+ * first character at offset 0). A link continues only strictly inside it.
+ */
+export declare function inheritedMarks(content: readonly EditorInline[], offset: number): readonly EditorMark[];
+/** Apply `update` to the marks of every text character in `[from, to)`. */
+export declare function mapMarks(content: readonly EditorInline[], from: number, to: number, update: (marks: readonly EditorMark[]) => readonly EditorMark[]): readonly EditorInline[];
+/** Every text run in `[from, to)` (sliced). */
+export declare const textRuns: (content: readonly EditorInline[], from: number, to: number) => Text[];
+/**
+ * Inline content for plain text: `\n` becomes a break, unsafe characters are
+ * stripped (`stripped` reports it), and every run gets `marks`.
+ */
+export declare function textToInline(text: string, marks?: readonly EditorMark[]): {
+    content: readonly EditorInline[];
+    stripped: boolean;
+};
+export {};

package/dist/editor/inline.js

@@ -0,0 +1,166 @@
+import { EDITOR_MARK_ORDER, } from "./types.js";
+// C0/C1 controls, bidi marks, embeddings, overrides and isolates, BOM, zero-width
+// space, word joiner and line/paragraph separators: the characters the block
+// schemas refuse. ZWJ/ZWNJ stay (emoji, some scripts).
+const UNSAFE = [
+    [0x00, 0x1f],
+    [0x7f, 0x9f],
+    [0x061c, 0x061c],
+    [0x200b, 0x200b],
+    [0x200e, 0x200f],
+    [0x2028, 0x2029],
+    [0x202a, 0x202e],
+    [0x2060, 0x2060],
+    [0x2066, 0x2069],
+    [0xfeff, 0xfeff],
+];
+function unsafe(code, keep) {
+    if (keep.includes(String.fromCharCode(code)))
+        return false;
+    return UNSAFE.some(([low, high]) => code >= low && code <= high);
+}
+/**
+ * Remove the characters the model never stores. `keep` lists control
+ * characters that stay (`'\n\t'` for code). Line and paragraph separators and
+ * `\r\n` become `\n` first.
+ */
+export function cleanText(text, keep = '') {
+    const source = text.replace(/\r\n?|[\u2028\u2029]/g, '\n');
+    let out = '';
+    let stripped = false;
+    for (const char of source) {
+        if (unsafe(char.codePointAt(0) ?? 0, keep))
+            stripped = true;
+        else
+            out += char;
+    }
+    return { text: out, stripped };
+}
+/** The identity of a mark: its type, plus the href for links. */
+export const markKey = (mark) => mark.type === 'link' ? `link:${mark.href}` : mark.type;
+export const hasMark = (marks, type) => marks.some((mark) => mark.type === type);
+/**
+ * Canonical mark set: one mark per type (the first wins), sorted in
+ * `EDITOR_MARK_ORDER`, and `code` excludes every mark but `link`.
+ */
+export function sortMarks(marks) {
+    const byType = new Map();
+    for (const mark of marks)
+        if (!byType.has(mark.type))
+            byType.set(mark.type, mark);
+    const code = byType.has('code');
+    const out = EDITOR_MARK_ORDER.flatMap((type) => {
+        const mark = byType.get(type);
+        return mark && (!code || type === 'link' || type === 'code') ? [mark] : [];
+    });
+    return out.length === marks.length && out.every((mark, i) => mark === marks[i]) ? marks : out;
+}
+export const sameMarks = (a, b) => a.length === b.length && a.every((mark, i) => markKey(mark) === markKey(b[i]));
+export const withMark = (marks, mark) => sortMarks([mark, ...marks.filter((m) => m.type !== mark.type)]);
+export const withoutMark = (marks, type) => marks.filter((mark) => mark.type !== type);
+const length = (node) => (node.type === 'text' ? node.text.length : 1);
+/** Length in UTF-16 code units; a break counts 1. */
+export const inlineLength = (content) => content.reduce((sum, node) => sum + length(node), 0);
+/** The text of inline content; a break is `\n`. */
+export const inlineText = (content) => content.map((node) => (node.type === 'text' ? node.text : '\n')).join('');
+/**
+ * Canonical inline content: marks sorted, empty runs dropped, neighbors with
+ * equal marks merged. Returns `content` itself when it is already canonical.
+ */
+export function normalizeInline(content) {
+    const out = [];
+    let changed = false;
+    for (const node of content) {
+        if (node.type === 'break') {
+            out.push(node);
+            continue;
+        }
+        if (node.text === '') {
+            changed = true;
+            continue;
+        }
+        const marks = sortMarks(node.marks);
+        const previous = out.at(-1);
+        if (previous?.type === 'text' && sameMarks(previous.marks, marks)) {
+            out[out.length - 1] = {
+                type: 'text',
+                text: previous.text + node.text,
+                marks: previous.marks,
+            };
+            changed = true;
+            continue;
+        }
+        if (marks !== node.marks)
+            changed = true;
+        out.push(marks === node.marks ? node : { type: 'text', text: node.text, marks });
+    }
+    return changed ? out : content;
+}
+/** Inline content between two offsets. */
+export function sliceInline(content, from, to = Number.POSITIVE_INFINITY) {
+    const out = [];
+    let at = 0;
+    for (const node of content) {
+        const end = at + length(node);
+        if (end > from && at < to) {
+            out.push(node.type === 'text'
+                ? {
+                    ...node,
+                    text: node.text.slice(Math.max(0, from - at), Math.min(node.text.length, to - at)),
+                }
+                : node);
+        }
+        at = end;
+    }
+    return out;
+}
+export const concatInline = (...parts) => normalizeInline(parts.flat());
+/** Replace `[from, to)` with `insert`. */
+export const spliceInline = (content, from, to, insert = []) => concatInline(sliceInline(content, 0, from), insert, sliceInline(content, to));
+/** The run covering the character at `offset`, if it is text. */
+function textAt(content, offset) {
+    let at = 0;
+    for (const node of content) {
+        const end = at + length(node);
+        if (offset >= at && offset < end)
+            return node.type === 'text' ? node : undefined;
+        at = end;
+    }
+    return undefined;
+}
+/**
+ * The marks text typed at `offset` gets: those of the character before (the
+ * first character at offset 0). A link continues only strictly inside it.
+ */
+export function inheritedMarks(content, offset) {
+    const before = offset > 0 ? textAt(content, offset - 1) : undefined;
+    const after = textAt(content, offset);
+    const marks = (offset > 0 ? before : after)?.marks ?? [];
+    const link = marks.find((mark) => mark.type === 'link');
+    const inside = link !== undefined &&
+        before !== undefined &&
+        after?.marks.some((mark) => markKey(mark) === markKey(link)) === true;
+    return link && !inside ? withoutMark(marks, 'link') : marks;
+}
+/** Apply `update` to the marks of every text character in `[from, to)`. */
+export function mapMarks(content, from, to, update) {
+    const middle = sliceInline(content, from, to).map((node) => node.type === 'text' ? { ...node, marks: sortMarks(update(node.marks)) } : node);
+    return concatInline(sliceInline(content, 0, from), middle, sliceInline(content, to));
+}
+/** Every text run in `[from, to)` (sliced). */
+export const textRuns = (content, from, to) => sliceInline(content, from, to).filter((node) => node.type === 'text');
+/**
+ * Inline content for plain text: `\n` becomes a break, unsafe characters are
+ * stripped (`stripped` reports it), and every run gets `marks`.
+ */
+export function textToInline(text, marks = []) {
+    const clean = cleanText(text, '\n');
+    const content = [];
+    clean.text.split('\n').forEach((part, i) => {
+        if (i > 0)
+            content.push({ type: 'break' });
+        if (part)
+            content.push({ type: 'text', text: part, marks: sortMarks(marks) });
+    });
+    return { content: normalizeInline(content), stripped: clean.stripped };
+}

package/dist/editor/input-rules.d.ts

@@ -0,0 +1,17 @@
+import { type EditorTransformOptions } from './transforms.js';
+import type { EditorState, EditorTransformResult } from './types.js';
+/**
+ * Markdown input rules, run by the binding after typed text (the result is
+ * its own undo step, so undo restores the literal characters):
+ *
+ * - at a paragraph's start: `#`–`####` and a space make a heading; `-`, `*`
+ *   or `+` and a space a bullet list; `1.` and a space an ordered list;
+ *   `[ ]` or `[x]` and a space a todo; `>` and a space a quote; three
+ *   backticks (and a language) and a space a code block; `---` a divider;
+ * - inline: `**x**`, `*x*`, `~~x~~` and `` `x` `` mark `x`, and a typed URL
+ *   followed by a space becomes a link when `safeHref` accepts it (always at
+ *   the `untrusted` tier).
+ *
+ * Returns `null` when no rule applies.
+ */
+export declare function applyInputRules(state: EditorState, options?: EditorTransformOptions): EditorTransformResult | null;

package/dist/editor/input-rules.js

@@ -0,0 +1,151 @@
+import { safeHref } from "../url/safe-href.js";
+import { blockText, locateBlock, paragraph, replaceBlock, replaceItem, } from "./document.js";
+import { hasMark, inlineText, mapMarks, sliceInline, spliceInline, textRuns, withMark, } from "./inline.js";
+import { caret, isCollapsed } from "./selection.js";
+import { insertBlock, setBlockType, toggleList, toggleQuote, } from "./transforms.js";
+const INLINE_RULES = [
+    { pattern: /(?:^|[^`\\])`([^`\n]+)`$/, size: 1, mark: { type: 'code' } },
+    {
+        pattern: /(?:^|[^*\\])\*\*([^*\s\n](?:[^*\n]*[^*\s\n])?)\*\*$/,
+        size: 2,
+        mark: { type: 'strong' },
+    },
+    { pattern: /(?:^|[^~\\])~~([^~\s\n](?:[^~\n]*[^~\s\n])?)~~$/, size: 2, mark: { type: 'strike' } },
+    { pattern: /(?:^|[^*\\])\*([^*\s\n](?:[^*\n]*[^*\s\n])?)\*$/, size: 1, mark: { type: 'em' } },
+];
+const AUTOLINK = /(?:^|\s)((?:https?:\/\/|mailto:)[^\s]+) $/i;
+/**
+ * Markdown input rules, run by the binding after typed text (the result is
+ * its own undo step, so undo restores the literal characters):
+ *
+ * - at a paragraph's start: `#`–`####` and a space make a heading; `-`, `*`
+ *   or `+` and a space a bullet list; `1.` and a space an ordered list;
+ *   `[ ]` or `[x]` and a space a todo; `>` and a space a quote; three
+ *   backticks (and a language) and a space a code block; `---` a divider;
+ * - inline: `**x**`, `*x*`, `~~x~~` and `` `x` `` mark `x`, and a typed URL
+ *   followed by a space becomes a link when `safeHref` accepts it (always at
+ *   the `untrusted` tier).
+ *
+ * Returns `null` when no rule applies.
+ */
+export function applyInputRules(state, options) {
+    if (state.selection.kind !== 'text' || !isCollapsed(state.selection))
+        return null;
+    const { block: id, offset } = state.selection.focus;
+    const location = locateBlock(state.doc, id);
+    const block = location?.block;
+    if (!location || !block || (block.type !== 'paragraph' && block.type !== 'heading'))
+        return null;
+    const before = blockText(block).slice(0, offset);
+    if (block.type === 'paragraph' && !before.includes('\n')) {
+        const result = blockRule(state, block, location, before, options);
+        if (result)
+            return result;
+    }
+    return inlineRule(state, block, before, offset);
+}
+function blockRule(state, block, location, before, options) {
+    const firstInItem = location.ancestors.at(-1)?.kind === 'item' && location.index === 0;
+    const strip = (size) => ({
+        ...state,
+        doc: replaceBlock(state.doc, block.id, () => [
+            { ...block, content: sliceInline(block.content, size) },
+        ]),
+        selection: caret(block.id, 0),
+    });
+    const accepted = (result) => (result.ok ? result : null);
+    const heading = /^(#{1,4}) $/.exec(before);
+    if (heading && !firstInItem) {
+        const level = heading[1].length;
+        return accepted(setBlockType(strip(before.length), 'heading', level, options));
+    }
+    if (firstInItem)
+        return null;
+    if (/^[-*+] $/.test(before))
+        return accepted(toggleList(strip(before.length), 'bullet', options));
+    const ordered = /^(\d{1,9})[.)] $/.exec(before);
+    if (ordered) {
+        const result = toggleList(strip(before.length), 'ordered', options);
+        const start = Number(ordered[1]);
+        if (!result.ok || start === 1)
+            return accepted(result);
+        const list = locateBlock(result.state.doc, block.id)?.ancestors.at(-1);
+        if (list?.kind !== 'item')
+            return result;
+        const doc = replaceBlock(result.state.doc, list.list.id, (l) => [
+            { ...l, start },
+        ]);
+        return { ok: true, state: { ...result.state, doc } };
+    }
+    const todo = /^\[([ xX])\] $/.exec(before);
+    if (todo) {
+        const result = toggleList(strip(before.length), 'todo', options);
+        if (!result.ok || todo[1] === ' ')
+            return accepted(result);
+        const item = locateBlock(result.state.doc, block.id)?.ancestors.at(-1);
+        if (item?.kind !== 'item')
+            return result;
+        const doc = replaceItem(result.state.doc, item.item.id, (i) => [{ ...i, checked: true }]);
+        return { ok: true, state: { ...result.state, doc } };
+    }
+    if (before === '> ')
+        return accepted(toggleQuote(strip(2), options));
+    const fence = /^```([a-z][a-z0-9+-]{0,31})? $/i.exec(before);
+    if (fence) {
+        const stripped = strip(before.length);
+        const result = setBlockType(stripped, 'code', 1, options);
+        if (!result.ok || !fence[1])
+            return accepted(result);
+        const lang = fence[1].toLowerCase();
+        const doc = replaceBlock(result.state.doc, block.id, (b) => [{ ...b, lang }]);
+        return { ok: true, state: { ...result.state, doc } };
+    }
+    if (before === '---' && inlineText(block.content) === '---') {
+        const emptied = {
+            ...state,
+            doc: replaceBlock(state.doc, block.id, () => [paragraph([], block.id)]),
+            selection: caret(block.id, 0),
+        };
+        return accepted(insertBlock(emptied, { type: 'divider' }, options));
+    }
+    return null;
+}
+function inlineRule(state, block, before, offset) {
+    const done = (content, at) => ({
+        ok: true,
+        state: {
+            ...state,
+            doc: replaceBlock(state.doc, block.id, () => [{ ...block, content }]),
+            selection: caret(block.id, at),
+            storedMarks: null,
+        },
+    });
+    for (const { pattern, size, mark } of INLINE_RULES) {
+        const match = pattern.exec(before);
+        if (!match)
+            continue;
+        const inner = match[1];
+        const close = offset - size;
+        const start = close - inner.length;
+        const open = start - size;
+        const runs = textRuns(block.content, open, offset);
+        if (runs.some((run) => hasMark(run.marks, 'code')))
+            continue;
+        let content = spliceInline(block.content, close, offset);
+        content = mapMarks(content, start, close, (marks) => withMark(marks, mark));
+        content = spliceInline(content, open, start);
+        return done(content, offset - 2 * size);
+    }
+    const link = AUTOLINK.exec(before);
+    if (link) {
+        const url = link[1];
+        const href = safeHref(url, 'untrusted');
+        const end = offset - 1;
+        const start = end - url.length;
+        const runs = textRuns(block.content, start, end);
+        if (href && !runs.some((run) => hasMark(run.marks, 'link') || hasMark(run.marks, 'code'))) {
+            return done(mapMarks(block.content, start, end, (marks) => withMark(marks, { type: 'link', href })), offset);
+        }
+    }
+    return null;
+}

package/dist/editor/keymap.d.ts

@@ -0,0 +1,30 @@
+import { type KeyboardEventLike } from '../keyboard/keys.js';
+import { type ShortcutBinding, type ShortcutPlatform, type ShortcutStyle } from '../keyboard/shortcuts.js';
+/** What a key chord asks the editor to do. The binding maps intents to transforms. */
+export type EditorKeyIntent = 'toggle-strong' | 'toggle-em' | 'toggle-code' | 'toggle-strike' | 'link' | 'undo' | 'redo' | 'paragraph' | 'heading-1' | 'heading-2' | 'heading-3' | 'heading-4' | 'ordered-list' | 'bullet-list' | 'todo-list' | 'quote' | 'toggle-todo'
+/** Tab: indent a list item. Outside lists the binding lets Tab move focus. */
+ | 'indent' | 'outdent'
+/** Leave the toolbar or dialog; in the text, let the next Tab leave the editor. */
+ | 'escape';
+/** The editor's key chords (ADR-003). `Mod` is ⌘ on Apple platforms, Ctrl elsewhere. */
+export declare const EDITOR_SHORTCUTS: readonly ShortcutBinding<EditorKeyIntent>[];
+export interface EditorKeymap {
+    readonly platform: ShortcutPlatform;
+    /** The intent of a keydown, or `null`. Composing events never match. */
+    match(event: KeyboardEventLike): EditorKeyIntent | null;
+    /** Value for `aria-keyshortcuts` on the control that runs `intent`. */
+    ariaKeyShortcuts(intent: EditorKeyIntent): string;
+    /** The chords of `intent`, formatted for tooltips and help text. */
+    describe(intent: EditorKeyIntent, style?: ShortcutStyle): string[];
+}
+/** The editor keymap for one platform (see `detectPlatform`). */
+export declare function createEditorKeymap(platform: ShortcutPlatform): EditorKeymap;
+/** What a `beforeinput` event asks for. */
+export type EditorInputIntent = 'insert-text' | 'split-block' | 'insert-break' | 'delete-backward' | 'delete-forward' | 'delete-word-backward' | 'delete-word-forward' | 'delete-line-backward' | 'delete-line-forward' | 'delete-selection' | 'paste' | 'drop' | 'replace-text' | 'undo' | 'redo' | 'toggle-strong' | 'toggle-em' | 'toggle-strike'
+/** Leave the DOM alone; apply the change at `compositionend`. */
+ | 'composition';
+/**
+ * The intent of a `beforeinput` `inputType`, or `null` for types the editor
+ * refuses (formatting it does not support, such as `formatUnderline`).
+ */
+export declare const intentFromInputType: (inputType: string) => EditorInputIntent | null;

package/dist/editor/keymap.js

@@ -0,0 +1,69 @@
+import { isComposing } from "../keyboard/keys.js";
+import { createShortcutMap, } from "../keyboard/shortcuts.js";
+/** The editor's key chords (ADR-003). `Mod` is ⌘ on Apple platforms, Ctrl elsewhere. */
+export const EDITOR_SHORTCUTS = [
+    { id: 'toggle-strong', keys: 'Mod+B' },
+    { id: 'toggle-em', keys: 'Mod+I' },
+    { id: 'toggle-code', keys: 'Mod+E' },
+    { id: 'toggle-strike', keys: 'Mod+Shift+X' },
+    { id: 'link', keys: 'Mod+K' },
+    { id: 'undo', keys: 'Mod+Z' },
+    { id: 'redo', keys: ['Mod+Shift+Z', 'Mod+Y'] },
+    { id: 'paragraph', keys: 'Mod+Alt+0' },
+    { id: 'heading-1', keys: 'Mod+Alt+1' },
+    { id: 'heading-2', keys: 'Mod+Alt+2' },
+    { id: 'heading-3', keys: 'Mod+Alt+3' },
+    { id: 'heading-4', keys: 'Mod+Alt+4' },
+    { id: 'ordered-list', keys: 'Mod+Shift+7' },
+    { id: 'bullet-list', keys: 'Mod+Shift+8' },
+    { id: 'todo-list', keys: 'Mod+Shift+9' },
+    { id: 'quote', keys: 'Mod+Shift+B' },
+    { id: 'toggle-todo', keys: 'Mod+Enter' },
+    { id: 'indent', keys: 'Tab' },
+    { id: 'outdent', keys: 'Shift+Tab' },
+    { id: 'escape', keys: 'Escape' },
+];
+/** The editor keymap for one platform (see `detectPlatform`). */
+export function createEditorKeymap(platform) {
+    const map = createShortcutMap(EDITOR_SHORTCUTS, platform);
+    return {
+        platform,
+        match: (event) => (isComposing(event) ? null : map.match(event)),
+        ariaKeyShortcuts: (intent) => map.ariaKeyShortcuts(intent),
+        describe: (intent, style) => map.describe(intent, style),
+    };
+}
+const INPUT_TYPES = {
+    insertText: 'insert-text',
+    insertParagraph: 'split-block',
+    insertLineBreak: 'insert-break',
+    deleteContentBackward: 'delete-backward',
+    deleteContentForward: 'delete-forward',
+    deleteWordBackward: 'delete-word-backward',
+    deleteWordForward: 'delete-word-forward',
+    deleteSoftLineBackward: 'delete-line-backward',
+    deleteHardLineBackward: 'delete-line-backward',
+    deleteSoftLineForward: 'delete-line-forward',
+    deleteHardLineForward: 'delete-line-forward',
+    deleteContent: 'delete-selection',
+    deleteByCut: 'delete-selection',
+    deleteByDrag: 'delete-selection',
+    insertFromPaste: 'paste',
+    insertFromPasteAsQuotation: 'paste',
+    insertFromDrop: 'drop',
+    insertReplacementText: 'replace-text',
+    insertFromYank: 'insert-text',
+    historyUndo: 'undo',
+    historyRedo: 'redo',
+    formatBold: 'toggle-strong',
+    formatItalic: 'toggle-em',
+    formatStrikeThrough: 'toggle-strike',
+    insertCompositionText: 'composition',
+    deleteCompositionText: 'composition',
+    insertFromComposition: 'composition',
+};
+/**
+ * The intent of a `beforeinput` `inputType`, or `null` for types the editor
+ * refuses (formatting it does not support, such as `formatUnderline`).
+ */
+export const intentFromInputType = (inputType) => Object.hasOwn(INPUT_TYPES, inputType) ? INPUT_TYPES[inputType] : null;