tui-editor

tui-editor

Version 1.4.10
Published 5 years ago
21.9 MB
14 dependencies
MIT license

Install

npm i tui-editor

yarn add tui-editor

pnpm add tui-editor

Overview

GFM Markdown Wysiwyg Editor - Productive and Extensible

Namespaces

namespace tui-editor

module 'tui-editor' {}

variable default

const default: typeof tuiEditor.Editor;

namespace tui-editor/dist/tui-editor-Editor-all

module 'tui-editor/dist/tui-editor-Editor-all' {}

variable default

const default: typeof tuiEditor.Editor;

namespace tui-editor/dist/tui-editor-Viewer

module 'tui-editor/dist/tui-editor-Viewer' {}

variable default

const default: typeof tuiEditor.Viewer;

namespace tui-editor/dist/tui-editor-Viewer-all

module 'tui-editor/dist/tui-editor-Viewer-all' {}

variable default

const default: typeof tuiEditor.Viewer;

namespace tuiEditor

namespace tuiEditor {}

class Button

class Button extends ToolbarItem {}

constructor

constructor(options?: IButtonOptions);

property className

static className: string;

property name

static name: string;

method disable

disable: () => void;

method enable

enable: () => void;

method getName

getName: () => string;

method isEnabled

isEnabled: () => boolean;

method setTooltip

setTooltip: (text: string) => void;

class CodeBlockManager

class CodeBlockManager {}

method createCodeBlockHtml

createCodeBlockHtml: (language: string, codeText: string) => string;

method getHighlightJSLanguages

static getHighlightJSLanguages: () => string[];

method getReplacer

getReplacer: (language: string) => ReplacerFunc;

method setReplacer

setReplacer: (language: string, replacer: ReplacerFunc) => void;

class Command

class Command {}

constructor

constructor(name: string, type: number, keyMap?: string[]);

property TYPE

static TYPE: ICommandType;

method factory

static factory: (typeStr: string, props: ICommandProps) => Command;

method getName

getName: () => string;

method getType

getType: () => number;

method isGlobalType

isGlobalType: () => boolean;

method isMDType

isMDType: () => boolean;

method isWWType

isWWType: () => boolean;

method setKeyMap

setKeyMap: (win: string, mac: string) => void;

class CommandManager

class CommandManager {}

constructor

constructor(base: Editor, options?: ICommandManagerOptions);

method addCommand

addCommand: (command: Command) => Command;

method command

static command: (type: string, props: ICommandPropsOptions) => Command;

method exec

exec: (name: string, ...args: any[]) => any;

class DefaultToolbar

class DefaultToolbar extends Toolbar {}

class Editor

class Editor {}

constructor

constructor(options: IEditorOptions);

property Button

static Button: typeof Button;

property codeBlockManager

static codeBlockManager: CodeBlockManager;

property CommandManager

static CommandManager: typeof CommandManager;

property domUtils

static domUtils: IDomUtil;

property i18n

static i18n: I18n;

property isViewer

static isViewer: boolean;

property markdownit

static markdownit: markdownit;

property markdownitHighlight

static markdownitHighlight: markdownit;

property WwCodeBlockManager

static WwCodeBlockManager: typeof WwCodeBlockManager;

property WwTableManager

static WwTableManager: typeof WwTableManager;

property WwTableSelectionManager

static WwTableSelectionManager: typeof WwTableSelectionManager;

method addHook

addHook: (type: string, handler: HandlerFunc) => void;

method addWidget

addWidget: (
    selection: Range,
    node: Node,
    style: string,
    offset?: number
) => void;

method afterAddedCommand

afterAddedCommand: () => void;

method blur

blur: () => void;

method changeMode

changeMode: (mode: string, isWithoutFocus?: boolean) => void;

method changePreviewStyle

changePreviewStyle: (style: string) => void;

method defineExtension

static defineExtension: (name: string, ext: HandlerFunc) => void;

method exec

exec: (name: string, ...args: any[]) => void;

method factory

static factory: (options: IEditorOptions) => Editor | Viewer;

method focus

focus: () => void;

method getCodeMirror

getCodeMirror: () => CodeMirror.EditorFromTextArea;

method getCurrentModeEditor

getCurrentModeEditor: () => MarkDownEditor | WysiwygEditor;

