@ones-editor/editor 0.0.1

package/@ones-editor/core/src/core/selection/select-handler.d.ts

@@ -0,0 +1,15 @@
+import { OnesEditorSelectionHandler, BlockPosition, OnesEditor } from '../types';
+export declare class EditorSelectionHandler implements OnesEditorSelectionHandler {
+    editor: OnesEditor;
+    startPos: BlockPosition | null;
+    lastCaretRect: DOMRect;
+    mouseDownEvent: MouseEvent | null;
+    constructor(editor: OnesEditor);
+    isSelecting(): boolean;
+    stopSelection(): void;
+    handleMouseDown: (event: MouseEvent) => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleMouseUp: (event: MouseEvent) => void;
+    handleDblClick(event: MouseEvent): void;
+    handleTripleClick(event: MouseEvent): void;
+}

package/@ones-editor/core/src/core/selection/selection-background.d.ts

@@ -0,0 +1,2 @@
+import { OnesEditor } from '../types';
+export declare function updateSelectionBackground(editor: OnesEditor): void;

package/@ones-editor/core/src/core/selection/simple-block-position.d.ts

@@ -0,0 +1,8 @@
+import { BlockElement, PositionType, SimpleBlockPosition } from '../types';
+export default class EditorSimpleBlockPosition implements SimpleBlockPosition {
+    readonly blockId: string;
+    readonly offset: number;
+    readonly type: PositionType;
+    constructor(block: string | BlockElement, offset: number, type: PositionType);
+    isSimple(): this is SimpleBlockPosition;
+}

package/@ones-editor/core/src/core/settings/index.d.ts

@@ -0,0 +1,9 @@
+import { OnesEditor, OnesEditorSettingsProvider } from '../types';
+export default class DefaultSettingsProvider implements OnesEditorSettingsProvider {
+    private editor;
+    constructor(editor: OnesEditor);
+    getKey(key: string): string;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string | null): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}

package/@ones-editor/core/src/core/types.d.ts

