efficient-easel 10.1.0 → 10.3.0

package/dist/copy/index.d.ts

@@ -1,403 +1,13 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
-import { MarkStyle, MarkupTool, WrapResult, InlineRule, MarkedLine } from '../markup/index.js';
-import { C as CopyWords, a as CopyAlign } from '../words-dsex49Jh.js';
-export { b as COPY_ALIGNS, c as COPY_ALIGN_FIT, d as COPY_ALIGN_GLYPHS, e as COPY_ALIGN_LABELS, f as copyAlignOptions } from '../words-dsex49Jh.js';
-import { TextToolbarCase, TextToolbarMark } from 'efficient-shell/ui';
+import { b as CopyBoxProps, c as CopyCell, T as TextBoxHandle } from '../canvas-typing-CJodefPO.js';
+export { d as COPY_CELLS, a as CanvasTypingEnd, e as CanvasTypingOptions, f as CanvasTypingSession, g as ColorWindow, h as CopyBoxAlign, i as CopyBoxFooter, C as CopyBoxLastTool, j as CopyCase, k as CopyCellPreset, l as CopyCells, m as CopyThemeColor, M as MarkBar, n as MarkBarProps, o as MarkWriter, S as SelectionSource, p as TextAreaHandle, q as TextMap, r as ToolbarMark, s as ariaShortcut, t as insertSelection, u as markSelection, v as startCanvasTyping, w as textMap } from '../canvas-typing-CJodefPO.js';
 export { TextToolbar, TextToolbarProps } from 'efficient-shell/ui';
-import { g as FieldOption } from '../types-C97TAUKi.js';
-export { C as CanvasTypingEnd, a as CanvasTypingOptions, b as CanvasTypingSession, T as TextMap, s as startCanvasTyping, t as textMap } from '../canvas-typing-Cnvlsh_V.js';
+import { F as FieldOption } from '../types-Dkx1VAIQ.js';
+import { a as CopyAlign } from '../words-dsex49Jh.js';
+export { b as COPY_ALIGNS, c as COPY_ALIGN_FIT, d as COPY_ALIGN_GLYPHS, e as COPY_ALIGN_LABELS, C as CopyWords, f as copyAlignOptions } from '../words-dsex49Jh.js';
+import { InlineRule, MarkStyle, MarkedLine, WrapResult } from '../markup/index.js';
 import '../buckets-Tj-nkBpg.js';
 