method getCurrentPreviewStyle

getCurrentPreviewStyle: () => string;

method getHtml

getHtml: () => string;

method getInstances

static getInstances: () => Editor[];

method getMarkdown

getMarkdown: () => string;

method getRange

getRange: () => RangeType;

method getSelectedText

getSelectedText: () => string;

method getSquire

getSquire: () => SquireExt;

method getTextObject

getTextObject: (range: RangeType) => IMdTextObject | IWwTextObject;

method getUI

getUI: () => IUI;

method getValue

getValue: () => string;

method height

height: (height: string) => string;

method hide

hide: () => void;

method insertText

insertText: (text: string) => void;

method isMarkdownMode

isMarkdownMode: () => boolean;

method isViewer

isViewer: () => boolean;

method isWysiwygMode

isWysiwygMode: () => boolean;

method minHeight

minHeight: (minHeight: string) => string;

method moveCursorToEnd

moveCursorToEnd: () => void;

method moveCursorToStart

moveCursorToStart: () => void;

method off

off: (type: string) => void;

method on

on: (type: string, handler: HandlerFunc) => void;

method remove

remove: () => void;

method removeHook

removeHook: (type: string) => void;

method reset

reset: () => void;

method scrollTop

scrollTop: (value: number) => number;

method setHtml

setHtml: (html: string, cursorToEnd?: boolean) => void;

method setMarkdown

setMarkdown: (markdown: string, cursorToEnd?: boolean) => void;

method setUI

setUI: (UI: IUI) => void;

method setValue

setValue: (value: string, cursorToEnd?: boolean) => void;

method show

show: () => void;

class EventManager

class EventManager {}

method addEventType

addEventType: (type: string) => void;

method emit

emit: (eventName: string) => any[];

method emitReduce

emitReduce: (eventName: string, sourceText: string) => string;

method listen

listen: (typeStr: string, handler: HandlerFunc) => void;

method removeEventHandler

removeEventHandler: (typeStr: string, handler?: HandlerFunc) => void;

class I18n

class I18n {}

method get

get: (key: string, code: string) => string;

method setCode

setCode: (code: string) => void;

method setLanguage

setLanguage: (codes: string | string[], data: ILanguageData) => void;

class MarkDownEditor

class MarkDownEditor {}

constructor

constructor($el: JQuery, eventManager: EventManager);

method getTextObject

getTextObject: (range: IRangeType) => IMdTextObject;

method setValue

setValue: (markdown: string, cursorToEnd?: boolean) => void;

class Toolbar extends UIController {}

addButton: (button: Button, index?: number) => void;

addDivider: () => JQuery;

addItem: (item: ToolbarItem | IButtonItem | string) => void;

disableAllButton: () => void;

enableAllButton: () => void;

getItem: (index: number) => ToolbarItem;

getItems: () => ToolbarItem[];

indexOfItem: (item: ToolbarItem) => number;

insertItem: (index: number, item: ToolbarItem | IButtonItem | string) => void;

removeAllItems: () => void;

removeItem: (
    item: ToolbarItem | number,
    destroy?: boolean
) => ToolbarItem | undefined;

setItems: (items: ToolbarItem[]) => void;

class ToolbarItem

class ToolbarItem extends UIController {}

property className

static className: string;

property name

static name: string;

method getName

getName: () => string;

class UIController

class UIController {}

property $el

$el: JQuery;

property className

className: string;

property tagName

tagName: string;

method destroy

destroy: () => void;

method off

off: (type: string, fn: (...args: any[]) => void) => void;

method on

on: (aType: string | object, aFn: (...args: any[]) => void) => void;

method remove

remove: () => void;

method trigger

trigger: (
    eventTypeEvent: string | JQuery.Event,
    extraParameters?: TriggerExtraParameterType
) => JQuery;

class Viewer

class Viewer {}

constructor

constructor(options: IViewerOptions);

property codeBlockManager

static codeBlockManager: CodeBlockManager;

property domUtils

static domUtils: IDomUtil;

property isViewer

static isViewer: boolean;

property markdownitHighlight

static markdownitHighlight: markdownit;

method addHook

addHook: (type: string, handler: HandlerFunc) => void;

method defineExtension

static defineExtension: (name: string, ext: HandlerFunc) => void;

method isMarkdownMode

isMarkdownMode: () => boolean;