@@ -0,0 +1,637 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { DocBlock, DocBlockAttributes, DocBlocks, DocBlockText, DocBlockTextAttributes, DocBox, DocEmbedBlock, DocEmbedData, DocInsertion, DocObject, OnesEditorDoc, OnesEditorDocRange } from './doc';
+export type ContainerElement = HTMLDivElement & {
+    __neverUse: 'ContainerElement';
+};
+export type ContainerBlocksElement = HTMLDivElement & {
+    __neverUse: 'ContainerBlocksElement';
+};
+export type ContainerToolsElement = HTMLDivElement & {
+    __neverUse: 'ContainerBlocksElement';
+};
+export type BlockElement = HTMLDivElement & {
+    __neverUse: 'BlockElement';
+};
+export type BlockContentElement = HTMLElement & {
+    __neverUse: 'BlockContentElement';
+};
+export type BlockToolsElement = HTMLElement & {
+    __neverUse: 'BlockToolsElement';
+};
+export type BlockBackgroundElement = HTMLDivElement & {
+    __neverUse: 'BlockBackgroundElement';
+};
+export type BoxElement = HTMLSpanElement & {
+    __neverUse: 'BoxElement';
+};
+export type BoxContentElement = HTMLSpanElement & {
+    __neverUse: 'BoxContentElement';
+};
+export type InsertionElement = HTMLSpanElement & {
+    __neverUse: 'InsertionElement';
+};
+export type InsertionContentElement = HTMLSpanElement & {
+    __neverUse: 'InsertionContentElement';
+};
+export type MoveDirection = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown';
+export type BlockKind = 'text' | 'embed' | 'complex';
+export type PositionType = 'normal' | 'home' | 'end';
+export interface SimpleBlockPosition {
+    readonly blockId: string;
+    readonly offset: number;
+    readonly type: PositionType;
+    isSimple: () => this is SimpleBlockPosition;
+}
+export interface ComplexBlockPosition {
+    readonly blockId: string;
+    readonly childContainerId: string;
+    readonly custom?: unknown;
+    isSimple: () => false;
+}
+export type BlockPosition = SimpleBlockPosition | ComplexBlockPosition;
+export interface Box {
+    boxType: string;
+    updateBoxContent: (editor: OnesEditor, boxElement: BoxElement, boxContent: BoxContentElement, boxData: DocBox) => void;
+    convertFrom?: (editor: OnesEditor, text: string) => DocBox | null;
+    handleClickBox?: (editor: OnesEditor, box: BoxElement, event: MouseEvent) => void;
+    toStandardText?: (editor: OnesEditor, box: DocBox) => Promise<DocBlockText | undefined>;
+}
+export interface Insertion {
+    insertionType: string;
+    updateInsertionContent: (editor: OnesEditor, insertionElement: InsertionElement, boxContent: InsertionContentElement, childData: DocInsertion) => void;
+}
+export interface InsertEmptyBlockOptions {
+    item: CommandItem;
+    containerId: string;
+    blockIndex: number;
+    data?: Record<string, unknown>;
+}
+export interface EmbedOptions {
+    name: string;
+    insertEmbedCommandItems?: CommandItem[];
+    handleInsertEmptyEmbed?: (editor: OnesEditor, options: InsertEmptyBlockOptions) => Promise<BlockElement | null>;
+}
+export interface Embed {
+    embedType: string;
+    createEmbedContent: (editor: OnesEditor, content: BlockContentElement, block: DocEmbedBlock, path: BlockPath, container: ContainerElement, blockElement: BlockElement) => void;
+    convertTo?: (editor: OnesEditor, blockData: DocEmbedBlock, doc: DocObject, type: 'text' | 'html' | 'markdown') => string;
+    getBlockProperties?: (editor: OnesEditor, block: BlockElement) => BlockProperties;
+    getOptions?: (editor: OnesEditor) => EmbedOptions;
+    handleDeleteBlock?: (editor: OnesEditor, block: BlockElement, local: boolean, options: DeleteBlockEventOptions) => void;
+    handleUpdateBlock?: (editor: OnesEditor, block: BlockElement, blockData: DocEmbedBlock) => boolean;
+    handleDropOver?: (editor: OnesEditor, block: BlockElement, dragObject: DragObject, x: number, y: number) => DropInsertPos | undefined;
+    handleDrop?: (editor: OnesEditor, block: BlockElement, dragObject: DragObject, insertPos: DropInsertPos, options: DropOptions) => boolean | undefined;
+    convertFrom?: (editor: OnesEditor, srcBlock: BlockElement, options: {
+        offset: number;
+        data?: DocBlockAttributes;
+    }) => ConvertBlockResult | null;
+}
+export interface ConvertBlockResult {
+    blockData: DocBlock;
+    focusBlockId?: string;
+    onConverted?: (editor: OnesEditor, block: BlockElement) => void;
+}
+export interface DeleteBlockEventOptions {
+    child: boolean;
+}
+export type CommandItemType = 'normal' | 'separator' | 'section';
+export type CommandItemState = 'disabled' | 'checked' | 'selected';
+export interface Closeable {
+    close: () => void;
+    click: (item: CommandItem, target: HTMLElement) => void;
+}
+export type CommandItemChildrenPlacement = 'auto' | 'top' | 'left' | 'right' | 'bottom' | 'auto-start' | 'auto-end' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
+export interface CommandItem {
+    id: string;
+    name: string;
+    desc?: string;
+    states?: CommandItemState[];
+    value?: string;
+    order?: number;
+    type?: CommandItemType;
+    element?: HTMLElement;
+    icon?: string;
+    childrenType?: 'menu' | 'toolbar';
+    children?: CommandItem[];
+    data?: unknown;
+    group?: string;
+    groupOrder?: number;
+    dropdown?: boolean;
+    manualShowChildren?: boolean;
+    childrenPlacement?: CommandItemChildrenPlacement;
+    childrenOffset?: [number, number];
+    setCloseable?: (closeable: Closeable) => void;
+    beforePopup?: (parent: unknown) => void;
+}
+export interface BlockCommandItem extends CommandItem {
+    blockId: string;
+    blockType: string;
+    blockKind: BlockKind;
+    groupIndex: number;
+}
+export type StyleType = boolean | string | number;
+export type BlockStyles = {
+    [index: string]: StyleType;
+};
+export type BlockPathComponent = {
+    containerId: string;
+    blockIndex: number;
+};
+export type BlockPath = BlockPathComponent[];
+export interface BlockCommands {
+    group: string;
+    commands: CommandItem[];
+    executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem) => unknown;
+}
+export interface BlockProperties {
+    blockCommands?: Record<string, BlockCommands>;
+    abstract?: string;
+}
+export interface BlockOptions {
+    name: string;
+    insertBlockCommandItems?: CommandItem[];
+    handleInsertEmptyBlock?: (editor: OnesEditor, options: InsertEmptyBlockOptions) => Promise<BlockElement | null>;
+}
+export interface StandardDragObject {
+    type: 'block';
+    editorId: string;
+    containerId: string;
+    blockId: string;
+}
+export interface CustomDragObject {
+    type: 'custom';
+    customType: string;
+    editorId: string;
+    containerId: string;
+    blockId: string;
+    data: unknown;
+}
+export type DragObject = StandardDragObject | CustomDragObject;
+export interface CustomDropInsertPos {
+    rect: DOMRect;
+    data: unknown;
+}
+export type DropInsertPos = 'before' | 'after' | CustomDropInsertPos;
+export interface DropOptions {
+    isSourceBlock: boolean;
+    targetBlock: BlockElement;
+}
+export interface Block {
+    blockType: string;
+    blockKind: BlockKind;
+    createBlockContent: (editor: OnesEditor, path: BlockPath, container: ContainerElement, blockElement: BlockElement, blockData: DocBlock) => BlockContentElement;
+    getBlockTextLength: (block: BlockElement) => number;
+    getRangeFromPoint: (editor: OnesEditor, block: BlockElement, x: number, y: number) => SelectionRange | null;
+    moveCaret: (editor: OnesEditor, block: BlockElement, position: SimpleBlockPosition, direction: MoveDirection) => SimpleBlockPosition | null;
+    getCaretRect: (block: BlockElement, pos: SimpleBlockPosition) => DOMRect;
+    updateSelection: (editor: OnesEditor, block: BlockElement, from: BlockPosition, to: BlockPosition) => void;
+    clearSelection: (editor: OnesEditor) => void;
+    getBlockProperties?: (editor: OnesEditor, block: BlockElement) => BlockProperties;
+    getOptions?: (editor: OnesEditor) => BlockOptions;
+    handleBlockElementUpdated?: (editor: OnesEditor, block: BlockElement, blockData: DocBlock) => void;
+    handleContainerResized?: (editor: OnesEditor, block: BlockElement) => void;
+    handleDeleteBlock?: (editor: OnesEditor, block: BlockElement, local: boolean, options: DeleteBlockEventOptions) => void;
+    handleUpdateBlock?: (editor: OnesEditor, block: BlockElement, blockData: DocBlock) => boolean;
+    handleDropOver?: (editor: OnesEditor, block: BlockElement, dragObject: DragObject, x: number, y: number) => DropInsertPos | undefined;
+    handleDrop?: (editor: OnesEditor, block: BlockElement, dragObject: DragObject, insertPos: DropInsertPos, options: DropOptions) => boolean | undefined;
+    getClientRects?: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => DOMRect[];
+    getMinWidth?: (editor: OnesEditor, block: BlockElement) => number | undefined;
+    convertFrom?: (editor: OnesEditor, srcBlock: BlockElement, options: {
+        offset: number;
+        data?: DocBlockAttributes;
+    }) => ConvertBlockResult | null;
+    selectionToDoc?: (editor: OnesEditor, selectedBlock: SelectedBlock) => DocObject;
+    convertTo?: (editor: OnesEditor, blockData: DocBlock, doc: DocObject, type: 'text' | 'html' | 'markdown') => string;
+    toStandardDoc?: (editor: OnesEditor, blockData: DocBlock, doc: DocObject) => Promise<DocObject | undefined>;
+    getBlockStyles?: (editor: OnesEditor, block: BlockElement) => BlockStyles;
+    blockToDoc?: (srcDoc: DocObject, srcBlockData: DocBlock, childBlockConverter: (srcDoc: DocObject, srcBlockData: DocBlock) => DocObject) => DocObject;
+    getResources?: (data: DocBlock) => string[];
+    replaceResources?: (data: DocBlock, resources: Map<string, string>) => void;
+}
+export type TextStyles = {
+    [index: string]: StyleType;
+};
+export interface TextKindBlock extends Block {
+    setBlockText: (editor: OnesEditor, block: BlockElement, text: DocBlockText) => void;
+}
+export interface NextContainerOptions {
+    noWrap?: boolean;
+}
+export interface ComplexKindBlock extends Block {
+    enableKeyboardSelect?: boolean;
+    getChildContainers: (editor: OnesEditor, complexBlock: BlockElement) => ContainerElement[];
+    getNextContainer: (editor: OnesEditor, complexBlock: BlockElement, childContainer: ContainerElement, type: MoveDirection, options?: NextContainerOptions) => ContainerElement | null;
+    getSelectedContainers: (editor: OnesEditor, complexBlock: BlockElement, start: ComplexBlockPosition, end: ComplexBlockPosition) => ContainerElement[];
+    adjustSelectionPos?: (editor: OnesEditor, complexBlock: BlockElement, anchor: ComplexBlockPosition, focus: ComplexBlockPosition) => {
+        anchor: ComplexBlockPosition;
+        focus: ComplexBlockPosition;
+    };
+    getTextToolbarReferenceClient?: (editor: OnesEditor, complexBlock: BlockElement) => DOMRect | undefined;
+}
+export interface SelectedBlock {
+    block: BlockElement;
+    start: BlockPosition;
+    end: BlockPosition;
+}
+export interface SelectionRange {
+    readonly start: BlockPosition;
+    readonly end: BlockPosition;
+    readonly anchor: BlockPosition;
+    readonly focus: BlockPosition;
+    isCollapsed: () => boolean;
+    isReverse: () => boolean;
+    isEqual: (other: SelectionRange) => boolean;
+    getEditor: () => OnesEditor;
+    getSelectedBlocks: () => SelectedBlock[];
+    getSelectedContainers: () => ContainerElement[];
+    clone: () => SelectionRange;
+    isSimple: () => boolean;
+    toDocRange: () => OnesEditorDocRange;
+}
+export interface SimpleSelectionRange extends SelectionRange {
+    readonly start: SimpleBlockPosition;
+    readonly end: SimpleBlockPosition;
+    readonly anchor: SimpleBlockPosition;
+    readonly focus: SimpleBlockPosition;
+    isSimple: () => this is SimpleBlockPosition;
+}
+export interface ComplexSelectionRange extends SelectionRange {
+    readonly start: ComplexBlockPosition;
+    readonly end: ComplexBlockPosition;
+    readonly anchor: ComplexBlockPosition;
+    readonly focus: ComplexBlockPosition;
+    isSimple: () => false;
+}
+export interface OnesEditorUndoAction {
+    undo: (editor: OnesEditor) => boolean;
+    redo: (editor: OnesEditor) => boolean;
+    combinable: (other: OnesEditorUndoAction) => boolean;
+    combine: (other: OnesEditorUndoAction) => void;
+}
+export interface OnesEditorUndoManager {
+    reset: () => void;
+    addAction: (action: OnesEditorUndoAction) => void;
+    hasGroup: () => boolean;
+    undo: () => boolean;
+    redo: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    runInGroup: <T>(action: () => T) => T;
+    lastAction: () => OnesEditorUndoAction | null;
+    undoTo: (action: OnesEditorUndoAction | null) => boolean;
+}
+export interface ShortcutRecords {
+    [index: string]: (editor: OnesEditor, event: Event) => boolean | undefined;
+}
+export interface OnesEditorShortcuts {
+    shortcuts: ShortcutRecords[];
+    handleKeyboardEvents: (editor: OnesEditor, event: KeyboardEvent) => boolean | undefined;
+}
+export interface OnesEditorDecorator {
+    decorateBlock?: (editor: OnesEditor, path: BlockPath, blockData: DocBlock) => DocBlock | undefined;
+    decorateText?: (editor: OnesEditor, path: BlockPath, blockText: DocBlockText) => {
+        insertions?: Map<number, DocInsertion[]>;
+        text?: DocBlockText;
+    };
+}
+export interface OnesEditorDecorators {
+    registerDecorator: (decorator: OnesEditorDecorator) => void;
+    decorateBlock: (path: BlockPath, blockData: DocBlock) => DocBlock;
+    decorateText: (path: BlockPath, blockText: DocBlockText) => {
+        insertions: Map<number, DocInsertion[]>;
+        text: DocBlockText;
+    };
+}
+export type CSSCustomProperties = Record<`--${string}`, string>;
+export type CSSStyles = Partial<CSSStyleDeclaration> & CSSCustomProperties;
+export interface OnesEditorBlockRenderResult {
+    classes?: string[];
+    styles?: CSSStyles;
+    attributes?: Record<string, string>;
+}
+export interface OnesEditorBlockRenderer {
+    renderText?: (editor: OnesEditor, path: BlockPath, attributes: DocBlockTextAttributes) => OnesEditorBlockRenderResult;
+    renderBlock?: (editor: OnesEditor, path: BlockPath, blockData: DocBlock) => OnesEditorBlockRenderResult;
+    updateBlock?: (editor: OnesEditor, path: BlockPath, blockElement: BlockElement, blockData: DocBlock) => void;
+}
+export interface OnesEditorBlockRenderers {
+    renderText: (path: BlockPath, attributes: DocBlockTextAttributes) => OnesEditorBlockRenderResult;
+    renderBlock: (editor: OnesEditor, path: BlockPath, blockData: DocBlock) => OnesEditorBlockRenderResult;
+    updateBlock: (editor: OnesEditor, path: BlockPath, blockElement: BlockElement, blockData: DocBlock) => void;
+    registerRender: (decorator: OnesEditorBlockRenderer) => void;
+}
+export type OnesEditorDocSource = 'text/html' | 'text/office-html' | 'text/plain' | 'text/markdown' | 'image/*' | 'text/x-ones-editor-doc' | '*';
+export type OnesEditorDocs = Partial<Record<OnesEditorDocSource, DocObject>>;
+export interface OnesEditorDataConverter {
+    fromData: (editor: OnesEditor, data: DataTransfer) => Promise<OnesEditorDocs | undefined>;
+}
+export interface OnesEditorDataConverters {
+    fromData: (editor: OnesEditor, data: DataTransfer) => Promise<OnesEditorDocs | undefined>;
+    addConverter: (converter: OnesEditorDataConverter) => void;
+}
+export interface BreakTextOptions {
+    forceInsertAfter?: boolean;
+    newBlockData?: DocBlock;
+}
+export interface OnesEditorEvents {
+    'docChanged': (editor: OnesEditor) => void;
+    'readonlyChanged': (editor: OnesEditor) => void;
+    'selectionChanged': (editor: OnesEditor) => void;
+    'focusBlockChanged': (editor: OnesEditor, newBlock: BlockElement | null, oldBlock: BlockElement | null) => void;
+    'blockDeleted': (editor: OnesEditor, block: BlockElement, local: boolean, options: DeleteBlockEventOptions) => void;
+    'destroy': (editor: OnesEditor) => void;
+    'resize': (editor: OnesEditor) => void;
+    'load': (editor: OnesEditor, reload: boolean) => void;
+    'click': (editor: OnesEditor, event: MouseEvent) => void;
+    'beforeClearSelection': (editor: OnesEditor) => void;
+    'afterClearSelection': (editor: OnesEditor) => void;
+    'blur': (editor: OnesEditor) => void;
+    'focus': (editor: OnesEditor) => void;
+}
+export interface OnesEditorSettingsProvider {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string | null) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+}
+export interface OnesEditorOptionalOptions {
+    shortcuts?: ShortcutRecords[];
+    id?: string;
+    components?: OnesEditorComponents;
+    colors?: string[];
+    scrollContainer?: HTMLElement;
+    settingsProvider?: OnesEditorSettingsProvider;
+}
+export interface OnesEditorOptions {
+    colors: string[];
+    componentsOptions: {
+        [index: string]: unknown;
+    };
+    scrollContainer?: HTMLElement;
+}
+export interface OnesEditorComponents {
+    blocks?: Block[];
+    boxes?: Box[];
+    embeds?: Embed[];
+    insertions?: Insertion[];
+    decorators?: OnesEditorDecorator[];
+    dataConverters?: OnesEditorDataConverter[];
+    commandProviders?: OnesEditorCommandProvider[];
+    textRenders?: OnesEditorBlockRenderer[];
+    blockHooks?: OnesEditorBlockHook[];
+    options?: {
+        [index: string]: unknown;
+    };
+}
+export interface BlockTextPosition {
+    container: ContainerElement;
+    block: BlockElement;
+    containerId: string;
+    blockIndex: number;
+    offset: number;
+}
+export type OnesEditorDocWithExternalDoc = OnesEditorDoc & {
+    externalDoc: OnesEditorDoc;
+};
+export interface OnesEditorCustom {
+    destroy: () => void;
+}
+export declare class OnesEditorCustomDataWrapper<T> {
+    private editor;
+    private data;
+    constructor(editor: OnesEditor, data: T);
+    getData<T>(): T;
+    getEditor(): OnesEditor;
+    destroy(): void;
+}
+export type OnesEditorCustomCreator = (editor: OnesEditor) => OnesEditorCustom;
+export interface CloneBlockResultInfo {
+    containerIdMap: Map<string, string>;
+    blockIdMap: Map<string, string>;
+}
+export interface OnesEditorDomEvents extends OnesEditorCustom {
+    addEventListener: (element: Element | Document | Window, eventName: string, eventHandler: (editor: OnesEditor, event: Event) => void) => void;
+    removeEventListener: (element: Element | Document | Window | null, eventName: string | null, eventHandler: (editor: OnesEditor, event: Event) => void) => void;
+    removeAllListeners: (element: Element | Document | Window, eventName?: string) => void;
+}
+export interface OnesEditor extends TypedEmitter<OnesEditorEvents> {
+    readonly parent: HTMLElement;
+    readonly rootElement: HTMLDivElement;
+    readonly contentElement: HTMLDivElement;
+    readonly rootContainer: ContainerElement;
+    readonly scrollContainer: HTMLElement;
+    readonly doc: OnesEditorDocWithExternalDoc;
+    readonly input: OnesEditorInput;
+    readonly selection: OnesEditorSelection;
+    readonly selectionHandler: OnesEditorSelectionHandler;
+    readonly id: string;
+    readonly clientId: string;
+    readonly compositingText: string;
+    readonly undoManager: OnesEditorUndoManager;
+    readonly shortcuts: OnesEditorShortcuts;
+    readonly dataConverter: OnesEditorDataConverters;
+    readonly editorBlocks: OnesEditorBlocks;
+    readonly editorEmbeds: OnesEditorEmbeds;
+    readonly editorBoxes: OnesEditorBoxes;
+    readonly editorInsertions: OnesEditorInsertions;
+    readonly editorDecorators: OnesEditorDecorators;
+    readonly editorCommandProviders: OnesEditorCommandProviders;
+    readonly editorBlockRenders: OnesEditorBlockRenderers;
+    readonly blockHooks: OnesEditorBlockHook[];
+    readonly options: OnesEditorOptions;
+    readonly domEvents: OnesEditorDomEvents;
+    readonly settingsProvider: OnesEditorSettingsProvider;
+    readonly: boolean;
+    addCustom: <T extends OnesEditorCustom>(name: string, creator: OnesEditorCustomCreator) => T;
+    getCustom: <T extends OnesEditorCustom>(name: string) => T;
+    replaceCustom: <T extends OnesEditorCustom>(name: string, newCustom: T) => T;
+    findCustom: <T extends OnesEditorCustom>(name: string) => T | null;
+    destroyCustom: (name: string) => void;
+    getComponentOptions: <T>(name: string) => T | null;
+    registerLocalEvents: (events: EditorDocLocalActionCallbacks) => void;
+    createBlock: (path: BlockPath, container: ContainerElement, block: DocBlock) => BlockElement;
+    createBox: (blockContent: BlockContentElement, box: DocBox) => BoxElement;
+    createInsertion: (blockContent: BlockContentElement, insertion: DocInsertion) => InsertionElement;
+    destroy: () => void;
+    focus: () => void;
+    focusToBlock: (block: BlockElement, options?: {
+        tryFocusToChildSimpleBlock?: boolean;
+    }) => void;
+    isWritable: () => boolean;
+    isBlockWritable: (block: BlockElement) => boolean;
+    reload: () => void;
+    getChildContainerData: (childContainerId: string) => DocBlocks;
+    createChildContainer: (path: BlockPath, parentElement: HTMLElement, childContainerId: string) => ContainerElement;
+    getFirstBlock: () => BlockElement;
+    getLastBlock: () => BlockElement;
+    getFocusedBlock: () => BlockElement;
+    findBlockById: (id: string) => BlockElement | null;
+    findBoxById: (id: string) => BoxElement | null;
+    getBlockById: (id: string) => BlockElement;
+    getBoxById: (id: string) => BoxElement;
+    getBlockByIndex: (containerId: string, blockIndex: number) => BlockElement;
+    getBlockIndex: (block: BlockElement | string) => number;
+    getContainerById: (id: string) => ContainerElement;
+    getParentContainer: (block: BlockElement) => ContainerElement;
+    reloadBlock: (block: BlockElement) => void;
+    contains: (node: Node) => boolean;
+    getSelectedText: () => string;
+    clearSelectedContents: () => void;
+    insertBlock: (containerId: string, blockIndex: number, blockData: DocBlock, newRange?: OnesEditorDocRange) => BlockElement;
+    insertEmbed: (containerId: string, blockIndex: number, embedType: string, embedData: DocEmbedData, newRange?: OnesEditorDocRange) => BlockElement;
+    deleteBlock: (block: BlockElement, newRange?: OnesEditorDocRange) => void;
+    getTextPosition: () => BlockTextPosition;
+    getBlockString: (block: BlockElement, options?: {
+        boxReplacement: string;
+    }) => string;
+    getBlockData: (block: BlockElement) => DocBlock;
+    getBlockText: (block: BlockElement) => DocBlockText;
+    setBlockText: (block: BlockElement, text: DocBlockText) => void;
+    getBoxData: (box: BoxElement) => DocBox;
+    deleteTextFromBlock: (block: BlockElement, offset: number, count: number) => number;
+    insertTextToBlock: (block: BlockElement, offset: number, text: string | DocBlockText) => DocBlockText;
+    insertBoxToBlock: (block: BlockElement, offset: number, boxData: DocBox) => DocBlockText;
+    mergeTextBlock: (block1: BlockElement, block2: BlockElement, options?: {
+        focus?: boolean;
+    }) => DocBlockText;
+    breakTextBlock: (block: BlockElement, offset: number, options?: BreakTextOptions) => BlockElement;
+    insertTextBlock: (text?: string | DocBlockText, containerId?: string, blockIndex?: number, options?: {
+        newRange?: OnesEditorDocRange;
+    }) => BlockElement;
+    insertDoc: (block: BlockElement, offset: number, doc: DocObject, cloneDocResult?: CloneBlockResultInfo) => void;
+    insertDocAt: (container: ContainerElement, blockIndex: number, doc: DocObject, cloneDocResult?: CloneBlockResultInfo) => BlockElement[];
+    pasteDoc: (doc: DocObject) => Promise<void>;
+    deleteChildContainers: (containerIds: string[]) => void;
+    updateBlockData: (block: BlockElement, data: DocBlockAttributes, newRange?: SelectionRange) => DocBlock;
+    updateEmbedData: (block: BlockElement, data: DocEmbedData, newRange?: SelectionRange) => DocBlock;
+    updateBoxData: (boxData: DocBox) => void;
+    updateCompositionText: (text: string, end: boolean) => void;
+    getColor: (index: number, type?: string) => string;
+}
+export interface ChangeSelectionOptions {
+    noScroll?: boolean;
+}
+export interface OnesEditorSelection {
+    readonly range: SelectionRange;
+    readonly caret: OnesEditorCaret;
+    readonly focusedBlock: BlockElement;
+    readonly startBlock: BlockElement;
+    readonly endBlock: BlockElement;
+    setSelection: (anchor: BlockPosition, focus?: BlockPosition, options?: ChangeSelectionOptions) => SelectionRange;
+    setRange: (range: SelectionRange) => SelectionRange;
+    selectBlock: (block: BlockElement, start: number, end?: number) => void;
+    updateSelection: (old: SelectionRange | null) => void;
+    updateLastCaretRect: () => void;
+    getSuggestedCaretX: () => number | undefined;
+    getAnchorPos: () => BlockPosition;
+    getFocusedPos: () => BlockPosition;
+    scrollIntoView: () => void;
+}
+export type RemoteChangeType = 'UpdateBlockText' | 'UpdateBlockData' | 'InsertBlock' | 'DeleteBlock' | 'InsertChildContainer' | 'DeleteChildContainer';
+export interface OnesEditorInput {
+    readonly inputElement: HTMLInputElement;
+    destroy: () => void;
+    focus: () => void;
+    handleDocumentSelectionChange: () => void;
+    handleCompositionstart: (event: CompositionEvent) => void;
+    handleCompositionend: (event: CompositionEvent) => void;
+    handleInput: (event: Event) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    handleChanged: (action: OnesEditorUndoAction) => void;
+    handleRemoteChanged: (type: RemoteChangeType) => void;
+    addHandler: (handler: OnesEditorInputHandler) => void;
+    removeHandler: (handler: OnesEditorInputHandler) => void;
+    defaultInsertText: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number, text: string) => void;
+    defaultHandleKeydown: (editor: OnesEditor, event: KeyboardEvent) => boolean;
+}
+export interface OnesEditorSelectionHandler {
+    isSelecting: () => boolean;
+    stopSelection: () => void;
+    handleMouseDown: (event: MouseEvent) => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleMouseUp: (event: MouseEvent) => void;
+    handleDblClick: (event: MouseEvent) => void;
+    handleTripleClick: (event: MouseEvent) => void;
+}
+export interface OnesEditorCaret {
+    update: () => void;
+    visible: () => boolean;
+}
+export interface OnesEditorInputHandler {
+    handleBeforeInsertText?: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number, text: string) => boolean;
+    handleAfterInsertText?: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number, text: string) => boolean;
+    handleBeforeKeyDown?: (editor: OnesEditor, event: KeyboardEvent) => boolean;
+    handleAfterKeyDown?: (editor: OnesEditor, event: KeyboardEvent) => boolean;
+    handleBeforePaste?: (editor: OnesEditor, event: ClipboardEvent, doc: OnesEditorDocs) => Promise<boolean>;
+    handleAfterPaste?: (editor: OnesEditor, event: ClipboardEvent, doc: OnesEditorDocs) => Promise<boolean>;
+    handleBeforePasteDoc?: (editor: OnesEditor, doc: DocObject) => Promise<boolean>;
+    handleAfterPasteDoc?: (editor: OnesEditor, doc: DocObject) => Promise<boolean>;
+    handleChanged?: (editor: OnesEditor, action: OnesEditorUndoAction) => void;
+    handleRemoteChanged?: (editor: OnesEditor, type: RemoteChangeType) => void;
+    handleCompositionStart?: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number) => void;
+    handleUpdateCompositionText?: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number, end: boolean) => void;
+    destroy?: (editor: OnesEditor) => void;
+}
+export interface OnesEditorBlocks {
+    registerBlockClass: (blockClass: Block) => void;
+    getBlockClass: (type: string) => Block;
+    createBlock: (path: BlockPath, container: ContainerElement, block: DocBlock) => BlockElement;
+    forEach: (callback: (blockClass: Block) => void) => void;
+}
+export interface OnesEditorEmbeds {
+    registerEmbedClass: (embedClass: Embed) => void;
+    getEmbedClass: (type: string) => Embed;
+    forEach: (callback: (embedClass: Embed) => void) => void;
+}
+export interface OnesEditorBoxes {
+    registerBoxClass: (boxClass: Box) => void;
+    getBoxClass: (type: string) => Box;
+    createBox: (blockContent: BlockContentElement, box: DocBox) => BoxElement;
+}
+export interface OnesEditorInsertions {
+    registerInsertionClass: (insertionClass: Insertion) => void;
+    getInsertionClass: (type: string) => Insertion;
+    createInsertion: (blockContent: BlockContentElement, insertion: DocInsertion) => InsertionElement;
+}
+export type CommandParams = {
+    [index: string]: unknown;
+};
+export type CommandResult = {
+    [index: string]: unknown;
+};
+export interface OnesEditorCommandProvider {
+    id: string;
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => BlockCommandItem[];
+    executeCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams, result: CommandResult) => boolean;
+    filterCommands?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, commands: BlockCommandItemWithSource[]) => BlockCommandItemWithSource[] | undefined;
+    beforeExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams) => boolean | undefined;
+    afterExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams, result: CommandResult) => void;
+    getEmptyBlockTextAttributes?: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
+    executeRangeCommand?: (editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult) => boolean;
+}
+export interface BlockCommandItemWithSource extends BlockCommandItem {
+    source: string;
+}
+export interface OnesEditorCommandProviders {
+    registerCommandProvider: (provider: OnesEditorCommandProvider) => void;
+    getCommandProviders: () => OnesEditorCommandProvider[];
+    getCommandProvider: (id: string) => OnesEditorCommandProvider;
+    getCommands: (range: SelectionRange) => BlockCommandItemWithSource[];
+    executeCommand: (range: SelectionRange, item: BlockCommandItemWithSource, params: CommandParams) => {
+        [index: string]: CommandResult;
+    };
+    getEmptyBlockTextAttributes: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
+}
+export interface EditorDocLocalActionCallbacks {
+    onBeforeUpdateBlockText: (containerId: string, blockId: string, oldText: DocBlockText, newText: DocBlockText, newRange: OnesEditorDocRange) => void;
+    onBeforeUpdateBlockData: (containerId: string, blockId: string, oldData: DocBlock, newData: DocBlock, newRange: OnesEditorDocRange) => void;
+    onBeforeInsertBlock: (containerId: string, blockIndex: number, blockData: DocBlock, newRange: OnesEditorDocRange) => void;
+    onBeforeDeleteBlock: (containerId: string, blockIndex: number, blockData: DocBlock, newRange: OnesEditorDocRange) => void;
+    onBeforeInsertChildContainer: (containerId: string, blocks: DocBlock[]) => void;
+    onBeforeDeleteChildContainer: (containerId: string, blocks: DocBlock[]) => void;
+}
+export interface OnesEditorBlockHook {
+    create?: (editor: OnesEditor, path: BlockPath, container: ContainerElement, blockElement: BlockElement, blockData: DocBlock) => void;
+    update?: (editor: OnesEditor, path: BlockPath, container: ContainerElement, blockElement: BlockElement, blockData: DocBlock) => void;
+    writable?: (editor: OnesEditor, blockElement: BlockElement) => boolean | undefined;
+    commands?: (editor: OnesEditor, blockElement: BlockElement) => BlockCommands;
+}