-type CellWords = NonNullable<CopyWords['cells']>;
-interface CopyCell {
-    /** Which cell this is — a stable key for the grid. */
-    key: string;
-    /** The cell's name, from the copy words (the four the design draws)… */
-    nameKey?: Exclude<keyof CellWords, 'tip'>;
-    /** …or the host's own (a cell the package does not know). */
-    name?: string;
-    icon?: ReactNode;
-    unit?: string;
-    /** What an arrow or ↑↓ moves by, in SHOWN units. */
-    step?: number;
-    /** What Shift moves by. Default ten steps. */
-    shiftStep?: number;
-    /** Bounds, in SHOWN units. */
-    min?: number;
-    max?: number;
-    /** Shown = stored × scale (100 for a multiple shown in %). Default 1. */
-    scale?: number;
-    /** The STORED value, or `undefined` while the cell follows the style. */
-    value: number | undefined;
-    /** The style's STORED value, shown grey while the cell is empty. */
-    styleValue?: number;
-    /** A STORED value, or `undefined` when the cell is emptied. */
-    onChange: (value: number | undefined) => void;
-}
-/** A cell's preset: everything but its value and its write. */
-type CopyCellPreset = Omit<CopyCell, 'value' | 'styleValue' | 'onChange'>;
-/** The four cells the final design draws, with its steps and ranges
- *  (the campaign page's "三个框的规则" table, read 2026-10-06). */
-declare const COPY_CELLS: {
-    fontSize: CopyCellPreset;
-    lineHeight: CopyCellPreset;
-    letterSpacing: CopyCellPreset;
-    paragraphSpacing: CopyCellPreset;
-};
-declare function CopyCells({ cells, words, readOnly }: {
-    cells: readonly CopyCell[];
-    words?: CellWords;
-    readOnly?: boolean;
-}): react.JSX.Element;
-
-interface CopyThemeColor {
-    name: string;
-    label: string;
-    value: string;
-}
-declare function ColorWindow({ colors, current, words, onPick, }: {
-    colors: readonly CopyThemeColor[];
-    /** The colour the selection wears — a theme name or a hex — or null. */
-    current: string | null;
-    words: NonNullable<CopyWords['colors']>;
-    /** A theme name, a lowercase `#rrggbb`, or null to take the colour off. */
-    onPick: (color: string | null) => void;
-}): react.JSX.Element;
-
-/** `'b'` → `Meta+B`, `'shift+x'` → `Meta+Shift+X` — the ARIA spelling of a
- *  shortcut. Meta is what the tooltips promise (⌘); Ctrl works too. */
-declare function ariaShortcut(shortcut: string | undefined): string | undefined;
-interface MarkBarProps {
-    /**
-     * Which buttons to show.
-     *
-     * TWO FORMS, and the second is not a convenience — it is the only way a
-     * product with marks of its OWN can use this bar at all.
-     *
-     *   `MarkStyle[]`   resolved against the shared grammar's `MARKUP_TOOLS`, in
-     *                   that order. What the campaign designer passes.
-     *   `MarkupTool[]`  used verbatim. What `efficient-storefront` passes.
-     *
-     * ⚠️ WHY VERBATIM DESCRIPTORS HAD TO EXIST. The storefront offered SEVEN
-     * marks: the grammar's four, plus its three word styles (`@@`, `++`, `^^`),
-     * which then lived only in the shop because the grammar was
-     * `efficient-shell/markup`. Resolving through `markupTools` can only ever
-     * return marks the grammar knows, so it silently DROPPED all three — the bar
-     * rendered four buttons where the panel had seven, and nothing failed to
-     * compile. Since 2026-09-28 the grammar is ours and holds Quiet (`^^`) and
-     * reads `@@` / `++` as Emphasis and Strong, but a host may still hand in
-     * marks of its own.
-     *
-     * So a host that has its own marks builds its own descriptors (the shop
-     * already did: `shopMarkupTools()`) and hands them over whole. The bar's job
-     * is the ROW — the buttons, the focus guard, the naming, the group — and that
-     * job does not depend on who defined the mark.
-     */
-    tools: readonly MarkStyle[] | readonly MarkupTool[];
-    onApply: (style: MarkStyle) => void;
-    disabled?: boolean;
-    /** Buttons that write no mark, after a divider — see `CopyBoxProps.actions`. */
-    actions?: ReactNode;
-    /** The alignment strip, already built by the control. */
-    align?: ReactNode;
-    /**
-     * WHAT A BUTTON IS DRAWN AS, per style. Default: the grammar's own letter —
-     * `B`, `I`, `S`, `◆` — which is what the campaign designer has always shown.
-     *
-     * ⚠️ THIS IS NOT A THEME KNOB, AND IT IS NOT OPTIONAL POLISH. This package
-     * already says that WHICH buttons and WHAT they write are the grammar's, while
-     * how they LOOK is the host's, "because this bar has to belong to the
-     * storefront inspector's chrome and the campaign designer's bar has to belong
-     * to the portal's". Colour was delegated by tokens on day one; the DRAWING was
-     * not, and a letter is a drawing. `efficient-storefront` renders each mark as a 14px
-     * stroked SVG at the weight of its other inspector glyphs, on the stated
-     * ground that the row should read "as part of the field rather than as
-     * pasted-in icons" — so without this it could not adopt the bar without losing
-     * that, which is a regression dressed as a refactor.
-     *
-     * The set now HAS a glyph for every mark (0.94.0: bold, italic, strike,
-     * emphasis, quiet, clear-marks — the owner's call, made 2026-10-02), and they
-     * are the default. This map stays so a host can still draw its own.
-     *
-     * A style the map does not name falls back to the icon set's glyph for it
-     * (`SET_GLYPH`, 0.94.0, when the owner added the mark glyphs to the set) and
-     * then to the letter, so a host may override one button and leave the rest.
-     */
-    glyphs?: Partial<Record<MarkStyle, ReactNode>>;
-    /**
-     * What the group is CALLED. Defaults to "Formatting" (`EaselStrings.copy.formatting`).
-     *
-     * A bar bound to one box needs nothing more. A bar SHARED by several rows has
-     * to say which row it is aimed at, because the visible cue — the marked row —
-     * is not readable. `efficient-storefront` has that case today.
-     */
-    ariaLabel?: string;
-    /**
-     * The marks the selection already wears — a button drawn pressed is one
-     * whose press takes the mark OFF (`markedAt`, the same test `applyMark`
-     * unwraps by), so the two cannot disagree. A style not named is not pressed;
-     * with no map at all no button says either way (`aria-pressed` is left off),
-     * which is what every host that does not track the selection still gets.
-     */
-    pressed?: Partial<Record<MarkStyle, boolean>>;
-    /** The style whose own window is open — the link button while its "Link
-     *  to" window is showing. Drawn pressed, and named as expanded. */
-    open?: MarkStyle | null;
-}
-declare function MarkBar({ tools, onApply, disabled, actions, align, glyphs, ariaLabel, pressed, open, }: MarkBarProps): react.JSX.Element | null;
-
-/**
- * Just enough of a text control to read a selection off it. Narrowed to these
- * two fields so a caller may hand in a plain object in a test.
- *
- * A `<textarea>` OR an `<input>` (blueprint 4.9). An input's selection is
- * `number | null` where a textarea's is `number`, so the type had to be the
- * wider of the two: typed to the textarea, every one-line row in the website
- * editor needed a cast or a copy of this file, and the shop kept a copy.
- */
-type SelectionSource = {
-    readonly selectionStart: number | null;
-    readonly selectionEnd: number | null;
-} | null;
-/**
- * How a mark is written. Defaults to the shared grammar's own `applyMark`.
- *
- * INJECTED RATHER THAN ASSUMED, because the storefront legitimately writes marks
- * the shell's grammar does not know: its three word styles (`@@`, `++`, `^^`)
- * go through `applyShopMark`, which delegates here for everything else. Making
- * the writer a parameter is what lets one control serve both products without
- * this package learning a vocabulary that belongs to one of them.
- */
-type MarkWriter = (text: string, start: number, end: number, style: MarkStyle) => WrapResult;
-/** Apply a style to whatever the field has selected. */
-declare function markSelection(value: string, style: MarkStyle, el: SelectionSource, write?: MarkWriter): WrapResult;
-/**
- * Put a literal string where the caret is.
- *
- * The caret lands AFTER the inserted text and selects nothing, because the thing
- * inserted is finished — a merge tag is not a placeholder to type over, and
- * leaving it selected invites the next keystroke to delete it.
- */
-declare function insertSelection(value: string, text: string, el: SelectionSource): WrapResult;
-
-/** A letter case the toolbar sets on the host's field: the shell toolbar's. */
-type CopyCase = TextToolbarCase;
-/** The marks row 1 of the toolbar carries: the shell toolbar's. */
-type ToolbarMark = TextToolbarMark;
-/**
- * A handle on the box's textarea.
- *
- * DECLARED STRUCTURALLY rather than as React's `RefObject`, and the reason is
- * the package's `react >=18` peer range. React 18 types read `RefObject<T>` as
- * `{ readonly current: T | null }`, React 19's `useRef<T>(null)` produces
- * `RefObject<T | null>`, and the interface is covariant in `T` — so the two
- * spellings of the same object do not assign to each other, and a package that
- * has to compile against both cannot name either one. The shape is the whole
- * contract; naming it here costs one line and no version branch.
- */
-type TextAreaHandle = {
-    current: HTMLTextAreaElement | null;
-};
-/**
- * A handle on ANY text control the caret machinery can drive — a `<textarea>`
- * or a one-line `<input>` (blueprint 4.9). `useCaretEdit` takes this, so a host
- * with its own input rows (the website editor's list lines) uses the same
- * twelve lines instead of a copy of them. A {@link TextAreaHandle} is one.
- */
-type TextBoxHandle = {
-    current: HTMLInputElement | HTMLTextAreaElement | null;
-};
-/**
- * What a host may put UNDER the box, and what it needs to draw it.
- *
- * A render prop rather than a plain node, for one reason that is not style: the
- * campaign's merge-tag chips have to insert at the caret, and only this control
- * knows where the caret is. Handing the host `insert` is what lets the chips
- * live in the app — where the tag list, the audience call and the product's
- * vocabulary belong — while the caret machinery stays here, written once.
- *
- * `focused` is passed for the same reason the portal tracked it locally: the row
- * appears while the merchant is typing in THIS box and not in its neighbour.
- */
-interface CopyBoxFooter {
-    focused: boolean;
-    /** Put a literal string where the caret is, replacing any selection. */
-    insert: (text: string) => void;
-}
-/**
- * What a host needs to draw its OWN control in row 1's 9th cell of the final
- * toolbar ({@link CopyBoxProps.lastTool}) — the campaign designer's Insert
- * (merge tags), owner ruling 2026-10-07. The website editor passes nothing.
- *
- * `className` makes it a cell that looks like its neighbours; `keepCaret` on
- * its mousedown keeps the caret and the selection in the box; `insert` writes
- * at the caret, as {@link CopyBoxFooter.insert} does.
- */
-interface CopyBoxLastTool {
-    className: string;
-    /** The box is read-only. */
-    disabled: boolean;
-    /** Words are selected (not just a caret). */
-    selected: boolean;
-    keepCaret: (e: {
-        preventDefault(): void;
-    }) => void;
-    /** Put a literal string where the caret is, replacing any selection. */
-    insert: (text: string) => void;
-}
-/**
- * The alignment strip, when the host has an alignment to offer.
- *
- * GENERIC IN THE DIRECTIONS IT ALLOWS, so `onChange` RECEIVES only what the
- * host said it could honour. Before this it received the whole union, and a
- * host allowing three directions had to narrow a `justify` it had just
- * declared impossible before storing. Raised by the strip's first consumer,
- * which did write that narrowing; the next one might not.
- *
- * `A` is inferred from `allow`, so nothing has to be spelled at the call site.
- *
- * ⚠️ IT DOES NOT FORBID A WIDER HANDLER, and cannot: a function taking the
- * whole `CopyAlign` is assignable where one taking three is wanted, because
- * parameters are contravariant — and that direction is SAFE, since only the
- * three can ever arrive. What this buys is that the narrow handler now
- * type-checks without a cast, which is what makes writing the safe one the
- * path of least resistance.
- */
-interface CopyBoxAlign<A extends CopyAlign = CopyAlign> {
-    value: A | '';
-    onChange: (next: A) => void;
-    /**
-     * Which directions this host can honour. Required and with no default: a
-     * renderer that cannot justify must not be given a Justify button because a
-     * default handed it one, which is the shape of mistake this whole card exists
-     * to stop. It is also what `A` above is inferred from.
-     */
-    allow: readonly A[];
-    /** The strip exists but cannot apply right now. Distinct from the whole
-     *  control being read-only. */
-    disabled?: boolean;
-}
-interface CopyBoxProps {
-    /** The authored string, delimiters and all. The single source of truth. */
-    value: string;
-    /** Every keystroke, and every button press. */
-    onChange: (value: string) => void;
-    /** The edit is finished and may be written: on blur, and on Enter when
-     *  {@link multiline} is false. */
-    onCommit?: (value: string) => void;
-    /** Escape. The argument is the value the box was given when it gained focus;
-     *  the HOST puts it back, because the host owns the string. */
-    onCancel?: (restored: string) => void;
-    /** What Enter means — NOT how the text wraps. Both modes soft-wrap. */
-    multiline?: boolean;
-    placeholder?: string;
-    /** Accessible name for the box. */
-    ariaLabel?: string;
-    className?: string;
-    /** Nothing may be typed or pressed. */
-    readOnly?: boolean;
-    /**
-     * The grammar's rule set — `CAMPAIGN_MARKUP` in the designer,
-     * `STOREFRONT_MARKUP` in the shop, both from `efficient-easel/markup`. It
-     * decides what the LAYER paints; {@link tools} decides what the BAR offers,
-     * and a host that lets those two disagree gets a button whose mark draws as
-     * plain text.
-     */
-    rules?: readonly InlineRule[];
-    /**
-     * Which mark buttons to show — styles resolved against the shared grammar, or
-     * the host's own descriptors used verbatim. See `MarkBarProps.tools`. Empty
-     * draws no bar.
-     */
-    tools?: MarkBarProps['tools'];
-    /**
-     * How a mark is written. Defaults to the shared grammar's `applyMark`; the
-     * storefront passes its own so its three word styles reach the same bar.
-     */
-    writeMark?: MarkWriter;
-    /**
-     * Buttons that are NOT marks, drawn after a divider at the end of the bar.
-     *
-     * The storefront's "Clear formatting" is the one that exists: it writes no
-     * mark at all, so it is not in the grammar's tool list and must not be added
-     * to it. Drawing it here keeps `MARKUP_TOOLS` meaning "what a mark MEANS".
-     */
-    actions?: ReactNode;
-    /** The alignment strip. Omitted = no strip. */
-    align?: CopyBoxAlign<CopyAlign>;
-    /** What each mark button is DRAWN as — see `MarkBarProps.glyphs`. Default is
-     *  the grammar's own letter. */
-    glyphs?: MarkBarProps['glyphs'];
-    /** What the formatting group is CALLED — see `MarkBarProps.ariaLabel`. */
-    barLabel?: string;
-    /** What goes under the box — see {@link CopyBoxFooter}. */
-    renderFooter?: (ctx: CopyBoxFooter) => ReactNode;
-    /**
-     * When the bar is drawn. `'always'` (the default) keeps it over the box at
-     * rest. `'focus'` draws it only while this box is being typed in — the text
-     * box design for 4.9: a column of text settings at rest is a column of
-     * words, not a column of toolbars.
-     */
-    barShows?: 'always' | 'focus';
-    /**
-     * Show the EFFECT, not the marks (0.95.0, rulings B + C — the default). A
-     * many-line box gets a "Show marks" switch under it that flips to the raw
-     * text with its marks and back; a one-line box is always the effect.
-     * `false` keeps the 0.94 box (the raw text, painted) with no switch.
-     *
-     * ⚠️ In the rich view there is no textarea, so {@link inputRef} holds null.
-     * Insert at the caret through `renderFooter`'s `insert`, which works in both.
-     */
-    richText?: boolean;
-    /** A many-line box opens with its marks shown. Default false. */
-    defaultShowMarks?: boolean;
-    /**
-     * Which toolbar (E5b). `'final'` — the default — is the design made final
-     * on 2026-10-06: two rows on one 9-column grid, B · I · U · S · Color ·
-     * Link · Superscript · Subscript · the host's {@link lastTool} (Undo until
-     * 2026-10-07) over Left · Center · Right · Justify
-     * · Bulleted · Numbered · Aa · AA · aa, with the number {@link cells}
-     * between it and the box. `'classic'` is the bar before it (`MarkBar` and
-     * the alignment strip), for a host not moved over yet.
-     */
-    toolbar?: 'final' | 'classic';
-    /**
-     * The theme colours the colour window offers (final toolbar): the NAME
-     * saved in `[words]{color=name}`, what it is called, and its value. The box
-     * paints a coloured word with the value (`--es-color-<name>`). The window
-     * also offers Any color, saved as a hex (`[words]{color=#rrggbb}`). No colours:
-     * no colour button, and no blank where it was (Lewis 2026-10-13).
-     */
-    colors?: readonly CopyThemeColor[];
-    /** The number cells between the toolbar and the box (final toolbar), each
-     *  the host's value — see `COPY_CELLS`. None: no cells. */
-    cells?: readonly CopyCell[];
-    /**
-     * The host's letter-case field, set by Aa · AA · aa (final toolbar). The
-     * lit one pressed again writes `''`: no case of its own, the style decides.
-     * Left out: no case buttons, and no blanks where they were (Lewis
-     * 2026-10-13). A row with no tool at all is not drawn.
-     */
-    letterCase?: {
-        value: CopyCase | '';
-        onChange: (next: CopyCase | '') => void;
-        disabled?: boolean;
-    };
-    /**
-     * Row 1's 9th cell of the final toolbar, drawn by the host (owner ruling
-     * 2026-10-07: Undo left that cell). Return one control; it is placed in the
-     * cell as given; one that draws nothing (`null`) leaves no blank. Left
-     * out, row 1 is eight buttons spread over the row. See
-     * {@link CopyBoxLastTool}.
-     */
-    lastTool?: (slot: CopyBoxLastTool) => ReactNode;
-    /** A handle on the textarea, for a host that needs one — and the SAME object
-     *  the control uses, so there is never a second ref to reconcile. A plain prop
-     *  rather than `ref`, for the reason `GoldLayer.layerRef` gives. */
-    inputRef?: TextAreaHandle;
-}
-
 declare function CopyBox({ value, onChange, onCommit, onCancel, multiline, placeholder, ariaLabel, className, readOnly, rules, tools, writeMark, actions, align, glyphs, barLabel, renderFooter, inputRef, barShows, richText, defaultShowMarks, toolbar, colors, cells, letterCase, lastTool, }: CopyBoxProps): react.JSX.Element;
 
 /** Whether the lines are a list, and which kind. */