method isViewer

isViewer: () => boolean;

method isWysiwygMode

isWysiwygMode: () => boolean;

method off

off: (type: string) => void;

method on

on: (type: string, handler: HandlerFunc) => void;

method remove

remove: () => void;

method setMarkdown

setMarkdown: (markdown: string) => void;

method setValue

setValue: (markdown: string) => void;

class WwCodeBlockManager

class WwCodeBlockManager {}

constructor

constructor(wwe: WysiwygEditor);

method convertNodesToText

static convertNodesToText: (nodes: Node[]) => string;

method destroy

destroy: () => void;

method isInCodeBlock

isInCodeBlock: (range: Range) => boolean;

method prepareToPasteOnCodeblock

prepareToPasteOnCodeblock: (nodes: Node[]) => DocumentFragment;

class WwTableManager

class WwTableManager {}

constructor

constructor(wwe: WysiwygEditor);

method destroy

destroy: () => void;

method getTableIDClassName

getTableIDClassName: () => string;

method isInTable

isInTable: (range: Range) => boolean;

method isNonTextDeleting

isNonTextDeleting: (range: Range) => boolean;

method isTableOrSubTableElement

isTableOrSubTableElement: (pastingNodeName: string) => string;

method pasteClipboardData

pasteClipboardData: ($clipboardTable: JQuery) => boolean;

method prepareToTableCellStuffing

prepareToTableCellStuffing: ($trs: JQuery) => object;

method resetLastCellNode

resetLastCellNode: () => void;

method setLastCellNode

setLastCellNode: (node: Element) => void;

method tableCellAppendAidForTableElement

tableCellAppendAidForTableElement: (node: Element) => void;

method updateTableHtmlOfClipboardIfNeed

updateTableHtmlOfClipboardIfNeed: ($clipboardContainer: JQuery) => void;

method wrapDanglingTableCellsIntoTrIfNeed

wrapDanglingTableCellsIntoTrIfNeed: ($container: JQuery) => Element | null;

method wrapTheadAndTbodyIntoTableIfNeed

wrapTheadAndTbodyIntoTableIfNeed: ($container: JQuery) => Element | null;

method wrapTrsIntoTbodyIfNeed

wrapTrsIntoTbodyIfNeed: ($container: JQuery) => Element | null;

class WwTableSelectionManager

class WwTableSelectionManager {}

constructor

constructor(wwe: WysiwygEditor);

method createRangeBySelectedCells

createRangeBySelectedCells: () => void;

method destroy

destroy: () => void;

method getSelectedCells

getSelectedCells: () => JQuery;

method getSelectionRangeFromTable

getSelectionRangeFromTable: (
    selectionStart: Element,
    selectionEnd: Element
) => object;

method highlightTableCellsBy

highlightTableCellsBy: (selectionStart: Element, selectionEnd: Element) => void;

method removeClassAttrbuteFromAllCellsIfNeed

removeClassAttrbuteFromAllCellsIfNeed: () => void;

method setTableSelectionTimerIfNeed

setTableSelectionTimerIfNeed: (selectionStart: Element) => void;

method styleToSelectedCells

styleToSelectedCells: (onStyle: SquireExt, options?: any) => void;

class WysiwygEditor

class WysiwygEditor {}

constructor

constructor($el: JQuery, eventManager: EventManager);

method addKeyEventHandler

addKeyEventHandler: (keyMap: string | string[], handler: HandlerFunc) => void;

method addWidget

addWidget: (range: Range, node: Node, style: string, offset?: number) => void;

method blur

blur: () => void;

method breakToNewDefaultBlock

breakToNewDefaultBlock: (range: Range, where?: string) => void;

method changeBlockFormatTo

changeBlockFormatTo: (targetTagName: string) => void;

method findTextNodeFilter

findTextNodeFilter: () => boolean;

method fixIMERange

fixIMERange: () => void;

method focus

focus: () => void;

method get$Body

get$Body: () => JQuery;

method getEditor

getEditor: () => SquireExt;

method getIMERange

getIMERange: () => Range;

method getRange

getRange: () => Range;

method getTextObject

getTextObject: (range: Range) => IWwTextObject;

method getValue

getValue: () => string;

method hasFormatWithRx

hasFormatWithRx: (rx: RegExp) => boolean;

method init

init: () => void;

method insertText

insertText: (text: string) => void;

method makeEmptyBlockCurrentSelection

makeEmptyBlockCurrentSelection: () => void;

method moveCursorToEnd

moveCursorToEnd: () => void;

method moveCursorToStart

moveCursorToStart: () => void;

method postProcessForChange

postProcessForChange: () => void;

method readySilentChange

readySilentChange: () => void;

method remove

remove: () => void;

method removeKeyEventHandler

removeKeyEventHandler: (keyMap: string, handler: HandlerFunc) => void;

method replaceContentText

replaceContentText: (container: Node, from: string, to: string) => void;

method replaceRelativeOffset

replaceRelativeOffset: (
    content: string,
    offset: number,
    overwriteLength: number
) => void;

method replaceSelection

replaceSelection: (content: string, range: Range) => void;

method reset

reset: () => void;

method restoreSavedSelection

restoreSavedSelection: () => void;

method saveSelection

saveSelection: (range: Range) => void;

method scrollTop

scrollTop: (value: number) => boolean;

method setHeight

setHeight: (height: number | string) => void;

method setMinHeight

setMinHeight: (minHeight: number) => void;

method setRange

setRange: (range: Range) => void;

method setSelectionByContainerAndOffset

setSelectionByContainerAndOffset: (
    startContainer: Node,
    startOffset: number,
    endContainer: Node,
    endOffset: number
) => Range;

method setValue

setValue: (html: string, cursorToEnd?: boolean) => void;

method unwrapBlockTag

unwrapBlockTag: (condition?: (tagName: string) => boolean) => void;

interface IButtonItem

interface IButtonItem {}

property name

name: string;

property options

options: IButtonOptions;

interface IButtonOptions

interface IButtonOptions {}

property $el

$el: JQuery;

property className

className: string;

property command

command?: string;

property event

event?: string;

property state

state?: string;

property style

style?: string;

property text

text?: string;

property tooltip

tooltip?: string;

interface ICommandManagerOptions

interface ICommandManagerOptions {}

property useCommandShortcut

useCommandShortcut?: boolean;

interface ICommandProps

interface ICommandProps {}

property name

name: string;

property type

type: number;

interface ICommandPropsOptions

interface ICommandPropsOptions {}

property exec

exec?: CommandManagerExecFunc;

property keyMap

keyMap?: string[];

property name

name: string;

interface ICommandType

interface ICommandType {}

property GB

GB: 2;

property MD

MD: 0;

property WW

WW: 1;

interface IConvertor

interface IConvertor {}

method getMarkdownitHighlightRenderer

getMarkdownitHighlightRenderer: () => markdownit;

method initHtmlSanitizer

initHtmlSanitizer: () => void;

method toHTML

toHTML: (makrdown: string) => string;

method toHTMLWithCodeHightlight

toHTMLWithCodeHightlight: (markdown: string) => string;

method toMarkdown

toMarkdown: (html: string, toMarkdownOptions: IToMarkOptions) => string;

interface IDomUtil

interface IDomUtil {}

method containsNode

containsNode: (root: Node, node: Node) => boolean;

method findOffsetNode

findOffsetNode: (
    root: Element,
    offsetList: number[],
    textNodeFilter: (text: string) => string
) => IFindOffsetNodeInfo[];

method getChildNodeByOffset

getChildNodeByOffset: (node: Node, index: number) => Node;

method getNodeInfo

getNodeInfo: (node: Node) => INodeInfo;

method getNodeName

getNodeName: (node: Node) => string;

method getNodeOffsetOfParent

getNodeOffsetOfParent: (node: Node) => number;

method getOffsetLength

getOffsetLength: (node: Node) => number;

method getParentUntil

getParentUntil: (node: Node, untilNode: string | Node) => Node;

method getParentUntilBy

getParentUntilBy: (
    node: Node,
    matchCondition: (node: Node) => boolean,
    stopCondition: (node: Node) => boolean
) => Node;

method getPath

getPath: (node: Node, root: Node) => INodeInfo[];

method getPrevOffsetNodeUntil

getPrevOffsetNodeUntil: (
    node: Node,
    index: number,
    untilNodeName: string
) => Node;

method getPrevTextNode

getPrevTextNode: (node: Node) => Node;

method getSiblingRowCellByDirection