@@ -413,6 +23,15 @@ interface TextPartStrip<V extends string> {
 interface TextPartPanelProps {
     /** The kept box, on top: a `CopyBox` for words the canvas cannot take. */
     kept?: CopyBoxProps;
+    /** One line under the kept box (what its host tool does, say). A name is
+     *  never a manual: the hint is where a clause goes (`SettingsField`'s). */
+    keptHint?: string;
+    /**
+     * Nothing can be changed (a sent campaign, a page held by somebody else):
+     * every control is shown and disabled, and nothing writes. The kept box is
+     * read-only too.
+     */
+    readOnly?: boolean;
     style?: {
         value: string;
         /** The site's (or the email's) text styles. `description` is the second
@@ -435,7 +54,9 @@ interface TextPartPanelProps {
         /** A long list (the website's fonts): the field is a search. */
         searchable?: boolean;
     };
-    /** The Italic button at the end of the Font row. `undefined` follows the style. */
+    /** The Italic button at the end of the Font row — or, where the host hands
+     *  no `font` (a phone has no font of its own), on a row of its own named
+     *  Italic, where the Font row stands. `undefined` follows the style. */
     italic?: {
         value: boolean | undefined;
         styleValue?: boolean;
@@ -448,7 +69,7 @@ interface TextPartPanelProps {
     list?: TextPartStrip<TextList>;
     letterCase?: TextPartStrip<TextCase>;
 }
-declare function TextPartPanel({ kept, style, font, italic, cells, align, list, letterCase }: TextPartPanelProps): react.JSX.Element;
+declare function TextPartPanel({ kept, keptHint, readOnly, style, font, italic, cells, align, list, letterCase, }: TextPartPanelProps): react.JSX.Element;
 
 interface PasteData {
     /** The clipboard's `text/html`, when there is one. */
@@ -700,4 +321,4 @@ interface CaretEdit {
  */
 declare function useCaretEdit({ target, onChange }: CaretEdit): (edit: (el: HTMLInputElement | HTMLTextAreaElement | null) => WrapResult) => void;
 
-export { COPY_CELLS, type CaretEdit, ColorWindow, CopyAlign, CopyBox, type CopyBoxAlign, type CopyBoxFooter, type CopyBoxLastTool, type CopyBoxProps, type CopyCase, type CopyCell, type CopyCellPreset, CopyCells, type CopyThemeColor, CopyWords, type History, MARKUP_CLIPBOARD_TYPE, MarkBar, type MarkBarProps, type MarkWriter, type PasteData, type PasteOptions, RichBox, type RichBoxProps, type RichEdit, type RichHandle, type RichInputEvent, type RichInputResult, type RichInsert, type RichLayout, type RichLine, type RichPending, type SelectionSource, type Snapshot, TYPING_BURST_MS, type TextAreaHandle, type TextBoxHandle, type TextCase, type TextList, TextPartPanel, type TextPartPanelProps, type TextPartStrip, type ToolbarMark, ariaShortcut, createHistory, editVisible, insertSelection, markSelection, markupOfRange, newLine, pasteToMarkup, richInput, richLayout, selectionToSource, selectionToVisible, setBullet, toSource, toSourceStart, toVisible, useCaretEdit };
+export { type CaretEdit, CopyAlign, CopyBox, CopyBoxProps, CopyCell, type History, MARKUP_CLIPBOARD_TYPE, type PasteData, type PasteOptions, RichBox, type RichBoxProps, type RichEdit, type RichHandle, type RichInputEvent, type RichInputResult, type RichInsert, type RichLayout, type RichLine, type RichPending, type Snapshot, TYPING_BURST_MS, TextBoxHandle, type TextCase, type TextList, TextPartPanel, type TextPartPanelProps, type TextPartStrip, createHistory, editVisible, markupOfRange, newLine, pasteToMarkup, richInput, richLayout, selectionToSource, selectionToVisible, setBullet, toSource, toSourceStart, toVisible, useCaretEdit };