getSiblingRowCellByDirection: (
    node: Element,
    direction: string,
    needEdgeCell?: boolean
) => Element | null;

method getTableCellByDirection

getTableCellByDirection: (node: Element, direction: string) => Element | null;

method getTextLength

getTextLength: (node: Node) => number;

method getTopBlockNode

getTopBlockNode: (node: Node) => Node;

method getTopNextNodeUnder

getTopNextNodeUnder: (node: Node, underNode: Node) => Node;

method getTopPrevNodeUnder

getTopPrevNodeUnder: (node: Node, underNode: Node) => Node;

method isElemNode

isElemNode: (node: Node) => boolean;

method isTextNode

isTextNode: (node: Node) => boolean;

interface IEditorOptions

interface IEditorOptions {}

property codeBlockLanguages

codeBlockLanguages?: string[];

property customConvertor

customConvertor?: IConvertor;

property el

el: Element;

property events

events?: IEvent[];

property exts

exts?: string[];

property height

height?: string;

property hideModeSwitch

hideModeSwitch?: boolean;

property hooks

hooks?: IEvent[];

property initialEditType

initialEditType?: string;

property initialValue

initialValue?: string;

property language

language?: string;

property minHeight

minHeight?: string;

property placeholder

placeholder?: string;

property previewStyle

previewStyle?: string;

property toolbarItems

toolbarItems?: string[];

property usageStatistics

usageStatistics?: boolean;

property useCommandShortcut

useCommandShortcut?: boolean;

property useDefaultHTMLSanitizer

useDefaultHTMLSanitizer?: boolean;

property viewer

viewer?: boolean;

interface IEvent

interface IEvent {}

index signature

[propName: string]: HandlerFunc;

interface IFindOffsetNodeInfo

interface IFindOffsetNodeInfo {}

property container

container: Node;

property offset

offset: number;

property offsetInContainer

offsetInContainer: number;

interface ILanguageData

interface ILanguageData {}

index signature

[propType: string]: string;

interface ILayerPopup

interface ILayerPopup extends IUIController {}

method getTitleElement

getTitleElement: () => Element;

method hide

hide: () => void;

method isFitToWindow

isFitToWindow: () => boolean;

method isShow

isShow: () => boolean;

method remove

remove: () => void;

method setContent

setContent: ($content: JQuery) => void;

method setFitToWindow

setFitToWindow: (fit: boolean) => void;

method setTitle

setTitle: (title: string) => void;

method show

show: () => void;

method toggleFitToWindow

toggleFitToWindow: () => boolean;

interface ILayerPopupOptions

interface ILayerPopupOptions {}

property $el

$el: JQuery;

property $target

$target?: JQuery;

property closerCssQuery

closerCssQuery?: string[];

property content

content?: JQuery | string;

header?: boolean;

property headerButtons

headerButtons?: string;

modal: boolean;

property openerCssQuery

openerCssQuery?: string[];

property textContent

textContent?: string;

property title

title: string;

interface IMdTextObject

interface IMdTextObject {}

method deleteContent

deleteContent: () => void;

method expandEndOffset

expandEndOffset: () => void;

method expandStartOffset

expandStartOffset: () => void;

method getTextContent

getTextContent: () => IRangeType;

method peekStartBeforeOffset

peekStartBeforeOffset: (offset: number) => IRangeType;

method replaceContent

replaceContent: (content: string) => void;

method setEndBeforeRange

setEndBeforeRange: (range: IRangeType) => void;

method setRange

setRange: (range: IRangeType) => void;

interface IModeSwitch

interface IModeSwitch extends IUIController {}

property TYPE

TYPE: IModeSwitchType;

method hide

hide: () => void;

method isShown

isShown: () => boolean;

method show

show: () => void;

interface IModeSwitchType

interface IModeSwitchType {}

property MARKDOWN

MARKDOWN: 'markdown';

property WYSIWYG

WYSIWYG: 'wysiwyg';

interface INodeInfo

interface INodeInfo {}

property className

className?: string;

property id

id?: string;

property tagName

tagName: string;

interface IRangeType

interface IRangeType {}

property end

end: {
    line: number;
    ch: number;
};

property start

start: {
    line: number;
    ch: number;
};

interface IToMarkOptions

interface IToMarkOptions {}

property gfm

gfm?: boolean;

property renderer

renderer?: any;

interface IUI

interface IUI {}

method createPopup

createPopup: (options: ILayerPopupOptions) => ILayerPopup;

method getEditorHeight

getEditorHeight: () => number;

method getEditorSectionHeight

getEditorSectionHeight: () => number;

method getModeSwitch

getModeSwitch: () => IModeSwitch;

method getPopupTableUtils

getPopupTableUtils: () => PopupTableUtils;

method getToolbar

getToolbar: () => Toolbar;

method hide

hide: () => void;

method remove

remove: () => void;

method setToolbar

setToolbar: (toolbar: Toolbar) => void;

method show

show: () => void;

interface IUIController

interface IUIController {}

property $el

$el: JQuery;

property className

className: string;

property tagName

tagName: string;

method destroy

destroy: () => void;

method off

off: (type: string, fn: (...args: any[]) => void) => void;

method on

on: (aType: string | object, aFn: (...args: any[]) => void) => void;

method remove

remove: () => void;

method trigger

trigger: (
    eventTypeEvent: string | JQuery.Event,
    extraParameters?: TriggerExtraParameterType
) => JQuery;

interface IViewerOptions

interface IViewerOptions {}

property el

el: Element;

property events

events?: IEvent[];

property exts

exts?: string[];

property hooks

hooks?: IEvent[];

property initialValue

initialValue?: string;

interface IWwTextObject

interface IWwTextObject {}

method deleteContent

deleteContent: () => void;

method expandEndOffset

expandEndOffset: () => void;

method expandStartOffset

expandStartOffset: () => void;

method getTextContent

getTextContent: () => string;

method peekStartBeforeOffset

peekStartBeforeOffset: (offset: number) => string;

method replaceContent

replaceContent: (content: string) => void;

method setEndBeforeRange

setEndBeforeRange: (range: Range) => void;

method setRange

setRange: (range: Range) => void;

type CodeMirrorType

type CodeMirrorType = CodeMirror.EditorFromTextArea;

type CommandManagerExecFunc

type CommandManagerExecFunc = (name: string, ...args: any[]) => any;

type HandlerFunc

type HandlerFunc = (...args: any[]) => void;

type PopupTableUtils

type PopupTableUtils = ILayerPopup;

type RangeType

type RangeType = Range | IRangeType;

type ReplacerFunc

type ReplacerFunc = (inputString: string) => string;

type SquireExt

type SquireExt = any;

type TriggerExtraParameterType

type TriggerExtraParameterType =
    | any[]
    | JQuery.PlainObject
    | string
    | number
    | boolean;

Package Files (1)

index.d.ts

Dependencies (14)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/tui-editor.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/tui-editor)

HTML

<a href="https://www.jsdocs.io/package/tui-editor"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 years ago.
Package analyzed in 7936 ms.
Missing or incorrect documentation? Open an issue for this package.

tui-editor

Install

Overview

Index

Namespaces

Namespaces

namespace tui-editor

variable default

namespace tui-editor/dist/tui-editor-Editor-all

variable default

namespace tui-editor/dist/tui-editor-Viewer

variable default

namespace tui-editor/dist/tui-editor-Viewer-all

variable default

namespace tuiEditor

class Button

constructor

property className

property name

method disable

method enable

method getName

method isEnabled

method setTooltip

class CodeBlockManager

method createCodeBlockHtml

method getHighlightJSLanguages

method getReplacer

method setReplacer

class Command

constructor

property TYPE

method factory

method getName

method getType

method isGlobalType

method isMDType

method isWWType

method setKeyMap

class CommandManager

constructor

method addCommand

method command

method exec

class DefaultToolbar

class Editor

constructor

property Button

property codeBlockManager

property CommandManager

property domUtils

property i18n

property isViewer

property markdownit

property markdownitHighlight

property WwCodeBlockManager

property WwTableManager

property WwTableSelectionManager

method addHook

method addWidget

method afterAddedCommand

method blur

method changeMode

method changePreviewStyle

method defineExtension

method exec

method factory

method focus

method getCodeMirror

method getCurrentModeEditor

method getCurrentPreviewStyle

method getHtml

method getInstances

method getMarkdown

method getRange

method getSelectedText

method getSquire

method getTextObject

method getUI

method getValue